update template

app/.astro/astro/content.d.ts

@@ -0,0 +1,204 @@
+declare module 'astro:content' {
+	interface Render {
+		'.mdx': Promise<{
+			Content: import('astro').MarkdownInstance<{}>['Content'];
+			headings: import('astro').MarkdownHeading[];
+			remarkPluginFrontmatter: Record<string, any>;
+			components: import('astro').MDXInstance<{}>['components'];
+		}>;
+	}
+}
+
+declare module 'astro:content' {
+	interface RenderResult {
+		Content: import('astro/runtime/server/index.js').AstroComponentFactory;
+		headings: import('astro').MarkdownHeading[];
+		remarkPluginFrontmatter: Record<string, any>;
+	}
+	interface Render {
+		'.md': Promise<RenderResult>;
+	}
+
+	export interface RenderedContent {
+		html: string;
+		metadata?: {
+			imagePaths: Array<string>;
+			[key: string]: unknown;
+		};
+	}
+}
+
+declare module 'astro:content' {
+	type Flatten<T> = T extends { [K: string]: infer U } ? U : never;
+
+	export type CollectionKey = keyof AnyEntryMap;
+	export type CollectionEntry<C extends CollectionKey> = Flatten<AnyEntryMap[C]>;
+
+	export type ContentCollectionKey = keyof ContentEntryMap;
+	export type DataCollectionKey = keyof DataEntryMap;
+
+	type AllValuesOf<T> = T extends any ? T[keyof T] : never;
+	type ValidContentEntrySlug<C extends keyof ContentEntryMap> = AllValuesOf<
+		ContentEntryMap[C]
+	>['slug'];
+
+	/** @deprecated Use `getEntry` instead. */
+	export function getEntryBySlug<
+		C extends keyof ContentEntryMap,
+		E extends ValidContentEntrySlug<C> | (string & {}),
+	>(
+		collection: C,
+		// Note that this has to accept a regular string too, for SSR
+		entrySlug: E,
+	): E extends ValidContentEntrySlug<C>
+		? Promise<CollectionEntry<C>>
+		: Promise<CollectionEntry<C> | undefined>;
+
+	/** @deprecated Use `getEntry` instead. */
+	export function getDataEntryById<C extends keyof DataEntryMap, E extends keyof DataEntryMap[C]>(
+		collection: C,
+		entryId: E,
+	): Promise<CollectionEntry<C>>;
+
+	export function getCollection<C extends keyof AnyEntryMap, E extends CollectionEntry<C>>(
+		collection: C,
+		filter?: (entry: CollectionEntry<C>) => entry is E,
+	): Promise<E[]>;
+	export function getCollection<C extends keyof AnyEntryMap>(
+		collection: C,
+		filter?: (entry: CollectionEntry<C>) => unknown,
+	): Promise<CollectionEntry<C>[]>;
+
+	export function getEntry<
+		C extends keyof ContentEntryMap,
+		E extends ValidContentEntrySlug<C> | (string & {}),
+	>(entry: {
+		collection: C;
+		slug: E;
+	}): E extends ValidContentEntrySlug<C>
+		? Promise<CollectionEntry<C>>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getEntry<
+		C extends keyof DataEntryMap,
+		E extends keyof DataEntryMap[C] | (string & {}),
+	>(entry: {
+		collection: C;
+		id: E;
+	}): E extends keyof DataEntryMap[C]
+		? Promise<DataEntryMap[C][E]>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getEntry<
+		C extends keyof ContentEntryMap,
+		E extends ValidContentEntrySlug<C> | (string & {}),
+	>(
+		collection: C,
+		slug: E,
+	): E extends ValidContentEntrySlug<C>
+		? Promise<CollectionEntry<C>>
+		: Promise<CollectionEntry<C> | undefined>;
+	export function getEntry<
+		C extends keyof DataEntryMap,
+		E extends keyof DataEntryMap[C] | (string & {}),
+	>(
+		collection: C,
+		id: E,
+	): E extends keyof DataEntryMap[C]
+		? Promise<DataEntryMap[C][E]>
+		: Promise<CollectionEntry<C> | undefined>;
+
+	/** Resolve an array of entry references from the same collection */
+	export function getEntries<C extends keyof ContentEntryMap>(
+		entries: {
+			collection: C;
+			slug: ValidContentEntrySlug<C>;
+		}[],
+	): Promise<CollectionEntry<C>[]>;
+	export function getEntries<C extends keyof DataEntryMap>(
+		entries: {
+			collection: C;
+			id: keyof DataEntryMap[C];
+		}[],
+	): Promise<CollectionEntry<C>[]>;
+
+	export function render<C extends keyof AnyEntryMap>(
+		entry: AnyEntryMap[C][string],
+	): Promise<RenderResult>;
+
+	export function reference<C extends keyof AnyEntryMap>(
+		collection: C,
+	): import('astro/zod').ZodEffects<
+		import('astro/zod').ZodString,
+		C extends keyof ContentEntryMap
+			? {
+					collection: C;
+					slug: ValidContentEntrySlug<C>;
+				}
+			: {
+					collection: C;
+					id: keyof DataEntryMap[C];
+				}
+	>;
+	// Allow generic `string` to avoid excessive type errors in the config
+	// if `dev` is not running to update as you edit.
+	// Invalid collection names will be caught at build time.
+	export function reference<C extends string>(
+		collection: C,
+	): import('astro/zod').ZodEffects<import('astro/zod').ZodString, never>;
+
+	type ReturnTypeOrOriginal<T> = T extends (...args: any[]) => infer R ? R : T;
+	type InferEntrySchema<C extends keyof AnyEntryMap> = import('astro/zod').infer<
+		ReturnTypeOrOriginal<Required<ContentConfig['collections'][C]>['schema']>
+	>;
+
+	type ContentEntryMap = {
+		"chapters": {
+"available-blocks.mdx": {
+	id: "available-blocks.mdx";
+  slug: "available-blocks";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+"best-pratices.mdx": {
+	id: "best-pratices.mdx";
+  slug: "best-pratices";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+"getting-started.mdx": {
+	id: "getting-started.mdx";
+  slug: "getting-started";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+"writing-your-content.mdx": {
+	id: "writing-your-content.mdx";
+  slug: "writing-your-content";
+  body: string;
+  collection: "chapters";
+  data: any
+} & { render(): Render[".mdx"] };
+};
+
+	};
+
+	type DataEntryMap = {
+		"assets": Record<string, {
+  id: string;
+  collection: "assets";
+  data: any;
+}>;
+"embeds": Record<string, {
+  id: string;
+  collection: "embeds";
+  data: any;
+}>;
+
+	};
+
+	type AnyEntryMap = ContentEntryMap & DataEntryMap;
+
+	export type ContentConfig = never;
+}

app/astro.config.mjs

@@ -8,137 +8,14 @@ import remarkFootnotes from 'remark-footnotes';
 import rehypeSlug from 'rehype-slug';
 import rehypeAutolinkHeadings from 'rehype-autolink-headings';
 import rehypeCitation from 'rehype-citation';
+import rehypeCodeCopyAndLabel from './plugins/rehype/code-copy-and-label.mjs';
+import rehypeReferencesAndFootnotes from './plugins/rehype/post-citation.mjs';
+import remarkIgnoreCitationsInCode from './plugins/remark/ignore-citations-in-code.mjs';
+import rehypeRestoreAtInCode from './plugins/rehype/restore-at-in-code.mjs';
+import rehypeWrapTables from './plugins/rehype/wrap-tables.mjs';
 // Built-in Shiki (dual themes) — no rehype-pretty-code
 
-// Minimal rehype plugin to wrap code blocks with a copy button and a language label
-function rehypeCodeCopyAndLabel() {
-  return (tree) => {
-    // Walk the tree; lightweight visitor to find <pre><code>
-    const visit = (node, parent) => {
-      if (!node || typeof node !== 'object') return;
-      const children = Array.isArray(node.children) ? node.children : [];
-      if (node.tagName === 'pre' && children.some(c => c.tagName === 'code')) {
-        // Find code child and guess language
-        const code = children.find(c => c.tagName === 'code');
-        const collectClasses = (val) => Array.isArray(val) ? val.map(String) : (typeof val === 'string' ? String(val).split(/\s+/) : []);
-        const fromClass = (names) => {
-          const hit = names.find((n) => /^language-/.test(String(n)));
-          return hit ? String(hit).replace(/^language-/, '') : '';
-        };
-        const codeClasses = collectClasses(code?.properties?.className);
-        const preClasses = collectClasses(node?.properties?.className);
-        const candidates = [
-          code?.properties?.['data-language'],
-          fromClass(codeClasses),
-          node?.properties?.['data-language'],
-          fromClass(preClasses),
-        ];
-        let lang = candidates.find(Boolean) || '';
-        const lower = String(lang).toLowerCase();
-        const toExt = (s) => {
-          switch (String(s).toLowerCase()) {
-            case 'typescript': case 'ts': return 'ts';
-            case 'tsx': return 'tsx';
-            case 'javascript': case 'js': case 'node': return 'js';
-            case 'jsx': return 'jsx';
-            case 'python': case 'py': return 'py';
-            case 'bash': case 'shell': case 'sh': return 'sh';
-            case 'markdown': case 'md': return 'md';
-            case 'yaml': case 'yml': return 'yml';
-            case 'html': return 'html';
-            case 'css': return 'css';
-            case 'json': return 'json';
-            default: return lower || '';
-          }
-        };
-        const ext = toExt(lower);
-        const displayLang = ext ? String(ext).toUpperCase() : '';
-        // Determine if single-line block: prefer Shiki lines, then text content
-        const countLinesFromShiki = () => {
-          const isLineEl = (el) => el && el.type === 'element' && el.tagName === 'span' && Array.isArray(el.properties?.className) && el.properties.className.includes('line');
-          const hasNonWhitespaceText = (node) => {
-            if (!node) return false;
-            if (node.type === 'text') return /\S/.test(String(node.value || ''));
-            const kids = Array.isArray(node.children) ? node.children : [];
-            return kids.some(hasNonWhitespaceText);
-          };
-          const collectLines = (node, acc) => {
-            if (!node || typeof node !== 'object') return;
-            if (isLineEl(node)) acc.push(node);
-            const kids = Array.isArray(node.children) ? node.children : [];
-            kids.forEach((k) => collectLines(k, acc));
-          };
-          const lines = [];
-          collectLines(code, lines);
-          const nonEmpty = lines.filter((ln) => hasNonWhitespaceText(ln)).length;
-          return nonEmpty || 0;
-        };
-        const countLinesFromText = () => {
-          // Parse raw text content of the <code> node including nested spans
-          const extractText = (node) => {
-            if (!node) return '';
-            if (node.type === 'text') return String(node.value || '');
-            const kids = Array.isArray(node.children) ? node.children : [];
-            return kids.map(extractText).join('');
-          };
-          const raw = extractText(code);
-          if (!raw || !/\S/.test(raw)) return 0;
-          return raw.split('\n').filter(line => /\S/.test(line)).length;
-        };
-        const lines = countLinesFromShiki() || countLinesFromText();
-        const isSingleLine = lines <= 1;
-        // Also treat code blocks shorter than a threshold as single-line (defensive)
-        if (!isSingleLine) {
-          const approxChars = (() => {
-            const extract = (n) => Array.isArray(n?.children) ? n.children.map(extract).join('') : (n?.type === 'text' ? String(n.value||'') : '');
-            return extract(code).length;
-          })();
-          if (approxChars < 6) {
-            // e.g., "npm i" alone
-            // downgrade to single-line behavior
-            node.__forceSingle = true;
-          }
-        }
-        // Ensure CSS-only label works: set data-language on <code> and <pre>, and wrapper
-        code.properties = code.properties || {};
-        if (ext) code.properties['data-language'] = ext;
-        node.properties = node.properties || {};
-        if (ext) node.properties['data-language'] = ext;
-        // Replace <pre> with wrapper div.code-card containing button + pre
-        const wrapper = {
-          type: 'element',
-          tagName: 'div',
-          properties: { className: ['code-card'].concat((isSingleLine || node.__forceSingle) ? ['no-copy'] : []), 'data-language': ext },
-          children: (isSingleLine || node.__forceSingle) ? [ node ] : [
-            {
-              type: 'element',
-              tagName: 'button',
-              properties: { className: ['code-copy', 'button--ghost'], type: 'button', 'aria-label': 'Copy code' },
-              children: [
-                {
-                  type: 'element',
-                  tagName: 'svg',
-                  properties: { viewBox: '0 0 24 24', 'aria-hidden': 'true', focusable: 'false' },
-                  children: [
-                    { type: 'element', tagName: 'path', properties: { d: 'M16 1H4c-1.1 0-2 .9-2 2v12h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z' }, children: [] }
-                  ]
-                }
-              ]
-            },
-            node
-          ]
-        };
-        if (parent && Array.isArray(parent.children)) {
-          const idx = parent.children.indexOf(node);
-          if (idx !== -1) parent.children[idx] = wrapper;
-        }
-        return; // don't visit nested
-      }
-      children.forEach((c) => visit(c, node));
-    };
-    visit(tree, null);
-  };
-}
+// Plugins moved to app/plugins/*
 
 export default defineConfig({
   output: 'static',
@@ -165,6 +42,7 @@ export default defineConfig({
       }
     },
     remarkPlugins: [
+      remarkIgnoreCitationsInCode,
       remarkMath,
       [remarkFootnotes, { inlineNotes: true }]
     ],
@@ -174,10 +52,12 @@ export default defineConfig({
       rehypeKatex,
       [rehypeCitation, {
         bibliography: 'src/content/bibliography.bib',
-        linkCitations: true,
-        csl: 'vancouver'
+        linkCitations: true
       }],
-      rehypeCodeCopyAndLabel
+      rehypeReferencesAndFootnotes,
+      rehypeRestoreAtInCode,
+      rehypeCodeCopyAndLabel,
+      rehypeWrapTables
     ]
   }
 });

app/plugins/rehype/code-copy-and-label.mjs

@@ -0,0 +1,129 @@
+// Minimal rehype plugin to wrap code blocks with a copy button and a language label
+// Exported as a standalone module to keep astro.config.mjs lean
+export default function rehypeCodeCopyAndLabel() {
+  return (tree) => {
+    // Walk the tree; lightweight visitor to find <pre><code>
+    const visit = (node, parent) => {
+      if (!node || typeof node !== 'object') return;
+      const children = Array.isArray(node.children) ? node.children : [];
+      if (node.tagName === 'pre' && children.some(c => c.tagName === 'code')) {
+        // Find code child and guess language
+        const code = children.find(c => c.tagName === 'code');
+        const collectClasses = (val) => Array.isArray(val) ? val.map(String) : (typeof val === 'string' ? String(val).split(/\s+/) : []);
+        const fromClass = (names) => {
+          const hit = names.find((n) => /^language-/.test(String(n)));
+          return hit ? String(hit).replace(/^language-/, '') : '';
+        };
+        const codeClasses = collectClasses(code?.properties?.className);
+        const preClasses = collectClasses(node?.properties?.className);
+        const candidates = [
+          code?.properties?.['data-language'],
+          fromClass(codeClasses),
+          node?.properties?.['data-language'],
+          fromClass(preClasses),
+        ];
+        let lang = candidates.find(Boolean) || '';
+        const lower = String(lang).toLowerCase();
+        const toExt = (s) => {
+          switch (String(s).toLowerCase()) {
+            case 'typescript': case 'ts': return 'ts';
+            case 'tsx': return 'tsx';
+            case 'javascript': case 'js': case 'node': return 'js';
+            case 'jsx': return 'jsx';
+            case 'python': case 'py': return 'py';
+            case 'bash': case 'shell': case 'sh': return 'sh';
+            case 'markdown': case 'md': return 'md';
+            case 'yaml': case 'yml': return 'yml';
+            case 'html': return 'html';
+            case 'css': return 'css';
+            case 'json': return 'json';
+            default: return lower || '';
+          }
+        };
+        const ext = toExt(lower);
+        // Determine if single-line block: prefer Shiki lines, then text content
+        const countLinesFromShiki = () => {
+          const isLineEl = (el) => el && el.type === 'element' && el.tagName === 'span' && Array.isArray(el.properties?.className) && el.properties.className.includes('line');
+          const hasNonWhitespaceText = (node) => {
+            if (!node) return false;
+            if (node.type === 'text') return /\S/.test(String(node.value || ''));
+            const kids = Array.isArray(node.children) ? node.children : [];
+            return kids.some(hasNonWhitespaceText);
+          };
+          const collectLines = (node, acc) => {
+            if (!node || typeof node !== 'object') return;
+            if (isLineEl(node)) acc.push(node);
+            const kids = Array.isArray(node.children) ? node.children : [];
+            kids.forEach((k) => collectLines(k, acc));
+          };
+          const lines = [];
+          collectLines(code, lines);
+          const nonEmpty = lines.filter((ln) => hasNonWhitespaceText(ln)).length;
+          return nonEmpty || 0;
+        };
+        const countLinesFromText = () => {
+          // Parse raw text content of the <code> node including nested spans
+          const extractText = (node) => {
+            if (!node) return '';
+            if (node.type === 'text') return String(node.value || '');
+            const kids = Array.isArray(node.children) ? node.children : [];
+            return kids.map(extractText).join('');
+          };
+          const raw = extractText(code);
+          if (!raw || !/\S/.test(raw)) return 0;
+          return raw.split('\n').filter(line => /\S/.test(line)).length;
+        };
+        const lines = countLinesFromShiki() || countLinesFromText();
+        const isSingleLine = lines <= 1;
+        // Also treat code blocks shorter than a threshold as single-line (defensive)
+        if (!isSingleLine) {
+          const approxChars = (() => {
+            const extract = (n) => Array.isArray(n?.children) ? n.children.map(extract).join('') : (n?.type === 'text' ? String(n.value||'') : '');
+            return extract(code).length;
+          })();
+          if (approxChars < 6) {
+            node.__forceSingle = true;
+          }
+        }
+        // Ensure CSS-only label works: set data-language on <code> and <pre>, and wrapper
+        code.properties = code.properties || {};
+        if (ext) code.properties['data-language'] = ext;
+        node.properties = node.properties || {};
+        if (ext) node.properties['data-language'] = ext;
+        // Replace <pre> with wrapper div.code-card containing button + pre
+        const wrapper = {
+          type: 'element',
+          tagName: 'div',
+          properties: { className: ['code-card'].concat((isSingleLine || node.__forceSingle) ? ['no-copy'] : []), 'data-language': ext },
+          children: (isSingleLine || node.__forceSingle) ? [ node ] : [
+            {
+              type: 'element',
+              tagName: 'button',
+              properties: { className: ['code-copy', 'button--ghost'], type: 'button', 'aria-label': 'Copy code' },
+              children: [
+                {
+                  type: 'element',
+                  tagName: 'svg',
+                  properties: { viewBox: '0 0 24 24', 'aria-hidden': 'true', focusable: 'false' },
+                  children: [
+                    { type: 'element', tagName: 'path', properties: { d: 'M16 1H4c-1.1 0-2 .9-2 2v12h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z' }, children: [] }
+                  ]
+                }
+              ]
+            },
+            node
+          ]
+        };
+        if (parent && Array.isArray(parent.children)) {
+          const idx = parent.children.indexOf(node);
+          if (idx !== -1) parent.children[idx] = wrapper;
+        }
+        return; // don't visit nested
+      }
+      children.forEach((c) => visit(c, node));
+    };
+    visit(tree, null);
+  };
+}
+
+

app/plugins/rehype/post-citation.mjs

@@ -0,0 +1,441 @@
+// rehype plugin to post-process citations and footnotes at build-time
+// - Normalizes the bibliography into <ol class="references"> with <li id="...">
+// - Linkifies DOI/URL occurrences inside references
+// - Appends back-reference links (↩ back: 1, 2, ...) from each reference to in-text citation anchors
+// - Cleans up footnotes block (.footnotes)
+
+export default function rehypeReferencesAndFootnotes() {
+  return (tree) => {
+    const isElement = (n) => n && typeof n === 'object' && n.type === 'element';
+    const getChildren = (n) => (Array.isArray(n?.children) ? n.children : []);
+
+    const walk = (node, parent, fn) => {
+      if (!node || typeof node !== 'object') return;
+      fn && fn(node, parent);
+      const kids = getChildren(node);
+      for (const child of kids) walk(child, node, fn);
+    };
+
+    const ensureArray = (v) => (Array.isArray(v) ? v : v != null ? [v] : []);
+
+    const hasClass = (el, name) => {
+      const cn = ensureArray(el?.properties?.className).map(String);
+      return cn.includes(name);
+    };
+
+    const setAttr = (el, key, val) => {
+      el.properties = el.properties || {};
+      if (val == null) delete el.properties[key];
+      else el.properties[key] = val;
+    };
+
+    const getAttr = (el, key) => (el?.properties ? el.properties[key] : undefined);
+
+    // Shared helpers for backlinks + backrefs block
+    const collectBacklinksForIdSet = (idSet, anchorPrefix) => {
+      const idToBacklinks = new Map();
+      const idToAnchorNodes = new Map();
+      if (!idSet || idSet.size === 0) return { idToBacklinks, idToAnchorNodes };
+      walk(tree, null, (node) => {
+        if (!isElement(node) || node.tagName !== 'a') return;
+        const href = String(getAttr(node, 'href') || '');
+        if (!href.startsWith('#')) return;
+        const id = href.slice(1);
+        if (!idSet.has(id)) return;
+        // Ensure a stable id
+        let anchorId = String(getAttr(node, 'id') || '');
+        if (!anchorId) {
+          const list = idToBacklinks.get(id) || [];
+          anchorId = `${anchorPrefix}-${id}-${list.length + 1}`;
+          setAttr(node, 'id', anchorId);
+        }
+        const list = idToBacklinks.get(id) || [];
+        list.push(anchorId);
+        idToBacklinks.set(id, list);
+        const nodes = idToAnchorNodes.get(id) || [];
+        nodes.push(node);
+        idToAnchorNodes.set(id, nodes);
+      });
+      return { idToBacklinks, idToAnchorNodes };
+    };
+
+    const createBackIcon = () => ({
+      type: 'element',
+      tagName: 'svg',
+      properties: {
+        className: ['back-icon'],
+        width: 12,
+        height: 12,
+        viewBox: '0 0 24 24',
+        fill: 'none',
+        stroke: 'currentColor',
+        'stroke-width': 2,
+        'stroke-linecap': 'round',
+        'stroke-linejoin': 'round',
+        'aria-hidden': 'true',
+        focusable: 'false'
+      },
+      children: [
+        { type: 'element', tagName: 'line', properties: { x1: 12, y1: 19, x2: 12, y2: 5 }, children: [] },
+        { type: 'element', tagName: 'polyline', properties: { points: '5 12 12 5 19 12' }, children: [] }
+      ]
+    });
+
+    const appendBackrefsBlock = (listElement, idToBacklinks, ariaLabel) => {
+      if (!listElement || !idToBacklinks || idToBacklinks.size === 0) return;
+      for (const li of getChildren(listElement)) {
+        if (!isElement(li) || li.tagName !== 'li') continue;
+        const id = String(getAttr(li, 'id') || '');
+        if (!id) continue;
+        const keys = idToBacklinks.get(id);
+        if (!keys || !keys.length) continue;
+        // Remove pre-existing .backrefs in this li to avoid duplicates
+        li.children = getChildren(li).filter((n) => !(isElement(n) && n.tagName === 'small' && hasClass(n, 'backrefs')));
+        const small = {
+          type: 'element',
+          tagName: 'small',
+          properties: { className: ['backrefs'] },
+          children: []
+        };
+        if (keys.length === 1) {
+          // Single backlink: just the icon wrapped in the anchor
+          const a = {
+            type: 'element',
+            tagName: 'a',
+            properties: { href: `#${keys[0]}`, 'aria-label': ariaLabel },
+            children: [ createBackIcon() ]
+          };
+          small.children.push(a);
+        } else {
+          // Multiple backlinks: icon + label + numbered links
+          small.children.push(createBackIcon());
+          small.children.push({ type: 'text', value: ' back: ' });
+          keys.forEach((backId, idx) => {
+            small.children.push({
+              type: 'element',
+              tagName: 'a',
+              properties: { href: `#${backId}`, 'aria-label': ariaLabel },
+              children: [ { type: 'text', value: String(idx + 1) } ]
+            });
+            if (idx < keys.length - 1) small.children.push({ type: 'text', value: ', ' });
+          });
+        }
+        li.children.push(small);
+      }
+    };
+    // Remove default back-reference anchors generated by remark-footnotes inside a footnote item
+    const getTextContent = (el) => {
+      if (!el) return '';
+      const stack = [el];
+      let out = '';
+      while (stack.length) {
+        const cur = stack.pop();
+        if (!cur) continue;
+        if (cur.type === 'text') out += String(cur.value || '');
+        const kids = getChildren(cur);
+        for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);
+      }
+      return out;
+    };
+
+    const removeFootnoteBackrefAnchors = (el) => {
+      if (!isElement(el)) return;
+      const kids = getChildren(el);
+      for (let i = kids.length - 1; i >= 0; i--) {
+        const child = kids[i];
+        if (isElement(child)) {
+          if (
+            child.tagName === 'a' && (
+              getAttr(child, 'data-footnote-backref') != null ||
+              hasClass(child, 'footnote-backref') ||
+              String(getAttr(child, 'role') || '').toLowerCase() === 'doc-backlink' ||
+              String(getAttr(child, 'aria-label') || '').toLowerCase().includes('back to content') ||
+              String(getAttr(child, 'href') || '').startsWith('#fnref') ||
+              // Fallback: text-based detection like "↩" or "↩2"
+              /^\s*↩\s*\d*\s*$/u.test(getTextContent(child))
+            )
+          ) {
+            // Remove the anchor
+            el.children.splice(i, 1);
+            continue;
+          }
+          // Recurse into element
+          removeFootnoteBackrefAnchors(child);
+          // If a wrapper like <sup> or <span> became empty, remove it
+          const becameKids = getChildren(child);
+          if ((child.tagName === 'sup' || child.tagName === 'span') && (!becameKids || becameKids.length === 0)) {
+            el.children.splice(i, 1);
+          }
+        }
+      }
+    };
+
+
+    const normDoiHref = (href) => {
+      if (!href) return href;
+      const DUP = /https?:\/\/(?:dx\.)?doi\.org\/(?:https?:\/\/(?:dx\.)?doi\.org\/)+/gi;
+      const ONE = /https?:\/\/(?:dx\.)?doi\.org\/(10\.[^\s<>"']+)/i;
+      href = String(href).replace(DUP, 'https://doi.org/');
+      const m = href.match(ONE);
+      return m ? `https://doi.org/${m[1]}` : href;
+    };
+
+    const DOI_BARE = /\b10\.[0-9]{4,9}\/[\-._;()\/:A-Z0-9]+\b/gi;
+    const URL_GEN = /\bhttps?:\/\/[^\s<>()"']+/gi;
+
+    const linkifyTextNode = (textNode) => {
+      const text = String(textNode.value || '');
+      let last = 0;
+      const parts = [];
+      const pushText = (s) => { if (s) parts.push({ type: 'text', value: s }); };
+
+      const matches = [];
+      // Collect URL matches
+      let m;
+      URL_GEN.lastIndex = 0;
+      while ((m = URL_GEN.exec(text)) !== null) {
+        matches.push({ type: 'url', start: m.index, end: URL_GEN.lastIndex, raw: m[0] });
+      }
+      // Collect DOI matches
+      DOI_BARE.lastIndex = 0;
+      while ((m = DOI_BARE.exec(text)) !== null) {
+        matches.push({ type: 'doi', start: m.index, end: DOI_BARE.lastIndex, raw: m[0] });
+      }
+      matches.sort((a, b) => a.start - b.start);
+
+      for (const match of matches) {
+        if (match.start < last) continue; // overlapping
+        pushText(text.slice(last, match.start));
+        if (match.type === 'url') {
+          const href = normDoiHref(match.raw);
+          const doiOne = href.match(/https?:\/\/(?:dx\.)?doi\.org\/(10\.[^\s<>"']+)/i);
+          const a = {
+            type: 'element',
+            tagName: 'a',
+            properties: { href, target: '_blank', rel: 'noopener noreferrer' },
+            children: [{ type: 'text', value: doiOne ? doiOne[1] : href }]
+          };
+          parts.push(a);
+        } else {
+          const href = `https://doi.org/${match.raw}`;
+          const a = {
+            type: 'element',
+            tagName: 'a',
+            properties: { href, target: '_blank', rel: 'noopener noreferrer' },
+            children: [{ type: 'text', value: match.raw }]
+          };
+          parts.push(a);
+        }
+        last = match.end;
+      }
+
+      pushText(text.slice(last));
+      return parts;
+    };
+
+    const linkifyInElement = (el) => {
+      const kids = getChildren(el);
+      for (let i = 0; i < kids.length; i++) {
+        const child = kids[i];
+        if (!child) continue;
+        if (child.type === 'text') {
+          const replacement = linkifyTextNode(child);
+          if (replacement.length === 1 && replacement[0].type === 'text') continue;
+          // Replace the single text node with multiple nodes
+          el.children.splice(i, 1, ...replacement);
+          i += replacement.length - 1;
+        } else if (isElement(child)) {
+          if (child.tagName === 'a') {
+            const href = normDoiHref(getAttr(child, 'href'));
+            setAttr(child, 'href', href);
+            const m = String(href || '').match(/https?:\/\/(?:dx\.)?doi\.org\/(10\.[^\s<>"']+)/i);
+            if (m && (!child.children || child.children.length === 0)) {
+              child.children = [{ type: 'text', value: m[1] }];
+            }
+            continue;
+          }
+          linkifyInElement(child);
+        }
+      }
+      // Deduplicate adjacent identical anchors
+      for (let i = 1; i < el.children.length; i++) {
+        const prev = el.children[i - 1];
+        const curr = el.children[i];
+        if (isElement(prev) && isElement(curr) && prev.tagName === 'a' && curr.tagName === 'a') {
+          const key = `${getAttr(prev, 'href') || ''}|${(prev.children?.[0]?.value) || ''}`;
+          const key2 = `${getAttr(curr, 'href') || ''}|${(curr.children?.[0]?.value) || ''}`;
+          if (key === key2) {
+            el.children.splice(i, 1);
+            i--;
+          }
+        }
+      }
+    };
+
+    // Find references container and normalize its list
+    const findReferencesRoot = () => {
+      let found = null;
+      walk(tree, null, (node) => {
+        if (found) return;
+        if (!isElement(node)) return;
+        const id = getAttr(node, 'id');
+        if (id === 'references' || hasClass(node, 'references') || hasClass(node, 'bibliography')) {
+          found = node;
+        }
+      });
+      return found;
+    };
+
+    const toOrderedList = (container) => {
+      // If there is already an <ol>, use it; otherwise convert common structures
+      let ol = getChildren(container).find((c) => isElement(c) && c.tagName === 'ol');
+      if (!ol) {
+        ol = { type: 'element', tagName: 'ol', properties: { className: ['references'] }, children: [] };
+        const candidates = getChildren(container).filter((n) => isElement(n));
+        if (candidates.length) {
+          for (const node of candidates) {
+            if (hasClass(node, 'csl-entry') || node.tagName === 'li' || node.tagName === 'p' || node.tagName === 'div') {
+              const li = { type: 'element', tagName: 'li', properties: {}, children: getChildren(node) };
+              if (getAttr(node, 'id')) setAttr(li, 'id', getAttr(node, 'id'));
+              ol.children.push(li);
+            }
+          }
+        }
+        // Replace container children by the new ol
+        container.children = [ol];
+      }
+      if (!hasClass(ol, 'references')) {
+        const cls = ensureArray(ol.properties?.className).map(String);
+        if (!cls.includes('references')) cls.push('references');
+        ol.properties = ol.properties || {};
+        ol.properties.className = cls;
+      }
+      return ol;
+    };
+
+    const refsRoot = findReferencesRoot();
+    let refsOl = null;
+    const refIdSet = new Set();
+    const refIdToExternalHref = new Map();
+
+    if (refsRoot) {
+      refsOl = toOrderedList(refsRoot);
+      // Collect item ids and linkify their content
+      for (const li of getChildren(refsOl)) {
+        if (!isElement(li) || li.tagName !== 'li') continue;
+        if (!getAttr(li, 'id')) {
+          // Try to find a nested element with id to promote
+          const nestedWithId = getChildren(li).find((n) => isElement(n) && getAttr(n, 'id'));
+          if (nestedWithId) setAttr(li, 'id', getAttr(nestedWithId, 'id'));
+        }
+        const id = getAttr(li, 'id');
+        if (id) refIdSet.add(String(id));
+        linkifyInElement(li);
+        // Record first external link href (e.g., DOI/URL) if present
+        if (id) {
+          let externalHref = null;
+          const stack = [li];
+          while (stack.length) {
+            const cur = stack.pop();
+            const kids = getChildren(cur);
+            for (const k of kids) {
+              if (isElement(k) && k.tagName === 'a') {
+                const href = String(getAttr(k, 'href') || '');
+                if (/^https?:\/\//i.test(href)) {
+                  externalHref = href;
+                  break;
+                }
+              }
+              if (isElement(k)) stack.push(k);
+            }
+            if (externalHref) break;
+          }
+          if (externalHref) refIdToExternalHref.set(String(id), externalHref);
+        }
+      }
+      setAttr(refsRoot, 'data-built-refs', '1');
+    }
+
+    // Collect in-text anchors that point to references ids
+    const { idToBacklinks: refIdToBacklinks, idToAnchorNodes: refIdToCitationAnchors } = collectBacklinksForIdSet(refIdSet, 'refctx');
+
+    // Append backlinks into references list items
+    appendBackrefsBlock(refsOl, refIdToBacklinks, 'Back to citation');
+
+    // Rewrite in-text citation anchors to external link when available
+    if (refIdToCitationAnchors.size > 0) {
+      for (const [id, anchors] of refIdToCitationAnchors.entries()) {
+        const ext = refIdToExternalHref.get(id);
+        if (!ext) continue;
+        for (const a of anchors) {
+          setAttr(a, 'data-ref-id', id);
+          setAttr(a, 'href', ext);
+          const existingTarget = getAttr(a, 'target');
+          if (!existingTarget) setAttr(a, 'target', '_blank');
+          const rel = String(getAttr(a, 'rel') || '');
+          const relSet = new Set(rel ? rel.split(/\s+/) : []);
+          relSet.add('noopener');
+          relSet.add('noreferrer');
+          setAttr(a, 'rel', Array.from(relSet).join(' '));
+        }
+      }
+    }
+
+    // Footnotes cleanup + backrefs harmonized with references
+    const cleanupFootnotes = () => {
+      let root = null;
+      walk(tree, null, (node) => {
+        if (!isElement(node)) return;
+        if (hasClass(node, 'footnotes')) root = node;
+      });
+      if (!root) return { root: null, ol: null, idSet: new Set() };
+      // Remove <hr> direct children
+      root.children = getChildren(root).filter((n) => !(isElement(n) && n.tagName === 'hr'));
+      // Ensure an <ol>
+      let ol = getChildren(root).find((c) => isElement(c) && c.tagName === 'ol');
+      if (!ol) {
+        ol = { type: 'element', tagName: 'ol', properties: {}, children: [] };
+        const items = getChildren(root).filter((n) => isElement(n) && (n.tagName === 'li' || hasClass(n, 'footnote') || n.tagName === 'p' || n.tagName === 'div'));
+        if (items.length) {
+          for (const it of items) {
+            const li = { type: 'element', tagName: 'li', properties: {}, children: getChildren(it) };
+            // Promote nested id if present (e.g., <p id="fn-1">)
+            const nestedWithId = getChildren(it).find((n) => isElement(n) && getAttr(n, 'id'));
+            if (nestedWithId) setAttr(li, 'id', getAttr(nestedWithId, 'id'));
+            ol.children.push(li);
+          }
+        }
+        root.children = [ol];
+      }
+      // For existing structures, try to promote ids from children when missing
+      for (const li of getChildren(ol)) {
+        if (!isElement(li) || li.tagName !== 'li') continue;
+        if (!getAttr(li, 'id')) {
+          const nestedWithId = getChildren(li).find((n) => isElement(n) && getAttr(n, 'id'));
+          if (nestedWithId) setAttr(li, 'id', getAttr(nestedWithId, 'id'));
+        }
+        // Remove default footnote backrefs anywhere inside (to avoid duplication)
+        removeFootnoteBackrefAnchors(li);
+      }
+      setAttr(root, 'data-built-footnotes', '1');
+      // Collect id set
+      const idSet = new Set();
+      for (const li of getChildren(ol)) {
+        if (!isElement(li) || li.tagName !== 'li') continue;
+        const id = getAttr(li, 'id');
+        if (id) idSet.add(String(id));
+      }
+      return { root, ol, idSet };
+    };
+
+    const { root: footRoot, ol: footOl, idSet: footIdSet } = cleanupFootnotes();
+
+    // Collect in-text anchors pointing to footnotes
+    const { idToBacklinks: footIdToBacklinks } = collectBacklinksForIdSet(footIdSet, 'footctx');
+
+    // Append backlinks into footnote list items (identical pattern to references)
+    appendBackrefsBlock(footOl, footIdToBacklinks, 'Back to footnote call');
+  };
+}
+
+

app/plugins/rehype/restore-at-in-code.mjs

@@ -0,0 +1,22 @@
+// Rehype plugin to restore '@' inside code nodes after rehype-citation ran
+export default function rehypeRestoreAtInCode() {
+  return (tree) => {
+    const restoreInNode = (node) => {
+      if (!node || typeof node !== 'object') return;
+      const isText = node.type === 'text';
+      if (isText && typeof node.value === 'string' && node.value.includes('__AT_SENTINEL__')) {
+        node.value = node.value.replace(/__AT_SENTINEL__/g, '@');
+      }
+      const isCodeEl = node.type === 'element' && node.tagName === 'code';
+      const children = Array.isArray(node.children) ? node.children : [];
+      if (isCodeEl && children.length) {
+        children.forEach(restoreInNode);
+        return;
+      }
+      children.forEach(restoreInNode);
+    };
+    restoreInNode(tree);
+  };
+}
+
+

app/plugins/rehype/wrap-tables.mjs

@@ -0,0 +1,43 @@
+// rehype plugin: wrap bare <table> elements in a <div class="table-scroll"> container
+// so that tables stay width:100% while enabling horizontal scroll when content overflows
+
+export default function rehypeWrapTables() {
+  return (tree) => {
+    const isElement = (n) => n && typeof n === 'object' && n.type === 'element';
+    const getChildren = (n) => (Array.isArray(n?.children) ? n.children : []);
+
+    const walk = (node, parent, fn) => {
+      if (!node || typeof node !== 'object') return;
+      fn && fn(node, parent);
+      const kids = getChildren(node);
+      for (const child of kids) walk(child, node, fn);
+    };
+
+    const ensureArray = (v) => (Array.isArray(v) ? v : v != null ? [v] : []);
+    const hasClass = (el, name) => ensureArray(el?.properties?.className).map(String).includes(name);
+
+    const wrapTable = (tableNode, parent) => {
+      if (!parent || !Array.isArray(parent.children)) return;
+      // Don't double-wrap if already inside .table-scroll
+      if (parent.tagName === 'div' && hasClass(parent, 'table-scroll')) return;
+
+      const wrapper = {
+        type: 'element',
+        tagName: 'div',
+        properties: { className: ['table-scroll'] },
+        children: [tableNode]
+      };
+
+      const idx = parent.children.indexOf(tableNode);
+      if (idx >= 0) parent.children.splice(idx, 1, wrapper);
+    };
+
+    walk(tree, null, (node, parent) => {
+      if (!isElement(node)) return;
+      if (node.tagName !== 'table') return;
+      wrapTable(node, parent);
+    });
+  };
+}
+
+

app/plugins/remark/ignore-citations-in-code.mjs

@@ -0,0 +1,21 @@
+// Remark plugin to ignore citations inside code (block and inline)
+export default function remarkIgnoreCitationsInCode() {
+  return (tree) => {
+    const visit = (node) => {
+      if (!node || typeof node !== 'object') return;
+      const type = node.type;
+      if (type === 'code' || type === 'inlineCode') {
+        if (typeof node.value === 'string' && node.value.includes('@')) {
+          // Use a sentinel to avoid rehype-citation, will be restored later in rehype
+          node.value = node.value.replace(/@/g, '__AT_SENTINEL__');
+        }
+        return; // do not traverse into code
+      }
+      const children = Array.isArray(node.children) ? node.children : [];
+      children.forEach(visit);
+    };
+    visit(tree);
+  };
+}
+
+

app/postcss.config.mjs

@@ -0,0 +1,14 @@
+// PostCSS config enabling Custom Media Queries
+// Allows usage of: @media (--bp-content-collapse) { ... }
+
+import postcssCustomMedia from 'postcss-custom-media';
+import postcssPresetEnv from 'postcss-preset-env';
+
+export default {
+  plugins: [
+    postcssCustomMedia(),
+    postcssPresetEnv({
+      stage: 0
+    })
+  ]
+};

app/src/components/Accordion.astro

@@ -76,6 +76,8 @@ const wrapperClass = ["accordion", className].filter(Boolean).join(" ");
 
 <style>
   .accordion {
+    margin: 0 0 var(--spacing-4);
+    padding: 0;
     border: 1px solid var(--border-color);
     border-radius: 10px;
     background: var(--surface-bg);
@@ -87,16 +89,16 @@ const wrapperClass = ["accordion", className].filter(Boolean).join(" ");
   }
 
   .accordion__summary {
+    margin: 0;
     list-style: none;
     display: flex;
     align-items: center;
-    justify-content: center;
+    justify-content: space-between;
     gap: 4px;
-    padding: 4px;
+    padding: 10px 8px;
     cursor: pointer;
     color: var(--text-color);
     user-select: none;
-    position: relative;
   }
 
   /* Remove conditional padding to avoid jump on close */
@@ -114,8 +116,7 @@ const wrapperClass = ["accordion", className].filter(Boolean).join(" ");
   }
 
   .accordion__chevron {
-    position: absolute;
-    right: 8px;
+    flex: 0 0 auto;
     transition: transform 220ms ease;
     opacity: .85;
   }
@@ -133,7 +134,8 @@ const wrapperClass = ["accordion", className].filter(Boolean).join(" ");
   }
 
   .accordion__content {
-    padding: 12px 4px 4px;
+    margin: 0;
+    padding: 0;
   }
 
   /* Ensure the very last slotted element has no bottom spacing */
@@ -142,15 +144,30 @@ const wrapperClass = ["accordion", className].filter(Boolean).join(" ");
     margin-bottom: 0 !important;
   }
 
+  /* Ensure the very first slotted element has no top spacing */
+  .accordion .accordion__content > :global(*:first-child) {
+    margin-top: 0 !important;
+  }
+
+  /* Content padding: default for direct children, opt-out for code/tables */
+  .accordion .accordion__content > :global(*) {
+    padding: 8px;
+  }
+  .accordion .accordion__content > :global(.table-scroll),
+  .accordion .accordion__content > :global(pre),
+  .accordion .accordion__content > :global(.code-card) {
+    padding: 0;
+  }
+
   /* Separator between header and content when open (edge-to-edge) */
   .accordion[open] .accordion__content-wrapper::before {
     content: "";
     position: absolute;
     left: 0;
     right: 0;
-    top: 6px; /* space below header */
+    top: 0px; /* space below header */
     height: 1px;
-    background: var(--neutral-300);
+    background: var(--border-color);
     pointer-events: none;
   }
 
@@ -160,6 +177,8 @@ const wrapperClass = ["accordion", className].filter(Boolean).join(" ");
     outline-offset: 3px;
     border-radius: 8px;
   }
+
+
 </style>
 
 

app/src/components/Footer.astro

@@ -2,10 +2,12 @@
 interface Props {
   citationText: string;
   bibtex: string;
+  licence?: string;
+  doi?: string;
 }
-const { citationText, bibtex } = Astro.props as Props;
+const { citationText, bibtex, licence, doi } = Astro.props as Props;
 ---
-<footer class="distill-footer">
+<footer class="footer">
   <div class="footer-inner">
     <section class="citation-block">
       <h3>Citation</h3>
@@ -15,6 +17,18 @@ const { citationText, bibtex } = Astro.props as Props;
       <p>BibTeX citation</p>
       <pre class="citation long">{bibtex}</pre>
     </section>
+    {doi && (
+      <section class="doi-block">
+        <h3>DOI</h3>
+        <p><a href={`https://doi.org/${doi}`} target="_blank" rel="noopener noreferrer">{doi}</a></p>
+      </section>
+    )}
+    {licence && (
+      <section class="reuse-block">
+        <h3>Reuse</h3>
+        <p set:html={licence}></p>
+      </section>
+    )}
     <section class="references-block">
       <slot />
     </section>
@@ -24,7 +38,7 @@ const { citationText, bibtex } = Astro.props as Props;
 
 <script is:inline>
   (() => {
-    const getFooter = () => document.currentScript?.closest('footer') || document.querySelector('footer.distill-footer');
+    const getFooter = () => document.currentScript?.closest('footer') || document.querySelector('footer.footer');
     const footer = getFooter();
     if (!footer) return;
     const target = footer.querySelector('.references-block');
@@ -32,14 +46,6 @@ const { citationText, bibtex } = Astro.props as Props;
 
     const contentRoot = document.querySelector('section.content-grid main') || document.querySelector('main') || document.body;
 
-    const findFirstOutsideFooter = (selectors) => {
-      for (const sel of selectors) {
-        const el = contentRoot.querySelector(sel);
-        if (el && !footer.contains(el)) return el;
-      }
-      return null;
-    };
-
     const ensureHeading = (text) => {
       const exists = Array.from(target.children).some((c) => c.tagName === 'H3' && c.textContent.trim().toLowerCase() === text.toLowerCase());
       if (!exists) {
@@ -51,10 +57,6 @@ const { citationText, bibtex } = Astro.props as Props;
 
     const moveIntoFooter = (element, headingText) => {
       if (!element) return false;
-      if (element.classList.contains('footnotes')) {
-        const hr = element.querySelector('hr');
-        if (hr) hr.remove();
-      }
       // Remove an eventual heading already included inside the block (avoid duplicates)
       const firstHeading = element.querySelector(':scope > h1, :scope > h2, :scope > h3');
       if (firstHeading) {
@@ -68,10 +70,18 @@ const { citationText, bibtex } = Astro.props as Props;
       target.appendChild(element);
       return true;
     };
-
     const run = () => {
+      const findFirstOutsideFooter = (selectors) => {
+        for (const sel of selectors) {
+          const el = contentRoot.querySelector(sel);
+          if (el && !footer.contains(el)) return el;
+        }
+        return null;
+      };
+
       const referencesEl = findFirstOutsideFooter(['#references', '.references', '.bibliography']);
       const footnotesEl = findFirstOutsideFooter(['.footnotes']);
+
       const movedRefs = moveIntoFooter(referencesEl, 'References');
       const movedNotes = moveIntoFooter(footnotesEl, 'Footnotes');
       return movedRefs || movedNotes;
@@ -94,3 +104,141 @@ const { citationText, bibtex } = Astro.props as Props;
 </script>
 
 
+<style is:global>
+  .footer {
+    contain: layout style;
+    font-size: 0.8em;
+    line-height: 1.7em;
+    margin-top: 60px;
+    margin-bottom: 0;
+    border-top: 1px solid rgba(0, 0, 0, 0.1);
+    color: rgba(0, 0, 0, 0.5);
+  }
+
+  .footer-inner {
+    max-width: 1280px;
+    margin: 0 auto;
+    padding: 60px 16px 48px;
+    display: grid;
+    grid-template-columns: 220px minmax(0, 680px) 260px;
+    gap: 32px;
+    align-items: start;
+  }
+
+  /* Use the parent grid (3 columns like .content-grid) */
+  .citation-block,
+  .references-block,
+  .reuse-block,
+  .doi-block {
+    display: contents;
+  }
+
+  .citation-block > h3,
+  .references-block > h3,
+  .reuse-block > h3,
+  .doi-block > h3 {
+    grid-column: 1;
+    font-size: 15px;
+    margin: 0;
+    text-align: right;
+    padding-right: 30px;
+  }
+
+  .citation-block > :not(h3),
+  .references-block > :not(h3),
+  .reuse-block > :not(h3),
+  .doi-block > :not(h3) {
+    grid-column: 2;
+  }
+
+
+  .citation-block h3 {
+    margin: 0 0 8px;
+  }
+
+  .citation-block h4 {
+    margin: 16px 0 8px;
+    font-size: 14px;
+    text-transform: uppercase;
+    color: var(--muted-color);
+  }
+
+  .citation-block p,
+  .reuse-block p,
+  .doi-block p,
+  .footnotes ol,
+  .footnotes ol p,
+  .references {
+    margin-top: 0;
+  }
+
+  /* Distill-like appendix citation styling */
+  .citation {
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    font-size: 11px;
+    line-height: 15px;
+    border-left: 1px solid rgba(0, 0, 0, 0.1);
+    padding-left: 18px;
+    border: 1px solid rgba(0,0,0,0.1);
+    background: rgba(0, 0, 0, 0.02);
+    padding: 10px 18px;
+    border-radius: 3px;
+    color: rgba(150, 150, 150, 1);
+    overflow: hidden;
+    margin-top: -12px;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+  }
+
+  .citation a {
+    color: rgba(0, 0, 0, 0.6);
+    text-decoration: underline;
+  }
+
+  .citation.short {
+    margin-top: -4px;
+  }
+
+  .references-block h3 {
+    margin: 0;
+  }
+
+  /* Distill-like list styling for references/footnotes */
+  .references-block ol {
+    padding: 0 0 0 15px;
+  }
+
+  @media (min-width: 768px) {
+    .references-block ol {
+      padding: 0 0 0 30px;
+      margin-left: -30px;
+    }
+  }
+
+  .references-block li {
+    margin-bottom: 1em;
+  }
+
+  .references-block a {
+    color: var(--text-color);
+  }
+
+  [data-theme="dark"] .footer { border-top-color: rgba(255,255,255,.15); color: rgba(200,200,200,.8); }
+  [data-theme="dark"] .citation { background: rgba(255,255,255,0.04); border-color: rgba(255,255,255,.15); color: rgba(200,200,200,1); }
+[data-theme="dark"] .citation a { color: rgba(255,255,255,0.75); }
+
+
+  /* Footer links: use primary color consistently */
+  .footer a {
+    color: var(--primary-color);
+    border-bottom: 1px solid var(--link-underline);
+    text-decoration: none;
+  }
+  .footer a:hover {
+    color: var(--primary-color-hover);
+    border-bottom-color: var(--link-underline-hover);
+  }
+  [data-theme="dark"] .footer a {
+    color: var(--primary-color);
+  }
+</style>

app/src/components/Hero.astro

@@ -5,12 +5,45 @@ interface Props {
   title: string; // may contain HTML (e.g., <br/>)
   titleRaw?: string; // plain title for slug/PDF (optional)
   description?: string;
-  authors?: string[];
-  affiliation?: string;
+  authors?: Array<string | { name: string; url?: string; affiliationIndices?: number[] }>;
+  affiliations?: Array<{ id: number; name: string; url?: string }>;
+  affiliation?: string; // legacy single affiliation
   published?: string;
+  doi?: string;
 }
 
-const { title, titleRaw, description, authors = [], affiliation, published } = Astro.props as Props;
+const { title, titleRaw, description, authors = [], affiliations = [], affiliation, published, doi } = Astro.props as Props;
+
+type Author = { name: string; url?: string; affiliationIndices?: number[] };
+
+function normalizeAuthors(input: Array<string | { name?: string; url?: string; link?: string; affiliationIndices?: number[] }>): Author[] {
+  return (Array.isArray(input) ? input : [])
+    .map((a) => {
+      if (typeof a === 'string') {
+        return { name: a } as Author;
+      }
+      const name = (a?.name ?? '').toString();
+      const url = (a?.url ?? a?.link) as string | undefined;
+      const affiliationIndices = Array.isArray((a as any)?.affiliationIndices) ? (a as any).affiliationIndices : undefined;
+      return { name, url, affiliationIndices } as Author;
+    })
+    .filter((a) => a.name && a.name.trim().length > 0);
+}
+
+const normalizedAuthors: Author[] = normalizeAuthors(authors as any);
+
+// Determine if affiliation superscripts should be shown (only when there are multiple distinct affiliations referenced by authors)
+const authorAffiliationIndexSet = new Set<number>();
+for (const author of normalizedAuthors) {
+  const indices = Array.isArray(author.affiliationIndices) ? author.affiliationIndices : [];
+  for (const idx of indices) {
+    if (typeof idx === 'number') {
+      authorAffiliationIndexSet.add(idx);
+    }
+  }
+}
+const shouldShowAffiliationSupers = authorAffiliationIndexSet.size > 1;
+const hasMultipleAffiliations = Array.isArray(affiliations) && affiliations.length > 1;
 
 function stripHtml(text: string): string {
   return String(text || '').replace(/<[^>]*>/g, '');
@@ -37,69 +70,169 @@ const pdfFilename = `${slugify(pdfBase)}.pdf`;
   </div>
 </section>
 
-<header class="meta">
+<header class="meta" aria-label="Article meta information">
   <div class="meta-container">
-    {authors.length > 0 && (
+    {normalizedAuthors.length > 0 && (
       <div class="meta-container-cell">
-        <h3>Authors</h3>
-        <p>{authors.join(', ')}</p>
+        <h3>Author{normalizedAuthors.length > 1 ? 's' : ''}</h3>
+        <ul class="authors">
+          {normalizedAuthors.map((a, i) => {
+            const supers = shouldShowAffiliationSupers && Array.isArray(a.affiliationIndices) && a.affiliationIndices.length
+              ? <sup>{a.affiliationIndices.join(',')}</sup>
+              : null;
+            return (
+              <li>
+                {a.url ? <a href={a.url}>{a.name}</a> : a.name}{supers}
+              </li>
+            );
+          })}
+        </ul>
       </div>
     )}
-    {affiliation && (
+    {(Array.isArray(affiliations) && affiliations.length > 0) && (
+      <div class="meta-container-cell">
+        <h3>Affiliation{affiliations.length > 1 ? 's' : ''}</h3>
+        {hasMultipleAffiliations ? (
+          <ol class="affiliations">
+            {affiliations.map((af) => (
+              <li value={af.id}>{af.url ? <a href={af.url} target="_blank" rel="noopener noreferrer">{af.name}</a> : af.name}</li>
+            ))}
+          </ol>
+        ) : (
+          <p>
+            {affiliations[0]?.url 
+              ? <a href={affiliations[0].url} target="_blank" rel="noopener noreferrer">{affiliations[0].name}</a> 
+              : affiliations[0]?.name}
+          </p>
+        )}
+      </div>
+    )}
+    {(!affiliations || affiliations.length === 0) && affiliation && (
       <div class="meta-container-cell">
         <h3>Affiliation</h3>
         <p>{affiliation}</p>
       </div>
     )}
     {published && (
-      <div class="meta-container-cell">
+      <div class="meta-container-cell meta-container-cell--published">
         <h3>Published</h3>
         <p>{published}</p>
       </div>
     )}
+    <!-- {doi && (
+      <div class="meta-container-cell">
+        <h3>DOI</h3>
+        <p><a href={`https://doi.org/${doi}`} target="_blank" rel="noopener noreferrer">{doi}</a></p>
+      </div>
+    )} -->
     <div class="meta-container-cell meta-container-cell--pdf">
       <h3>PDF</h3>
-      <p><button id="download-pdf-btn" data-pdf-filename={pdfFilename}>Download PDF</button></p>
+      <p>
+        <a class="button" href={`/${pdfFilename}`} download={pdfFilename} aria-label={`Download PDF ${pdfFilename}`}>
+          Download PDF
+        </a>
+      </p>
     </div>
   </div>
 </header>
 
-<script>
-  // Attach a handler to trigger a programmatic download
-  (() => {
-    const ready = () => {
-      const btn = document.getElementById('download-pdf-btn');
-      if (!btn) return;
-      btn.addEventListener('click', () => {
-        const a = document.createElement('a');
-        const pdf = btn.getAttribute('data-pdf-filename') || 'article.pdf';
-        a.href = `/${pdf}`;
-        a.setAttribute('download', pdf);
-        document.body.appendChild(a);
-        a.click();
-        a.remove();
-      });
-    };
-    if (document.readyState === 'loading') {
-      document.addEventListener('DOMContentLoaded', ready, { once: true });
-    } else { ready(); }
-  })();
-</script>
 
 <style>
   /* Hero (full-width) */
-  .hero { width: 100%; padding: 48px 16px 16px; text-align: center; }
-  .hero-title { font-size: clamp(28px, 4vw, 48px); font-weight: 800; line-height: 1.1; margin: 0 0 8px; max-width: 60%; margin: auto; }
-  .hero-banner { max-width: 980px; margin: 0 auto; }
-  .hero-desc { color: var(--muted-color); font-style: italic; margin: 0 0 16px 0; }
+  .hero {
+    width: 100%;
+    padding: 48px 16px 16px;
+    text-align: center;
+  }
+  .hero-title {
+    font-size: clamp(28px, 4vw, 48px);
+    font-weight: 800;
+    line-height: 1.1;
+    margin: 0 0 8px;
+    max-width: 100%;
+    margin: auto;
+  }
+  .hero-banner {
+    max-width: 980px;
+    margin: 0 auto;
+  }
+  .hero-desc {
+    color: var(--muted-color);
+    font-style: italic;
+    margin: 0 0 16px 0;
+  }
 
   /* Meta (byline-like header) */
-  .meta { border-top: 1px solid var(--border-color); border-bottom: 1px solid var(--border-color); padding: 1rem 0; font-size: 0.9rem; line-height: 1.8em; }
-  .meta-container { max-width: 720px; display: flex; flex-direction: row; justify-content: space-between; margin: 0 auto; gap: 8px; }
-  .meta-container-cell { display: flex; flex-direction: column; gap: 8px; }
-  .meta-container-cell h3 { margin: 0; font-size: 12px; font-weight: 400; color: var(--muted-color); text-transform: uppercase; letter-spacing: .02em; }
-  .meta-container-cell p { margin: 0; }
-  @media print { .meta-container-cell--pdf { display: none !important; } }
+  .meta {
+    border-top: 1px solid var(--border-color);
+    border-bottom: 1px solid var(--border-color);
+    padding: 1rem 0;
+    font-size: 0.9rem;
+  }
+  .meta-container {
+    max-width: 760px;
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+    margin: 0 auto;
+    padding: 0 var(--content-padding-x);
+    gap: 8px;
+  }
+  /* Subtle underline for links in meta; keep buttons without underline */
+  .meta-container a {
+    color: var(--primary-color);
+    text-decoration: underline;
+    text-underline-offset: 2px;
+    text-decoration-thickness: 0.06em;
+    text-decoration-color: var(--link-underline);
+    transition: text-decoration-color .15s ease-in-out;
+  }
+  .meta-container a:hover {
+    text-decoration-color: var(--link-underline-hover);
+  }
+  .meta-container a.button,
+  .meta-container .button {
+    text-decoration: none;
+  }
+  .meta-container-cell {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+  }
+  .meta-container-cell h3 {
+    margin: 0;
+    font-size: 12px;
+    font-weight: 400;
+    color: var(--muted-color);
+    text-transform: uppercase;
+    letter-spacing: .02em;
+  }
+  .meta-container-cell p {
+    margin: 0;
+  } 
+  .authors {
+    margin: 0;
+    list-style-type: none;
+    padding-left: 0;
+  }
+  .affiliations {
+    margin: 0;
+    padding-left: 1.25em;
+  }
+  .affiliations li {
+    margin: 0;
+  }
+
+  header.meta .meta-container {
+    flex-wrap: wrap;
+    row-gap: 12px;
+  }
+  
+  @media print {
+    .meta-container-cell--pdf {
+      display: none !important;
+    }
+  }
 </style>
 
 

app/src/components/HtmlEmbed.astro

@@ -31,6 +31,12 @@ const mountId = `frag-${Math.random().toString(36).slice(2)}`;
   <div><!-- Fragment not found: {src} --></div>
  ) }
 
+<script type="module" is:inline>
+  // Ensure global color palettes generator is loaded once per page
+  import '../scripts/color-palettes.js';
+  export {};
+</script>
+
 <script>
   // Re-execute <script> tags inside the injected fragment (innerHTML doesn't run scripts)
   const scriptEl = document.currentScript;
@@ -45,7 +51,7 @@ const mountId = `frag-${Math.random().toString(36).slice(2)}`;
       old.dataset.executed = 'true';
       if (old.src) {
         const s = document.createElement('script');
-        Array.from(old.attributes).forEach(({ name, value }) => s.setAttribute(name, value));
+        Array.from(old.attributes).forEach(attr => s.setAttribute(attr.name, attr.value));
         document.body.appendChild(s);
       } else {
         try {
@@ -57,14 +63,13 @@ const mountId = `frag-${Math.random().toString(36).slice(2)}`;
       }
     });
   };
-  // Ensure execution when ready: run now if Plotly or D3 is present, or when document is ready; otherwise wait for 'load'
-  // @ts-expect-error: Plotly/d3 are attached globally at runtime via embeds
-  if (window.Plotly || window.d3 || document.readyState === 'complete') execute();
-  else window.addEventListener('load', execute, { once: true });
+  // Execute after DOM is parsed (ensures deferred module scripts are executed first)
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', execute, { once: true });
+  else execute();
   </script>
 
-<style>
-  .html-embed { margin: 0; }
+<style is:global>
+  .html-embed { margin: 0 0 var(--block-spacing-y); overflow: hidden; }
   .html-embed__title { 
     text-align: left; 
     font-weight: 600; 
@@ -89,9 +94,38 @@ const mountId = `frag-${Math.random().toString(36).slice(2)}`;
     color: var(--muted-color); 
     margin: 6px 0 0 0; 
   }
-  @media (prefers-color-scheme: dark) {
-    [data-theme="dark"] .html-embed__card:not(.is-frameless) { background: #12151b; border-color: rgba(255,255,255,.15); }
-  }
+  /* Plotly – fragments & controls */
+  .html-embed__card svg text { fill: var(--text-color) !important; }
+  .html-embed__card label { color: var(--text-color) !important; }
+  .plotly-graph-div { width: 100% !important; min-height: 320px; }
+  @media (max-width: 768px) { .plotly-graph-div { min-height: 260px; } }
+  [id^="plot-"] { display: flex; flex-direction: column; align-items: center; gap: 15px; }
+  .plotly_caption { font-style: italic; margin-top: 10px; }
+  .plotly_controls { display: flex; flex-wrap: wrap; justify-content: center; gap: 30px; }
+  .plotly_input_container { display: flex; align-items: center; flex-direction: column; gap: 10px; }
+  .plotly_input_container > select { padding: 2px 4px; line-height: 1.5em; text-align: center; border-radius: 4px; font-size: 12px; background-color: var(--neutral-200); outline: none; border: 1px solid var(--neutral-300); }
+  .plotly_slider { display: flex; align-items: center; gap: 10px; }
+  .plotly_slider > input[type="range"] { -webkit-appearance: none; appearance: none; height: 2px; background: var(--neutral-400); border-radius: 5px; outline: none; }
+  .plotly_slider > input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; width: 18px; height: 18px; border-radius: 50%; background: var(--primary-color); cursor: pointer; }
+  .plotly_slider > input[type="range"]::-moz-range-thumb { width: 18px; height: 18px; border-radius: 50%; background: var(--primary-color); cursor: pointer; }
+  .plotly_slider > span { font-size: 14px; line-height: 1.6em; min-width: 16px; }
+  /* Dark mode overrides for Plotly readability */
+  [data-theme="dark"] .html-embed__card:not(.is-frameless) { background: #12151b; border-color: rgba(255,255,255,.15); }
+  [data-theme="dark"] .html-embed__card .xaxislayer-above text,
+  [data-theme="dark"] .html-embed__card .yaxislayer-above text,
+  [data-theme="dark"] .html-embed__card .infolayer text,
+  [data-theme="dark"] .html-embed__card .legend text,
+  [data-theme="dark"] .html-embed__card .annotation text,
+  [data-theme="dark"] .html-embed__card .colorbar text,
+  [data-theme="dark"] .html-embed__card .hoverlayer text { fill: #fff !important; }
+  [data-theme="dark"] .html-embed__card .xaxislayer-above path,
+  [data-theme="dark"] .html-embed__card .yaxislayer-above path,
+  [data-theme="dark"] .html-embed__card .xlines-above,
+  [data-theme="dark"] .html-embed__card .ylines-above { stroke: rgba(255,255,255,.35) !important; }
+  [data-theme="dark"] .html-embed__card .gridlayer path { stroke: rgba(255,255,255,.15) !important; }
+  [data-theme="dark"] .html-embed__card .legend rect.bg { fill: rgba(0,0,0,.25) !important; stroke: rgba(255,255,255,.2) !important; }
+  [data-theme="dark"] .html-embed__card .hoverlayer .bg { fill: rgba(0,0,0,.8) !important; stroke: rgba(255,255,255,.2) !important; }
+  [data-theme="dark"] .html-embed__card .colorbar .cbbg { fill: rgba(0,0,0,.25) !important; stroke: rgba(255,255,255,.2) !important; }
   @media print {
     .html-embed, .html-embed__card { max-width: 100% !important; width: 100% !important; margin-left: 0 !important; margin-right: 0 !important; }
     .html-embed__card { padding: 6px; }

app/src/components/Note.astro

@@ -1,24 +1,43 @@
 ---
-const { title, emoji, class: className, ...props } = Astro.props;
-const wrapperClass = ["note", className].filter(Boolean).join(" ");
+interface Props {
+  title?: string;
+  emoji?: string;
+  class?: string;
+  variant?: 'neutral' | 'info' | 'success' | 'danger';
+}
+const { title, emoji, class: className, variant = 'neutral', ...props } = Astro.props as Props;
+const wrapperClass = ["note", `note--${variant}`, className].filter(Boolean).join(" ");
 const hasHeader = (emoji && String(emoji).length > 0) || (title && String(title).length > 0);
 ---
 <div class={wrapperClass} {...props}>
-  {hasHeader && <div class="note__header">
-    {emoji && <span class="note__emoji">{emoji}</span>}
-    {title && <span class="note__title">{title}</span>}
-  </div>}
-  <div class="note__content">
-    <slot />
+  <div class="note__layout">
+    {emoji && <div class="note__icon" aria-hidden="true">
+      <span class="note__emoji">{emoji}</span>
+    </div>}
+    <div class="note__body">
+      {title && <div class="note__title">{title}</div>}
+      <div class="note__content">
+        <slot />
+      </div>
+    </div>
   </div>
 </div>
 
 <style>
-  .note { background: var(--surface-bg); border-left: 2px solid var(--border-color); border-radius: 4px; padding: 10px 14px; margin: 12px 0; }
-  .note__header { display: flex; align-items: center; gap: 6px; font-weight: 600; color: var(--text-color); margin-bottom: 6px; }
-  .note__emoji { font-size: 24px; line-height: 1; }
-  .note__title { font-size: 13px; letter-spacing: .2px; }
-  .note__content { color: var(--text-color); font-size: 0.95rem; }
-  .note__content > p:last-of-type { margin-bottom: 0 !important; }
+  .note { background: var(--surface-bg); border-left: 2px solid var(--border-color); border-radius: 4px; padding: 10px 14px; margin: var(--block-spacing-y) 0; }
+  .note__layout { display: flex; align-items: center; gap: 10px; }
+  .note__icon { flex: 0 0 auto; line-height: 1; }
+  .note__emoji { font-size: 32px; line-height: 1; display: block; }
+  .note__body { flex: 1 1 auto; min-width: 0; }
+  .note__title { font-size: 13px; letter-spacing: .2px; font-weight: 600; color: var(--text-color); margin-bottom: 4px; text-align: left; }
+  .note__content { color: var(--text-color); font-size: 0.95rem; text-align: left; }
+  /* Ensure the very last slotted element has no bottom margin */
+  .note .note__content > :global(*:last-child) { margin-bottom: 0 !important; }
+
+  /* Variants */
+  .note.note--neutral { border-left-color: var(--border-color); background: var(--surface-bg); }
+  .note.note--info { border-left-color: #f39c12; background: color-mix(in oklab, #f39c12 10%, var(--surface-bg)); }
+  .note.note--success { border-left-color: #2ecc71; background: color-mix(in oklab, #2ecc71 8%, var(--surface-bg)); }
+  .note.note--danger { border-left-color: #e74c3c; background: color-mix(in oklab, #e74c3c 8%, var(--surface-bg)); }
 </style>
 

app/src/components/ResponsiveImage.astro

@@ -0,0 +1,213 @@
+---
+// @ts-ignore - types provided by Astro at runtime
+import { Image } from 'astro:assets';
+
+interface Props {
+  /** Source image imported via astro:assets */
+  src: any;
+  /** Alt text for accessibility */
+  alt: string;
+  /** Optional HTML string caption (use slot caption for rich content) */
+  caption?: string;
+  /** Optional class to apply on the <figure> wrapper when caption is used */
+  figureClass?: string;
+  /** Enable medium-zoom behavior on this image */
+  zoomable?: boolean;
+  /** Show a download button overlay and enable download flow */
+  downloadable?: boolean;
+  /** Optional explicit file name to use on download */
+  downloadName?: string;
+  /** Optional explicit source URL to download instead of currentSrc */
+  downloadSrc?: string;
+  /** Any additional attributes should be forwarded to the underlying <Image> */
+  [key: string]: any;
+}
+
+const { caption, figureClass, zoomable, downloadable, downloadName, downloadSrc, ...imgProps } = Astro.props as Props;
+const hasCaptionSlot = Astro.slots.has('caption');
+const hasCaption = hasCaptionSlot || (typeof caption === 'string' && caption.length > 0);
+const uid = `ri_${Math.random().toString(36).slice(2)}`;
+const dataZoomable = (zoomable === true || (imgProps as any)['data-zoomable']) ? '1' : undefined;
+const dataDownloadable = (downloadable === true || (imgProps as any)['data-downloadable']) ? '1' : undefined;
+---
+<div class="ri-root" data-ri-root={uid}>
+  {hasCaption ? (
+    <figure class={(figureClass || '') + (dataDownloadable ? ' has-dl-btn' : '')}>
+      {dataDownloadable ? (
+        <span class="img-dl-wrap">
+          <Image {...imgProps} data-zoomable={dataZoomable} data-downloadable={dataDownloadable} data-download-name={downloadName} data-download-src={downloadSrc} />
+          <button type="button" class="button button--ghost img-dl-btn" aria-label="Download image" title={downloadName ? `Download ${downloadName}` : 'Download image'}>
+            <svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M12 16c-.26 0-.52-.11-.71-.29l-5-5a1 1 0 0 1 1.42-1.42L11 12.59V4a1 1 0 1 1 2 0v8.59l3.29-3.3a1 1 0 1 1 1.42 1.42l-5 5c-.19.18-.45.29-.71.29zM5 20a1 1 0 1 1 0-2h14a1 1 0 1 1 0 2H5z"/></svg>
+          </button>
+        </span>
+      ) : (
+        <Image {...imgProps} data-zoomable={dataZoomable} />
+      )}
+      <figcaption>
+        {hasCaptionSlot ? (
+          <slot name="caption" />
+        ) : (
+          caption && <span set:html={caption} />
+        )}
+      </figcaption>
+    </figure>
+  ) : (
+    dataDownloadable ? (
+      <span class="img-dl-wrap">
+        <Image {...imgProps} data-zoomable={dataZoomable} data-downloadable={dataDownloadable} data-download-name={downloadName} data-download-src={downloadSrc} />
+        <button type="button" class="button button--ghost img-dl-btn" aria-label="Download image" title={downloadName ? `Download ${downloadName}` : 'Download image'}>
+          <svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M12 16c-.26 0-.52-.11-.71-.29l-5-5a1 1 0 0 1 1.42-1.42L11 12.59V4a1 1 0 1 1 2 0v8.59l3.29-3.3a1 1 0 1 1 1.42 1.42l-5 5c-.19.18-.45.29-.71.29zM5 20a1 1 0 1 1 0-2h14a1 1 0 1 1 0 2H5z"/></svg>
+        </button>
+      </span>
+    ) : (
+      <Image {...imgProps} data-zoomable={dataZoomable} />
+    )
+  )}
+</div>
+
+<script is:inline>
+  (() => {
+    const scriptEl = document.currentScript;
+    const root = scriptEl ? scriptEl.previousElementSibling : null;
+    if (!root) return;
+    const img = (root.tagName === 'IMG' ? root : (root.querySelector ? root.querySelector('img') : null));
+    if (!img) return;
+
+    // medium-zoom integration scoped to this image only
+    const ensureMediumZoomReady = (cb) => {
+      // @ts-ignore
+      if (window.mediumZoom) return cb();
+      const retry = () => {
+        // @ts-ignore
+        if (window.mediumZoom) cb(); else setTimeout(retry, 30);
+      };
+      retry();
+    };
+
+    const initZoomIfNeeded = () => {
+      if (img.getAttribute('data-zoomable') !== '1') return;
+      const isDark = document.documentElement.getAttribute('data-theme') === 'dark';
+      const background = isDark ? 'rgba(0,0,0,.9)' : 'rgba(0,0,0,.85)';
+      ensureMediumZoomReady(() => {
+        // @ts-ignore
+        const instance = window.mediumZoom ? window.mediumZoom(img, { background, margin: 24, scrollOffset: 0 }) : null;
+        if (!instance) return;
+        let onScrollLike;
+        const attachCloseOnScroll = () => {
+          if (onScrollLike) return;
+          onScrollLike = () => { try { instance.close && instance.close(); } catch {} };
+          window.addEventListener('wheel', onScrollLike, { passive: true });
+          window.addEventListener('touchmove', onScrollLike, { passive: true });
+          window.addEventListener('scroll', onScrollLike, { passive: true });
+        };
+        const detachCloseOnScroll = () => {
+          if (!onScrollLike) return;
+          window.removeEventListener('wheel', onScrollLike);
+          window.removeEventListener('touchmove', onScrollLike);
+          window.removeEventListener('scroll', onScrollLike);
+          onScrollLike = null;
+        };
+        try { instance.on && instance.on('open', attachCloseOnScroll); } catch {}
+        try { instance.on && instance.on('close', detachCloseOnScroll); } catch {}
+        const themeObserver = new MutationObserver(() => {
+          const dark = document.documentElement.getAttribute('data-theme') === 'dark';
+          try { instance.update && instance.update({ background: dark ? 'rgba(0,0,0,.9)' : 'rgba(0,0,0,.85)' }); } catch {}
+        });
+        themeObserver.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
+      });
+    };
+
+    // Download button handler
+    const dlBtn = (root.querySelector ? root.querySelector('.img-dl-btn') : null);
+    if (dlBtn) {
+      dlBtn.addEventListener('click', async (ev) => {
+        try {
+          ev.preventDefault();
+          ev.stopPropagation();
+          const pickHrefAndName = () => {
+            const current = img.currentSrc || img.src || '';
+            let href = img.getAttribute('data-download-src') || current;
+            const deriveName = () => {
+              try {
+                const u = new URL(current, location.href);
+                const rawHref = u.searchParams.get('href');
+                const candidate = rawHref ? decodeURIComponent(rawHref) : u.pathname;
+                const last = String(candidate).split('/').pop() || '';
+                const base = last.split('?')[0].split('#')[0];
+                const m = base.match(/^(.+?\.(?:png|jpe?g|webp|avif|gif|svg))(?:[._-].*)?$/i);
+                if (m && m[1]) return m[1];
+                return base || 'image';
+              } catch { return 'image'; }
+            };
+            const name = img.getAttribute('data-download-name') || deriveName();
+            return { href, name };
+          };
+          const picked = pickHrefAndName();
+          const res = await fetch(picked.href, { credentials: 'same-origin' });
+          const blob = await res.blob();
+          const objectUrl = URL.createObjectURL(blob);
+          const tmp = document.createElement('a');
+          tmp.href = objectUrl;
+          tmp.download = picked.name || 'image';
+          tmp.target = '_self';
+          tmp.rel = 'noopener';
+          tmp.style.display = 'none';
+          document.body.appendChild(tmp);
+          tmp.click();
+          setTimeout(() => { URL.revokeObjectURL(objectUrl); tmp.remove(); }, 1000);
+        } catch {}
+      });
+    }
+
+    if (document.readyState === 'complete') initZoomIfNeeded();
+    else window.addEventListener('load', initZoomIfNeeded, { once: true });
+  })();
+</script>
+
+
+<style>
+
+  figure { margin: var(--block-spacing-y) 0; }
+  figcaption { text-align: left; font-size: 0.9rem; color: var(--muted-color); margin-top: 6px; }
+  .image-credit { display: block; margin-top: 4px; font-size: 12px; color: var(--muted-color); }
+  .image-credit a { color: inherit; text-decoration: underline; text-underline-offset: 2px; }
+
+  /* Zoomable overlay container (if used by any lightbox implementation) */
+  [data-zoom-overlay],
+  .zoom-overlay {
+    position: fixed;
+    inset: 0;
+    z-index: var(--z-overlay);
+  }
+
+  /* Download link inside figures */
+  figure .download-link { position: relative; z-index: var(--z-elevated); }
+
+    /* Opt-in zoomable images */
+  img[data-zoomable] { cursor: zoom-in; }
+  .medium-zoom--opened img[data-zoomable] { cursor: zoom-out; }
+
+  /* Download button for img[data-downloadable] */
+  figure.has-dl-btn { position: relative; }
+  .dl-host { position: relative; }
+  .img-dl-wrap { position: relative; display: inline-block; }
+  .img-dl-btn {
+    position: absolute;
+    right: 8px;
+    bottom: 8px;
+    align-items: center;
+    justify-content: center;
+    width: 30px;
+    height: 30px;
+    border-radius: 6px;
+    color: white;
+    text-decoration: none;
+    border: 1px solid rgba(255,255,255,0.25);
+    z-index: var(--z-elevated);
+    display: none;
+  }
+  .img-dl-btn svg { width: 18px; height: 18px; fill: currentColor; }
+  .img-dl-wrap:hover .img-dl-btn { display: inline-flex; }
+  [data-theme="dark"] .img-dl-btn { background: rgba(255,255,255,0.15); color: white; border-color: rgba(255,255,255,0.25); }
+  [data-theme="dark"] .img-dl-btn:hover { background: rgba(255,255,255,0.25); }
+</style>

app/src/components/Sidenote.astro

@@ -1,12 +1,37 @@
 ---
 ---
-<div class="margin-aside">
-  <div class="margin-aside__main">
+<div class="aside">
+  <div class="aside__main">
     <slot />
   </div>
-  <aside class="margin-aside__aside">
+  <aside class="aside__aside">
     <slot name="aside" />
   </aside>
 </div>
 
 
+<style is:global>
+  .aside {
+    position: relative;
+    margin: 12px 0;
+  }
+
+  .aside__aside {
+    position: absolute;
+    top: 0;
+    right: -260px; /* push into the right grid column (width 260 + gap 32) */
+    width: 260px;
+    border-radius: 8px;
+    padding: 0 30px;
+    font-size: 0.9rem;
+    color: var(--muted-color);
+  }
+
+  @media (--bp-content-collapse) {
+    .aside__aside {
+      position: static;
+      width: auto;
+      margin-top: 8px;
+    }
+  }
+</style>

app/src/components/TableOfContents.astro

@@ -0,0 +1,396 @@
+---
+export interface Props { tableOfContentAutoCollapse?: boolean }
+const { tableOfContentAutoCollapse = false } = Astro.props as Props;
+---
+<nav class="table-of-contents" aria-label="Table of Contents" data-auto-collapse={tableOfContentAutoCollapse ? '1' : '0'}>
+  <div class="title">Table of Contents</div>
+  <div id="article-toc-placeholder"></div>
+</nav>
+<details class="table-of-contents-mobile">
+  <summary>Table of Contents</summary>
+  <div id="article-toc-mobile-placeholder"></div>
+</details>
+
+<script is:inline>
+  // Build TOC from article headings (h2/h3/h4) and render into the sticky aside
+  const buildTOC = () => {
+    const holder = document.getElementById('article-toc-placeholder');
+    const holderMobile = document.getElementById('article-toc-mobile-placeholder');
+    // Always rebuild TOC to avoid stale entries
+    if (holder) holder.innerHTML = '';
+    if (holderMobile) holderMobile.innerHTML = '';
+    const articleRoot = document.querySelector('section.content-grid main');
+    if (!articleRoot) return;
+    const headings = articleRoot.querySelectorAll('h2, h3, h4');
+    if (!headings.length) return;
+
+    // Filter out headings that should not appear in TOC
+    const normalize = (s) => String(s || '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, ' ')
+      .trim();
+    const isTocLabel = (s) => /^(table\s+of\s+contents?)$|^toc$/i.test(String(s || '').replace(/[^a-zA-Z0-9]+/g, ' ').trim());
+    const shouldSkip = (h) => {
+      const t = h.textContent || '';
+      const id = String(h.id || '');
+      const slug = normalize(t).replace(/\s+/g, '_');
+      if (isTocLabel(t)) return true;
+      if (isTocLabel(id.replace(/[_-]+/g, ' '))) return true;
+      if (isTocLabel(slug.replace(/[_-]+/g, ' '))) return true;
+      return false;
+    };
+    const headingsArr = Array.from(headings).filter(h => !shouldSkip(h));
+    if (!headingsArr.length) return;
+
+    // Ensure unique ids for headings (deduplicate duplicates)
+    const usedIds = new Set();
+    const slugify = (s) => String(s || '')
+      .toLowerCase()
+      .trim()
+      .replace(/\s+/g, '_')
+      .replace(/[^a-z0-9_\-]/g, '');
+    headingsArr.forEach((h) => {
+      let id = (h.id || '').trim();
+      if (!id) {
+        const base = slugify(h.textContent || '');
+        id = base || 'section';
+      }
+      let candidate = id;
+      let n = 2;
+      while (usedIds.has(candidate)) {
+        candidate = `${id}-${n++}`;
+      }
+      if (h.id !== candidate) h.id = candidate;
+      usedIds.add(candidate);
+    });
+
+    const nav = document.createElement('nav');
+    let ulStack = [document.createElement('ul')];
+    nav.appendChild(ulStack[0]);
+
+    const levelOf = (tag) => tag === 'H2' ? 2 : tag === 'H3' ? 3 : 4;
+    let prev = 2;
+    let h2Count = -1;
+    const h2List = headingsArr.filter(h => h.tagName === 'H2');
+    headingsArr.forEach((h) => {
+      const lvl = levelOf(h.tagName);
+      // adjust depth
+      while (lvl > prev) { const ul = document.createElement('ul'); ulStack[ulStack.length-1].lastElementChild?.appendChild(ul); ulStack.push(ul); prev++; }
+      while (lvl < prev) { ulStack.pop(); prev--; }
+      const li = document.createElement('li');
+      const a = document.createElement('a');
+      a.href = '#' + h.id; a.textContent = h.textContent; a.target = '_self';
+      li.appendChild(a);
+      if (lvl === 2) {
+        h2Count += 1;
+        li.setAttribute('data-h2-idx', String(h2Count));
+      }
+      ulStack[ulStack.length-1].appendChild(li);
+    });
+
+    if (holder) holder.appendChild(nav);
+    const navClone = nav.cloneNode(true);
+    if (holderMobile) holderMobile.appendChild(navClone);
+
+    // active link on scroll
+    const links = [
+      ...(holder ? holder.querySelectorAll('a') : []),
+      ...(holderMobile ? holderMobile.querySelectorAll('a') : [])
+    ];
+    // Read breakpoint from CSS var and set autoCollapse only on desktop (disabled on mobile)
+    const getCollapsePx = () => {
+      const root = document.documentElement;
+      const raw = getComputedStyle(root).getPropertyValue('--bp-content-collapse').trim();
+      return raw || '1100px';
+    };
+    const mq = window.matchMedia(`(max-width: ${getCollapsePx()})`);
+    const attrEnabled = (document.querySelector('.table-of-contents')?.getAttribute('data-auto-collapse') === '1');
+    let autoCollapse = attrEnabled && !mq.matches;
+
+    // Inject styles for collapsible & animation
+    const ensureStyles = () => {
+      if (document.getElementById('toc-collapse-style')) return;
+      const style = document.createElement('style');
+      style.id = 'toc-collapse-style';
+      style.textContent = `
+        .table-of-contents nav.table-of-contents-collapsible > ul > li > ul,
+        details.table-of-contents-mobile nav.table-of-contents-collapsible > ul > li > ul { overflow: hidden; transition: height 200ms ease; }
+        .table-of-contents nav.table-of-contents-collapsible > ul > li.collapsed > ul,
+        details.table-of-contents-mobile nav.table-of-contents-collapsible > ul > li.collapsed > ul { display: block; }
+      `;
+      document.head.appendChild(style);
+    };
+    ensureStyles();
+
+    const getTopLevelItems = () => {
+      const sideNav = holder ? holder.querySelector('nav') : null;
+      const mobileNav = holderMobile ? holderMobile.querySelector('nav') : null;
+      const q = (navEl) => navEl ? Array.from(navEl.querySelectorAll(':scope > ul > li[data-h2-idx]')) : [];
+      return { sideNav, mobileNav, sideTop: q(sideNav), mobileTop: q(mobileNav) };
+    };
+
+    const setNavCollapsible = () => {
+      const sideNav = holder ? holder.querySelector('nav') : null;
+      const mobileNav = holderMobile ? holderMobile.querySelector('nav') : null;
+      if (sideNav) sideNav.classList.add('table-of-contents-collapsible');
+      if (mobileNav) mobileNav.classList.add('table-of-contents-collapsible');
+    };
+
+    const measure = (el) => {
+      if (!el) return 0;
+      // Temporarily set height to auto to measure scrollHeight reliably
+      const prev = el.style.height;
+      el.style.height = 'auto';
+      const h = el.scrollHeight;
+      el.style.height = prev || '';
+      return h;
+    };
+
+    const animateTo = (el, target) => {
+      if (!el) return;
+      const current = parseFloat(getComputedStyle(el).height) || 0;
+      if (Math.abs(current - target) < 1) {
+        el.style.height = target ? 'auto' : '0px';
+        return;
+      }
+      el.style.height = current + 'px';
+      // Force reflow
+      void el.offsetHeight;
+      el.style.height = target + 'px';
+      const onEnd = (e) => {
+        if (e.propertyName !== 'height') return;
+        el.removeEventListener('transitionend', onEnd);
+        if (target > 0) el.style.height = 'auto';
+      };
+      el.addEventListener('transitionend', onEnd);
+    };
+
+    let prevActiveIdx = -1;
+    const setCollapsedState = (activeIdx) => {
+      if (!autoCollapse) return;
+      if (activeIdx == null || activeIdx < 0) activeIdx = 0;
+      const { sideTop, mobileTop } = getTopLevelItems();
+      const update = (items) => items.forEach((li) => {
+        const idx = Number(li.getAttribute('data-h2-idx') || '-1');
+        const sub = li.querySelector(':scope > ul');
+        if (!sub) return;
+        if (idx === activeIdx) {
+          li.classList.remove('collapsed');
+          const target = measure(sub);
+          animateTo(sub, target);
+        } else {
+          li.classList.add('collapsed');
+          animateTo(sub, 0);
+        }
+      });
+      update(sideTop);
+      update(mobileTop);
+      setNavCollapsible();
+      prevActiveIdx = activeIdx;
+    };
+
+    // When switching between desktop/mobile, refresh autoCollapse and expand all on mobile
+    const expandAll = () => {
+      const { sideTop, mobileTop } = getTopLevelItems();
+      const expand = (items) => items.forEach((li) => {
+        li.classList.remove('collapsed');
+        const sub = li.querySelector(':scope > ul');
+        if (sub) sub.style.height = 'auto';
+      });
+      expand(sideTop);
+      expand(mobileTop);
+    };
+
+    const onMqChange = () => {
+      autoCollapse = attrEnabled && !mq.matches;
+      if (!autoCollapse) {
+        expandAll();
+      } else {
+        setCollapsedState(prevActiveIdx);
+      }
+    };
+    if (mq.addEventListener) mq.addEventListener('change', onMqChange);
+    else if (mq.addListener) mq.addListener(onMqChange);
+
+    const onScroll = () => {
+      // active link highlight
+      let activeIdx = -1;
+      for (let i = headingsArr.length - 1; i >= 0; i--) {
+        const top = headingsArr[i].getBoundingClientRect().top;
+        if (top - 60 <= 0) {
+          links.forEach(l => l.classList.remove('active'));
+          const id = '#' + headingsArr[i].id;
+          const actives = Array.from(links).filter(l => l.getAttribute('href') === id);
+          actives.forEach(a => a.classList.add('active'));
+          if (headingsArr[i].tagName === 'H2') {
+            activeIdx = h2List.indexOf(headingsArr[i]);
+          } else {
+            for (let j = i; j >= 0; j--) {
+              if (headingsArr[j].tagName === 'H2') { activeIdx = h2List.indexOf(headingsArr[j]); break; }
+            }
+          }
+          break;
+        }
+      }
+      if (activeIdx !== prevActiveIdx) setCollapsedState(activeIdx);
+    };
+
+    // If auto-collapse, collapse immediately (expand first section) before any scroll
+    if (autoCollapse) setCollapsedState(0);
+
+    window.addEventListener('scroll', onScroll);
+    // Initialize state
+    onScroll();
+
+    // Close mobile accordion when a link inside it is clicked
+    if (holderMobile) {
+      const details = holderMobile.closest('details');
+      holderMobile.addEventListener('click', (ev) => {
+        const target = ev.target;
+        const anchor = target && 'closest' in target ? target.closest('a') : null;
+        if (anchor instanceof HTMLAnchorElement && details && details.open) {
+          details.open = false;
+        }
+      });
+    }
+  };
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', buildTOC, { once: true });
+  } else { buildTOC(); }
+</script>
+
+<style is:global>
+  /* Sticky aside */
+  .table-of-contents {
+    position: sticky;
+    top: 32px;
+  }
+
+  .table-of-contents nav {
+    border-left: 1px solid var(--border-color);
+    padding-left: 16px;
+    font-size: 13px;
+  }
+
+  .table-of-contents .title {
+    font-weight: 600;
+    font-size: 14px;
+    margin-bottom: 8px;
+  }
+
+  /* Look & feel */
+  .table-of-contents nav ul {
+    margin: 0 0 6px;
+    padding-left: 1em;
+  }
+
+  .table-of-contents nav li {
+    list-style: none;
+    margin: .25em 0;
+  }
+
+  .table-of-contents nav a,
+  .table-of-contents nav a:link,
+  .table-of-contents nav a:visited {
+    color: var(--text-color);
+    text-decoration: none;
+    border-bottom: none;
+  }
+
+  .table-of-contents nav > ul > li > a {
+    font-weight: 700;
+  }
+
+  .table-of-contents nav a:hover {
+    text-decoration: underline solid var(--muted-color);
+  }
+
+  .table-of-contents nav a.active {
+    text-decoration: underline;
+  }
+
+  /* Mobile accordion */
+  .table-of-contents-mobile {
+    display: none;
+    margin: 8px 0 16px;
+  }
+
+  .table-of-contents-mobile > summary {
+    cursor: pointer;
+    list-style: none;
+    padding: var(--spacing-3) var(--spacing-4);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    color: var(--text-color);
+    font-weight: 600;
+    position: relative;
+  }
+
+  .table-of-contents-mobile[open] > summary {
+    border-bottom-left-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  /* Disclosure arrow for mobile summary */
+  .table-of-contents-mobile > summary::after {
+    content: '';
+    position: absolute;
+    right: var(--spacing-4);
+    top: 50%;
+    width: 8px;
+    height: 8px;
+    border-right: 2px solid currentColor;
+    border-bottom: 2px solid currentColor;
+    transform: translateY(-70%) rotate(45deg);
+    transition: transform 150ms ease;
+    opacity: .7;
+  }
+
+  .table-of-contents-mobile[open] > summary::after {
+    transform: translateY(-30%) rotate(-135deg);
+  }
+
+  .table-of-contents-mobile nav {
+    border-left: none;
+    padding: 10px 12px;
+    font-size: 14px;
+    border: 1px solid var(--border-color);
+    border-top: none;
+    border-bottom-left-radius: 8px;
+    border-bottom-right-radius: 8px;
+  }
+
+  .table-of-contents-mobile nav ul {
+    margin: 0 0 6px;
+    padding-left: 1em;
+  }
+
+  .table-of-contents-mobile nav li {
+    list-style: none;
+    margin: .25em 0;
+  }
+
+  .table-of-contents-mobile nav a,
+  .table-of-contents-mobile nav a:link,
+  .table-of-contents-mobile nav a:visited {
+    color: var(--text-color);
+    text-decoration: none;
+    border-bottom: none;
+  }
+
+  .table-of-contents-mobile nav > ul > li > a {
+    font-weight: 700;
+  }
+
+  .table-of-contents-mobile nav a:hover {
+    text-decoration: underline solid var(--muted-color);
+  }
+
+  .table-of-contents-mobile nav a.active {
+    text-decoration: underline;
+  }
+
+
+
+</style>

app/src/components/ThemeToggle.astro

@@ -44,3 +44,10 @@
 </button>
 
 
+<style>
+  #theme-toggle { display: inline-flex; align-items: center; gap: 8px; border: none; background: transparent; padding: 6px 10px; border-radius: 8px; cursor: pointer; margin: 12px 16px; color: var(--text-color) !important; }
+#theme-toggle .icon.dark { display: none; }
+[data-theme="dark"] #theme-toggle .icon.light { display: none; }
+[data-theme="dark"] #theme-toggle .icon.dark { display: inline; }
+#theme-toggle .icon { filter: none !important; }
+</style>

app/src/content/article.mdx

@@ -3,12 +3,24 @@ title: "FineVision:<br/> Open Data is all you need"
 subtitle: "A new open dataset for data-centric training of Vision Language Models"
 description: "A new open dataset for data-centric training of Vision Language Models"
 authors:
-  - "Luis Wiedmann"
-  - "Orr Zohar"
-  - "Andi Marafioti"
-  - "Amir Mahla"
-  - "Thibaud Frere"
-affiliation: "Hugging Face"
+  - name: "Luis Wiedmann"
+    url: "https://huggingface.co/lusxvr"
+    affiliations: [1]
+  - name: "Orr Zohar"
+    url: "https://huggingface.co/orrzohar"
+    affiliations: [1]
+  - name: "Andi Marafioti"
+    url: "https://huggingface.co/andito" 
+    affiliations: [1]
+  - name: "Amir Mahla"
+    url: "https://huggingface.co/A-Mahla"
+    affiliations: [1]
+  - name: "Thibaud Frere"
+    url: "https://huggingface.co/tfrere"
+    affiliations: [1]
+affiliations:
+  - name: "Hugging Face"
+    url: "https://huggingface.co"
 published: "Sep 4, 2025"
 tags:
   - research
@@ -33,6 +45,8 @@ import Accordion from '../components/Accordion.astro'
   Additionally, we ran extensive ablations and compared the performance of models trained on our dataset with common open source alternatives. Our dataset is both more divers, and achieves an average improvement of **35%** in **10 common benchmarks** over all baselines.
 
   To use the dataset, simply load it with:
+
+  <small class="muted">python</small>
   ```python
   from datasets import load_dataset
 
@@ -51,7 +65,6 @@ Projects like The Cauldron, LLaVa and Cambrian aim to provide such datasets, but
 ### Data Collection
 We manually collect **over 180** image-text datasets from the recent literature and create new subsets in lacking domains.
 
-<Wide>
 <Accordion title="FineVision Subsets">
 |Subset Name                           |Total Images|Total Samples|Total Turns|Total Question Tokens|Total Answer Tokens|Category              |Source                                                             |
 |--------------------------------------|------------|-------------|-----------|---------------------|-------------------|----------------------|-------                                                            |
@@ -242,7 +255,6 @@ We manually collect **over 180** image-text datasets from the recent literature
 |text_OpenMathInstruct-2               |0           |1,000,000    |1,000,000  |74,905,850           |413,132,418        |Text-only             |[@toshniwal_openmathinstruct-2_2024]                               |
 
 </Accordion>
-</Wide>
 
 ### Cleaning
 After gathering all the sub-datasets, every turn is cleaned.

app/src/content/assets/data/against_baselines.csv

@@ -1,961 +1,3 @@
-run,step,metric,value,stderr
-FineVision,1000,ai2d_exact_match,0.2548575129533679,0.007843322436924496
-FineVision,1000,average,0.27120689295763617,
-FineVision,1000,average_rank,2.8,
-FineVision,1000,chartqa_relaxed_overall,0.3308,0.009411906161401973
-FineVision,1000,docvqa_val_anls,0.3528553494243383,0.005852289239342309
-FineVision,1000,infovqa_val_anls,0.17320578642581314,0.006297063452679795
-FineVision,1000,mme_total_score,977.4280712284914,
-FineVision,1000,mmmu_val_mmmu_acc,0.25222,
-FineVision,1000,mmstar_average,0.23215874078908072,
-FineVision,1000,ocrbench_ocrbench_accuracy,0.286,
-FineVision,1000,seedbench_seed_all,0.2563646470261256,
-FineVision,1000,textvqa_val_exact_match,0.3024,0.00628900296642181
-FineVision,2000,ai2d_exact_match,0.26295336787564766,0.007923526907377255
-FineVision,2000,average,0.3202068275596269,
-FineVision,2000,average_rank,2.6,
-FineVision,2000,chartqa_relaxed_overall,0.4688,0.009982508912777261
-FineVision,2000,docvqa_val_anls,0.4452261510942785,0.00614755494712251
-FineVision,2000,infovqa_val_anls,0.1820547866557169,0.006217861455795791
-FineVision,2000,mme_total_score,1049.3036214485794,
-FineVision,2000,mmmu_val_mmmu_acc,0.24556,
-FineVision,2000,mmstar_average,0.21305462434540698,
-FineVision,2000,ocrbench_ocrbench_accuracy,0.395,
-FineVision,2000,seedbench_seed_all,0.258532518065592,
-FineVision,2000,textvqa_val_exact_match,0.41068000000000005,0.006697862330024289
-FineVision,3000,ai2d_exact_match,0.25226683937823835,0.007816909588794397
-FineVision,3000,average,0.3507423834414229,
-FineVision,3000,average_rank,2.6,
-FineVision,3000,chartqa_relaxed_overall,0.5028,0.010001843767601082
-FineVision,3000,docvqa_val_anls,0.502653993831009,0.006267072346683124
-FineVision,3000,infovqa_val_anls,0.21728617578189535,0.006796941784959762
-FineVision,3000,mme_total_score,1170.2383953581434,
-FineVision,3000,mmmu_val_mmmu_acc,0.27556,
-FineVision,3000,mmstar_average,0.25432376938577683,
-FineVision,3000,ocrbench_ocrbench_accuracy,0.436,
-FineVision,3000,seedbench_seed_all,0.2792106725958866,
-FineVision,3000,textvqa_val_exact_match,0.43658,0.006766885462882726
-FineVision,4000,ai2d_exact_match,0.2645725388601036,0.007939149662089447
-FineVision,4000,average,0.36961781722974835,
-FineVision,4000,average_rank,2.7,
-FineVision,4000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-FineVision,4000,docvqa_val_anls,0.5374434618615119,0.0062905728113059655
-FineVision,4000,infovqa_val_anls,0.2287924838861707,0.006994568698639919
-FineVision,4000,mme_total_score,1155.203781512605,
-FineVision,4000,mmmu_val_mmmu_acc,0.25556,
-FineVision,4000,mmstar_average,0.2575590188757354,
-FineVision,4000,ocrbench_ocrbench_accuracy,0.453,
-FineVision,4000,seedbench_seed_all,0.33913285158421347,
-FineVision,4000,textvqa_val_exact_match,0.4593,0.006791695475025738
-FineVision,5000,ai2d_exact_match,0.3125,0.008342439145556371
-FineVision,5000,average,0.3974627910380972,
-FineVision,5000,average_rank,2.6,
-FineVision,5000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-FineVision,5000,docvqa_val_anls,0.552360266782429,0.006300308519952055
-FineVision,5000,infovqa_val_anls,0.23425555286643698,0.007002254622066442
-FineVision,5000,mme_total_score,1181.4653861544618,
-FineVision,5000,mmmu_val_mmmu_acc,0.26667,
-FineVision,5000,mmstar_average,0.29596648146165705,
-FineVision,5000,ocrbench_ocrbench_accuracy,0.462,
-FineVision,5000,seedbench_seed_all,0.43107281823235133,
-FineVision,5000,textvqa_val_exact_match,0.47354000000000007,0.0068172185364497985
-FineVision,6000,ai2d_exact_match,0.358160621761658,0.008629463221867162
-FineVision,6000,average,0.4161227404571003,
-FineVision,6000,average_rank,2.1,
-FineVision,6000,chartqa_relaxed_overall,0.5628,0.00992279440175477
-FineVision,6000,docvqa_val_anls,0.5747451497228876,0.00625495440870239
-FineVision,6000,infovqa_val_anls,0.22152017368968838,0.006604546680525351
-FineVision,6000,mme_total_score,1284.1648659463785,
-FineVision,6000,mmmu_val_mmmu_acc,0.27111,
-FineVision,6000,mmstar_average,0.2978489412854164,
-FineVision,6000,ocrbench_ocrbench_accuracy,0.495,
-FineVision,6000,seedbench_seed_all,0.4795997776542524,
-FineVision,6000,textvqa_val_exact_match,0.48432,0.006800535050670284
-FineVision,7000,ai2d_exact_match,0.3707901554404145,0.00869347755587734
-FineVision,7000,average,0.4291083177345374,
-FineVision,7000,average_rank,2.4,
-FineVision,7000,chartqa_relaxed_overall,0.5656,0.009915542506251351
-FineVision,7000,docvqa_val_anls,0.5940907049431567,0.006224236305767187
-FineVision,7000,infovqa_val_anls,0.2515675215816963,0.007105097396092786
-FineVision,7000,mme_total_score,1185.875650260104,
-FineVision,7000,mmmu_val_mmmu_acc,0.26556,
-FineVision,7000,mmstar_average,0.31372400960777047,
-FineVision,7000,ocrbench_ocrbench_accuracy,0.504,
-FineVision,7000,seedbench_seed_all,0.4964424680377988,
-FineVision,7000,textvqa_val_exact_match,0.5002,0.006794794025220267
-FineVision,8000,ai2d_exact_match,0.37759067357512954,0.008725299846043883
-FineVision,8000,average,0.43846759477995995,
-FineVision,8000,average_rank,2.2,
-FineVision,8000,chartqa_relaxed_overall,0.5832,0.009862556058385773
-FineVision,8000,docvqa_val_anls,0.6017336419437208,0.006231612198089698
-FineVision,8000,infovqa_val_anls,0.2449256624147254,0.006992518502948913
-FineVision,8000,mme_total_score,1199.2409963985594,
-FineVision,8000,mmmu_val_mmmu_acc,0.28111,
-FineVision,8000,mmstar_average,0.33512257186205047,
-FineVision,8000,ocrbench_ocrbench_accuracy,0.51,
-FineVision,8000,seedbench_seed_all,0.5024458032240133,
-FineVision,8000,textvqa_val_exact_match,0.51008,0.006796301690135059
-FineVision,9000,ai2d_exact_match,0.4067357512953368,0.008841214921078996
-FineVision,9000,average,0.4422510732201056,
-FineVision,9000,average_rank,2.0,
-FineVision,9000,chartqa_relaxed_overall,0.5912,0.009834211136815875
-FineVision,9000,docvqa_val_anls,0.6170968481662739,0.00617235763542544
-FineVision,9000,infovqa_val_anls,0.23537031288570615,0.00670318154156447
-FineVision,9000,mme_total_score,1231.5195078031213,
-FineVision,9000,mmmu_val_mmmu_acc,0.25889,
-FineVision,9000,mmstar_average,0.3216444898242951,
-FineVision,9000,ocrbench_ocrbench_accuracy,0.515,
-FineVision,9000,seedbench_seed_all,0.5120622568093385,
-FineVision,9000,textvqa_val_exact_match,0.52226,0.006792711289708482
-FineVision,10000,ai2d_exact_match,0.39993523316062174,0.008817096257082848
-FineVision,10000,average,0.4523875703250908,
-FineVision,10000,average_rank,1.7,
-FineVision,10000,chartqa_relaxed_overall,0.5996,0.00980154906867574
-FineVision,10000,docvqa_val_anls,0.6262613496433054,0.006147756371688175
-FineVision,10000,infovqa_val_anls,0.263290074230132,0.007186788766942786
-FineVision,10000,mme_total_score,1240.8218287314926,
-FineVision,10000,mmmu_val_mmmu_acc,0.28778,
-FineVision,10000,mmstar_average,0.32972717906018517,
-FineVision,10000,ocrbench_ocrbench_accuracy,0.517,
-FineVision,10000,seedbench_seed_all,0.5217342968315731,
-FineVision,10000,textvqa_val_exact_match,0.5261600000000001,0.006785774843600811
-FineVision,11000,ai2d_exact_match,0.422279792746114,0.008889771831066474
-FineVision,11000,average,0.4561398159525099,
-FineVision,11000,average_rank,1.7,
-FineVision,11000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-FineVision,11000,docvqa_val_anls,0.6373130149166712,0.006128022584995044
-FineVision,11000,infovqa_val_anls,0.24419378339723755,0.006897644885887063
-FineVision,11000,mme_total_score,1322.9488795518205,
-FineVision,11000,mmmu_val_mmmu_acc,0.27778,
-FineVision,11000,mmstar_average,0.3298563439522548,
-FineVision,11000,ocrbench_ocrbench_accuracy,0.521,
-FineVision,11000,seedbench_seed_all,0.5237354085603113,
-FineVision,11000,textvqa_val_exact_match,0.5387,0.006770851562852138
-FineVision,12000,ai2d_exact_match,0.42001295336787564,0.008883255931688034
-FineVision,12000,average,0.4582751140055433,
-FineVision,12000,average_rank,1.6,
-FineVision,12000,chartqa_relaxed_overall,0.618,0.009719474639861454
-FineVision,12000,docvqa_val_anls,0.6393961983751871,0.0061228747388476674
-FineVision,12000,infovqa_val_anls,0.24798874058574302,0.006855374548993139
-FineVision,12000,mme_total_score,1225.6453581432572,
-FineVision,12000,mmmu_val_mmmu_acc,0.27889,
-FineVision,12000,mmstar_average,0.34010867846816534,
-FineVision,12000,ocrbench_ocrbench_accuracy,0.512,
-FineVision,12000,seedbench_seed_all,0.5350194552529183,
-FineVision,12000,textvqa_val_exact_match,0.5330600000000001,0.006777713092109446
-FineVision,13000,ai2d_exact_match,0.4375,0.008928571428571428
-FineVision,13000,average,0.4692868662590049,
-FineVision,13000,average_rank,1.5,
-FineVision,13000,chartqa_relaxed_overall,0.6148,0.00973479791861169
-FineVision,13000,docvqa_val_anls,0.6511374872549951,0.006086953065248391
-FineVision,13000,infovqa_val_anls,0.24465055100441893,0.006808432538374664
-FineVision,13000,mme_total_score,1281.7122849139657,
-FineVision,13000,mmmu_val_mmmu_acc,0.28222,
-FineVision,13000,mmstar_average,0.3453069542917521,
-FineVision,13000,ocrbench_ocrbench_accuracy,0.549,
-FineVision,13000,seedbench_seed_all,0.5442468037798777,
-FineVision,13000,textvqa_val_exact_match,0.55472,0.0067416788982325
-FineVision,14000,ai2d_exact_match,0.4572538860103627,0.00896620675297095
-FineVision,14000,average,0.47352486841689195,
-FineVision,14000,average_rank,1.4,
-FineVision,14000,chartqa_relaxed_overall,0.6172,0.009723347231923635
-FineVision,14000,docvqa_val_anls,0.6502269393708169,0.006057950730638126
-FineVision,14000,infovqa_val_anls,0.25805460837190913,0.007037735231659539
-FineVision,14000,mme_total_score,1309.1444577831132,
-FineVision,14000,mmmu_val_mmmu_acc,0.28111,
-FineVision,14000,mmstar_average,0.34575818188776586,
-FineVision,14000,ocrbench_ocrbench_accuracy,0.551,
-FineVision,14000,seedbench_seed_all,0.5483602001111729,
-FineVision,14000,textvqa_val_exact_match,0.55276,0.006751206724612103
-FineVision,15000,ai2d_exact_match,0.45045336787564766,0.008954861634252399
-FineVision,15000,average,0.47878665012878824,
-FineVision,15000,average_rank,1.3,
-FineVision,15000,chartqa_relaxed_overall,0.612,0.009747841205275417
-FineVision,15000,docvqa_val_anls,0.6621413031955148,0.006056838050222495
-FineVision,15000,infovqa_val_anls,0.2706898598157733,0.007200315730154543
-FineVision,15000,mme_total_score,1384.2171868747498,
-FineVision,15000,mmmu_val_mmmu_acc,0.30222,
-FineVision,15000,mmstar_average,0.35408135695920684,
-FineVision,15000,ocrbench_ocrbench_accuracy,0.558,
-FineVision,15000,seedbench_seed_all,0.5411339633129516,
-FineVision,15000,textvqa_val_exact_match,0.5583600000000001,0.0067279027203879065
-FineVision,16000,ai2d_exact_match,0.45077720207253885,0.008955440137395838
-FineVision,16000,average,0.47665128022935843,
-FineVision,16000,average_rank,1.5,
-FineVision,16000,chartqa_relaxed_overall,0.632,0.00964715642305132
-FineVision,16000,docvqa_val_anls,0.6709415729142987,0.005999818105621502
-FineVision,16000,infovqa_val_anls,0.26050032542402035,0.006997451875879188
-FineVision,16000,mme_total_score,1317.8491396558625,
-FineVision,16000,mmmu_val_mmmu_acc,0.27556,
-FineVision,16000,mmstar_average,0.33214333327093315,
-FineVision,16000,ocrbench_ocrbench_accuracy,0.56,
-FineVision,16000,seedbench_seed_all,0.5463590883824346,
-FineVision,16000,textvqa_val_exact_match,0.56158,0.006723854754867398
-FineVision,17000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-FineVision,17000,average,0.4777141780162423,
-FineVision,17000,average_rank,1.3,
-FineVision,17000,chartqa_relaxed_overall,0.632,0.00964715642305132
-FineVision,17000,docvqa_val_anls,0.6796338519136422,0.005948761388267941
-FineVision,17000,infovqa_val_anls,0.28070956072505215,0.007298333094144192
-FineVision,17000,mme_total_score,1381.9161664665867,
-FineVision,17000,mmmu_val_mmmu_acc,0.27667,
-FineVision,17000,mmstar_average,0.3370289492329521,
-FineVision,17000,ocrbench_ocrbench_accuracy,0.519,
-FineVision,17000,seedbench_seed_all,0.5510283490828238,
-FineVision,17000,textvqa_val_exact_match,0.56416,0.006724830373229479
-FineVision,18000,ai2d_exact_match,0.46567357512953367,0.008977921602780726
-FineVision,18000,average,0.4819834595278701,
-FineVision,18000,average_rank,1.2,
-FineVision,18000,chartqa_relaxed_overall,0.6376,0.009615793331418735
-FineVision,18000,docvqa_val_anls,0.6775884603912571,0.005972234236435759
-FineVision,18000,infovqa_val_anls,0.27154318420389256,0.007164903131667027
-FineVision,18000,mme_total_score,1336.922769107643,
-FineVision,18000,mmmu_val_mmmu_acc,0.28667,
-FineVision,18000,mmstar_average,0.34482796716566916,
-FineVision,18000,ocrbench_ocrbench_accuracy,0.533,
-FineVision,18000,seedbench_seed_all,0.5543079488604781,
-FineVision,18000,textvqa_val_exact_match,0.5666399999999999,0.006713392287599574
-FineVision,19000,ai2d_exact_match,0.4682642487046632,0.008981008686994101
-FineVision,19000,average,0.4899006713916878,
-FineVision,19000,average_rank,1.2,
-FineVision,19000,chartqa_relaxed_overall,0.6444,0.009575809858898698
-FineVision,19000,docvqa_val_anls,0.678226526479947,0.005970619221588814
-FineVision,19000,infovqa_val_anls,0.26993847247278,0.0071348470764911525
-FineVision,19000,mme_total_score,1406.6628651460583,
-FineVision,19000,mmmu_val_mmmu_acc,0.28333,
-FineVision,19000,mmstar_average,0.356220913822775,
-FineVision,19000,ocrbench_ocrbench_accuracy,0.577,
-FineVision,19000,seedbench_seed_all,0.554585881045025,
-FineVision,19000,textvqa_val_exact_match,0.57714,0.0066918487914812905
-FineVision,20000,ai2d_exact_match,0.47571243523316065,0.00898853090258662
-FineVision,20000,average,0.4873169067639118,
-FineVision,20000,average_rank,1.2,
-FineVision,20000,chartqa_relaxed_overall,0.6336,0.009638338810708618
-FineVision,20000,docvqa_val_anls,0.6895214454380043,0.005896462073053767
-FineVision,20000,infovqa_val_anls,0.2655657550458317,0.007033265532032538
-FineVision,20000,mme_total_score,1324.6738695478193,
-FineVision,20000,mmmu_val_mmmu_acc,0.30111,
-FineVision,20000,mmstar_average,0.33806766134497995,
-FineVision,20000,ocrbench_ocrbench_accuracy,0.555,
-FineVision,20000,seedbench_seed_all,0.5587548638132296,
-FineVision,20000,textvqa_val_exact_match,0.56852,0.006720151338087659
-Cauldron,1000,ai2d_exact_match,0.28886010362694303,0.008157423105367313
-Cauldron,1000,average,0.29904301214549334,
-Cauldron,1000,average_rank,1.9,
-Cauldron,1000,chartqa_relaxed_overall,0.1936,0.007903961351247664
-Cauldron,1000,docvqa_val_anls,0.32153744261519257,0.005317068996930092
-Cauldron,1000,infovqa_val_anls,0.1431990055083018,0.005424936025458022
-Cauldron,1000,mme_total_score,1172.0779311724689,
-Cauldron,1000,mmmu_val_mmmu_acc,0.27667,
-Cauldron,1000,mmstar_average,0.2911329978035828,
-Cauldron,1000,ocrbench_ocrbench_accuracy,0.337,
-Cauldron,1000,seedbench_seed_all,0.39360755975541967,
-Cauldron,1000,textvqa_val_exact_match,0.44578,0.0067711747933144
-Cauldron,2000,ai2d_exact_match,0.41871761658031087,0.008879446246519871
-Cauldron,2000,average,0.34894207663644056,
-Cauldron,2000,average_rank,1.9,
-Cauldron,2000,chartqa_relaxed_overall,0.2056,0.00808440468059435
-Cauldron,2000,docvqa_val_anls,0.37496112947656884,0.005489559822643159
-Cauldron,2000,infovqa_val_anls,0.14667060624395192,0.005473110880489631
-Cauldron,2000,mme_total_score,1248.6002400960383,
-Cauldron,2000,mmmu_val_mmmu_acc,0.28667,
-Cauldron,2000,mmstar_average,0.34478967650439835,
-Cauldron,2000,ocrbench_ocrbench_accuracy,0.368,
-Cauldron,2000,seedbench_seed_all,0.5013896609227348,
-Cauldron,2000,textvqa_val_exact_match,0.49368,0.0068081481840761415
-Cauldron,3000,ai2d_exact_match,0.4653497409326425,0.00897751861457722
-Cauldron,3000,average,0.3647655686453986,
-Cauldron,3000,average_rank,2.4,
-Cauldron,3000,chartqa_relaxed_overall,0.2192,0.008275744025504309
-Cauldron,3000,docvqa_val_anls,0.3999560247980121,0.005545460541574292
-Cauldron,3000,infovqa_val_anls,0.15452276899525894,0.005625373377223539
-Cauldron,3000,mme_total_score,1164.4316726690677,
-Cauldron,3000,mmmu_val_mmmu_acc,0.27667,
-Cauldron,3000,mmstar_average,0.34444117730168444,
-Cauldron,3000,ocrbench_ocrbench_accuracy,0.403,
-Cauldron,3000,seedbench_seed_all,0.5147304057809894,
-Cauldron,3000,textvqa_val_exact_match,0.50502,0.006802809387533405
-Cauldron,4000,ai2d_exact_match,0.48121761658031087,0.008992802471886854
-Cauldron,4000,average,0.3694904966669109,
-Cauldron,4000,average_rank,2.3,
-Cauldron,4000,chartqa_relaxed_overall,0.2184,0.008264859294607735
-Cauldron,4000,docvqa_val_anls,0.40927640030259055,0.005557758057811595
-Cauldron,4000,infovqa_val_anls,0.15259984907145144,0.005629341537638722
-Cauldron,4000,mme_total_score,1238.5236094437776,
-Cauldron,4000,mmmu_val_mmmu_acc,0.26667,
-Cauldron,4000,mmstar_average,0.36056167686607765,
-Cauldron,4000,ocrbench_ocrbench_accuracy,0.414,
-Cauldron,4000,seedbench_seed_all,0.5240689271817677,
-Cauldron,4000,textvqa_val_exact_match,0.49862,0.006804563140709856
-Cauldron,5000,ai2d_exact_match,0.48607512953367876,0.008995663534025174
-Cauldron,5000,average,0.3715613183242104,
-Cauldron,5000,average_rank,2.3,
-Cauldron,5000,chartqa_relaxed_overall,0.2236,0.008334806752495259
-Cauldron,5000,docvqa_val_anls,0.42332206291362884,0.005573327842684563
-Cauldron,5000,infovqa_val_anls,0.15868297927477548,0.005670852175948406
-Cauldron,5000,mme_total_score,1159.8522408963586,
-Cauldron,5000,mmmu_val_mmmu_acc,0.26889,
-Cauldron,5000,mmstar_average,0.360337335219157,
-Cauldron,5000,ocrbench_ocrbench_accuracy,0.401,
-Cauldron,5000,seedbench_seed_all,0.5198443579766537,
-Cauldron,5000,textvqa_val_exact_match,0.5023,0.0068036313744923
-Cauldron,6000,ai2d_exact_match,0.5025906735751295,0.008999033321198393
-Cauldron,6000,average,0.3678206000506273,
-Cauldron,6000,average_rank,2.2,
-Cauldron,6000,chartqa_relaxed_overall,0.2228,0.008324168469720259
-Cauldron,6000,docvqa_val_anls,0.4147154618557465,0.005557478918091434
-Cauldron,6000,infovqa_val_anls,0.14825798330117057,0.005517775162348899
-Cauldron,6000,mme_total_score,1182.059923969588,
-Cauldron,6000,mmmu_val_mmmu_acc,0.27111,
-Cauldron,6000,mmstar_average,0.3484854117958612,
-Cauldron,6000,ocrbench_ocrbench_accuracy,0.391,
-Cauldron,6000,seedbench_seed_all,0.5185658699277377,
-Cauldron,6000,textvqa_val_exact_match,0.49285999999999996,0.0068052528515312825
-Cauldron,7000,ai2d_exact_match,0.49838082901554404,0.008999106932714641
-Cauldron,7000,average,0.3749288136256422,
-Cauldron,7000,average_rank,2.0,
-Cauldron,7000,chartqa_relaxed_overall,0.2276,0.00838733777631434
-Cauldron,7000,docvqa_val_anls,0.42525461500166023,0.005595478547875609
-Cauldron,7000,infovqa_val_anls,0.14305767989732765,0.005444282186253047
-Cauldron,7000,mme_total_score,1262.065426170468,
-Cauldron,7000,mmmu_val_mmmu_acc,0.29333,
-Cauldron,7000,mmstar_average,0.35012603751558075,
-Cauldron,7000,ocrbench_ocrbench_accuracy,0.403,
-Cauldron,7000,seedbench_seed_all,0.5222901612006671,
-Cauldron,7000,textvqa_val_exact_match,0.51132,0.00682164778449453
-Cauldron,8000,ai2d_exact_match,0.49028497409326427,0.008997455247470544
-Cauldron,8000,average,0.3674367285685282,
-Cauldron,8000,average_rank,2.8,
-Cauldron,8000,chartqa_relaxed_overall,0.2256,0.008361209238380008
-Cauldron,8000,docvqa_val_anls,0.40937518311359955,0.005568234588180622
-Cauldron,8000,infovqa_val_anls,0.14953110986986237,0.005518589617885333
-Cauldron,8000,mme_total_score,1210.7711084433772,
-Cauldron,8000,mmmu_val_mmmu_acc,0.28889,
-Cauldron,8000,mmstar_average,0.32742675529850473,
-Cauldron,8000,ocrbench_ocrbench_accuracy,0.406,
-Cauldron,8000,seedbench_seed_all,0.512562534741523,
-Cauldron,8000,textvqa_val_exact_match,0.49726000000000004,0.006823680165585169
-Cauldron,9000,ai2d_exact_match,0.49287564766839376,0.008998240543632314
-Cauldron,9000,average,0.3635862393983371,
-Cauldron,9000,average_rank,3.0,
-Cauldron,9000,chartqa_relaxed_overall,0.2264,0.008371693383064148
-Cauldron,9000,docvqa_val_anls,0.4019142603693516,0.005557969721056488
-Cauldron,9000,infovqa_val_anls,0.15576345355793061,0.005631711679425604
-Cauldron,9000,mme_total_score,1161.06112444978,
-Cauldron,9000,mmmu_val_mmmu_acc,0.27,
-Cauldron,9000,mmstar_average,0.33510800699714055,
-Cauldron,9000,ocrbench_ocrbench_accuracy,0.401,
-Cauldron,9000,seedbench_seed_all,0.5066147859922179,
-Cauldron,9000,textvqa_val_exact_match,0.4825999999999999,0.006824717089570126
-Cauldron,10000,ai2d_exact_match,0.4951424870466321,0.008998729431386465
-Cauldron,10000,average,0.3613896970671388,
-Cauldron,10000,average_rank,3.2,
-Cauldron,10000,chartqa_relaxed_overall,0.2276,0.00838733777631434
-Cauldron,10000,docvqa_val_anls,0.400968382089468,0.005551850287661274
-Cauldron,10000,infovqa_val_anls,0.15155496077062244,0.0055346119867504375
-Cauldron,10000,mme_total_score,1230.2276910764306,
-Cauldron,10000,mmmu_val_mmmu_acc,0.26,
-Cauldron,10000,mmstar_average,0.32908517910608676,
-Cauldron,10000,ocrbench_ocrbench_accuracy,0.395,
-Cauldron,10000,seedbench_seed_all,0.4972762645914397,
-Cauldron,10000,textvqa_val_exact_match,0.49588000000000004,0.006836984276038533
-Cauldron,11000,ai2d_exact_match,0.49676165803108807,0.008998965371572357
-Cauldron,11000,average,0.36198497174992383,
-Cauldron,11000,average_rank,3.0,
-Cauldron,11000,chartqa_relaxed_overall,0.2284,0.008397713059747491
-Cauldron,11000,docvqa_val_anls,0.4051111426655002,0.0055740680205303966
-Cauldron,11000,infovqa_val_anls,0.14954437197310022,0.005537262124650125
-Cauldron,11000,mme_total_score,1210.5605242096838,
-Cauldron,11000,mmmu_val_mmmu_acc,0.27111,
-Cauldron,11000,mmstar_average,0.33316183100069335,
-Cauldron,11000,ocrbench_ocrbench_accuracy,0.383,
-Cauldron,11000,seedbench_seed_all,0.5043357420789327,
-Cauldron,11000,textvqa_val_exact_match,0.48644,0.006834542228525236
-Cauldron,12000,ai2d_exact_match,0.5009715025906736,0.008999137132137068
-Cauldron,12000,average,0.3661893496614986,
-Cauldron,12000,average_rank,3.2,
-Cauldron,12000,chartqa_relaxed_overall,0.2332,0.008459061785476934
-Cauldron,12000,docvqa_val_anls,0.40826612382074784,0.0055749766883040515
-Cauldron,12000,infovqa_val_anls,0.1451043668322714,0.0054346014264420334
-Cauldron,12000,mme_total_score,1204.859843937575,
-Cauldron,12000,mmmu_val_mmmu_acc,0.29222,
-Cauldron,12000,mmstar_average,0.3322773065724958,
-Cauldron,12000,ocrbench_ocrbench_accuracy,0.386,
-Cauldron,12000,seedbench_seed_all,0.5047248471372985,
-Cauldron,12000,textvqa_val_exact_match,0.49294000000000004,0.006824466715369768
-Cauldron,13000,ai2d_exact_match,0.4880181347150259,0.00899656981935399
-Cauldron,13000,average,0.3609903418270159,
-Cauldron,13000,average_rank,3.2,
-Cauldron,13000,chartqa_relaxed_overall,0.23,0.008418334000200726
-Cauldron,13000,docvqa_val_anls,0.39428463826041577,0.005550710740937849
-Cauldron,13000,infovqa_val_anls,0.15077272156398794,0.005555043265840396
-Cauldron,13000,mme_total_score,1199.0380152060825,
-Cauldron,13000,mmmu_val_mmmu_acc,0.27667,
-Cauldron,13000,mmstar_average,0.3323119954668039,
-Cauldron,13000,ocrbench_ocrbench_accuracy,0.39,
-Cauldron,13000,seedbench_seed_all,0.5000555864369094,
-Cauldron,13000,textvqa_val_exact_match,0.4868,0.006822203492428118
-Cauldron,14000,ai2d_exact_match,0.49060880829015546,0.00899756662777987
-Cauldron,14000,average,0.36202481121184005,
-Cauldron,14000,average_rank,2.9,
-Cauldron,14000,chartqa_relaxed_overall,0.2264,0.008371693383064148
-Cauldron,14000,docvqa_val_anls,0.40917044569115923,0.0055666808292464285
-Cauldron,14000,infovqa_val_anls,0.1424839907142797,0.0054301311838352165
-Cauldron,14000,mme_total_score,1183.6356542617045,
-Cauldron,14000,mmmu_val_mmmu_acc,0.29,
-Cauldron,14000,mmstar_average,0.31528335804531843,
-Cauldron,14000,ocrbench_ocrbench_accuracy,0.393,
-Cauldron,14000,seedbench_seed_all,0.5020566981656476,
-Cauldron,14000,textvqa_val_exact_match,0.48922,0.006837726904596613
-Cauldron,15000,ai2d_exact_match,0.4896373056994819,0.008997221155546275
-Cauldron,15000,average,0.3560155869130515,
-Cauldron,15000,average_rank,3.2,
-Cauldron,15000,chartqa_relaxed_overall,0.2264,0.008371693383064148
-Cauldron,15000,docvqa_val_anls,0.39997251595677663,0.0055655493795707745
-Cauldron,15000,infovqa_val_anls,0.13834600428667498,0.005423970029609658
-Cauldron,15000,mme_total_score,1171.8512404961984,
-Cauldron,15000,mmmu_val_mmmu_acc,0.27667,
-Cauldron,15000,mmstar_average,0.31369390041016126,
-Cauldron,15000,ocrbench_ocrbench_accuracy,0.385,
-Cauldron,15000,seedbench_seed_all,0.5010005558643691,
-Cauldron,15000,textvqa_val_exact_match,0.47342,0.006818885551175648
-Cauldron,16000,ai2d_exact_match,0.4838082901554404,0.008994434238637765
-Cauldron,16000,average,0.3566345947908368,
-Cauldron,16000,average_rank,3.4,
-Cauldron,16000,chartqa_relaxed_overall,0.22,0.008286583553358689
-Cauldron,16000,docvqa_val_anls,0.40446794741098796,0.005565712054024941
-Cauldron,16000,infovqa_val_anls,0.1414810779340465,0.005414255001486301
-Cauldron,16000,mme_total_score,1163.921468587435,
-Cauldron,16000,mmmu_val_mmmu_acc,0.26444,
-Cauldron,16000,mmstar_average,0.3211159497904861,
-Cauldron,16000,ocrbench_ocrbench_accuracy,0.392,
-Cauldron,16000,seedbench_seed_all,0.5045580878265703,
-Cauldron,16000,textvqa_val_exact_match,0.47784,0.0068411071493878735
-Cauldron,17000,ai2d_exact_match,0.4795984455958549,0.008991659681159872
-Cauldron,17000,average,0.35664663136828295,
-Cauldron,17000,average_rank,3.3,
-Cauldron,17000,chartqa_relaxed_overall,0.2232,0.008329493152795851
-Cauldron,17000,docvqa_val_anls,0.39683521379075226,0.0055483771434975925
-Cauldron,17000,infovqa_val_anls,0.14519383287788715,0.005493162839439223
-Cauldron,17000,mme_total_score,1216.2439975990396,
-Cauldron,17000,mmmu_val_mmmu_acc,0.27667,
-Cauldron,17000,mmstar_average,0.3294722845469949,
-Cauldron,17000,ocrbench_ocrbench_accuracy,0.386,
-Cauldron,17000,seedbench_seed_all,0.4938299055030573,
-Cauldron,17000,textvqa_val_exact_match,0.47902,0.006822615153700749
-Cauldron,18000,ai2d_exact_match,0.48575129533678757,0.008995499260034972
-Cauldron,18000,average,0.3559572601168983,
-Cauldron,18000,average_rank,3.3,
-Cauldron,18000,chartqa_relaxed_overall,0.22,0.008286583553358689
-Cauldron,18000,docvqa_val_anls,0.39553075414155453,0.005560094600545488
-Cauldron,18000,infovqa_val_anls,0.1441200977793978,0.005482620397489444
-Cauldron,18000,mme_total_score,1146.935774309724,
-Cauldron,18000,mmmu_val_mmmu_acc,0.28333,
-Cauldron,18000,mmstar_average,0.31718334943636844,
-Cauldron,18000,ocrbench_ocrbench_accuracy,0.393,
-Cauldron,18000,seedbench_seed_all,0.49571984435797667,
-Cauldron,18000,textvqa_val_exact_match,0.46897999999999995,0.006834829544251984
-Cauldron,19000,ai2d_exact_match,0.47506476683937826,0.00898795641911507
-Cauldron,19000,average,0.35389113555756785,
-Cauldron,19000,average_rank,3.4,
-Cauldron,19000,chartqa_relaxed_overall,0.2196,0.008281169428700436
-Cauldron,19000,docvqa_val_anls,0.3927677091095705,0.005557918115613283
-Cauldron,19000,infovqa_val_anls,0.14242963523056748,0.005420426599891758
-Cauldron,19000,mme_total_score,1156.7713085234095,
-Cauldron,19000,mmmu_val_mmmu_acc,0.26667,
-Cauldron,19000,mmstar_average,0.3300183589775604,
-Cauldron,19000,ocrbench_ocrbench_accuracy,0.393,
-Cauldron,19000,seedbench_seed_all,0.4895497498610339,
-Cauldron,19000,textvqa_val_exact_match,0.47591999999999995,0.0068329619195279245
-Cauldron,20000,ai2d_exact_match,0.48218911917098445,0.008993442748995703
-Cauldron,20000,average,0.35315414152261965,
-Cauldron,20000,average_rank,3.1,
-Cauldron,20000,chartqa_relaxed_overall,0.2228,0.008324168469720259
-Cauldron,20000,docvqa_val_anls,0.3995019956467228,0.005554102577571356
-Cauldron,20000,infovqa_val_anls,0.13561089161386572,0.005312619238987202
-Cauldron,20000,mme_total_score,1205.715886354542,
-Cauldron,20000,mmmu_val_mmmu_acc,0.27667,
-Cauldron,20000,mmstar_average,0.3019064734976851,
-Cauldron,20000,ocrbench_ocrbench_accuracy,0.392,
-Cauldron,20000,seedbench_seed_all,0.49182879377431904,
-Cauldron,20000,textvqa_val_exact_match,0.4758799999999999,0.0068345144112400185
-Cambrian,1000,ai2d_exact_match,0.2969559585492228,0.00822373246069825
-Cambrian,1000,average,0.2927820669039429,
-Cambrian,1000,average_rank,2.3,
-Cambrian,1000,chartqa_relaxed_overall,0.3652,0.009631650506356148
-Cambrian,1000,docvqa_val_anls,0.3321611875422322,0.005779917542014128
-Cambrian,1000,infovqa_val_anls,0.14245417507906105,0.005737797137238206
-Cambrian,1000,mme_total_score,1199.468087234894,
-Cambrian,1000,mmmu_val_mmmu_acc,0.24556,
-Cambrian,1000,mmstar_average,0.25503356223234036,
-Cambrian,1000,ocrbench_ocrbench_accuracy,0.257,
-Cambrian,1000,seedbench_seed_all,0.3486937187326292,
-Cambrian,1000,textvqa_val_exact_match,0.39198,0.0066503820519040295
-Cambrian,2000,ai2d_exact_match,0.36204663212435234,0.008649846657326264
-Cambrian,2000,average,0.34977426052091565,
-Cambrian,2000,average_rank,2.3,
-Cambrian,2000,chartqa_relaxed_overall,0.4272,0.009895414680177737
-Cambrian,2000,docvqa_val_anls,0.4044005302893221,0.006099745172446295
-Cambrian,2000,infovqa_val_anls,0.16067123444748188,0.005906486800204124
-Cambrian,2000,mme_total_score,1191.6502601040415,
-Cambrian,2000,mmmu_val_mmmu_acc,0.27,
-Cambrian,2000,mmstar_average,0.3140124492167455,
-Cambrian,2000,ocrbench_ocrbench_accuracy,0.293,
-Cambrian,2000,seedbench_seed_all,0.4954974986103391,
-Cambrian,2000,textvqa_val_exact_match,0.42113999999999996,0.006720777771268006
-Cambrian,3000,ai2d_exact_match,0.3954015544041451,0.008800034697838395
-Cambrian,3000,average,0.36894910100121225,
-Cambrian,3000,average_rank,1.9,
-Cambrian,3000,chartqa_relaxed_overall,0.4512,0.00995424828018316
-Cambrian,3000,docvqa_val_anls,0.4317442116227413,0.006203480507897517
-Cambrian,3000,infovqa_val_anls,0.17555075927653038,0.006227695613801885
-Cambrian,3000,mme_total_score,1311.187975190076,
-Cambrian,3000,mmmu_val_mmmu_acc,0.28222,
-Cambrian,3000,mmstar_average,0.3241666733128301,
-Cambrian,3000,ocrbench_ocrbench_accuracy,0.289,
-Cambrian,3000,seedbench_seed_all,0.5216787103946637,
-Cambrian,3000,textvqa_val_exact_match,0.4495799999999999,0.006762330259763156
-Cambrian,4000,ai2d_exact_match,0.3960492227979275,0.00880252039912977
-Cambrian,4000,average,0.38270567946732525,
-Cambrian,4000,average_rank,2.2,
-Cambrian,4000,chartqa_relaxed_overall,0.4764,0.009990852959439592
-Cambrian,4000,docvqa_val_anls,0.46350742276594625,0.006276498296530657
-Cambrian,4000,infovqa_val_anls,0.17819320935276328,0.006230849386066924
-Cambrian,4000,mme_total_score,1239.0667266906762,
-Cambrian,4000,mmmu_val_mmmu_acc,0.26778,
-Cambrian,4000,mmstar_average,0.3298927333298682,
-Cambrian,4000,ocrbench_ocrbench_accuracy,0.334,
-Cambrian,4000,seedbench_seed_all,0.5273485269594219,
-Cambrian,4000,textvqa_val_exact_match,0.47118000000000004,0.0067854764061200295
-Cambrian,5000,ai2d_exact_match,0.40382124352331605,0.00883109414387431
-Cambrian,5000,average,0.3896927239658996,
-Cambrian,5000,average_rank,2.2,
-Cambrian,5000,chartqa_relaxed_overall,0.4912,0.01000045137036546
-Cambrian,5000,docvqa_val_anls,0.47067674424138894,0.006257580396259991
-Cambrian,5000,infovqa_val_anls,0.19432385292037085,0.00653326869729313
-Cambrian,5000,mme_total_score,1214.843337334934,
-Cambrian,5000,mmmu_val_mmmu_acc,0.26556,
-Cambrian,5000,mmstar_average,0.3255942091936794,
-Cambrian,5000,ocrbench_ocrbench_accuracy,0.348,
-Cambrian,5000,seedbench_seed_all,0.5292384658143413,
-Cambrian,5000,textvqa_val_exact_match,0.47881999999999997,0.0067962283116337965
-Cambrian,6000,ai2d_exact_match,0.4183937823834197,0.00887848400426025
-Cambrian,6000,average,0.39990121640985093,
-Cambrian,6000,average_rank,2.4,
-Cambrian,6000,chartqa_relaxed_overall,0.5048,0.010001539697392967
-Cambrian,6000,docvqa_val_anls,0.5016482570925722,0.006248476976439708
-Cambrian,6000,infovqa_val_anls,0.19206925076752404,0.006399951499514914
-Cambrian,6000,mme_total_score,1176.5368147258905,
-Cambrian,6000,mmmu_val_mmmu_acc,0.26667,
-Cambrian,6000,mmstar_average,0.33910121942401966,
-Cambrian,6000,ocrbench_ocrbench_accuracy,0.349,
-Cambrian,6000,seedbench_seed_all,0.5391884380211228,
-Cambrian,6000,textvqa_val_exact_match,0.48823999999999995,0.006792935247288521
-Cambrian,7000,ai2d_exact_match,0.4326424870466321,0.008917121282993509
-Cambrian,7000,average,0.40874111160527243,
-Cambrian,7000,average_rank,2.2,
-Cambrian,7000,chartqa_relaxed_overall,0.5088,0.01000045137036546
-Cambrian,7000,docvqa_val_anls,0.5036441729071615,0.006331057466984081
-Cambrian,7000,infovqa_val_anls,0.21047690542452482,0.0067248622097179815
-Cambrian,7000,mme_total_score,1226.7814125650261,
-Cambrian,7000,mmmu_val_mmmu_acc,0.29,
-Cambrian,7000,mmstar_average,0.338458434622219,
-Cambrian,7000,ocrbench_ocrbench_accuracy,0.366,
-Cambrian,7000,seedbench_seed_all,0.5344080044469149,
-Cambrian,7000,textvqa_val_exact_match,0.49423999999999996,0.006789004536492761
-Cambrian,8000,ai2d_exact_match,0.4375,0.008928571428571428
-Cambrian,8000,average,0.4145399236017655,
-Cambrian,8000,average_rank,2.2,
-Cambrian,8000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-Cambrian,8000,docvqa_val_anls,0.5139425879433994,0.006316907313170543
-Cambrian,8000,infovqa_val_anls,0.20402472511542052,0.00665285157736885
-Cambrian,8000,mme_total_score,1243.7800120048018,
-Cambrian,8000,mmmu_val_mmmu_acc,0.28222,
-Cambrian,8000,mmstar_average,0.3300028831814166,
-Cambrian,8000,ocrbench_ocrbench_accuracy,0.397,
-Cambrian,8000,seedbench_seed_all,0.5364091161756531,
-Cambrian,8000,textvqa_val_exact_match,0.49855999999999995,0.006793174127235705
-Cambrian,9000,ai2d_exact_match,0.4251943005181347,0.008897867521411106
-Cambrian,9000,average,0.41587431550154147,
-Cambrian,9000,average_rank,2.0,
-Cambrian,9000,chartqa_relaxed_overall,0.5316,0.009982005418395102
-Cambrian,9000,docvqa_val_anls,0.524278096798472,0.006327817979288962
-Cambrian,9000,infovqa_val_anls,0.2075069347958689,0.006574086714467312
-Cambrian,9000,mme_total_score,1196.0997398959585,
-Cambrian,9000,mmmu_val_mmmu_acc,0.28556,
-Cambrian,9000,mmstar_average,0.33833745626187595,
-Cambrian,9000,ocrbench_ocrbench_accuracy,0.381,
-Cambrian,9000,seedbench_seed_all,0.5456920511395219,
-Cambrian,9000,textvqa_val_exact_match,0.5036999999999999,0.006790970877355565
-Cambrian,10000,ai2d_exact_match,0.44559585492227977,0.008945723914357835
-Cambrian,10000,average,0.41659534392300923,
-Cambrian,10000,average_rank,2.0,
-Cambrian,10000,chartqa_relaxed_overall,0.5416,0.00996732235888869
-Cambrian,10000,docvqa_val_anls,0.5215772912722147,0.006314944464077694
-Cambrian,10000,infovqa_val_anls,0.18925972424188112,0.006302599390246784
-Cambrian,10000,mme_total_score,1241.6579631852742,
-Cambrian,10000,mmmu_val_mmmu_acc,0.27889,
-Cambrian,10000,mmstar_average,0.34495128935097424,
-Cambrian,10000,ocrbench_ocrbench_accuracy,0.373,
-Cambrian,10000,seedbench_seed_all,0.5510839355197332,
-Cambrian,10000,textvqa_val_exact_match,0.5034000000000001,0.0067932111363852585
-Cambrian,11000,ai2d_exact_match,0.4481865284974093,0.008950704796242765
-Cambrian,11000,average,0.42096531591252645,
-Cambrian,11000,average_rank,2.0,
-Cambrian,11000,chartqa_relaxed_overall,0.5388,0.0099718403035556
-Cambrian,11000,docvqa_val_anls,0.5266496382012209,0.006315639724937912
-Cambrian,11000,infovqa_val_anls,0.210453542763111,0.006757501751011823
-Cambrian,11000,mme_total_score,1288.1182472989194,
-Cambrian,11000,mmmu_val_mmmu_acc,0.28556,
-Cambrian,11000,mmstar_average,0.33813173019346515,
-Cambrian,11000,ocrbench_ocrbench_accuracy,0.372,
-Cambrian,11000,seedbench_seed_all,0.547526403557532,
-Cambrian,11000,textvqa_val_exact_match,0.5213800000000001,0.00677771101429669
-Cambrian,12000,ai2d_exact_match,0.4566062176165803,0.008965198879336198
-Cambrian,12000,average,0.42647137409223257,
-Cambrian,12000,average_rank,2.1,
-Cambrian,12000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-Cambrian,12000,docvqa_val_anls,0.5432685128640529,0.006286968775744768
-Cambrian,12000,infovqa_val_anls,0.214068867667478,0.006728697021311144
-Cambrian,12000,mme_total_score,1272.0885354141656,
-Cambrian,12000,mmmu_val_mmmu_acc,0.27556,
-Cambrian,12000,mmstar_average,0.3364706975313428,
-Cambrian,12000,ocrbench_ocrbench_accuracy,0.396,
-Cambrian,12000,seedbench_seed_all,0.5505280711506393,
-Cambrian,12000,textvqa_val_exact_match,0.51694,0.00676817323313926
-Cambrian,13000,ai2d_exact_match,0.44591968911917096,0.008946359966425538
-Cambrian,13000,average,0.42595033048849396,
-Cambrian,13000,average_rank,2.1,
-Cambrian,13000,chartqa_relaxed_overall,0.5484,0.009955029736109216
-Cambrian,13000,docvqa_val_anls,0.5438384263330651,0.006322105329987294
-Cambrian,13000,infovqa_val_anls,0.2206834922799479,0.006931006985711701
-Cambrian,13000,mme_total_score,1294.3567426970787,
-Cambrian,13000,mmmu_val_mmmu_acc,0.27889,
-Cambrian,13000,mmstar_average,0.3258043460972802,
-Cambrian,13000,ocrbench_ocrbench_accuracy,0.404,
-Cambrian,13000,seedbench_seed_all,0.5466370205669816,
-Cambrian,13000,textvqa_val_exact_match,0.5193800000000001,0.006779976160381913
-Cambrian,14000,ai2d_exact_match,0.452720207253886,0.00895883074213608
-Cambrian,14000,average,0.4290628718702856,
-Cambrian,14000,average_rank,2.2,
-Cambrian,14000,chartqa_relaxed_overall,0.5624,0.009923804147377265
-Cambrian,14000,docvqa_val_anls,0.5501582985035621,0.006289139790552158
-Cambrian,14000,infovqa_val_anls,0.2108586833777777,0.006694603397438603
-Cambrian,14000,mme_total_score,1258.3851540616247,
-Cambrian,14000,mmmu_val_mmmu_acc,0.28444,
-Cambrian,14000,mmstar_average,0.3392338272359765,
-Cambrian,14000,ocrbench_ocrbench_accuracy,0.391,
-Cambrian,14000,seedbench_seed_all,0.5506948304613675,
-Cambrian,14000,textvqa_val_exact_match,0.5200600000000001,0.006762031077483937
-Cambrian,15000,ai2d_exact_match,0.4575777202072539,0.008966704964444827
-Cambrian,15000,average,0.4277300448618869,
-Cambrian,15000,average_rank,2.2,
-Cambrian,15000,chartqa_relaxed_overall,0.5572,0.009936335154498413
-Cambrian,15000,docvqa_val_anls,0.550106577844955,0.006305789516584643
-Cambrian,15000,infovqa_val_anls,0.2065365477570411,0.006585265308234506
-Cambrian,15000,mme_total_score,1191.499399759904,
-Cambrian,15000,mmmu_val_mmmu_acc,0.27667,
-Cambrian,15000,mmstar_average,0.3287834934674655,
-Cambrian,15000,ocrbench_ocrbench_accuracy,0.403,
-Cambrian,15000,seedbench_seed_all,0.5489160644802669,
-Cambrian,15000,textvqa_val_exact_match,0.52078,0.006761241098810132
-Cambrian,16000,ai2d_exact_match,0.45174870466321243,0.008957152666985158
-Cambrian,16000,average,0.4283932783055524,
-Cambrian,16000,average_rank,2.0,
-Cambrian,16000,chartqa_relaxed_overall,0.566,0.00991448025705367
-Cambrian,16000,docvqa_val_anls,0.5507111549470696,0.006298722691255348
-Cambrian,16000,infovqa_val_anls,0.21185403234992514,0.0065982885956266755
-Cambrian,16000,mme_total_score,1242.7407963185274,
-Cambrian,16000,mmmu_val_mmmu_acc,0.28111,
-Cambrian,16000,mmstar_average,0.32560559611383355,
-Cambrian,16000,ocrbench_ocrbench_accuracy,0.394,
-Cambrian,16000,seedbench_seed_all,0.5540300166759311,
-Cambrian,16000,textvqa_val_exact_match,0.5204799999999999,0.006783488561456611
-Cambrian,17000,ai2d_exact_match,0.4585492227979275,0.008968176705111413
-Cambrian,17000,average,0.43044446070382536,
-Cambrian,17000,average_rank,2.4,
-Cambrian,17000,chartqa_relaxed_overall,0.5656,0.009915542506251351
-Cambrian,17000,docvqa_val_anls,0.5528747665552118,0.006300095973166064
-Cambrian,17000,infovqa_val_anls,0.20960594545383252,0.0066643358201217045
-Cambrian,17000,mme_total_score,1292.4750900360143,
-Cambrian,17000,mmmu_val_mmmu_acc,0.27111,
-Cambrian,17000,mmstar_average,0.3297184661133375,
-Cambrian,17000,ocrbench_ocrbench_accuracy,0.409,
-Cambrian,17000,seedbench_seed_all,0.555141745414119,
-Cambrian,17000,textvqa_val_exact_match,0.5224,0.006774129151791618
-Cambrian,18000,ai2d_exact_match,0.4523963730569948,0.008958275210820045
-Cambrian,18000,average,0.43086034100304976,
-Cambrian,18000,average_rank,2.4,
-Cambrian,18000,chartqa_relaxed_overall,0.566,0.00991448025705367
-Cambrian,18000,docvqa_val_anls,0.5527950768923724,0.006311862091164367
-Cambrian,18000,infovqa_val_anls,0.21943552260393814,0.006848865968629337
-Cambrian,18000,mme_total_score,1271.4629851940776,
-Cambrian,18000,mmmu_val_mmmu_acc,0.28333,
-Cambrian,18000,mmstar_average,0.3399009269355101,
-Cambrian,18000,ocrbench_ocrbench_accuracy,0.403,
-Cambrian,18000,seedbench_seed_all,0.5493051695386326,
-Cambrian,18000,textvqa_val_exact_match,0.5115799999999999,0.0067870754820260944
-Cambrian,19000,ai2d_exact_match,0.45012953367875647,0.008954279299902583
-Cambrian,19000,average,0.43057935657557483,
-Cambrian,19000,average_rank,2.2,
-Cambrian,19000,chartqa_relaxed_overall,0.5704,0.009902361269085337
-Cambrian,19000,docvqa_val_anls,0.5526262050544066,0.006310038331338026
-Cambrian,19000,infovqa_val_anls,0.21937034023427093,0.006858602078113178
-Cambrian,19000,mme_total_score,1269.9476790716285,
-Cambrian,19000,mmmu_val_mmmu_acc,0.28556,
-Cambrian,19000,mmstar_average,0.3314266960826673,
-Cambrian,19000,ocrbench_ocrbench_accuracy,0.404,
-Cambrian,19000,seedbench_seed_all,0.5465814341300722,
-Cambrian,19000,textvqa_val_exact_match,0.51512,0.006773909823053313
-Cambrian,20000,ai2d_exact_match,0.45531088082901555,0.008963137311190377
-Cambrian,20000,average,0.42817340693945505,
-Cambrian,20000,average_rank,2.4,
-Cambrian,20000,chartqa_relaxed_overall,0.5684,0.009907968668564455
-Cambrian,20000,docvqa_val_anls,0.549188563518089,0.006325944032596611
-Cambrian,20000,infovqa_val_anls,0.21755406764942647,0.0068363256354831885
-Cambrian,20000,mme_total_score,1290.6296518607442,
-Cambrian,20000,mmmu_val_mmmu_acc,0.28444,
-Cambrian,20000,mmstar_average,0.32485343172593534,
-Cambrian,20000,ocrbench_ocrbench_accuracy,0.392,
-Cambrian,20000,seedbench_seed_all,0.5486937187326293,
-Cambrian,20000,textvqa_val_exact_match,0.51312,0.006789609184524225
-LLaVa,1000,ai2d_exact_match,0.25777202072538863,0.007872600874396432
-LLaVa,1000,average,0.2581360512843851,
-LLaVa,1000,average_rank,3.0,
-LLaVa,1000,chartqa_relaxed_overall,0.1576,0.007288768514542319
-LLaVa,1000,docvqa_val_anls,0.2850280465017524,0.005237571860745478
-LLaVa,1000,infovqa_val_anls,0.15291302898150733,0.005597827181699182
-LLaVa,1000,mme_total_score,844.0894357743098,
-LLaVa,1000,mmmu_val_mmmu_acc,0.25333,
-LLaVa,1000,mmstar_average,0.22969486173769915,
-LLaVa,1000,ocrbench_ocrbench_accuracy,0.35,
-LLaVa,1000,seedbench_seed_all,0.2717065036131184,
-LLaVa,1000,textvqa_val_exact_match,0.36518,0.006561838543046682
-LLaVa,2000,ai2d_exact_match,0.24676165803108807,0.007759553547248649
-LLaVa,2000,average,0.28023175511348764,
-LLaVa,2000,average_rank,3.2,
-LLaVa,2000,chartqa_relaxed_overall,0.19,0.007847587772910948
-LLaVa,2000,docvqa_val_anls,0.31839133336930814,0.005353711170722305
-LLaVa,2000,infovqa_val_anls,0.1625232406439703,0.005680709103352321
-LLaVa,2000,mme_total_score,677.0834333733493,
-LLaVa,2000,mmmu_val_mmmu_acc,0.25111,
-LLaVa,2000,mmstar_average,0.2602226545829147,
-LLaVa,2000,ocrbench_ocrbench_accuracy,0.389,
-LLaVa,2000,seedbench_seed_all,0.2864369093941078,
-LLaVa,2000,textvqa_val_exact_match,0.41764000000000007,0.006695635323587844
-LLaVa,3000,ai2d_exact_match,0.31541450777202074,0.00836346730591157
-LLaVa,3000,average,0.3241247472461608,
-LLaVa,3000,average_rank,3.1,
-LLaVa,3000,chartqa_relaxed_overall,0.2048,0.008072722684486087
-LLaVa,3000,docvqa_val_anls,0.33927313841893186,0.005424261898744584
-LLaVa,3000,infovqa_val_anls,0.17400826017663457,0.005878416771815313
-LLaVa,3000,mme_total_score,674.5895358143258,
-LLaVa,3000,mmmu_val_mmmu_acc,0.27778,
-LLaVa,3000,mmstar_average,0.28839612401739867,
-LLaVa,3000,ocrbench_ocrbench_accuracy,0.428,
-LLaVa,3000,seedbench_seed_all,0.4512506948304614,
-LLaVa,3000,textvqa_val_exact_match,0.4382,0.006743326070219196
-LLaVa,4000,ai2d_exact_match,0.30667098445595853,0.008299228398743067
-LLaVa,4000,average,0.34151562451124173,
-LLaVa,4000,average_rank,2.8,
-LLaVa,4000,chartqa_relaxed_overall,0.2168,0.00824295350666284
-LLaVa,4000,docvqa_val_anls,0.36894439928615425,0.005583877165382837
-LLaVa,4000,infovqa_val_anls,0.1815741433661475,0.005975096001960774
-LLaVa,4000,mme_total_score,660.3387354941976,
-LLaVa,4000,mmmu_val_mmmu_acc,0.29444,
-LLaVa,4000,mmstar_average,0.3089940618086463,
-LLaVa,4000,ocrbench_ocrbench_accuracy,0.439,
-LLaVa,4000,seedbench_seed_all,0.48265703168426904,
-LLaVa,4000,textvqa_val_exact_match,0.4745599999999999,0.006778004835488831
-LLaVa,5000,ai2d_exact_match,0.3176813471502591,0.00837955903737489
-LLaVa,5000,average,0.3488971740226244,
-LLaVa,5000,average_rank,2.9,
-LLaVa,5000,chartqa_relaxed_overall,0.2076,0.008113397986710395
-LLaVa,5000,docvqa_val_anls,0.37667351380566144,0.005504553709162657
-LLaVa,5000,infovqa_val_anls,0.19157302816202296,0.006066754825254386
-LLaVa,5000,mme_total_score,596.045218087235,
-LLaVa,5000,mmmu_val_mmmu_acc,0.28889,
-LLaVa,5000,mmstar_average,0.30911460927022283,
-LLaVa,5000,ocrbench_ocrbench_accuracy,0.471,
-LLaVa,5000,seedbench_seed_all,0.49972206781545303,
-LLaVa,5000,textvqa_val_exact_match,0.47781999999999997,0.00678922884027701
-LLaVa,6000,ai2d_exact_match,0.3626943005181347,0.00865318426683941
-LLaVa,6000,average,0.35336013036474917,
-LLaVa,6000,average_rank,3.3,
-LLaVa,6000,chartqa_relaxed_overall,0.2164,0.00823744852629073
-LLaVa,6000,docvqa_val_anls,0.3796381971300078,0.005512363416378596
-LLaVa,6000,infovqa_val_anls,0.1911083172357537,0.00606756561226675
-LLaVa,6000,mme_total_score,751.7179871948779,
-LLaVa,6000,mmmu_val_mmmu_acc,0.27111,
-LLaVa,6000,mmstar_average,0.3230226430014031,
-LLaVa,6000,ocrbench_ocrbench_accuracy,0.471,
-LLaVa,6000,seedbench_seed_all,0.49788771539744303,
-LLaVa,6000,textvqa_val_exact_match,0.46738,0.006777431212101451
-LLaVa,7000,ai2d_exact_match,0.3636658031088083,0.008658158841882565
-LLaVa,7000,average,0.36232264653787655,
-LLaVa,7000,average_rank,3.4,
-LLaVa,7000,chartqa_relaxed_overall,0.2276,0.00838733777631434
-LLaVa,7000,docvqa_val_anls,0.38862032747814834,0.005554025202613156
-LLaVa,7000,infovqa_val_anls,0.1987523491607365,0.006169459873730798
-LLaVa,7000,mme_total_score,700.0341136454582,
-LLaVa,7000,mmmu_val_mmmu_acc,0.28,
-LLaVa,7000,mmstar_average,0.32238002502982693,
-LLaVa,7000,ocrbench_ocrbench_accuracy,0.469,
-LLaVa,7000,seedbench_seed_all,0.5175653140633686,
-LLaVa,7000,textvqa_val_exact_match,0.49332,0.006784414578741135
-LLaVa,8000,ai2d_exact_match,0.38244818652849744,0.008746910624026853
-LLaVa,8000,average,0.36916094621046264,
-LLaVa,8000,average_rank,2.8,
-LLaVa,8000,chartqa_relaxed_overall,0.2276,0.00838733777631434
-LLaVa,8000,docvqa_val_anls,0.4000384036155175,0.005647492303754258
-LLaVa,8000,infovqa_val_anls,0.20267340215584623,0.006186451136703468
-LLaVa,8000,mme_total_score,787.0998399359744,
-LLaVa,8000,mmmu_val_mmmu_acc,0.28333,
-LLaVa,8000,mmstar_average,0.33877512170436386,
-LLaVa,8000,ocrbench_ocrbench_accuracy,0.47,
-LLaVa,8000,seedbench_seed_all,0.5221234018899389,
-LLaVa,8000,textvqa_val_exact_match,0.49546,0.006796875545678079
-LLaVa,9000,ai2d_exact_match,0.3856865284974093,0.008760803506529557
-LLaVa,9000,average,0.3660729124456708,
-LLaVa,9000,average_rank,3.0,
-LLaVa,9000,chartqa_relaxed_overall,0.2212,0.00830275847651416
-LLaVa,9000,docvqa_val_anls,0.3961556104365206,0.005555787005997977
-LLaVa,9000,infovqa_val_anls,0.20795411138332273,0.006302696156883479
-LLaVa,9000,mme_total_score,697.6510604241697,
-LLaVa,9000,mmmu_val_mmmu_acc,0.27444,
-LLaVa,9000,mmstar_average,0.33019217959261743,
-LLaVa,9000,ocrbench_ocrbench_accuracy,0.47,
-LLaVa,9000,seedbench_seed_all,0.5140077821011673,
-LLaVa,9000,textvqa_val_exact_match,0.49501999999999996,0.006795224421237829
-LLaVa,10000,ai2d_exact_match,0.3636658031088083,0.008658158841882561
-LLaVa,10000,average,0.36465272894871764,
-LLaVa,10000,average_rank,3.1,
-LLaVa,10000,chartqa_relaxed_overall,0.2216,0.008308127706914342
-LLaVa,10000,docvqa_val_anls,0.3905169927438113,0.005559588309122447
-LLaVa,10000,infovqa_val_anls,0.210842797817216,0.0062742161273205005
-LLaVa,10000,mme_total_score,710.1757703081232,
-LLaVa,10000,mmmu_val_mmmu_acc,0.25667,
-LLaVa,10000,mmstar_average,0.33485115141559363,
-LLaVa,10000,ocrbench_ocrbench_accuracy,0.484,
-LLaVa,10000,seedbench_seed_all,0.5220678154530295,
-LLaVa,10000,textvqa_val_exact_match,0.49766000000000005,0.0067820722630208075
-LLaVa,11000,ai2d_exact_match,0.3539507772020725,0.008606685322379343
-LLaVa,11000,average,0.3619647158138698,
-LLaVa,11000,average_rank,3.3,
-LLaVa,11000,chartqa_relaxed_overall,0.226,0.008366456779283321
-LLaVa,11000,docvqa_val_anls,0.39615321520069524,0.0055548098783566
-LLaVa,11000,infovqa_val_anls,0.20231707967850712,0.006189706400735626
-LLaVa,11000,mme_total_score,620.8629451780713,
-LLaVa,11000,mmmu_val_mmmu_acc,0.26778,
-LLaVa,11000,mmstar_average,0.3504522318333254,
-LLaVa,11000,ocrbench_ocrbench_accuracy,0.48,
-LLaVa,11000,seedbench_seed_all,0.5084491384102279,
-LLaVa,11000,textvqa_val_exact_match,0.47257999999999994,0.0067942373414689025
-LLaVa,12000,ai2d_exact_match,0.3963730569948187,0.008803757198545707
-LLaVa,12000,average,0.36835635606525785,
-LLaVa,12000,average_rank,3.1,
-LLaVa,12000,chartqa_relaxed_overall,0.234,0.008469137530835504
-LLaVa,12000,docvqa_val_anls,0.3998087503562603,0.005606788206948343
-LLaVa,12000,infovqa_val_anls,0.19486992137918643,0.006137557366661157
-LLaVa,12000,mme_total_score,707.7871148459384,
-LLaVa,12000,mmmu_val_mmmu_acc,0.26444,
-LLaVa,12000,mmstar_average,0.34510216846405867,
-LLaVa,12000,ocrbench_ocrbench_accuracy,0.466,
-LLaVa,12000,seedbench_seed_all,0.5159533073929962,
-LLaVa,12000,textvqa_val_exact_match,0.49866000000000005,0.006787787245571138
-LLaVa,13000,ai2d_exact_match,0.37661917098445596,0.008720866089740391
-LLaVa,13000,average,0.3660925061677603,
-LLaVa,13000,average_rank,3.2,
-LLaVa,13000,chartqa_relaxed_overall,0.23,0.008418334000200726
-LLaVa,13000,docvqa_val_anls,0.39678037656395876,0.005562201990102385
-LLaVa,13000,infovqa_val_anls,0.20007389352596994,0.006181717086032354
-LLaVa,13000,mme_total_score,762.4510804321728,
-LLaVa,13000,mmmu_val_mmmu_acc,0.26111,
-LLaVa,13000,mmstar_average,0.3487764851969923,
-LLaVa,13000,ocrbench_ocrbench_accuracy,0.487,
-LLaVa,13000,seedbench_seed_all,0.5187326292384659,
-LLaVa,13000,textvqa_val_exact_match,0.47573999999999994,0.006786037174972445
-LLaVa,14000,ai2d_exact_match,0.40382124352331605,0.008831094143874325
-LLaVa,14000,average,0.3665520961603681,
-LLaVa,14000,average_rank,3.5,
-LLaVa,14000,chartqa_relaxed_overall,0.224,0.0083401092900026
-LLaVa,14000,docvqa_val_anls,0.39653795108545226,0.0055480083540036754
-LLaVa,14000,infovqa_val_anls,0.1966338205713239,0.006145830112184984
-LLaVa,14000,mme_total_score,648.8810524209684,
-LLaVa,14000,mmmu_val_mmmu_acc,0.27222,
-LLaVa,14000,mmstar_average,0.3348780070169728,
-LLaVa,14000,ocrbench_ocrbench_accuracy,0.482,
-LLaVa,14000,seedbench_seed_all,0.5121178432462479,
-LLaVa,14000,textvqa_val_exact_match,0.47676,0.006784540255411228
-LLaVa,15000,ai2d_exact_match,0.38374352331606215,0.008752516998880439
-LLaVa,15000,average,0.3656314014070533,
-LLaVa,15000,average_rank,3.3,
-LLaVa,15000,chartqa_relaxed_overall,0.222,0.008313485768211027
-LLaVa,15000,docvqa_val_anls,0.3956148602850384,0.005571289516040145
-LLaVa,15000,infovqa_val_anls,0.2003939669503818,0.006205919365204143
-LLaVa,15000,mme_total_score,744.8995598239295,
-LLaVa,15000,mmmu_val_mmmu_acc,0.25111,
-LLaVa,15000,mmstar_average,0.34431451447442113,
-LLaVa,15000,ocrbench_ocrbench_accuracy,0.491,
-LLaVa,15000,seedbench_seed_all,0.5223457476375765,
-LLaVa,15000,textvqa_val_exact_match,0.48016000000000003,0.006780152577471598
-LLaVa,16000,ai2d_exact_match,0.38244818652849744,0.008746910624026851
-LLaVa,16000,average,0.3664952284054124,
-LLaVa,16000,average_rank,3.1,
-LLaVa,16000,chartqa_relaxed_overall,0.2272,0.008382133861209024
-LLaVa,16000,docvqa_val_anls,0.3971604594021061,0.005596507964441207
-LLaVa,16000,infovqa_val_anls,0.20130541865614268,0.006177273754737603
-LLaVa,16000,mme_total_score,741.5084033613446,
-LLaVa,16000,mmmu_val_mmmu_acc,0.25444,
-LLaVa,16000,mmstar_average,0.34322789378570057,
-LLaVa,16000,ocrbench_ocrbench_accuracy,0.488,
-LLaVa,16000,seedbench_seed_all,0.5151750972762645,
-LLaVa,16000,textvqa_val_exact_match,0.4895,0.0067890182024819105
-LLaVa,17000,ai2d_exact_match,0.36852331606217614,0.008682460781863906
-LLaVa,17000,average,0.3659850040618015,
-LLaVa,17000,average_rank,3.0,
-LLaVa,17000,chartqa_relaxed_overall,0.2264,0.008371693383064148
-LLaVa,17000,docvqa_val_anls,0.3895535425900796,0.005559420230793686
-LLaVa,17000,infovqa_val_anls,0.19870913061640477,0.0061833458200064835
-LLaVa,17000,mme_total_score,738.0654261704681,
-LLaVa,17000,mmmu_val_mmmu_acc,0.27667,
-LLaVa,17000,mmstar_average,0.3488362957589257,
-LLaVa,17000,ocrbench_ocrbench_accuracy,0.486,
-LLaVa,17000,seedbench_seed_all,0.514952751528627,
-LLaVa,17000,textvqa_val_exact_match,0.48422,0.006797929147037179
-LLaVa,18000,ai2d_exact_match,0.3785621761658031,0.008729696327646351
-LLaVa,18000,average,0.3667559662544118,
-LLaVa,18000,average_rank,3.1,
-LLaVa,18000,chartqa_relaxed_overall,0.2268,0.008376919070233621
-LLaVa,18000,docvqa_val_anls,0.39054490192374947,0.005557124380968682
-LLaVa,18000,infovqa_val_anls,0.19983100041999644,0.006171606410532323
-LLaVa,18000,mme_total_score,746.5269107643057,
-LLaVa,18000,mmmu_val_mmmu_acc,0.27,
-LLaVa,18000,mmstar_average,0.3522401814266279,
-LLaVa,18000,ocrbench_ocrbench_accuracy,0.497,
-LLaVa,18000,seedbench_seed_all,0.5137854363535297,
-LLaVa,18000,textvqa_val_exact_match,0.47203999999999996,0.006793178720998519
-LLaVa,19000,ai2d_exact_match,0.3707901554404145,0.008693477555877339
-LLaVa,19000,average,0.3627892845719615,
-LLaVa,19000,average_rank,3.2,
-LLaVa,19000,chartqa_relaxed_overall,0.2284,0.008397713059747491
-LLaVa,19000,docvqa_val_anls,0.3886627325813464,0.005572189741680524
-LLaVa,19000,infovqa_val_anls,0.18766806187395813,0.006047287494792444
-LLaVa,19000,mme_total_score,735.0644257703082,
-LLaVa,19000,mmmu_val_mmmu_acc,0.27556,
-LLaVa,19000,mmstar_average,0.34617955399790473,
-LLaVa,19000,ocrbench_ocrbench_accuracy,0.487,
-LLaVa,19000,seedbench_seed_all,0.50550305725403,
-LLaVa,19000,textvqa_val_exact_match,0.47534,0.00678734045691651
-LLaVa,20000,ai2d_exact_match,0.3746761658031088,0.008711886524907501
-LLaVa,20000,average,0.3636232406961286,
-LLaVa,20000,average_rank,3.3,
-LLaVa,20000,chartqa_relaxed_overall,0.2224,0.00831883268198588
-LLaVa,20000,docvqa_val_anls,0.3865323770909091,0.005551659686181904
-LLaVa,20000,infovqa_val_anls,0.1967140503390298,0.006138459642690392
-LLaVa,20000,mme_total_score,688.5517206882753,
-LLaVa,20000,mmmu_val_mmmu_acc,0.27556,
-LLaVa,20000,mmstar_average,0.3525069399025931,
-LLaVa,20000,ocrbench_ocrbench_accuracy,0.494,
-LLaVa,20000,seedbench_seed_all,0.5113396331295164,
-LLaVa,20000,textvqa_val_exact_match,0.45888,0.006775175991953595
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5e6173a1541b9798278da1729f1e357c0711d2e270f68aa4af8eae962f146dd
+size 53573

app/src/content/assets/data/all_ratings_luis.csv

@@ -1,1201 +1,3 @@
-run,step,metric,value,stderr
-Baseline,1000,ai2d_exact_match,0.2548575129533679,0.007843322436924496
-Baseline,1000,average,0.27120689295763617,
-Baseline,1000,average_rank,3.0,
-Baseline,1000,chartqa_relaxed_overall,0.3308,0.009411906161401973
-Baseline,1000,docvqa_val_anls,0.3528553494243383,0.005852289239342309
-Baseline,1000,infovqa_val_anls,0.17320578642581314,0.006297063452679795
-Baseline,1000,mme_total_score,977.4280712284914,
-Baseline,1000,mmmu_val_mmmu_acc,0.25222,
-Baseline,1000,mmstar_average,0.23215874078908072,
-Baseline,1000,ocrbench_ocrbench_accuracy,0.286,
-Baseline,1000,seedbench_seed_all,0.2563646470261256,
-Baseline,1000,textvqa_val_exact_match,0.3024,0.00628900296642181
-Baseline,2000,ai2d_exact_match,0.26295336787564766,0.007923526907377255
-Baseline,2000,average,0.3202068275596269,
-Baseline,2000,average_rank,2.8,
-Baseline,2000,chartqa_relaxed_overall,0.4688,0.009982508912777261
-Baseline,2000,docvqa_val_anls,0.4452261510942785,0.00614755494712251
-Baseline,2000,infovqa_val_anls,0.1820547866557169,0.006217861455795791
-Baseline,2000,mme_total_score,1049.3036214485794,
-Baseline,2000,mmmu_val_mmmu_acc,0.24556,
-Baseline,2000,mmstar_average,0.21305462434540698,
-Baseline,2000,ocrbench_ocrbench_accuracy,0.395,
-Baseline,2000,seedbench_seed_all,0.258532518065592,
-Baseline,2000,textvqa_val_exact_match,0.41068000000000005,0.006697862330024289
-Baseline,3000,ai2d_exact_match,0.25226683937823835,0.007816909588794397
-Baseline,3000,average,0.3507423834414229,
-Baseline,3000,average_rank,2.6,
-Baseline,3000,chartqa_relaxed_overall,0.5028,0.010001843767601082
-Baseline,3000,docvqa_val_anls,0.502653993831009,0.006267072346683124
-Baseline,3000,infovqa_val_anls,0.21728617578189535,0.006796941784959762
-Baseline,3000,mme_total_score,1170.2383953581434,
-Baseline,3000,mmmu_val_mmmu_acc,0.27556,
-Baseline,3000,mmstar_average,0.25432376938577683,
-Baseline,3000,ocrbench_ocrbench_accuracy,0.436,
-Baseline,3000,seedbench_seed_all,0.2792106725958866,
-Baseline,3000,textvqa_val_exact_match,0.43658,0.006766885462882726
-Baseline,4000,ai2d_exact_match,0.2645725388601036,0.007939149662089447
-Baseline,4000,average,0.36961781722974835,
-Baseline,4000,average_rank,2.8,
-Baseline,4000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-Baseline,4000,docvqa_val_anls,0.5374434618615119,0.0062905728113059655
-Baseline,4000,infovqa_val_anls,0.2287924838861707,0.006994568698639919
-Baseline,4000,mme_total_score,1155.203781512605,
-Baseline,4000,mmmu_val_mmmu_acc,0.25556,
-Baseline,4000,mmstar_average,0.2575590188757354,
-Baseline,4000,ocrbench_ocrbench_accuracy,0.453,
-Baseline,4000,seedbench_seed_all,0.33913285158421347,
-Baseline,4000,textvqa_val_exact_match,0.4593,0.006791695475025738
-Baseline,5000,ai2d_exact_match,0.3125,0.008342439145556371
-Baseline,5000,average,0.3974627910380972,
-Baseline,5000,average_rank,2.3,
-Baseline,5000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-Baseline,5000,docvqa_val_anls,0.552360266782429,0.006300308519952055
-Baseline,5000,infovqa_val_anls,0.23425555286643698,0.007002254622066442
-Baseline,5000,mme_total_score,1181.4653861544618,
-Baseline,5000,mmmu_val_mmmu_acc,0.26667,
-Baseline,5000,mmstar_average,0.29596648146165705,
-Baseline,5000,ocrbench_ocrbench_accuracy,0.462,
-Baseline,5000,seedbench_seed_all,0.43107281823235133,
-Baseline,5000,textvqa_val_exact_match,0.47354000000000007,0.0068172185364497985
-Baseline,6000,ai2d_exact_match,0.358160621761658,0.008629463221867162
-Baseline,6000,average,0.4161227404571003,
-Baseline,6000,average_rank,2.3,
-Baseline,6000,chartqa_relaxed_overall,0.5628,0.00992279440175477
-Baseline,6000,docvqa_val_anls,0.5747451497228876,0.00625495440870239
-Baseline,6000,infovqa_val_anls,0.22152017368968838,0.006604546680525351
-Baseline,6000,mme_total_score,1284.1648659463785,
-Baseline,6000,mmmu_val_mmmu_acc,0.27111,
-Baseline,6000,mmstar_average,0.2978489412854164,
-Baseline,6000,ocrbench_ocrbench_accuracy,0.495,
-Baseline,6000,seedbench_seed_all,0.4795997776542524,
-Baseline,6000,textvqa_val_exact_match,0.48432,0.006800535050670284
-Baseline,7000,ai2d_exact_match,0.3707901554404145,0.00869347755587734
-Baseline,7000,average,0.4291083177345374,
-Baseline,7000,average_rank,2.1,
-Baseline,7000,chartqa_relaxed_overall,0.5656,0.009915542506251351
-Baseline,7000,docvqa_val_anls,0.5940907049431567,0.006224236305767187
-Baseline,7000,infovqa_val_anls,0.2515675215816963,0.007105097396092786
-Baseline,7000,mme_total_score,1185.875650260104,
-Baseline,7000,mmmu_val_mmmu_acc,0.26556,
-Baseline,7000,mmstar_average,0.31372400960777047,
-Baseline,7000,ocrbench_ocrbench_accuracy,0.504,
-Baseline,7000,seedbench_seed_all,0.4964424680377988,
-Baseline,7000,textvqa_val_exact_match,0.5002,0.006794794025220267
-Baseline,8000,ai2d_exact_match,0.37759067357512954,0.008725299846043883
-Baseline,8000,average,0.43846759477995995,
-Baseline,8000,average_rank,1.9,
-Baseline,8000,chartqa_relaxed_overall,0.5832,0.009862556058385773
-Baseline,8000,docvqa_val_anls,0.6017336419437208,0.006231612198089698
-Baseline,8000,infovqa_val_anls,0.2449256624147254,0.006992518502948913
-Baseline,8000,mme_total_score,1199.2409963985594,
-Baseline,8000,mmmu_val_mmmu_acc,0.28111,
-Baseline,8000,mmstar_average,0.33512257186205047,
-Baseline,8000,ocrbench_ocrbench_accuracy,0.51,
-Baseline,8000,seedbench_seed_all,0.5024458032240133,
-Baseline,8000,textvqa_val_exact_match,0.51008,0.006796301690135059
-Baseline,9000,ai2d_exact_match,0.4067357512953368,0.008841214921078996
-Baseline,9000,average,0.4422510732201056,
-Baseline,9000,average_rank,2.5,
-Baseline,9000,chartqa_relaxed_overall,0.5912,0.009834211136815875
-Baseline,9000,docvqa_val_anls,0.6170968481662739,0.00617235763542544
-Baseline,9000,infovqa_val_anls,0.23537031288570615,0.00670318154156447
-Baseline,9000,mme_total_score,1231.5195078031213,
-Baseline,9000,mmmu_val_mmmu_acc,0.25889,
-Baseline,9000,mmstar_average,0.3216444898242951,
-Baseline,9000,ocrbench_ocrbench_accuracy,0.515,
-Baseline,9000,seedbench_seed_all,0.5120622568093385,
-Baseline,9000,textvqa_val_exact_match,0.52226,0.006792711289708482
-Baseline,10000,ai2d_exact_match,0.39993523316062174,0.008817096257082848
-Baseline,10000,average,0.4523875703250908,
-Baseline,10000,average_rank,1.9,
-Baseline,10000,chartqa_relaxed_overall,0.5996,0.00980154906867574
-Baseline,10000,docvqa_val_anls,0.6262613496433054,0.006147756371688175
-Baseline,10000,infovqa_val_anls,0.263290074230132,0.007186788766942786
-Baseline,10000,mme_total_score,1240.8218287314926,
-Baseline,10000,mmmu_val_mmmu_acc,0.28778,
-Baseline,10000,mmstar_average,0.32972717906018517,
-Baseline,10000,ocrbench_ocrbench_accuracy,0.517,
-Baseline,10000,seedbench_seed_all,0.5217342968315731,
-Baseline,10000,textvqa_val_exact_match,0.5261600000000001,0.006785774843600811
-Baseline,11000,ai2d_exact_match,0.422279792746114,0.008889771831066474
-Baseline,11000,average,0.4561398159525099,
-Baseline,11000,average_rank,2.3,
-Baseline,11000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-Baseline,11000,docvqa_val_anls,0.6373130149166712,0.006128022584995044
-Baseline,11000,infovqa_val_anls,0.24419378339723755,0.006897644885887063
-Baseline,11000,mme_total_score,1322.9488795518205,
-Baseline,11000,mmmu_val_mmmu_acc,0.27778,
-Baseline,11000,mmstar_average,0.3298563439522548,
-Baseline,11000,ocrbench_ocrbench_accuracy,0.521,
-Baseline,11000,seedbench_seed_all,0.5237354085603113,
-Baseline,11000,textvqa_val_exact_match,0.5387,0.006770851562852138
-Baseline,12000,ai2d_exact_match,0.42001295336787564,0.008883255931688034
-Baseline,12000,average,0.4582751140055433,
-Baseline,12000,average_rank,2.4,
-Baseline,12000,chartqa_relaxed_overall,0.618,0.009719474639861454
-Baseline,12000,docvqa_val_anls,0.6393961983751871,0.0061228747388476674
-Baseline,12000,infovqa_val_anls,0.24798874058574302,0.006855374548993139
-Baseline,12000,mme_total_score,1225.6453581432572,
-Baseline,12000,mmmu_val_mmmu_acc,0.27889,
-Baseline,12000,mmstar_average,0.34010867846816534,
-Baseline,12000,ocrbench_ocrbench_accuracy,0.512,
-Baseline,12000,seedbench_seed_all,0.5350194552529183,
-Baseline,12000,textvqa_val_exact_match,0.5330600000000001,0.006777713092109446
-Baseline,13000,ai2d_exact_match,0.4375,0.008928571428571428
-Baseline,13000,average,0.4692868662590049,
-Baseline,13000,average_rank,1.7,
-Baseline,13000,chartqa_relaxed_overall,0.6148,0.00973479791861169
-Baseline,13000,docvqa_val_anls,0.6511374872549951,0.006086953065248391
-Baseline,13000,infovqa_val_anls,0.24465055100441893,0.006808432538374664
-Baseline,13000,mme_total_score,1281.7122849139657,
-Baseline,13000,mmmu_val_mmmu_acc,0.28222,
-Baseline,13000,mmstar_average,0.3453069542917521,
-Baseline,13000,ocrbench_ocrbench_accuracy,0.549,
-Baseline,13000,seedbench_seed_all,0.5442468037798777,
-Baseline,13000,textvqa_val_exact_match,0.55472,0.0067416788982325
-Baseline,14000,ai2d_exact_match,0.4572538860103627,0.00896620675297095
-Baseline,14000,average,0.47352486841689195,
-Baseline,14000,average_rank,1.9,
-Baseline,14000,chartqa_relaxed_overall,0.6172,0.009723347231923635
-Baseline,14000,docvqa_val_anls,0.6502269393708169,0.006057950730638126
-Baseline,14000,infovqa_val_anls,0.25805460837190913,0.007037735231659539
-Baseline,14000,mme_total_score,1309.1444577831132,
-Baseline,14000,mmmu_val_mmmu_acc,0.28111,
-Baseline,14000,mmstar_average,0.34575818188776586,
-Baseline,14000,ocrbench_ocrbench_accuracy,0.551,
-Baseline,14000,seedbench_seed_all,0.5483602001111729,
-Baseline,14000,textvqa_val_exact_match,0.55276,0.006751206724612103
-Baseline,15000,ai2d_exact_match,0.45045336787564766,0.008954861634252399
-Baseline,15000,average,0.47878665012878824,
-Baseline,15000,average_rank,1.4,
-Baseline,15000,chartqa_relaxed_overall,0.612,0.009747841205275417
-Baseline,15000,docvqa_val_anls,0.6621413031955148,0.006056838050222495
-Baseline,15000,infovqa_val_anls,0.2706898598157733,0.007200315730154543
-Baseline,15000,mme_total_score,1384.2171868747498,
-Baseline,15000,mmmu_val_mmmu_acc,0.30222,
-Baseline,15000,mmstar_average,0.35408135695920684,
-Baseline,15000,ocrbench_ocrbench_accuracy,0.558,
-Baseline,15000,seedbench_seed_all,0.5411339633129516,
-Baseline,15000,textvqa_val_exact_match,0.5583600000000001,0.0067279027203879065
-Baseline,16000,ai2d_exact_match,0.45077720207253885,0.008955440137395838
-Baseline,16000,average,0.47665128022935843,
-Baseline,16000,average_rank,2.1,
-Baseline,16000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,16000,docvqa_val_anls,0.6709415729142987,0.005999818105621502
-Baseline,16000,infovqa_val_anls,0.26050032542402035,0.006997451875879188
-Baseline,16000,mme_total_score,1317.8491396558625,
-Baseline,16000,mmmu_val_mmmu_acc,0.27556,
-Baseline,16000,mmstar_average,0.33214333327093315,
-Baseline,16000,ocrbench_ocrbench_accuracy,0.56,
-Baseline,16000,seedbench_seed_all,0.5463590883824346,
-Baseline,16000,textvqa_val_exact_match,0.56158,0.006723854754867398
-Baseline,17000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-Baseline,17000,average,0.4777141780162423,
-Baseline,17000,average_rank,1.8,
-Baseline,17000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,17000,docvqa_val_anls,0.6796338519136422,0.005948761388267941
-Baseline,17000,infovqa_val_anls,0.28070956072505215,0.007298333094144192
-Baseline,17000,mme_total_score,1381.9161664665867,
-Baseline,17000,mmmu_val_mmmu_acc,0.27667,
-Baseline,17000,mmstar_average,0.3370289492329521,
-Baseline,17000,ocrbench_ocrbench_accuracy,0.519,
-Baseline,17000,seedbench_seed_all,0.5510283490828238,
-Baseline,17000,textvqa_val_exact_match,0.56416,0.006724830373229479
-Baseline,18000,ai2d_exact_match,0.46567357512953367,0.008977921602780726
-Baseline,18000,average,0.4819834595278701,
-Baseline,18000,average_rank,1.6,
-Baseline,18000,chartqa_relaxed_overall,0.6376,0.009615793331418735
-Baseline,18000,docvqa_val_anls,0.6775884603912571,0.005972234236435759
-Baseline,18000,infovqa_val_anls,0.27154318420389256,0.007164903131667027
-Baseline,18000,mme_total_score,1336.922769107643,
-Baseline,18000,mmmu_val_mmmu_acc,0.28667,
-Baseline,18000,mmstar_average,0.34482796716566916,
-Baseline,18000,ocrbench_ocrbench_accuracy,0.533,
-Baseline,18000,seedbench_seed_all,0.5543079488604781,
-Baseline,18000,textvqa_val_exact_match,0.5666399999999999,0.006713392287599574
-Baseline,19000,ai2d_exact_match,0.4682642487046632,0.008981008686994101
-Baseline,19000,average,0.4899006713916878,
-Baseline,19000,average_rank,1.4,
-Baseline,19000,chartqa_relaxed_overall,0.6444,0.009575809858898698
-Baseline,19000,docvqa_val_anls,0.678226526479947,0.005970619221588814
-Baseline,19000,infovqa_val_anls,0.26993847247278,0.0071348470764911525
-Baseline,19000,mme_total_score,1406.6628651460583,
-Baseline,19000,mmmu_val_mmmu_acc,0.28333,
-Baseline,19000,mmstar_average,0.356220913822775,
-Baseline,19000,ocrbench_ocrbench_accuracy,0.577,
-Baseline,19000,seedbench_seed_all,0.554585881045025,
-Baseline,19000,textvqa_val_exact_match,0.57714,0.0066918487914812905
-Baseline,20000,ai2d_exact_match,0.47571243523316065,0.00898853090258662
-Baseline,20000,average,0.4873169067639118,
-Baseline,20000,average_rank,1.4,
-Baseline,20000,chartqa_relaxed_overall,0.6336,0.009638338810708618
-Baseline,20000,docvqa_val_anls,0.6895214454380043,0.005896462073053767
-Baseline,20000,infovqa_val_anls,0.2655657550458317,0.007033265532032538
-Baseline,20000,mme_total_score,1324.6738695478193,
-Baseline,20000,mmmu_val_mmmu_acc,0.30111,
-Baseline,20000,mmstar_average,0.33806766134497995,
-Baseline,20000,ocrbench_ocrbench_accuracy,0.555,
-Baseline,20000,seedbench_seed_all,0.5587548638132296,
-Baseline,20000,textvqa_val_exact_match,0.56852,0.006720151338087659
-≥2,1000,ai2d_exact_match,0.27331606217616583,0.008021157484423315
-≥2,1000,average,0.2964817591841572,
-≥2,1000,average_rank,2.0,
-≥2,1000,chartqa_relaxed_overall,0.4016,0.009806398022560107
-≥2,1000,docvqa_val_anls,0.38703197724603455,0.0059317827343935035
-≥2,1000,infovqa_val_anls,0.17280000404070578,0.006201144732918485
-≥2,1000,mme_total_score,961.9496798719488,
-≥2,1000,mmmu_val_mmmu_acc,0.27556,
-≥2,1000,mmstar_average,0.20051212493658782,
-≥2,1000,ocrbench_ocrbench_accuracy,0.331,
-≥2,1000,seedbench_seed_all,0.25219566425792106,
-≥2,1000,textvqa_val_exact_match,0.37432,0.006614110432353112
-≥2,2000,ai2d_exact_match,0.27428756476683935,0.008030027397236182
-≥2,2000,average,0.3376151239444176,
-≥2,2000,average_rank,1.8,
-≥2,2000,chartqa_relaxed_overall,0.4984,0.010001949389825897
-≥2,2000,docvqa_val_anls,0.47035044389194575,0.006171152822696564
-≥2,2000,infovqa_val_anls,0.21264444578610614,0.006798221032077756
-≥2,2000,mme_total_score,995.0442176870747,
-≥2,2000,mmmu_val_mmmu_acc,0.26111,
-≥2,2000,mmstar_average,0.2371410151404708,
-≥2,2000,ocrbench_ocrbench_accuracy,0.386,
-≥2,2000,seedbench_seed_all,0.27276264591439686,
-≥2,2000,textvqa_val_exact_match,0.42583999999999994,0.006752390527477444
-≥2,3000,ai2d_exact_match,0.28886010362694303,0.008157423105367313
-≥2,3000,average,0.3650476191493284,
-≥2,3000,average_rank,2.1,
-≥2,3000,chartqa_relaxed_overall,0.5296,0.009984458511341809
-≥2,3000,docvqa_val_anls,0.5084048093337913,0.006266409805144786
-≥2,3000,infovqa_val_anls,0.226696840609911,0.0070183318907300766
-≥2,3000,mme_total_score,966.6394557823129,
-≥2,3000,mmmu_val_mmmu_acc,0.27556,
-≥2,3000,mmstar_average,0.25798680765602255,
-≥2,3000,ocrbench_ocrbench_accuracy,0.423,
-≥2,3000,seedbench_seed_all,0.3360200111172874,
-≥2,3000,textvqa_val_exact_match,0.4393,0.0067683280101374045
-≥2,4000,ai2d_exact_match,0.3180051813471503,0.00838183912252989
-≥2,4000,average,0.3939919625964655,
-≥2,4000,average_rank,2.0,
-≥2,4000,chartqa_relaxed_overall,0.5392,0.009971214271372281
-≥2,4000,docvqa_val_anls,0.5318426170932731,0.006287567577266625
-≥2,4000,infovqa_val_anls,0.24176968468370258,0.007226680233814427
-≥2,4000,mme_total_score,1052.9128651460585,
-≥2,4000,mmmu_val_mmmu_acc,0.27778,
-≥2,4000,mmstar_average,0.30433696178936676,
-≥2,4000,ocrbench_ocrbench_accuracy,0.447,
-≥2,4000,seedbench_seed_all,0.42779321845469703,
-≥2,4000,textvqa_val_exact_match,0.4581999999999999,0.006800867765254084
-≥2,5000,ai2d_exact_match,0.3448834196891192,0.008555140353607655
-≥2,5000,average,0.40963271881608265,
-≥2,5000,average_rank,2.1,
-≥2,5000,chartqa_relaxed_overall,0.548,0.009955804699716018
-≥2,5000,docvqa_val_anls,0.575799913178854,0.006211088978189562
-≥2,5000,infovqa_val_anls,0.25711323262099633,0.0073775881337487925
-≥2,5000,mme_total_score,1010.4850940376151,
-≥2,5000,mmmu_val_mmmu_acc,0.27667,
-≥2,5000,mmstar_average,0.2871021117490485,
-≥2,5000,ocrbench_ocrbench_accuracy,0.455,
-≥2,5000,seedbench_seed_all,0.46642579210672597,
-≥2,5000,textvqa_val_exact_match,0.4757,0.006785477915527278
-≥2,6000,ai2d_exact_match,0.3795336787564767,0.008734055590837087
-≥2,6000,average,0.423161039572533,
-≥2,6000,average_rank,1.4,
-≥2,6000,chartqa_relaxed_overall,0.5668,0.009912336039617753
-≥2,6000,docvqa_val_anls,0.5827000147792567,0.006217654063020532
-≥2,6000,infovqa_val_anls,0.24558020684647988,0.0071473774205313935
-≥2,6000,mme_total_score,1096.4623849539817,
-≥2,6000,mmmu_val_mmmu_acc,0.27222,
-≥2,6000,mmstar_average,0.3026938215293386,
-≥2,6000,ocrbench_ocrbench_accuracy,0.475,
-≥2,6000,seedbench_seed_all,0.49494163424124515,
-≥2,6000,textvqa_val_exact_match,0.4889799999999999,0.006798040496416463
-≥2,7000,ai2d_exact_match,0.3863341968911917,0.00876353292332671
-≥2,7000,average,0.43260201849012403,
-≥2,7000,average_rank,2.1,
-≥2,7000,chartqa_relaxed_overall,0.572,0.009897756626351943
-≥2,7000,docvqa_val_anls,0.5958889673096114,0.006197986096231253
-≥2,7000,infovqa_val_anls,0.24831461076228495,0.0071830066608344805
-≥2,7000,mme_total_score,1098.0422168867549,
-≥2,7000,mmmu_val_mmmu_acc,0.28333,
-≥2,7000,mmstar_average,0.31254705626181345,
-≥2,7000,ocrbench_ocrbench_accuracy,0.493,
-≥2,7000,seedbench_seed_all,0.5060033351862145,
-≥2,7000,textvqa_val_exact_match,0.496,0.006798444216786202
-≥2,8000,ai2d_exact_match,0.4025259067357513,0.00882649222855129
-≥2,8000,average,0.4423608272909927,
-≥2,8000,average_rank,2.1,
-≥2,8000,chartqa_relaxed_overall,0.5832,0.009862556058385773
-≥2,8000,docvqa_val_anls,0.6081292058298197,0.006190473638311687
-≥2,8000,infovqa_val_anls,0.25707448915865344,0.007179410853014501
-≥2,8000,mme_total_score,1100.4132653061224,
-≥2,8000,mmmu_val_mmmu_acc,0.28,
-≥2,8000,mmstar_average,0.3170263263849818,
-≥2,8000,ocrbench_ocrbench_accuracy,0.504,
-≥2,8000,seedbench_seed_all,0.5167315175097277,
-≥2,8000,textvqa_val_exact_match,0.5125600000000001,0.006790351320381798
-≥2,9000,ai2d_exact_match,0.4106217616580311,0.008854207883828036
-≥2,9000,average,0.4477239927349069,
-≥2,9000,average_rank,1.8,
-≥2,9000,chartqa_relaxed_overall,0.5884,0.009844437067525526
-≥2,9000,docvqa_val_anls,0.6233981201771228,0.006152789393932141
-≥2,9000,infovqa_val_anls,0.25099979430746866,0.006997337550850154
-≥2,9000,mme_total_score,1100.9423769507803,
-≥2,9000,mmmu_val_mmmu_acc,0.27778,
-≥2,9000,mmstar_average,0.3172130122236236,
-≥2,9000,ocrbench_ocrbench_accuracy,0.518,
-≥2,9000,seedbench_seed_all,0.5178432462479156,
-≥2,9000,textvqa_val_exact_match,0.5252600000000001,0.006790435073078627
-≥2,10000,ai2d_exact_match,0.41904145077720206,0.008880404559123598
-≥2,10000,average,0.450650749528602,
-≥2,10000,average_rank,2.2,
-≥2,10000,chartqa_relaxed_overall,0.5956,0.009817474681589429
-≥2,10000,docvqa_val_anls,0.6254308760372823,0.006142114135609194
-≥2,10000,infovqa_val_anls,0.23792853517114784,0.006776022015067822
-≥2,10000,mme_total_score,1157.0735294117646,
-≥2,10000,mmmu_val_mmmu_acc,0.27667,
-≥2,10000,mmstar_average,0.31479930233765546,
-≥2,10000,ocrbench_ocrbench_accuracy,0.53,
-≥2,10000,seedbench_seed_all,0.5238465814341301,
-≥2,10000,textvqa_val_exact_match,0.53254,0.006777862315178193
-≥2,11000,ai2d_exact_match,0.43555699481865284,0.008924095913829727
-≥2,11000,average,0.4613124059808435,
-≥2,11000,average_rank,1.8,
-≥2,11000,chartqa_relaxed_overall,0.5984,0.009806398022560106
-≥2,11000,docvqa_val_anls,0.6453200065413649,0.0060722869307158955
-≥2,11000,infovqa_val_anls,0.24059820801450565,0.006814633527776416
-≥2,11000,mme_total_score,1262.6299519807922,
-≥2,11000,mmmu_val_mmmu_acc,0.3,
-≥2,11000,mmstar_average,0.33559717819403534,
-≥2,11000,ocrbench_ocrbench_accuracy,0.527,
-≥2,11000,seedbench_seed_all,0.5226792662590328,
-≥2,11000,textvqa_val_exact_match,0.54666,0.0067526356704400645
-≥2,12000,ai2d_exact_match,0.44073834196891193,0.008935721506916777
-≥2,12000,average,0.46516707040731664,
-≥2,12000,average_rank,1.9,
-≥2,12000,chartqa_relaxed_overall,0.598,0.009808000752013664
-≥2,12000,docvqa_val_anls,0.6402481933825662,0.006107198073878916
-≥2,12000,infovqa_val_anls,0.2601009880983462,0.0070991293032872695
-≥2,12000,mme_total_score,1112.7142857142858,
-≥2,12000,mmmu_val_mmmu_acc,0.31,
-≥2,12000,mmstar_average,0.32603422027717016,
-≥2,12000,ocrbench_ocrbench_accuracy,0.547,
-≥2,12000,seedbench_seed_all,0.523401889938855,
-≥2,12000,textvqa_val_exact_match,0.54098,0.006767635340177507
-≥2,13000,ai2d_exact_match,0.44041450777202074,0.008935023865613881
-≥2,13000,average,0.46553651974650545,
-≥2,13000,average_rank,2.2,
-≥2,13000,chartqa_relaxed_overall,0.6092,0.009760545645634788
-≥2,13000,docvqa_val_anls,0.6433035796450283,0.006095519860378371
-≥2,13000,infovqa_val_anls,0.2594356954563223,0.007105630672634776
-≥2,13000,mme_total_score,1207.9944977991197,
-≥2,13000,mmmu_val_mmmu_acc,0.28111,
-≥2,13000,mmstar_average,0.3383640832831994,
-≥2,13000,ocrbench_ocrbench_accuracy,0.539,
-≥2,13000,seedbench_seed_all,0.5294608115619789,
-≥2,13000,textvqa_val_exact_match,0.5495399999999999,0.006753508692222968
-≥2,14000,ai2d_exact_match,0.44462435233160624,0.008943792697097361
-≥2,14000,average,0.46921726913331274,
-≥2,14000,average_rank,2.1,
-≥2,14000,chartqa_relaxed_overall,0.612,0.009747841205275417
-≥2,14000,docvqa_val_anls,0.65515509916543,0.006051151525703575
-≥2,14000,infovqa_val_anls,0.2677755343748415,0.007100955702899581
-≥2,14000,mme_total_score,1163.8374349739895,
-≥2,14000,mmmu_val_mmmu_acc,0.28556,
-≥2,14000,mmstar_average,0.32353974705611904,
-≥2,14000,ocrbench_ocrbench_accuracy,0.543,
-≥2,14000,seedbench_seed_all,0.5332406892718177,
-≥2,14000,textvqa_val_exact_match,0.55806,0.006725656411892758
-≥2,15000,ai2d_exact_match,0.44624352331606215,0.008946992176353901
-≥2,15000,average,0.4737967933693773,
-≥2,15000,average_rank,2.2,
-≥2,15000,chartqa_relaxed_overall,0.618,0.009719474639861454
-≥2,15000,docvqa_val_anls,0.6614354910767699,0.006013191753461033
-≥2,15000,infovqa_val_anls,0.26176573129112124,0.007093151287118967
-≥2,15000,mme_total_score,1229.438475390156,
-≥2,15000,mmmu_val_mmmu_acc,0.29556,
-≥2,15000,mmstar_average,0.32387576651370553,
-≥2,15000,ocrbench_ocrbench_accuracy,0.561,
-≥2,15000,seedbench_seed_all,0.5351306281267371,
-≥2,15000,textvqa_val_exact_match,0.56116,0.006722390124486763
-≥2,16000,ai2d_exact_match,0.4478626943005181,0.0089500956222288
-≥2,16000,average,0.4748174802839308,
-≥2,16000,average_rank,2.2,
-≥2,16000,chartqa_relaxed_overall,0.6192,0.009713613422114641
-≥2,16000,docvqa_val_anls,0.6585392720477772,0.0060616936904167125
-≥2,16000,infovqa_val_anls,0.2653830027853819,0.007108417358601188
-≥2,16000,mme_total_score,1157.8782513005203,
-≥2,16000,mmmu_val_mmmu_acc,0.29889,
-≥2,16000,mmstar_average,0.3217940710425999,
-≥2,16000,ocrbench_ocrbench_accuracy,0.561,
-≥2,16000,seedbench_seed_all,0.5349082823790995,
-≥2,16000,textvqa_val_exact_match,0.5657800000000001,0.006716429140851619
-≥2,17000,ai2d_exact_match,0.4540155440414508,0.00896101461327443
-≥2,17000,average,0.4765363782507968,
-≥2,17000,average_rank,2.2,
-≥2,17000,chartqa_relaxed_overall,0.6184,0.009717527882093043
-≥2,17000,docvqa_val_anls,0.6605538305641464,0.006048170352990264
-≥2,17000,infovqa_val_anls,0.27438351817158263,0.007183740557624646
-≥2,17000,mme_total_score,1231.31512605042,
-≥2,17000,mmmu_val_mmmu_acc,0.30111,
-≥2,17000,mmstar_average,0.3273406426639828,
-≥2,17000,ocrbench_ocrbench_accuracy,0.555,
-≥2,17000,seedbench_seed_all,0.5349638688160089,
-≥2,17000,textvqa_val_exact_match,0.5630599999999999,0.006726822229512349
-≥2,18000,ai2d_exact_match,0.4540155440414508,0.008961014613274428
-≥2,18000,average,0.4749977548559891,
-≥2,18000,average_rank,2.3,
-≥2,18000,chartqa_relaxed_overall,0.614,0.009738559226822298
-≥2,18000,docvqa_val_anls,0.6647865229953943,0.00602531683337989
-≥2,18000,infovqa_val_anls,0.26486387970800995,0.006977819681460442
-≥2,18000,mme_total_score,1245.188775510204,
-≥2,18000,mmmu_val_mmmu_acc,0.29222,
-≥2,18000,mmstar_average,0.32473355790957514,
-≥2,18000,ocrbench_ocrbench_accuracy,0.555,
-≥2,18000,seedbench_seed_all,0.5365202890494719,
-≥2,18000,textvqa_val_exact_match,0.56884,0.006699820027260398
-≥2,19000,ai2d_exact_match,0.45466321243523317,0.00896208360613934
-≥2,19000,average,0.4768734192584572,
-≥2,19000,average_rank,2.6,
-≥2,19000,chartqa_relaxed_overall,0.62,0.009709671008043154
-≥2,19000,docvqa_val_anls,0.6628357233664792,0.006042075311037487
-≥2,19000,infovqa_val_anls,0.2657171063652747,0.007078002720459511
-≥2,19000,mme_total_score,1248.7323929571828,
-≥2,19000,mmmu_val_mmmu_acc,0.28889,
-≥2,19000,mmstar_average,0.32802808302127334,
-≥2,19000,ocrbench_ocrbench_accuracy,0.565,
-≥2,19000,seedbench_seed_all,0.5399666481378543,
-≥2,19000,textvqa_val_exact_match,0.5667599999999999,0.00671422643700147
-≥2,20000,ai2d_exact_match,0.46178756476683935,0.008972834678172942
-≥2,20000,average,0.47802392695549656,
-≥2,20000,average_rank,2.3,
-≥2,20000,chartqa_relaxed_overall,0.618,0.009719474639861454
-≥2,20000,docvqa_val_anls,0.666568303416173,0.0059980334517589756
-≥2,20000,infovqa_val_anls,0.2651324480102521,0.0070565217028431
-≥2,20000,mme_total_score,1233.6009403761504,
-≥2,20000,mmmu_val_mmmu_acc,0.28,
-≥2,20000,mmstar_average,0.33277914424945065,
-≥2,20000,ocrbench_ocrbench_accuracy,0.562,
-≥2,20000,seedbench_seed_all,0.5381878821567537,
-≥2,20000,textvqa_val_exact_match,0.5777599999999999,0.00668799090343766
-≥3,1000,ai2d_exact_match,0.2661917098445596,0.007954634970279362
-≥3,1000,average,0.2680725844272073,
-≥3,1000,average_rank,3.2,
-≥3,1000,chartqa_relaxed_overall,0.3476,0.009526069199715017
-≥3,1000,docvqa_val_anls,0.3752729856163278,0.005939283617489936
-≥3,1000,infovqa_val_anls,0.17325429231808173,0.0062340220795234725
-≥3,1000,mme_total_score,707.53231292517,
-≥3,1000,mmmu_val_mmmu_acc,0.23889,
-≥3,1000,mmstar_average,0.19784737378907616,
-≥3,1000,ocrbench_ocrbench_accuracy,0.288,
-≥3,1000,seedbench_seed_all,0.25041689827682045,
-≥3,1000,textvqa_val_exact_match,0.27518000000000004,0.006128613668775364
-≥3,2000,ai2d_exact_match,0.27266839378238344,0.008015217564479073
-≥3,2000,average,0.31253656058741547,
-≥3,2000,average_rank,3.4,
-≥3,2000,chartqa_relaxed_overall,0.4308,0.00990574548014469
-≥3,2000,docvqa_val_anls,0.4481749259885666,0.00619992092326252
-≥3,2000,infovqa_val_anls,0.19674507942801486,0.006580664003046453
-≥3,2000,mme_total_score,786.0510204081633,
-≥3,2000,mmmu_val_mmmu_acc,0.23556,
-≥3,2000,mmstar_average,0.19768658271923586,
-≥3,2000,ocrbench_ocrbench_accuracy,0.377,
-≥3,2000,seedbench_seed_all,0.2653140633685381,
-≥3,2000,textvqa_val_exact_match,0.38888,0.006660461055234364
-≥3,3000,ai2d_exact_match,0.28270725388601037,0.008104913435481193
-≥3,3000,average,0.34936609328629703,
-≥3,3000,average_rank,3.2,
-≥3,3000,chartqa_relaxed_overall,0.4844,0.009997131241172205
-≥3,3000,docvqa_val_anls,0.49044354643512195,0.0062294371457984315
-≥3,3000,infovqa_val_anls,0.21295743099446893,0.006855571779287104
-≥3,3000,mme_total_score,861.8877551020407,
-≥3,3000,mmmu_val_mmmu_acc,0.24889,
-≥3,3000,mmstar_average,0.258368014597926,
-≥3,3000,ocrbench_ocrbench_accuracy,0.394,
-≥3,3000,seedbench_seed_all,0.3434685936631462,
-≥3,3000,textvqa_val_exact_match,0.42906000000000005,0.0067494454796565755
-≥3,4000,ai2d_exact_match,0.3325777202072539,0.00847966336079129
-≥3,4000,average,0.3855383645559374,
-≥3,4000,average_rank,2.8,
-≥3,4000,chartqa_relaxed_overall,0.508,0.010000720262176365
-≥3,4000,docvqa_val_anls,0.5226854794419781,0.006293466169647169
-≥3,4000,infovqa_val_anls,0.2322658206586996,0.007103396837310004
-≥3,4000,mme_total_score,912.9521808723489,
-≥3,4000,mmmu_val_mmmu_acc,0.26667,
-≥3,4000,mmstar_average,0.3070035703119584,
-≥3,4000,ocrbench_ocrbench_accuracy,0.438,
-≥3,4000,seedbench_seed_all,0.41684269038354643,
-≥3,4000,textvqa_val_exact_match,0.4458,0.006781745381100857
-≥3,5000,ai2d_exact_match,0.34520725388601037,0.008557040186364025
-≥3,5000,average,0.39676974212184324,
-≥3,5000,average_rank,2.7,
-≥3,5000,chartqa_relaxed_overall,0.51,0.01
-≥3,5000,docvqa_val_anls,0.5420071464866951,0.006256421242173299
-≥3,5000,infovqa_val_anls,0.21485812900527704,0.0066319183580626885
-≥3,5000,mme_total_score,957.2279911964786,
-≥3,5000,mmmu_val_mmmu_acc,0.26111,
-≥3,5000,mmstar_average,0.30632830702822333,
-≥3,5000,ocrbench_ocrbench_accuracy,0.44,
-≥3,5000,seedbench_seed_all,0.47031684269038354,
-≥3,5000,textvqa_val_exact_match,0.4811,0.00681344572213808
-≥3,6000,ai2d_exact_match,0.37629533678756477,0.008719379877890884
-≥3,6000,average,0.40447034433869705,
-≥3,6000,average_rank,3.3,
-≥3,6000,chartqa_relaxed_overall,0.5084,0.010000589018267121
-≥3,6000,docvqa_val_anls,0.5540669563018141,0.006258072329892215
-≥3,6000,infovqa_val_anls,0.216535214445592,0.00668611609159469
-≥3,6000,mme_total_score,864.5272108843537,
-≥3,6000,mmmu_val_mmmu_acc,0.26889,
-≥3,6000,mmstar_average,0.2932406887895669,
-≥3,6000,ocrbench_ocrbench_accuracy,0.454,
-≥3,6000,seedbench_seed_all,0.4848249027237354,
-≥3,6000,textvqa_val_exact_match,0.48398,0.006803464510517356
-≥3,7000,ai2d_exact_match,0.3947538860103627,0.008797532848529207
-≥3,7000,average,0.42355543935120793,
-≥3,7000,average_rank,2.7,
-≥3,7000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-≥3,7000,docvqa_val_anls,0.5797391833660968,0.006220930330963092
-≥3,7000,infovqa_val_anls,0.2221619185818123,0.00673372198453672
-≥3,7000,mme_total_score,866.3928571428571,
-≥3,7000,mmmu_val_mmmu_acc,0.28667,
-≥3,7000,mmstar_average,0.3209799250686363,
-≥3,7000,ocrbench_ocrbench_accuracy,0.476,
-≥3,7000,seedbench_seed_all,0.49327404113396334,
-≥3,7000,textvqa_val_exact_match,0.48962000000000006,0.006807769110659733
-≥3,8000,ai2d_exact_match,0.4102979274611399,0.008853146969712133
-≥3,8000,average,0.42791468613133354,
-≥3,8000,average_rank,3.4,
-≥3,8000,chartqa_relaxed_overall,0.5456,0.00996031822662661
-≥3,8000,docvqa_val_anls,0.5824594046059755,0.006268157085435711
-≥3,8000,infovqa_val_anls,0.22074277862778585,0.006618518997755148
-≥3,8000,mme_total_score,788.9880952380953,
-≥3,8000,mmmu_val_mmmu_acc,0.27556,
-≥3,8000,mmstar_average,0.32537357643818443,
-≥3,8000,ocrbench_ocrbench_accuracy,0.5,
-≥3,8000,seedbench_seed_all,0.5012784880489161,
-≥3,8000,textvqa_val_exact_match,0.48991999999999997,0.006810591424473371
-≥3,9000,ai2d_exact_match,0.4251943005181347,0.0088978675214111
-≥3,9000,average,0.4411468725875502,
-≥3,9000,average_rank,2.9,
-≥3,9000,chartqa_relaxed_overall,0.5648,0.009917647296166388
-≥3,9000,docvqa_val_anls,0.6050413765127355,0.006187758928771102
-≥3,9000,infovqa_val_anls,0.23301995192200392,0.00676964747288323
-≥3,9000,mme_total_score,825.0221088435375,
-≥3,9000,mmmu_val_mmmu_acc,0.27556,
-≥3,9000,mmstar_average,0.33219983189483276,
-≥3,9000,ocrbench_ocrbench_accuracy,0.504,
-≥3,9000,seedbench_seed_all,0.5115063924402445,
-≥3,9000,textvqa_val_exact_match,0.519,0.006787356896666665
-≥3,10000,ai2d_exact_match,0.4258419689119171,0.00889962357526378
-≥3,10000,average,0.44419201562479543,
-≥3,10000,average_rank,2.7,
-≥3,10000,chartqa_relaxed_overall,0.576,0.009885782289560632
-≥3,10000,docvqa_val_anls,0.6087522279355707,0.006173079977045839
-≥3,10000,infovqa_val_anls,0.24383042893389267,0.0069221731872859795
-≥3,10000,mme_total_score,915.8061224489795,
-≥3,10000,mmmu_val_mmmu_acc,0.27333,
-≥3,10000,mmstar_average,0.3351679228462254,
-≥3,10000,ocrbench_ocrbench_accuracy,0.489,
-≥3,10000,seedbench_seed_all,0.5180655919955531,
-≥3,10000,textvqa_val_exact_match,0.5277400000000001,0.006769908774345677
-≥3,11000,ai2d_exact_match,0.43426165803108807,0.008921034830887029
-≥3,11000,average,0.45138194167282136,
-≥3,11000,average_rank,2.9,
-≥3,11000,chartqa_relaxed_overall,0.5784,0.009878279615563902
-≥3,11000,docvqa_val_anls,0.6240570866567314,0.006144737191710238
-≥3,11000,infovqa_val_anls,0.2562175057951717,0.0071028888697453095
-≥3,11000,mme_total_score,852.3894557823129,
-≥3,11000,mmmu_val_mmmu_acc,0.28778,
-≥3,11000,mmstar_average,0.3331474836051967,
-≥3,11000,ocrbench_ocrbench_accuracy,0.5,
-≥3,11000,seedbench_seed_all,0.520733740967204,
-≥3,11000,textvqa_val_exact_match,0.5278400000000001,0.00678178334931745
-≥3,12000,ai2d_exact_match,0.4381476683937824,0.008930032335354965
-≥3,12000,average,0.45691171338244096,
-≥3,12000,average_rank,2.5,
-≥3,12000,chartqa_relaxed_overall,0.572,0.009897756626351943
-≥3,12000,docvqa_val_anls,0.6273497290110698,0.006129247411332687
-≥3,12000,infovqa_val_anls,0.268135358118058,0.007380056393275344
-≥3,12000,mme_total_score,893.8265306122448,
-≥3,12000,mmmu_val_mmmu_acc,0.29556,
-≥3,12000,mmstar_average,0.34474290394073753,
-≥3,12000,ocrbench_ocrbench_accuracy,0.508,
-≥3,12000,seedbench_seed_all,0.5255697609783213,
-≥3,12000,textvqa_val_exact_match,0.5327,0.006782133990735781
-≥3,13000,ai2d_exact_match,0.43458549222797926,0.008921805911548512
-≥3,13000,average,0.4607824778908788,
-≥3,13000,average_rank,2.7,
-≥3,13000,chartqa_relaxed_overall,0.5876,0.009847298295140926
-≥3,13000,docvqa_val_anls,0.6386402725745638,0.006069984676680257
-≥3,13000,infovqa_val_anls,0.2536816276782758,0.00704241123014852
-≥3,13000,mme_total_score,941.5953381352541,
-≥3,13000,mmmu_val_mmmu_acc,0.29667,
-≥3,13000,mmstar_average,0.34638755445148733,
-≥3,13000,ocrbench_ocrbench_accuracy,0.53,
-≥3,13000,seedbench_seed_all,0.5272373540856031,
-≥3,13000,textvqa_val_exact_match,0.53224,0.00678673179267349
-≥3,14000,ai2d_exact_match,0.43490932642487046,0.008922573118260885
-≥3,14000,average,0.4621098839598732,
-≥3,14000,average_rank,2.8,
-≥3,14000,chartqa_relaxed_overall,0.5936,0.009825183443166683
-≥3,14000,docvqa_val_anls,0.6373184890679852,0.006105256249191251
-≥3,14000,infovqa_val_anls,0.2624975120280117,0.007131056805776271
-≥3,14000,mme_total_score,901.2585034013605,
-≥3,14000,mmmu_val_mmmu_acc,0.28444,
-≥3,14000,mmstar_average,0.34930389493288816,
-≥3,14000,ocrbench_ocrbench_accuracy,0.517,
-≥3,14000,seedbench_seed_all,0.5355197331851028,
-≥3,14000,textvqa_val_exact_match,0.5444,0.006752217894092123
-≥3,15000,ai2d_exact_match,0.44527202072538863,0.008945084019331405
-≥3,15000,average,0.46643076140543904,
-≥3,15000,average_rank,3.0,
-≥3,15000,chartqa_relaxed_overall,0.5848,0.00985710144918839
-≥3,15000,docvqa_val_anls,0.642316016710227,0.006100312721783546
-≥3,15000,infovqa_val_anls,0.2596632231498878,0.007146587424008848
-≥3,15000,mme_total_score,891.8367346938775,
-≥3,15000,mmmu_val_mmmu_acc,0.29778,
-≥3,15000,mmstar_average,0.34413882163543197,
-≥3,15000,ocrbench_ocrbench_accuracy,0.538,
-≥3,15000,seedbench_seed_all,0.5361867704280155,
-≥3,15000,textvqa_val_exact_match,0.54972,0.006745330549116431
-≥3,16000,ai2d_exact_match,0.4494818652849741,0.008953103134587205
-≥3,16000,average,0.46786516199576034,
-≥3,16000,average_rank,2.7,
-≥3,16000,chartqa_relaxed_overall,0.5976,0.009809596692775395
-≥3,16000,docvqa_val_anls,0.6432815750341822,0.006081847680686157
-≥3,16000,infovqa_val_anls,0.2702450654855036,0.007372825383364985
-≥3,16000,mme_total_score,919.3826530612245,
-≥3,16000,mmmu_val_mmmu_acc,0.28333,
-≥3,16000,mmstar_average,0.3386692973489569,
-≥3,16000,ocrbench_ocrbench_accuracy,0.534,
-≥3,16000,seedbench_seed_all,0.5415786548082268,
-≥3,16000,textvqa_val_exact_match,0.5526,0.006745409410081935
-≥3,17000,ai2d_exact_match,0.4494818652849741,0.008953103134587206
-≥3,17000,average,0.4694732091424512,
-≥3,17000,average_rank,2.8,
-≥3,17000,chartqa_relaxed_overall,0.596,0.009815912634917984
-≥3,17000,docvqa_val_anls,0.6468732282054332,0.006069886071041202
-≥3,17000,infovqa_val_anls,0.2650584835459577,0.0072427928867972455
-≥3,17000,mme_total_score,889.5646258503401,
-≥3,17000,mmmu_val_mmmu_acc,0.29333,
-≥3,17000,mmstar_average,0.342978718252922,
-≥3,17000,ocrbench_ocrbench_accuracy,0.53,
-≥3,17000,seedbench_seed_all,0.5418565869927737,
-≥3,17000,textvqa_val_exact_match,0.5596800000000001,0.006734324743131207
-≥3,18000,ai2d_exact_match,0.45531088082901555,0.008963137311190377
-≥3,18000,average,0.46991408851845295,
-≥3,18000,average_rank,2.7,
-≥3,18000,chartqa_relaxed_overall,0.6036,0.009784943231599163
-≥3,18000,docvqa_val_anls,0.6501128555487647,0.006068985343727089
-≥3,18000,infovqa_val_anls,0.26796275265157754,0.007202201134473747
-≥3,18000,mme_total_score,894.1054421768707,
-≥3,18000,mmmu_val_mmmu_acc,0.28333,
-≥3,18000,mmstar_average,0.33590517144994875,
-≥3,18000,ocrbench_ocrbench_accuracy,0.534,
-≥3,18000,seedbench_seed_all,0.5412451361867704,
-≥3,18000,textvqa_val_exact_match,0.5577599999999999,0.0067408786051132655
-≥3,19000,ai2d_exact_match,0.4498056994818653,0.008953693133598168
-≥3,19000,average,0.47011136523574254,
-≥3,19000,average_rank,3.0,
-≥3,19000,chartqa_relaxed_overall,0.6096,0.009758751420735989
-≥3,19000,docvqa_val_anls,0.6538834113203496,0.006040538366936906
-≥3,19000,infovqa_val_anls,0.2705360277052952,0.007291872911349649
-≥3,19000,mme_total_score,906.3231292517007,
-≥3,19000,mmmu_val_mmmu_acc,0.27556,
-≥3,19000,mmstar_average,0.3356215177081144,
-≥3,19000,ocrbench_ocrbench_accuracy,0.539,
-≥3,19000,seedbench_seed_all,0.5441356309060589,
-≥3,19000,textvqa_val_exact_match,0.5528599999999999,0.006753272200724876
-≥3,20000,ai2d_exact_match,0.44656735751295334,0.008947620544957215
-≥3,20000,average,0.4679556547685855,
-≥3,20000,average_rank,2.9,
-≥3,20000,chartqa_relaxed_overall,0.5976,0.009809596692775395
-≥3,20000,docvqa_val_anls,0.6493769742508846,0.006072933213063366
-≥3,20000,infovqa_val_anls,0.26540905854876357,0.007209592372844281
-≥3,20000,mme_total_score,926.0901360544218,
-≥3,20000,mmmu_val_mmmu_acc,0.27333,
-≥3,20000,mmstar_average,0.34157097675697473,
-≥3,20000,ocrbench_ocrbench_accuracy,0.539,
-≥3,20000,seedbench_seed_all,0.5437465258476931,
-≥3,20000,textvqa_val_exact_match,0.555,0.0067346322137300735
-≥4,1000,ai2d_exact_match,0.25874352331606215,0.00788225861008497
-≥4,1000,average,0.27914578527127093,
-≥4,1000,average_rank,2.6,
-≥4,1000,chartqa_relaxed_overall,0.3512,0.009548816468986268
-≥4,1000,docvqa_val_anls,0.36858592315444033,0.005921151680127505
-≥4,1000,infovqa_val_anls,0.17699311795329079,0.006346227986201575
-≥4,1000,mme_total_score,671.343537414966,
-≥4,1000,mmmu_val_mmmu_acc,0.27111,
-≥4,1000,mmstar_average,0.2086858732233149,
-≥4,1000,ocrbench_ocrbench_accuracy,0.261,
-≥4,1000,seedbench_seed_all,0.2605336297943302,
-≥4,1000,textvqa_val_exact_match,0.35546000000000005,0.006549153835664011
-≥4,2000,ai2d_exact_match,0.280440414507772,0.008085099461783339
-≥4,2000,average,0.320025358717614,
-≥4,2000,average_rank,2.8,
-≥4,2000,chartqa_relaxed_overall,0.4488,0.009949423119365426
-≥4,2000,docvqa_val_anls,0.43140645952438456,0.006042366638541379
-≥4,2000,infovqa_val_anls,0.16528808420419083,0.005907032628809945
-≥4,2000,mme_total_score,705.5901360544218,
-≥4,2000,mmmu_val_mmmu_acc,0.27222,
-≥4,2000,mmstar_average,0.24877125799316246,
-≥4,2000,ocrbench_ocrbench_accuracy,0.329,
-≥4,2000,seedbench_seed_all,0.3196220122290161,
-≥4,2000,textvqa_val_exact_match,0.38468,0.006645983248449226
-≥4,3000,ai2d_exact_match,0.34617875647668395,0.008562713351618977
-≥4,3000,average,0.3596236953408542,
-≥4,3000,average_rank,2.8,
-≥4,3000,chartqa_relaxed_overall,0.468,0.009981495484186743
-≥4,3000,docvqa_val_anls,0.464923009199496,0.006156900593094097
-≥4,3000,infovqa_val_anls,0.18011502045718095,0.0061004080312330325
-≥4,3000,mme_total_score,709.3333333333333,
-≥4,3000,mmmu_val_mmmu_acc,0.27778,
-≥4,3000,mmstar_average,0.30716380934399923,
-≥4,3000,ocrbench_ocrbench_accuracy,0.351,
-≥4,3000,seedbench_seed_all,0.42679266259032794,
-≥4,3000,textvqa_val_exact_match,0.41466,0.006725300202411972
-≥4,4000,ai2d_exact_match,0.36593264248704666,0.008669617940526182
-≥4,4000,average,0.3829150140884673,
-≥4,4000,average_rank,2.7,
-≥4,4000,chartqa_relaxed_overall,0.5136,0.009998299975543861
-≥4,4000,docvqa_val_anls,0.5002844765367886,0.0062258433013991955
-≥4,4000,infovqa_val_anls,0.18808280764611432,0.006209185081756124
-≥4,4000,mme_total_score,700.1989795918367,
-≥4,4000,mmmu_val_mmmu_acc,0.28889,
-≥4,4000,mmstar_average,0.3128795636615537,
-≥4,4000,ocrbench_ocrbench_accuracy,0.379,
-≥4,4000,seedbench_seed_all,0.46214563646470264,
-≥4,4000,textvqa_val_exact_match,0.4354199999999999,0.006770365742739316
-≥4,5000,ai2d_exact_match,0.39702072538860106,0.008806218703419164
-≥4,5000,average,0.3990130243200321,
-≥4,5000,average_rank,3.0,
-≥4,5000,chartqa_relaxed_overall,0.5432,0.009964598400764347
-≥4,5000,docvqa_val_anls,0.5330701388059006,0.006244542429703876
-≥4,5000,infovqa_val_anls,0.20064814149562474,0.006400433745304747
-≥4,5000,mme_total_score,687.6802721088436,
-≥4,5000,mmmu_val_mmmu_acc,0.26333,
-≥4,5000,mmstar_average,0.30889646221740025,
-≥4,5000,ocrbench_ocrbench_accuracy,0.412,
-≥4,5000,seedbench_seed_all,0.47315175097276263,
-≥4,5000,textvqa_val_exact_match,0.4598,0.006799443983716428
-≥4,6000,ai2d_exact_match,0.41224093264248707,0.00885945303235887
-≥4,6000,average,0.4037939250305515,
-≥4,6000,average_rank,3.2,
-≥4,6000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-≥4,6000,docvqa_val_anls,0.5259911309932884,0.006272635836910295
-≥4,6000,infovqa_val_anls,0.22056731437063212,0.00674209963892894
-≥4,6000,mme_total_score,717.0051020408164,
-≥4,6000,mmmu_val_mmmu_acc,0.26667,
-≥4,6000,mmstar_average,0.3316518783413741,
-≥4,6000,ocrbench_ocrbench_accuracy,0.408,
-≥4,6000,seedbench_seed_all,0.48332406892718177,
-≥4,6000,textvqa_val_exact_match,0.4544999999999999,0.006790726970992053
-≥4,7000,ai2d_exact_match,0.4102979274611399,0.008853146969712133
-≥4,7000,average,0.41740315045514464,
-≥4,7000,average_rank,3.1,
-≥4,7000,chartqa_relaxed_overall,0.5588,0.009932597172675325
-≥4,7000,docvqa_val_anls,0.5597972576652357,0.0062571833970283125
-≥4,7000,infovqa_val_anls,0.21665617889681224,0.006562362156515704
-≥4,7000,mme_total_score,716.7908163265306,
-≥4,7000,mmmu_val_mmmu_acc,0.28556,
-≥4,7000,mmstar_average,0.32150517239662685,
-≥4,7000,ocrbench_ocrbench_accuracy,0.431,
-≥4,7000,seedbench_seed_all,0.4892718176764869,
-≥4,7000,textvqa_val_exact_match,0.48374000000000006,0.006820617761268334
-≥4,8000,ai2d_exact_match,0.4213082901554404,0.00888700282309854
-≥4,8000,average,0.4251708917847074,
-≥4,8000,average_rank,2.9,
-≥4,8000,chartqa_relaxed_overall,0.564,0.009919725822025206
-≥4,8000,docvqa_val_anls,0.5702706873242411,0.006237250618852069
-≥4,8000,infovqa_val_anls,0.24000454829818865,0.006935520157929643
-≥4,8000,mme_total_score,705.8180272108843,
-≥4,8000,mmmu_val_mmmu_acc,0.28778,
-≥4,8000,mmstar_average,0.3384645614295773,
-≥4,8000,ocrbench_ocrbench_accuracy,0.42,
-≥4,8000,seedbench_seed_all,0.5018899388549194,
-≥4,8000,textvqa_val_exact_match,0.48281999999999997,0.006811185503977551
-≥4,9000,ai2d_exact_match,0.4319948186528497,0.008915528710615487
-≥4,9000,average,0.4318231930659084,
-≥4,9000,average_rank,2.9,
-≥4,9000,chartqa_relaxed_overall,0.5676,0.009910165515884228
-≥4,9000,docvqa_val_anls,0.5846178021051754,0.006187149390116838
-≥4,9000,infovqa_val_anls,0.2228617948699063,0.0066001763459020155
-≥4,9000,mme_total_score,733.3503401360545,
-≥4,9000,mmmu_val_mmmu_acc,0.28444,
-≥4,9000,mmstar_average,0.3307124653782511,
-≥4,9000,ocrbench_ocrbench_accuracy,0.463,
-≥4,9000,seedbench_seed_all,0.5153418565869927,
-≥4,9000,textvqa_val_exact_match,0.48583999999999994,0.0068269187957708125
-≥4,10000,ai2d_exact_match,0.4410621761658031,0.0089364152923413
-≥4,10000,average,0.436822457787989,
-≥4,10000,average_rank,3.4,
-≥4,10000,chartqa_relaxed_overall,0.5756,0.009887009516677585
-≥4,10000,docvqa_val_anls,0.591441723638793,0.0062031994384821754
-≥4,10000,infovqa_val_anls,0.22327754225685992,0.00649750251357461
-≥4,10000,mme_total_score,695.8112244897959,
-≥4,10000,mmmu_val_mmmu_acc,0.28778,
-≥4,10000,mmstar_average,0.33369690927002266,
-≥4,10000,ocrbench_ocrbench_accuracy,0.472,
-≥4,10000,seedbench_seed_all,0.5107837687604224,
-≥4,10000,textvqa_val_exact_match,0.49576000000000003,0.006808118284439173
-≥4,11000,ai2d_exact_match,0.44332901554404147,0.008941163900483134
-≥4,11000,average,0.44624717945755144,
-≥4,11000,average_rank,3.0,
-≥4,11000,chartqa_relaxed_overall,0.5868,0.009850132691777215
-≥4,11000,docvqa_val_anls,0.60625861922937,0.006159202385167996
-≥4,11000,infovqa_val_anls,0.2435454505191485,0.006860039872881237
-≥4,11000,mme_total_score,751.1462585034014,
-≥4,11000,mmmu_val_mmmu_acc,0.29222,
-≥4,11000,mmstar_average,0.3470954764624236,
-≥4,11000,ocrbench_ocrbench_accuracy,0.486,
-≥4,11000,seedbench_seed_all,0.5128960533629794,
-≥4,11000,textvqa_val_exact_match,0.49808,0.006799508024988012
-≥4,12000,ai2d_exact_match,0.45142487046632124,0.008956585653027465
-≥4,12000,average,0.44514971381341617,
-≥4,12000,average_rank,3.3,
-≥4,12000,chartqa_relaxed_overall,0.5868,0.009850132691777215
-≥4,12000,docvqa_val_anls,0.6047188055272135,0.0061847009209673315
-≥4,12000,infovqa_val_anls,0.2506217753279014,0.006972909032069362
-≥4,12000,mme_total_score,742.969387755102,
-≥4,12000,mmmu_val_mmmu_acc,0.28556,
-≥4,12000,mmstar_average,0.33917912697374,
-≥4,12000,ocrbench_ocrbench_accuracy,0.459,
-≥4,12000,seedbench_seed_all,0.5211228460255698,
-≥4,12000,textvqa_val_exact_match,0.5079199999999999,0.006798462954205747
-≥4,13000,ai2d_exact_match,0.44689119170984454,0.00894824507304496
-≥4,13000,average,0.4478540374461813,
-≥4,13000,average_rank,3.5,
-≥4,13000,chartqa_relaxed_overall,0.5936,0.009825183443166683
-≥4,13000,docvqa_val_anls,0.6123877664020703,0.0061423212651813735
-≥4,13000,infovqa_val_anls,0.23197941094655744,0.0066388766376455225
-≥4,13000,mme_total_score,705.0068027210884,
-≥4,13000,mmmu_val_mmmu_acc,0.29444,
-≥4,13000,mmstar_average,0.3172158612312008,
-≥4,13000,ocrbench_ocrbench_accuracy,0.5,
-≥4,13000,seedbench_seed_all,0.5257921067259589,
-≥4,13000,textvqa_val_exact_match,0.50838,0.006803735244897213
-≥4,14000,ai2d_exact_match,0.45628238341968913,0.008964689215887884
-≥4,14000,average,0.4541657280018954,
-≥4,14000,average_rank,3.3,
-≥4,14000,chartqa_relaxed_overall,0.5988,0.0098047885010856
-≥4,14000,docvqa_val_anls,0.6230752215069362,0.006110772532320183
-≥4,14000,infovqa_val_anls,0.23950752488444424,0.00673701613611272
-≥4,14000,mme_total_score,693.2602040816327,
-≥4,14000,mmmu_val_mmmu_acc,0.29,
-≥4,14000,mmstar_average,0.3462132371031542,
-≥4,14000,ocrbench_ocrbench_accuracy,0.492,
-≥4,14000,seedbench_seed_all,0.519733185102835,
-≥4,14000,textvqa_val_exact_match,0.52188,0.0067822601638824
-≥4,15000,ai2d_exact_match,0.4536917098445596,0.008960474382205331
-≥4,15000,average,0.4546421832173102,
-≥4,15000,average_rank,3.5,
-≥4,15000,chartqa_relaxed_overall,0.6012,0.0097949885513097
-≥4,15000,docvqa_val_anls,0.6265798815467575,0.006118388682866076
-≥4,15000,infovqa_val_anls,0.24253641235942872,0.006778846024017067
-≥4,15000,mme_total_score,745.8826530612245,
-≥4,15000,mmmu_val_mmmu_acc,0.28111,
-≥4,15000,mmstar_average,0.3514223789460134,
-≥4,15000,ocrbench_ocrbench_accuracy,0.493,
-≥4,15000,seedbench_seed_all,0.5226792662590328,
-≥4,15000,textvqa_val_exact_match,0.51956,0.006792518600768668
-≥4,16000,ai2d_exact_match,0.4582253886010363,0.008967689939886603
-≥4,16000,average,0.46307812033280477,
-≥4,16000,average_rank,3.1,
-≥4,16000,chartqa_relaxed_overall,0.6092,0.009760545645634788
-≥4,16000,docvqa_val_anls,0.6397697311161549,0.006077931892063438
-≥4,16000,infovqa_val_anls,0.2566929717899322,0.007049147355082826
-≥4,16000,mme_total_score,769.8112244897959,
-≥4,16000,mmmu_val_mmmu_acc,0.29,
-≥4,16000,mmstar_average,0.3500855084419833,
-≥4,16000,ocrbench_ocrbench_accuracy,0.512,
-≥4,16000,seedbench_seed_all,0.5250694830461368,
-≥4,16000,textvqa_val_exact_match,0.5266599999999999,0.006785297114451678
-≥4,17000,ai2d_exact_match,0.46243523316062174,0.008973720555405783
-≥4,17000,average,0.4637285100748874,
-≥4,17000,average_rank,3.2,
-≥4,17000,chartqa_relaxed_overall,0.6072,0.00976941352263433
-≥4,17000,docvqa_val_anls,0.6316407990464801,0.006115829668357635
-≥4,17000,infovqa_val_anls,0.26095289130380417,0.007179006033610968
-≥4,17000,mme_total_score,772.2568027210884,
-≥4,17000,mmmu_val_mmmu_acc,0.29222,
-≥4,17000,mmstar_average,0.3487846654954876,
-≥4,17000,ocrbench_ocrbench_accuracy,0.516,
-≥4,17000,seedbench_seed_all,0.5254030016675931,
-≥4,17000,textvqa_val_exact_match,0.52892,0.006777692390690844
-≥4,18000,ai2d_exact_match,0.46729274611398963,0.00897987952745343
-≥4,18000,average,0.46301237822364466,
-≥4,18000,average_rank,3.5,
-≥4,18000,chartqa_relaxed_overall,0.6024,0.009789996609470577
-≥4,18000,docvqa_val_anls,0.6353229754668962,0.006102794809473289
-≥4,18000,infovqa_val_anls,0.2566414572268362,0.006998597263140097
-≥4,18000,mme_total_score,770.295918367347,
-≥4,18000,mmmu_val_mmmu_acc,0.27778,
-≥4,18000,mmstar_average,0.3522173046936848,
-≥4,18000,ocrbench_ocrbench_accuracy,0.518,
-≥4,18000,seedbench_seed_all,0.5224569205113953,
-≥4,18000,textvqa_val_exact_match,0.535,0.006782934589123506
-≥4,19000,ai2d_exact_match,0.4647020725388601,0.008976701230834869
-≥4,19000,average,0.4657296959805982,
-≥4,19000,average_rank,3.3,
-≥4,19000,chartqa_relaxed_overall,0.6088,0.009762332982341016
-≥4,19000,docvqa_val_anls,0.6386155506856869,0.006091782897731878
-≥4,19000,infovqa_val_anls,0.2477875071753752,0.006879861435025137
-≥4,19000,mme_total_score,772.204081632653,
-≥4,19000,mmmu_val_mmmu_acc,0.30333,
-≥4,19000,mmstar_average,0.3470027726694857,
-≥4,19000,ocrbench_ocrbench_accuracy,0.512,
-≥4,19000,seedbench_seed_all,0.5288493607559756,
-≥4,19000,textvqa_val_exact_match,0.54048,0.006763536279536092
-≥4,20000,ai2d_exact_match,0.4634067357512953,0.008975020819363737
-≥4,20000,average,0.46162598712482705,
-≥4,20000,average_rank,3.4,
-≥4,20000,chartqa_relaxed_overall,0.61,0.009756950303844571
-≥4,20000,docvqa_val_anls,0.6435026807424298,0.006070985460919362
-≥4,20000,infovqa_val_anls,0.2543282868714285,0.006962743278022537
-≥4,20000,mme_total_score,765.8690476190477,
-≥4,20000,mmmu_val_mmmu_acc,0.27222,
-≥4,20000,mmstar_average,0.34236379610014667,
-≥4,20000,ocrbench_ocrbench_accuracy,0.509,
-≥4,20000,seedbench_seed_all,0.5262923846581434,
-≥4,20000,textvqa_val_exact_match,0.53352,0.006776464123213716
-≥5,1000,ai2d_exact_match,0.24902849740932642,0.007783374690341817
-≥5,1000,average,0.23561247048158757,
-≥5,1000,average_rank,4.2,
-≥5,1000,chartqa_relaxed_overall,0.2548,0.008716718216771047
-≥5,1000,docvqa_val_anls,0.24096701334945672,0.004990683419188375
-≥5,1000,infovqa_val_anls,0.12232054164836681,0.0051959928578510384
-≥5,1000,mme_total_score,620.9336734693877,
-≥5,1000,mmmu_val_mmmu_acc,0.23778,
-≥5,1000,mmstar_average,0.26414819971479786,
-≥5,1000,ocrbench_ocrbench_accuracy,0.216,
-≥5,1000,seedbench_seed_all,0.2623679822123402,
-≥5,1000,textvqa_val_exact_match,0.27310000000000006,0.0061250290771750005
-≥5,2000,ai2d_exact_match,0.2344559585492228,0.007625132817591135
-≥5,2000,average,0.2752283006434932,
-≥5,2000,average_rank,4.2,
-≥5,2000,chartqa_relaxed_overall,0.3732,0.009675026948726469
-≥5,2000,docvqa_val_anls,0.331054267713041,0.005645142408620243
-≥5,2000,infovqa_val_anls,0.1253737215538702,0.00524700917894423
-≥5,2000,mme_total_score,678.2414965986395,
-≥5,2000,mmmu_val_mmmu_acc,0.24,
-≥5,2000,mmstar_average,0.24144442112149672,
-≥5,2000,ocrbench_ocrbench_accuracy,0.264,
-≥5,2000,seedbench_seed_all,0.33140633685380766,
-≥5,2000,textvqa_val_exact_match,0.33612,0.006470505591414144
-≥5,3000,ai2d_exact_match,0.22409326424870465,0.007505002611196186
-≥5,3000,average,0.29997958942235364,
-≥5,3000,average_rank,4.3,
-≥5,3000,chartqa_relaxed_overall,0.392,0.00976588700628918
-≥5,3000,docvqa_val_anls,0.37299390513630937,0.005683849773109756
-≥5,3000,infovqa_val_anls,0.13605101039483827,0.005410567699808442
-≥5,3000,mme_total_score,659.7210884353742,
-≥5,3000,mmmu_val_mmmu_acc,0.27,
-≥5,3000,mmstar_average,0.2682811266889234,
-≥5,3000,ocrbench_ocrbench_accuracy,0.287,
-≥5,3000,seedbench_seed_all,0.3745969983324069,
-≥5,3000,textvqa_val_exact_match,0.3748,0.006628980364742018
-≥5,4000,ai2d_exact_match,0.22733160621761658,0.007543244231635894
-≥5,4000,average,0.3084813519082869,
-≥5,4000,average_rank,4.7,
-≥5,4000,chartqa_relaxed_overall,0.43,0.00990349593288537
-≥5,4000,docvqa_val_anls,0.4066720118815712,0.006028824654560211
-≥5,4000,infovqa_val_anls,0.14319025154556023,0.005617800071290847
-≥5,4000,mme_total_score,656.1462585034013,
-≥5,4000,mmmu_val_mmmu_acc,0.25667,
-≥5,4000,mmstar_average,0.2585945343280555,
-≥5,4000,ocrbench_ocrbench_accuracy,0.294,
-≥5,4000,seedbench_seed_all,0.39277376320177876,
-≥5,4000,textvqa_val_exact_match,0.3671,0.006592830278584186
-≥5,5000,ai2d_exact_match,0.24028497409326424,0.007689893942245019
-≥5,5000,average,0.3230129052623469,
-≥5,5000,average_rank,4.9,
-≥5,5000,chartqa_relaxed_overall,0.442,0.009934479228979264
-≥5,5000,docvqa_val_anls,0.43465518326761016,0.006092084287625314
-≥5,5000,infovqa_val_anls,0.16044569408280707,0.005985099003597859
-≥5,5000,mme_total_score,700.9234693877552,
-≥5,5000,mmmu_val_mmmu_acc,0.26,
-≥5,5000,mmstar_average,0.27948727201527235,
-≥5,5000,ocrbench_ocrbench_accuracy,0.309,
-≥5,5000,seedbench_seed_all,0.39744302390216785,
-≥5,5000,textvqa_val_exact_match,0.3838,0.006651041968883851
-≥5,6000,ai2d_exact_match,0.21761658031088082,0.007426556596739526
-≥5,6000,average,0.3285664644731758,
-≥5,6000,average_rank,4.8,
-≥5,6000,chartqa_relaxed_overall,0.4708,0.009984929820955767
-≥5,6000,docvqa_val_anls,0.4274906773084525,0.005930539560380286
-≥5,6000,infovqa_val_anls,0.15122815225662642,0.005687399721363878
-≥5,6000,mme_total_score,692.2227891156463,
-≥5,6000,mmmu_val_mmmu_acc,0.27,
-≥5,6000,mmstar_average,0.27596736182231085,
-≥5,6000,ocrbench_ocrbench_accuracy,0.341,
-≥5,6000,seedbench_seed_all,0.4237354085603113,
-≥5,6000,textvqa_val_exact_match,0.37926,0.006628782590470618
-≥5,7000,ai2d_exact_match,0.22959844559585493,0.007569631399592313
-≥5,7000,average,0.3397133831241853,
-≥5,7000,average_rank,5.0,
-≥5,7000,chartqa_relaxed_overall,0.4864,0.009998299975543861
-≥5,7000,docvqa_val_anls,0.4538685197224749,0.00598758370400633
-≥5,7000,infovqa_val_anls,0.15500462855057698,0.005842239614739797
-≥5,7000,mme_total_score,662.3809523809523,
-≥5,7000,mmmu_val_mmmu_acc,0.26444,
-≥5,7000,mmstar_average,0.2946102327923966,
-≥5,7000,ocrbench_ocrbench_accuracy,0.339,
-≥5,7000,seedbench_seed_all,0.43351862145636466,
-≥5,7000,textvqa_val_exact_match,0.40098,0.00668858395709213
-≥5,8000,ai2d_exact_match,0.26878238341968913,0.007979127569354613
-≥5,8000,average,0.3468669425903158,
-≥5,8000,average_rank,4.7,
-≥5,8000,chartqa_relaxed_overall,0.4644,0.009976616117083942
-≥5,8000,docvqa_val_anls,0.43320064291973065,0.005825461000081097
-≥5,8000,infovqa_val_anls,0.1525871677997588,0.0057380999639673955
-≥5,8000,mme_total_score,714.7789115646258,
-≥5,8000,mmmu_val_mmmu_acc,0.27667,
-≥5,8000,mmstar_average,0.3189178311414238,
-≥5,8000,ocrbench_ocrbench_accuracy,0.358,
-≥5,8000,seedbench_seed_all,0.4440244580322401,
-≥5,8000,textvqa_val_exact_match,0.40522,0.006705157876473132
-≥5,9000,ai2d_exact_match,0.23834196891191708,0.007668527149232641
-≥5,9000,average,0.34742834361066494,
-≥5,9000,average_rank,4.9,
-≥5,9000,chartqa_relaxed_overall,0.4832,0.009996353076494045
-≥5,9000,docvqa_val_anls,0.44997891177952337,0.005999690608407377
-≥5,9000,infovqa_val_anls,0.15249014258349003,0.005725765633377559
-≥5,9000,mme_total_score,696.5544217687075,
-≥5,9000,mmmu_val_mmmu_acc,0.26444,
-≥5,9000,mmstar_average,0.3019547640515156,
-≥5,9000,ocrbench_ocrbench_accuracy,0.384,
-≥5,9000,seedbench_seed_all,0.44874930516953865,
-≥5,9000,textvqa_val_exact_match,0.4037,0.006699928343494548
-≥5,10000,ai2d_exact_match,0.2979274611398964,0.008231480357867917
-≥5,10000,average,0.3538147252476138,
-≥5,10000,average_rank,4.8,
-≥5,10000,chartqa_relaxed_overall,0.48,0.009993995796516643
-≥5,10000,docvqa_val_anls,0.45125781190343667,0.0059273100312449535
-≥5,10000,infovqa_val_anls,0.15739085013451903,0.005776029267754871
-≥5,10000,mme_total_score,718.7227891156463,
-≥5,10000,mmmu_val_mmmu_acc,0.27556,
-≥5,10000,mmstar_average,0.3004387942674594,
-≥5,10000,ocrbench_ocrbench_accuracy,0.357,
-≥5,10000,seedbench_seed_all,0.4556976097832129,
-≥5,10000,textvqa_val_exact_match,0.40906000000000003,0.006714715240436636
-≥5,11000,ai2d_exact_match,0.3167098445595855,0.008372690712254882
-≥5,11000,average,0.36396020347184427,
-≥5,11000,average_rank,5.0,
-≥5,11000,chartqa_relaxed_overall,0.4924,0.010000845102345324
-≥5,11000,docvqa_val_anls,0.4691277601070516,0.0060867637597330085
-≥5,11000,infovqa_val_anls,0.15562897334070494,0.005768608804593679
-≥5,11000,mme_total_score,680.7667066826731,
-≥5,11000,mmmu_val_mmmu_acc,0.27667,
-≥5,11000,mmstar_average,0.3111702671358657,
-≥5,11000,ocrbench_ocrbench_accuracy,0.388,
-≥5,11000,seedbench_seed_all,0.45497498610339077,
-≥5,11000,textvqa_val_exact_match,0.41096000000000005,0.006715250896200365
-≥5,12000,ai2d_exact_match,0.24838082901554404,0.007776597937116943
-≥5,12000,average,0.35400963042471534,
-≥5,12000,average_rank,4.9,
-≥5,12000,chartqa_relaxed_overall,0.4624,0.00997367964766694
-≥5,12000,docvqa_val_anls,0.46480289866811825,0.005910238300168798
-≥5,12000,infovqa_val_anls,0.15657154481637633,0.0057842205757870115
-≥5,12000,mme_total_score,742.4894957983194,
-≥5,12000,mmmu_val_mmmu_acc,0.28444,
-≥5,12000,mmstar_average,0.30237252416842486,
-≥5,12000,ocrbench_ocrbench_accuracy,0.391,
-≥5,12000,seedbench_seed_all,0.46197887715397445,
-≥5,12000,textvqa_val_exact_match,0.41414000000000006,0.0067237975855013775
-≥5,13000,ai2d_exact_match,0.27266839378238344,0.008015217564479081
-≥5,13000,average,0.3605408154099655,
-≥5,13000,average_rank,4.9,
-≥5,13000,chartqa_relaxed_overall,0.4796,0.00999367226769808
-≥5,13000,docvqa_val_anls,0.4888368998254502,0.006080092164054846
-≥5,13000,infovqa_val_anls,0.1685412928680358,0.006153102666352037
-≥5,13000,mme_total_score,715.9022609043617,
-≥5,13000,mmmu_val_mmmu_acc,0.27,
-≥5,13000,mmstar_average,0.30550310907874534,
-≥5,13000,ocrbench_ocrbench_accuracy,0.39,
-≥5,13000,seedbench_seed_all,0.46375764313507506,
-≥5,13000,textvqa_val_exact_match,0.40596000000000004,0.006708225975557757
-≥5,14000,ai2d_exact_match,0.27266839378238344,0.008015217564479094
-≥5,14000,average,0.35876061642606916,
-≥5,14000,average_rank,4.9,
-≥5,14000,chartqa_relaxed_overall,0.4832,0.009996353076494045
-≥5,14000,docvqa_val_anls,0.4686745608937551,0.005954780465596843
-≥5,14000,infovqa_val_anls,0.16026985404926572,0.00587737555538511
-≥5,14000,mme_total_score,694.7702080832332,
-≥5,14000,mmmu_val_mmmu_acc,0.27778,
-≥5,14000,mmstar_average,0.3065739842454048,
-≥5,14000,ocrbench_ocrbench_accuracy,0.388,
-≥5,14000,seedbench_seed_all,0.46575875486381324,
-≥5,14000,textvqa_val_exact_match,0.40592,0.006717590038338499
-≥5,15000,ai2d_exact_match,0.26295336787564766,0.007923526907377253
-≥5,15000,average,0.3594508046372947,
-≥5,15000,average_rank,4.9,
-≥5,15000,chartqa_relaxed_overall,0.4904,0.010000156861514821
-≥5,15000,docvqa_val_anls,0.47702085294845603,0.006014469495902542
-≥5,15000,infovqa_val_anls,0.1709556715444569,0.006117350998294382
-≥5,15000,mme_total_score,748.1163465386154,
-≥5,15000,mmmu_val_mmmu_acc,0.25667,
-≥5,15000,mmstar_average,0.2990729469212882,
-≥5,15000,ocrbench_ocrbench_accuracy,0.404,
-≥5,15000,seedbench_seed_all,0.46392440244580324,
-≥5,15000,textvqa_val_exact_match,0.4100599999999999,0.0067243737790625615
-≥5,16000,ai2d_exact_match,0.28950777202072536,0.00816284339533906
-≥5,16000,average,0.3652803192394071,
-≥5,16000,average_rank,4.9,
-≥5,16000,chartqa_relaxed_overall,0.5004,0.010001997399559365
-≥5,16000,docvqa_val_anls,0.4789319968433556,0.005936381904079473
-≥5,16000,infovqa_val_anls,0.16818261112655605,0.006062058685336811
-≥5,16000,mme_total_score,703.8838535414166,
-≥5,16000,mmmu_val_mmmu_acc,0.28111,
-≥5,16000,mmstar_average,0.30021933140749574,
-≥5,16000,ocrbench_ocrbench_accuracy,0.392,
-≥5,16000,seedbench_seed_all,0.4640911617565314,
-≥5,16000,textvqa_val_exact_match,0.41308,0.006723304491442948
-≥5,17000,ai2d_exact_match,0.28335492227979275,0.008110527983566212
-≥5,17000,average,0.36065417779712866,
-≥5,17000,average_rank,5.0,
-≥5,17000,chartqa_relaxed_overall,0.4688,0.009982508912777261
-≥5,17000,docvqa_val_anls,0.4676527518642357,0.00590362287731878
-≥5,17000,infovqa_val_anls,0.16818540516392913,0.00605571000794457
-≥5,17000,mme_total_score,754.0354141656662,
-≥5,17000,mmmu_val_mmmu_acc,0.26222,
-≥5,17000,mmstar_average,0.31626391497403816,
-≥5,17000,ocrbench_ocrbench_accuracy,0.404,
-≥5,17000,seedbench_seed_all,0.46309060589216233,
-≥5,17000,textvqa_val_exact_match,0.41231999999999996,0.006722044383678169
-≥5,18000,ai2d_exact_match,0.2911269430051813,0.00817630569100236
-≥5,18000,average,0.3642489832139911,
-≥5,18000,average_rank,4.9,
-≥5,18000,chartqa_relaxed_overall,0.488,0.009999119609104738
-≥5,18000,docvqa_val_anls,0.4852288069276555,0.006044640681137398
-≥5,18000,infovqa_val_anls,0.1659765406298008,0.006009331694189444
-≥5,18000,mme_total_score,748.4861944777911,
-≥5,18000,mmmu_val_mmmu_acc,0.28111,
-≥5,18000,mmstar_average,0.3014618713149217,
-≥5,18000,ocrbench_ocrbench_accuracy,0.389,
-≥5,18000,seedbench_seed_all,0.4660366870483602,
-≥5,18000,textvqa_val_exact_match,0.4103,0.0067180509406887
-≥5,19000,ai2d_exact_match,0.2817357512953368,0.008096452844781159
-≥5,19000,average,0.35871512802442374,
-≥5,19000,average_rank,4.7,
-≥5,19000,chartqa_relaxed_overall,0.452,0.009955804699716018
-≥5,19000,docvqa_val_anls,0.4693437417424619,0.005945802716190409
-≥5,19000,infovqa_val_anls,0.17352672765291935,0.006108049035774969
-≥5,19000,mme_total_score,757.4390756302521,
-≥5,19000,mmmu_val_mmmu_acc,0.29556,
-≥5,19000,mmstar_average,0.299605929305638,
-≥5,19000,ocrbench_ocrbench_accuracy,0.382,
-≥5,19000,seedbench_seed_all,0.4672040022234575,
-≥5,19000,textvqa_val_exact_match,0.40746,0.006711235192985202
-≥5,20000,ai2d_exact_match,0.28950777202072536,0.008162843395339051
-≥5,20000,average,0.3571101844602158,
-≥5,20000,average_rank,5.0,
-≥5,20000,chartqa_relaxed_overall,0.452,0.009955804699716018
-≥5,20000,docvqa_val_anls,0.4781541164812954,0.006040598891772297
-≥5,20000,infovqa_val_anls,0.16871824680773087,0.00599943702354704
-≥5,20000,mme_total_score,713.3514405762305,
-≥5,20000,mmmu_val_mmmu_acc,0.26667,
-≥5,20000,mmstar_average,0.30644375940695473,
-≥5,20000,ocrbench_ocrbench_accuracy,0.398,
-≥5,20000,seedbench_seed_all,0.4599777654252362,
-≥5,20000,textvqa_val_exact_match,0.39452000000000004,0.006680937127692554
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a47d8de2edf309fd39eb7e2ef5790d7f9c3ec4d5cc0f0c8680c12112f0d63e3
+size 63287

app/src/content/assets/data/formatting_filters.csv

@@ -1,1201 +1,3 @@
-run,step,metric,value,stderr
-Baseline,1000,ai2d_exact_match,0.2548575129533679,0.007843322436924496
-Baseline,1000,average,0.27120689295763617,
-Baseline,1000,average_rank,3.8,
-Baseline,1000,chartqa_relaxed_overall,0.3308,0.009411906161401973
-Baseline,1000,docvqa_val_anls,0.3528553494243383,0.005852289239342309
-Baseline,1000,infovqa_val_anls,0.17320578642581314,0.006297063452679795
-Baseline,1000,mme_total_score,977.4280712284914,
-Baseline,1000,mmmu_val_mmmu_acc,0.25222,
-Baseline,1000,mmstar_average,0.23215874078908072,
-Baseline,1000,ocrbench_ocrbench_accuracy,0.286,
-Baseline,1000,seedbench_seed_all,0.2563646470261256,
-Baseline,1000,textvqa_val_exact_match,0.3024,0.00628900296642181
-Baseline,2000,ai2d_exact_match,0.26295336787564766,0.007923526907377255
-Baseline,2000,average,0.3202068275596269,
-Baseline,2000,average_rank,3.7,
-Baseline,2000,chartqa_relaxed_overall,0.4688,0.009982508912777261
-Baseline,2000,docvqa_val_anls,0.4452261510942785,0.00614755494712251
-Baseline,2000,infovqa_val_anls,0.1820547866557169,0.006217861455795791
-Baseline,2000,mme_total_score,1049.3036214485794,
-Baseline,2000,mmmu_val_mmmu_acc,0.24556,
-Baseline,2000,mmstar_average,0.21305462434540698,
-Baseline,2000,ocrbench_ocrbench_accuracy,0.395,
-Baseline,2000,seedbench_seed_all,0.258532518065592,
-Baseline,2000,textvqa_val_exact_match,0.41068000000000005,0.006697862330024289
-Baseline,3000,ai2d_exact_match,0.25226683937823835,0.007816909588794397
-Baseline,3000,average,0.3507423834414229,
-Baseline,3000,average_rank,2.6,
-Baseline,3000,chartqa_relaxed_overall,0.5028,0.010001843767601082
-Baseline,3000,docvqa_val_anls,0.502653993831009,0.006267072346683124
-Baseline,3000,infovqa_val_anls,0.21728617578189535,0.006796941784959762
-Baseline,3000,mme_total_score,1170.2383953581434,
-Baseline,3000,mmmu_val_mmmu_acc,0.27556,
-Baseline,3000,mmstar_average,0.25432376938577683,
-Baseline,3000,ocrbench_ocrbench_accuracy,0.436,
-Baseline,3000,seedbench_seed_all,0.2792106725958866,
-Baseline,3000,textvqa_val_exact_match,0.43658,0.006766885462882726
-Baseline,4000,ai2d_exact_match,0.2645725388601036,0.007939149662089447
-Baseline,4000,average,0.36961781722974835,
-Baseline,4000,average_rank,2.8,
-Baseline,4000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-Baseline,4000,docvqa_val_anls,0.5374434618615119,0.0062905728113059655
-Baseline,4000,infovqa_val_anls,0.2287924838861707,0.006994568698639919
-Baseline,4000,mme_total_score,1155.203781512605,
-Baseline,4000,mmmu_val_mmmu_acc,0.25556,
-Baseline,4000,mmstar_average,0.2575590188757354,
-Baseline,4000,ocrbench_ocrbench_accuracy,0.453,
-Baseline,4000,seedbench_seed_all,0.33913285158421347,
-Baseline,4000,textvqa_val_exact_match,0.4593,0.006791695475025738
-Baseline,5000,ai2d_exact_match,0.3125,0.008342439145556371
-Baseline,5000,average,0.3974627910380972,
-Baseline,5000,average_rank,3.1,
-Baseline,5000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-Baseline,5000,docvqa_val_anls,0.552360266782429,0.006300308519952055
-Baseline,5000,infovqa_val_anls,0.23425555286643698,0.007002254622066442
-Baseline,5000,mme_total_score,1181.4653861544618,
-Baseline,5000,mmmu_val_mmmu_acc,0.26667,
-Baseline,5000,mmstar_average,0.29596648146165705,
-Baseline,5000,ocrbench_ocrbench_accuracy,0.462,
-Baseline,5000,seedbench_seed_all,0.43107281823235133,
-Baseline,5000,textvqa_val_exact_match,0.47354000000000007,0.0068172185364497985
-Baseline,6000,ai2d_exact_match,0.358160621761658,0.008629463221867162
-Baseline,6000,average,0.4161227404571003,
-Baseline,6000,average_rank,2.3,
-Baseline,6000,chartqa_relaxed_overall,0.5628,0.00992279440175477
-Baseline,6000,docvqa_val_anls,0.5747451497228876,0.00625495440870239
-Baseline,6000,infovqa_val_anls,0.22152017368968838,0.006604546680525351
-Baseline,6000,mme_total_score,1284.1648659463785,
-Baseline,6000,mmmu_val_mmmu_acc,0.27111,
-Baseline,6000,mmstar_average,0.2978489412854164,
-Baseline,6000,ocrbench_ocrbench_accuracy,0.495,
-Baseline,6000,seedbench_seed_all,0.4795997776542524,
-Baseline,6000,textvqa_val_exact_match,0.48432,0.006800535050670284
-Baseline,7000,ai2d_exact_match,0.3707901554404145,0.00869347755587734
-Baseline,7000,average,0.4291083177345374,
-Baseline,7000,average_rank,2.6,
-Baseline,7000,chartqa_relaxed_overall,0.5656,0.009915542506251351
-Baseline,7000,docvqa_val_anls,0.5940907049431567,0.006224236305767187
-Baseline,7000,infovqa_val_anls,0.2515675215816963,0.007105097396092786
-Baseline,7000,mme_total_score,1185.875650260104,
-Baseline,7000,mmmu_val_mmmu_acc,0.26556,
-Baseline,7000,mmstar_average,0.31372400960777047,
-Baseline,7000,ocrbench_ocrbench_accuracy,0.504,
-Baseline,7000,seedbench_seed_all,0.4964424680377988,
-Baseline,7000,textvqa_val_exact_match,0.5002,0.006794794025220267
-Baseline,8000,ai2d_exact_match,0.37759067357512954,0.008725299846043883
-Baseline,8000,average,0.43846759477995995,
-Baseline,8000,average_rank,2.1,
-Baseline,8000,chartqa_relaxed_overall,0.5832,0.009862556058385773
-Baseline,8000,docvqa_val_anls,0.6017336419437208,0.006231612198089698
-Baseline,8000,infovqa_val_anls,0.2449256624147254,0.006992518502948913
-Baseline,8000,mme_total_score,1199.2409963985594,
-Baseline,8000,mmmu_val_mmmu_acc,0.28111,
-Baseline,8000,mmstar_average,0.33512257186205047,
-Baseline,8000,ocrbench_ocrbench_accuracy,0.51,
-Baseline,8000,seedbench_seed_all,0.5024458032240133,
-Baseline,8000,textvqa_val_exact_match,0.51008,0.006796301690135059
-Baseline,9000,ai2d_exact_match,0.4067357512953368,0.008841214921078996
-Baseline,9000,average,0.4422510732201056,
-Baseline,9000,average_rank,2.1,
-Baseline,9000,chartqa_relaxed_overall,0.5912,0.009834211136815875
-Baseline,9000,docvqa_val_anls,0.6170968481662739,0.00617235763542544
-Baseline,9000,infovqa_val_anls,0.23537031288570615,0.00670318154156447
-Baseline,9000,mme_total_score,1231.5195078031213,
-Baseline,9000,mmmu_val_mmmu_acc,0.25889,
-Baseline,9000,mmstar_average,0.3216444898242951,
-Baseline,9000,ocrbench_ocrbench_accuracy,0.515,
-Baseline,9000,seedbench_seed_all,0.5120622568093385,
-Baseline,9000,textvqa_val_exact_match,0.52226,0.006792711289708482
-Baseline,10000,ai2d_exact_match,0.39993523316062174,0.008817096257082848
-Baseline,10000,average,0.4523875703250908,
-Baseline,10000,average_rank,2.4,
-Baseline,10000,chartqa_relaxed_overall,0.5996,0.00980154906867574
-Baseline,10000,docvqa_val_anls,0.6262613496433054,0.006147756371688175
-Baseline,10000,infovqa_val_anls,0.263290074230132,0.007186788766942786
-Baseline,10000,mme_total_score,1240.8218287314926,
-Baseline,10000,mmmu_val_mmmu_acc,0.28778,
-Baseline,10000,mmstar_average,0.32972717906018517,
-Baseline,10000,ocrbench_ocrbench_accuracy,0.517,
-Baseline,10000,seedbench_seed_all,0.5217342968315731,
-Baseline,10000,textvqa_val_exact_match,0.5261600000000001,0.006785774843600811
-Baseline,11000,ai2d_exact_match,0.422279792746114,0.008889771831066474
-Baseline,11000,average,0.4561398159525099,
-Baseline,11000,average_rank,2.1,
-Baseline,11000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-Baseline,11000,docvqa_val_anls,0.6373130149166712,0.006128022584995044
-Baseline,11000,infovqa_val_anls,0.24419378339723755,0.006897644885887063
-Baseline,11000,mme_total_score,1322.9488795518205,
-Baseline,11000,mmmu_val_mmmu_acc,0.27778,
-Baseline,11000,mmstar_average,0.3298563439522548,
-Baseline,11000,ocrbench_ocrbench_accuracy,0.521,
-Baseline,11000,seedbench_seed_all,0.5237354085603113,
-Baseline,11000,textvqa_val_exact_match,0.5387,0.006770851562852138
-Baseline,12000,ai2d_exact_match,0.42001295336787564,0.008883255931688034
-Baseline,12000,average,0.4582751140055433,
-Baseline,12000,average_rank,2.4,
-Baseline,12000,chartqa_relaxed_overall,0.618,0.009719474639861454
-Baseline,12000,docvqa_val_anls,0.6393961983751871,0.0061228747388476674
-Baseline,12000,infovqa_val_anls,0.24798874058574302,0.006855374548993139
-Baseline,12000,mme_total_score,1225.6453581432572,
-Baseline,12000,mmmu_val_mmmu_acc,0.27889,
-Baseline,12000,mmstar_average,0.34010867846816534,
-Baseline,12000,ocrbench_ocrbench_accuracy,0.512,
-Baseline,12000,seedbench_seed_all,0.5350194552529183,
-Baseline,12000,textvqa_val_exact_match,0.5330600000000001,0.006777713092109446
-Baseline,13000,ai2d_exact_match,0.4375,0.008928571428571428
-Baseline,13000,average,0.4692868662590049,
-Baseline,13000,average_rank,1.6,
-Baseline,13000,chartqa_relaxed_overall,0.6148,0.00973479791861169
-Baseline,13000,docvqa_val_anls,0.6511374872549951,0.006086953065248391
-Baseline,13000,infovqa_val_anls,0.24465055100441893,0.006808432538374664
-Baseline,13000,mme_total_score,1281.7122849139657,
-Baseline,13000,mmmu_val_mmmu_acc,0.28222,
-Baseline,13000,mmstar_average,0.3453069542917521,
-Baseline,13000,ocrbench_ocrbench_accuracy,0.549,
-Baseline,13000,seedbench_seed_all,0.5442468037798777,
-Baseline,13000,textvqa_val_exact_match,0.55472,0.0067416788982325
-Baseline,14000,ai2d_exact_match,0.4572538860103627,0.00896620675297095
-Baseline,14000,average,0.47352486841689195,
-Baseline,14000,average_rank,1.7,
-Baseline,14000,chartqa_relaxed_overall,0.6172,0.009723347231923635
-Baseline,14000,docvqa_val_anls,0.6502269393708169,0.006057950730638126
-Baseline,14000,infovqa_val_anls,0.25805460837190913,0.007037735231659539
-Baseline,14000,mme_total_score,1309.1444577831132,
-Baseline,14000,mmmu_val_mmmu_acc,0.28111,
-Baseline,14000,mmstar_average,0.34575818188776586,
-Baseline,14000,ocrbench_ocrbench_accuracy,0.551,
-Baseline,14000,seedbench_seed_all,0.5483602001111729,
-Baseline,14000,textvqa_val_exact_match,0.55276,0.006751206724612103
-Baseline,15000,ai2d_exact_match,0.45045336787564766,0.008954861634252399
-Baseline,15000,average,0.47878665012878824,
-Baseline,15000,average_rank,1.6,
-Baseline,15000,chartqa_relaxed_overall,0.612,0.009747841205275417
-Baseline,15000,docvqa_val_anls,0.6621413031955148,0.006056838050222495
-Baseline,15000,infovqa_val_anls,0.2706898598157733,0.007200315730154543
-Baseline,15000,mme_total_score,1384.2171868747498,
-Baseline,15000,mmmu_val_mmmu_acc,0.30222,
-Baseline,15000,mmstar_average,0.35408135695920684,
-Baseline,15000,ocrbench_ocrbench_accuracy,0.558,
-Baseline,15000,seedbench_seed_all,0.5411339633129516,
-Baseline,15000,textvqa_val_exact_match,0.5583600000000001,0.0067279027203879065
-Baseline,16000,ai2d_exact_match,0.45077720207253885,0.008955440137395838
-Baseline,16000,average,0.47665128022935843,
-Baseline,16000,average_rank,1.6,
-Baseline,16000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,16000,docvqa_val_anls,0.6709415729142987,0.005999818105621502
-Baseline,16000,infovqa_val_anls,0.26050032542402035,0.006997451875879188
-Baseline,16000,mme_total_score,1317.8491396558625,
-Baseline,16000,mmmu_val_mmmu_acc,0.27556,
-Baseline,16000,mmstar_average,0.33214333327093315,
-Baseline,16000,ocrbench_ocrbench_accuracy,0.56,
-Baseline,16000,seedbench_seed_all,0.5463590883824346,
-Baseline,16000,textvqa_val_exact_match,0.56158,0.006723854754867398
-Baseline,17000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-Baseline,17000,average,0.4777141780162423,
-Baseline,17000,average_rank,1.9,
-Baseline,17000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,17000,docvqa_val_anls,0.6796338519136422,0.005948761388267941
-Baseline,17000,infovqa_val_anls,0.28070956072505215,0.007298333094144192
-Baseline,17000,mme_total_score,1381.9161664665867,
-Baseline,17000,mmmu_val_mmmu_acc,0.27667,
-Baseline,17000,mmstar_average,0.3370289492329521,
-Baseline,17000,ocrbench_ocrbench_accuracy,0.519,
-Baseline,17000,seedbench_seed_all,0.5510283490828238,
-Baseline,17000,textvqa_val_exact_match,0.56416,0.006724830373229479
-Baseline,18000,ai2d_exact_match,0.46567357512953367,0.008977921602780726
-Baseline,18000,average,0.4819834595278701,
-Baseline,18000,average_rank,1.7,
-Baseline,18000,chartqa_relaxed_overall,0.6376,0.009615793331418735
-Baseline,18000,docvqa_val_anls,0.6775884603912571,0.005972234236435759
-Baseline,18000,infovqa_val_anls,0.27154318420389256,0.007164903131667027
-Baseline,18000,mme_total_score,1336.922769107643,
-Baseline,18000,mmmu_val_mmmu_acc,0.28667,
-Baseline,18000,mmstar_average,0.34482796716566916,
-Baseline,18000,ocrbench_ocrbench_accuracy,0.533,
-Baseline,18000,seedbench_seed_all,0.5543079488604781,
-Baseline,18000,textvqa_val_exact_match,0.5666399999999999,0.006713392287599574
-Baseline,19000,ai2d_exact_match,0.4682642487046632,0.008981008686994101
-Baseline,19000,average,0.4899006713916878,
-Baseline,19000,average_rank,1.5,
-Baseline,19000,chartqa_relaxed_overall,0.6444,0.009575809858898698
-Baseline,19000,docvqa_val_anls,0.678226526479947,0.005970619221588814
-Baseline,19000,infovqa_val_anls,0.26993847247278,0.0071348470764911525
-Baseline,19000,mme_total_score,1406.6628651460583,
-Baseline,19000,mmmu_val_mmmu_acc,0.28333,
-Baseline,19000,mmstar_average,0.356220913822775,
-Baseline,19000,ocrbench_ocrbench_accuracy,0.577,
-Baseline,19000,seedbench_seed_all,0.554585881045025,
-Baseline,19000,textvqa_val_exact_match,0.57714,0.0066918487914812905
-Baseline,20000,ai2d_exact_match,0.47571243523316065,0.00898853090258662
-Baseline,20000,average,0.4873169067639118,
-Baseline,20000,average_rank,1.7,
-Baseline,20000,chartqa_relaxed_overall,0.6336,0.009638338810708618
-Baseline,20000,docvqa_val_anls,0.6895214454380043,0.005896462073053767
-Baseline,20000,infovqa_val_anls,0.2655657550458317,0.007033265532032538
-Baseline,20000,mme_total_score,1324.6738695478193,
-Baseline,20000,mmmu_val_mmmu_acc,0.30111,
-Baseline,20000,mmstar_average,0.33806766134497995,
-Baseline,20000,ocrbench_ocrbench_accuracy,0.555,
-Baseline,20000,seedbench_seed_all,0.5587548638132296,
-Baseline,20000,textvqa_val_exact_match,0.56852,0.006720151338087659
-≥2,1000,ai2d_exact_match,0.2619818652849741,0.007914086941902845
-≥2,1000,average,0.2852885776543714,
-≥2,1000,average_rank,2.8,
-≥2,1000,chartqa_relaxed_overall,0.36,0.009601920576192066
-≥2,1000,docvqa_val_anls,0.3691495236959511,0.0059102400877721764
-≥2,1000,infovqa_val_anls,0.18005913830944342,0.006300821228003093
-≥2,1000,mme_total_score,1034.4992997198879,
-≥2,1000,mmmu_val_mmmu_acc,0.25222,
-≥2,1000,mmstar_average,0.20333316409480473,
-≥2,1000,ocrbench_ocrbench_accuracy,0.331,
-≥2,1000,seedbench_seed_all,0.264313507504169,
-≥2,1000,textvqa_val_exact_match,0.34554,0.006483180392801138
-≥2,2000,ai2d_exact_match,0.25971502590673573,0.007891865786132407
-≥2,2000,average,0.3309474525195546,
-≥2,2000,average_rank,2.3,
-≥2,2000,chartqa_relaxed_overall,0.4664,0.009979391329160321
-≥2,2000,docvqa_val_anls,0.44591152951098784,0.006197056264354256
-≥2,2000,infovqa_val_anls,0.20775747304541303,0.006645281501282388
-≥2,2000,mme_total_score,1083.1982793117247,
-≥2,2000,mmmu_val_mmmu_acc,0.26222,
-≥2,2000,mmstar_average,0.23515873070535015,
-≥2,2000,ocrbench_ocrbench_accuracy,0.413,
-≥2,2000,seedbench_seed_all,0.2757643135075042,
-≥2,2000,textvqa_val_exact_match,0.4126,0.006707581257746032
-≥2,3000,ai2d_exact_match,0.27299222797927464,0.00801819019286542
-≥2,3000,average,0.35386512749374127,
-≥2,3000,average_rank,1.8,
-≥2,3000,chartqa_relaxed_overall,0.5124,0.009998924311892653
-≥2,3000,docvqa_val_anls,0.48910828732243933,0.006274136020264289
-≥2,3000,infovqa_val_anls,0.2070472808493129,0.0065577848697521875
-≥2,3000,mme_total_score,1128.4556822729091,
-≥2,3000,mmmu_val_mmmu_acc,0.25222,
-≥2,3000,mmstar_average,0.25601322622316125,
-≥2,3000,ocrbench_ocrbench_accuracy,0.447,
-≥2,3000,seedbench_seed_all,0.30522512506948307,
-≥2,3000,textvqa_val_exact_match,0.44278,0.006763750733490772
-≥2,4000,ai2d_exact_match,0.3173575129533679,0.008377274276497445
-≥2,4000,average,0.3859767914191833,
-≥2,4000,average_rank,2.4,
-≥2,4000,chartqa_relaxed_overall,0.5388,0.0099718403035556
-≥2,4000,docvqa_val_anls,0.5360750144064242,0.006293888693576319
-≥2,4000,infovqa_val_anls,0.20188347210673038,0.0064101781168258935
-≥2,4000,mme_total_score,1110.1481592637056,
-≥2,4000,mmmu_val_mmmu_acc,0.25222,
-≥2,4000,mmstar_average,0.28905163247788923,
-≥2,4000,ocrbench_ocrbench_accuracy,0.473,
-≥2,4000,seedbench_seed_all,0.4102834908282379,
-≥2,4000,textvqa_val_exact_match,0.4551200000000001,0.0067829756649846785
-≥2,5000,ai2d_exact_match,0.32577720207253885,0.008435168191407938
-≥2,5000,average,0.4029564015858402,
-≥2,5000,average_rank,2.5,
-≥2,5000,chartqa_relaxed_overall,0.5628,0.00992279440175477
-≥2,5000,docvqa_val_anls,0.548770508666009,0.006315482288099859
-≥2,5000,infovqa_val_anls,0.20783386531525747,0.006421967027729742
-≥2,5000,mme_total_score,1206.0127050820329,
-≥2,5000,mmmu_val_mmmu_acc,0.25667,
-≥2,5000,mmstar_average,0.3210115801865161,
-≥2,5000,ocrbench_ocrbench_accuracy,0.484,
-≥2,5000,seedbench_seed_all,0.4440244580322401,
-≥2,5000,textvqa_val_exact_match,0.47572,0.006783457774606987
-≥2,6000,ai2d_exact_match,0.3542746113989637,0.00860846328571982
-≥2,6000,average,0.4118759304334577,
-≥2,6000,average_rank,3.3,
-≥2,6000,chartqa_relaxed_overall,0.5644,0.00991868984106597
-≥2,6000,docvqa_val_anls,0.5618652265799138,0.006261889040657647
-≥2,6000,infovqa_val_anls,0.2101901707833487,0.006387610514125727
-≥2,6000,mme_total_score,1135.471288515406,
-≥2,6000,mmmu_val_mmmu_acc,0.26333,
-≥2,6000,mmstar_average,0.3255666447386709,
-≥2,6000,ocrbench_ocrbench_accuracy,0.482,
-≥2,6000,seedbench_seed_all,0.4740967204002223,
-≥2,6000,textvqa_val_exact_match,0.47116,0.00678908456375694
-≥2,7000,ai2d_exact_match,0.37338082901554404,0.008705816961084268
-≥2,7000,average,0.4291995483001856,
-≥2,7000,average_rank,2.4,
-≥2,7000,chartqa_relaxed_overall,0.5716,0.009898917689756362
-≥2,7000,docvqa_val_anls,0.5846126379804475,0.006218823793449337
-≥2,7000,infovqa_val_anls,0.2243908724169204,0.006651785538916188
-≥2,7000,mme_total_score,1249.9180672268908,
-≥2,7000,mmmu_val_mmmu_acc,0.27556,
-≥2,7000,mmstar_average,0.32644844909642934,
-≥2,7000,ocrbench_ocrbench_accuracy,0.506,
-≥2,7000,seedbench_seed_all,0.4936631461923291,
-≥2,7000,textvqa_val_exact_match,0.5071399999999999,0.00678246300696791
-≥2,8000,ai2d_exact_match,0.3963730569948187,0.008803757198545703
-≥2,8000,average,0.43448504857720643,
-≥2,8000,average_rank,3.0,
-≥2,8000,chartqa_relaxed_overall,0.5784,0.009878279615563902
-≥2,8000,docvqa_val_anls,0.5935884981677085,0.006228109848938283
-≥2,8000,infovqa_val_anls,0.22034669568379356,0.006538842004996925
-≥2,8000,mme_total_score,1251.6327531012405,
-≥2,8000,mmmu_val_mmmu_acc,0.27444,
-≥2,8000,mmstar_average,0.3368503047476477,
-≥2,8000,ocrbench_ocrbench_accuracy,0.516,
-≥2,8000,seedbench_seed_all,0.4963868816008894,
-≥2,8000,textvqa_val_exact_match,0.49798000000000003,0.006777844181917349
-≥2,9000,ai2d_exact_match,0.4015544041450777,0.008822998789014784
-≥2,9000,average,0.4409076865862069,
-≥2,9000,average_rank,2.8,
-≥2,9000,chartqa_relaxed_overall,0.5952,0.0098190299592035
-≥2,9000,docvqa_val_anls,0.6142957639909281,0.006149142953850004
-≥2,9000,infovqa_val_anls,0.225441641847203,0.006565814507342015
-≥2,9000,mme_total_score,1170.923569427771,
-≥2,9000,mmmu_val_mmmu_acc,0.28,
-≥2,9000,mmstar_average,0.32763888124373686,
-≥2,9000,ocrbench_ocrbench_accuracy,0.514,
-≥2,9000,seedbench_seed_all,0.5012784880489161,
-≥2,9000,textvqa_val_exact_match,0.50876,0.006788539558245703
-≥2,10000,ai2d_exact_match,0.4018782383419689,0.008824167272304229
-≥2,10000,average,0.44844067183729286,
-≥2,10000,average_rank,2.7,
-≥2,10000,chartqa_relaxed_overall,0.5956,0.009817474681589429
-≥2,10000,docvqa_val_anls,0.6161881255627961,0.006150295182189919
-≥2,10000,infovqa_val_anls,0.2273186020139702,0.006609762944776786
-≥2,10000,mme_total_score,1244.6918767507002,
-≥2,10000,mmmu_val_mmmu_acc,0.28667,
-≥2,10000,mmstar_average,0.3405769394273513,
-≥2,10000,ocrbench_ocrbench_accuracy,0.529,
-≥2,10000,seedbench_seed_all,0.5174541411895498,
-≥2,10000,textvqa_val_exact_match,0.52128,0.0067723707312184415
-≥2,11000,ai2d_exact_match,0.41386010362694303,0.008864599272573477
-≥2,11000,average,0.4508015001273205,
-≥2,11000,average_rank,3.1,
-≥2,11000,chartqa_relaxed_overall,0.5916,0.0098327233755248
-≥2,11000,docvqa_val_anls,0.6132516406541649,0.006147223601932411
-≥2,11000,infovqa_val_anls,0.23136501765139353,0.006670154065298524
-≥2,11000,mme_total_score,1193.1198479391755,
-≥2,11000,mmmu_val_mmmu_acc,0.28222,
-≥2,11000,mmstar_average,0.34055130285985363,
-≥2,11000,ocrbench_ocrbench_accuracy,0.544,
-≥2,11000,seedbench_seed_all,0.5137854363535297,
-≥2,11000,textvqa_val_exact_match,0.52658,0.006779520123033763
-≥2,12000,ai2d_exact_match,0.42033678756476683,0.008884198538329101
-≥2,12000,average,0.4593162089992856,
-≥2,12000,average_rank,2.4,
-≥2,12000,chartqa_relaxed_overall,0.612,0.009747841205275417
-≥2,12000,docvqa_val_anls,0.6322256818549263,0.006037251396803284
-≥2,12000,infovqa_val_anls,0.23499854511160906,0.006635085630122106
-≥2,12000,mme_total_score,1282.3226290516207,
-≥2,12000,mmmu_val_mmmu_acc,0.29444,
-≥2,12000,mmstar_average,0.3455632878074604,
-≥2,12000,ocrbench_ocrbench_accuracy,0.542,
-≥2,12000,seedbench_seed_all,0.5148415786548082,
-≥2,12000,textvqa_val_exact_match,0.5374399999999999,0.0067549667056943374
-≥2,13000,ai2d_exact_match,0.4329663212435233,0.008917911748577596
-≥2,13000,average,0.4594856750450977,
-≥2,13000,average_rank,3.1,
-≥2,13000,chartqa_relaxed_overall,0.6116,0.009749676839741497
-≥2,13000,docvqa_val_anls,0.6480115225202001,0.006082136258345928
-≥2,13000,infovqa_val_anls,0.2390399772273204,0.006801403608154099
-≥2,13000,mme_total_score,1255.4888955582232,
-≥2,13000,mmmu_val_mmmu_acc,0.26667,
-≥2,13000,mmstar_average,0.3276926929918222,
-≥2,13000,ocrbench_ocrbench_accuracy,0.551,
-≥2,13000,seedbench_seed_all,0.5190105614230128,
-≥2,13000,textvqa_val_exact_match,0.5393800000000001,0.006748937157104821
-≥2,14000,ai2d_exact_match,0.43523316062176165,0.00892333645202351
-≥2,14000,average,0.46380397688227554,
-≥2,14000,average_rank,3.4,
-≥2,14000,chartqa_relaxed_overall,0.6136,0.009740429476494075
-≥2,14000,docvqa_val_anls,0.6474419557198757,0.006056802443739013
-≥2,14000,infovqa_val_anls,0.24341248035748822,0.006789396426159645
-≥2,14000,mme_total_score,1209.5489195678272,
-≥2,14000,mmmu_val_mmmu_acc,0.27556,
-≥2,14000,mmstar_average,0.35309886783724065,
-≥2,14000,ocrbench_ocrbench_accuracy,0.545,
-≥2,14000,seedbench_seed_all,0.5207893274041134,
-≥2,14000,textvqa_val_exact_match,0.5400999999999999,0.006762835587905254
-≥2,15000,ai2d_exact_match,0.43588082901554404,0.008924851504668983
-≥2,15000,average,0.46327247775474995,
-≥2,15000,average_rank,3.4,
-≥2,15000,chartqa_relaxed_overall,0.614,0.009738559226822298
-≥2,15000,docvqa_val_anls,0.638973421646662,0.005999307255506728
-≥2,15000,infovqa_val_anls,0.23590457960067904,0.006699424952743598
-≥2,15000,mme_total_score,1230.12775110044,
-≥2,15000,mmmu_val_mmmu_acc,0.28667,
-≥2,15000,mmstar_average,0.3545309625815601,
-≥2,15000,ocrbench_ocrbench_accuracy,0.536,
-≥2,15000,seedbench_seed_all,0.5225125069483046,
-≥2,15000,textvqa_val_exact_match,0.54498,0.006749227387936104
-≥2,16000,ai2d_exact_match,0.4413860103626943,0.008937105222785166
-≥2,16000,average,0.4691799993543692,
-≥2,16000,average_rank,3.1,
-≥2,16000,chartqa_relaxed_overall,0.6168,0.009725273074549106
-≥2,16000,docvqa_val_anls,0.6539654303329543,0.00605387835402321
-≥2,16000,infovqa_val_anls,0.251011584102177,0.006888371171829252
-≥2,16000,mme_total_score,1235.6986794717886,
-≥2,16000,mmmu_val_mmmu_acc,0.28556,
-≥2,16000,mmstar_average,0.35467603553935745,
-≥2,16000,ocrbench_ocrbench_accuracy,0.545,
-≥2,16000,seedbench_seed_all,0.5256809338521401,
-≥2,16000,textvqa_val_exact_match,0.5485399999999999,0.0067546057338473825
-≥2,17000,ai2d_exact_match,0.43976683937823835,0.008933617011753861
-≥2,17000,average,0.47032074037035837,
-≥2,17000,average_rank,3.1,
-≥2,17000,chartqa_relaxed_overall,0.6184,0.009717527882093043
-≥2,17000,docvqa_val_anls,0.655318828070759,0.005978737407680595
-≥2,17000,infovqa_val_anls,0.24899610305034758,0.006825123869520012
-≥2,17000,mme_total_score,1246.5548219287716,
-≥2,17000,mmmu_val_mmmu_acc,0.29556,
-≥2,17000,mmstar_average,0.3399003792152031,
-≥2,17000,ocrbench_ocrbench_accuracy,0.553,
-≥2,17000,seedbench_seed_all,0.5241245136186771,
-≥2,17000,textvqa_val_exact_match,0.55782,0.0067278542139723035
-≥2,18000,ai2d_exact_match,0.4413860103626943,0.008937105222785166
-≥2,18000,average,0.4720458439616472,
-≥2,18000,average_rank,3.0,
-≥2,18000,chartqa_relaxed_overall,0.6256,0.009681288495793083
-≥2,18000,docvqa_val_anls,0.6595541124701471,0.00598982698063352
-≥2,18000,infovqa_val_anls,0.24628476636774824,0.006771852338911992
-≥2,18000,mme_total_score,1246.580632252901,
-≥2,18000,mmmu_val_mmmu_acc,0.29556,
-≥2,18000,mmstar_average,0.3370877286888103,
-≥2,18000,ocrbench_ocrbench_accuracy,0.557,
-≥2,18000,seedbench_seed_all,0.5279599777654252,
-≥2,18000,textvqa_val_exact_match,0.5579800000000001,0.006730967620262408
-≥2,19000,ai2d_exact_match,0.44009067357512954,0.008934322367529354
-≥2,19000,average,0.47484048232505544,
-≥2,19000,average_rank,3.1,
-≥2,19000,chartqa_relaxed_overall,0.6236,0.009691583292459796
-≥2,19000,docvqa_val_anls,0.656845810830509,0.005998201285366962
-≥2,19000,infovqa_val_anls,0.2483428639081206,0.006859079557818024
-≥2,19000,mme_total_score,1255.002801120448,
-≥2,19000,mmmu_val_mmmu_acc,0.30667,
-≥2,19000,mmstar_average,0.3484268658746636,
-≥2,19000,ocrbench_ocrbench_accuracy,0.557,
-≥2,19000,seedbench_seed_all,0.5306281267370762,
-≥2,19000,textvqa_val_exact_match,0.56196,0.006711810587335734
-≥2,20000,ai2d_exact_match,0.44397668393782386,0.008942485993062323
-≥2,20000,average,0.4719647885204447,
-≥2,20000,average_rank,3.3,
-≥2,20000,chartqa_relaxed_overall,0.6252,0.009683361554563506
-≥2,20000,docvqa_val_anls,0.6531065052301426,0.005958657790556006
-≥2,20000,infovqa_val_anls,0.2515640311557441,0.00684713602725156
-≥2,20000,mme_total_score,1269.56512605042,
-≥2,20000,mmmu_val_mmmu_acc,0.29222,
-≥2,20000,mmstar_average,0.3405247257210479,
-≥2,20000,ocrbench_ocrbench_accuracy,0.557,
-≥2,20000,seedbench_seed_all,0.528071150639244,
-≥2,20000,textvqa_val_exact_match,0.5560200000000001,0.006742124529303335
-≥3,1000,ai2d_exact_match,0.25712435233160624,0.007866134203324925
-≥3,1000,average,0.2908366935977347,
-≥3,1000,average_rank,2.6,
-≥3,1000,chartqa_relaxed_overall,0.3724,0.009670817229291067
-≥3,1000,docvqa_val_anls,0.36190361730095816,0.005874681377878617
-≥3,1000,infovqa_val_anls,0.1897409167650202,0.006570751118077319
-≥3,1000,mme_total_score,938.3572428971589,
-≥3,1000,mmmu_val_mmmu_acc,0.26333,
-≥3,1000,mmstar_average,0.2361438073438948,
-≥3,1000,ocrbench_ocrbench_accuracy,0.313,
-≥3,1000,seedbench_seed_all,0.25758754863813227,
-≥3,1000,textvqa_val_exact_match,0.36629999999999996,0.006582851113746775
-≥3,2000,ai2d_exact_match,0.25647668393782386,0.007859644922870102
-≥3,2000,average,0.327478691314146,
-≥3,2000,average_rank,2.9,
-≥3,2000,chartqa_relaxed_overall,0.4708,0.009984929820955767
-≥3,2000,docvqa_val_anls,0.455859181323049,0.0061669106819143196
-≥3,2000,infovqa_val_anls,0.20804914764579785,0.0066905821266465505
-≥3,2000,mme_total_score,990.4248699479792,
-≥3,2000,mmmu_val_mmmu_acc,0.27111,
-≥3,2000,mmstar_average,0.21380673865938699,
-≥3,2000,ocrbench_ocrbench_accuracy,0.405,
-≥3,2000,seedbench_seed_all,0.26364647026125626,
-≥3,2000,textvqa_val_exact_match,0.40256,0.0066960030295180025
-≥3,3000,ai2d_exact_match,0.2697538860103627,0.007988222765138163
-≥3,3000,average,0.34640625458292296,
-≥3,3000,average_rank,3.1,
-≥3,3000,chartqa_relaxed_overall,0.514,0.009998079047189691
-≥3,3000,docvqa_val_anls,0.4749731938810012,0.00604931863100692
-≥3,3000,infovqa_val_anls,0.19785201580687228,0.00636819106561235
-≥3,3000,mme_total_score,1022.0748299319728,
-≥3,3000,mmmu_val_mmmu_acc,0.26556,
-≥3,3000,mmstar_average,0.2234035546364529,
-≥3,3000,ocrbench_ocrbench_accuracy,0.435,
-≥3,3000,seedbench_seed_all,0.29655364091161757,
-≥3,3000,textvqa_val_exact_match,0.44056000000000006,0.006770653264576898
-≥3,4000,ai2d_exact_match,0.31476683937823835,0.008358827401711809
-≥3,4000,average,0.3840989485719881,
-≥3,4000,average_rank,2.5,
-≥3,4000,chartqa_relaxed_overall,0.5244,0.009990083919101193
-≥3,4000,docvqa_val_anls,0.5398623644141017,0.006209437344747972
-≥3,4000,infovqa_val_anls,0.21841657659961455,0.006654701266433889
-≥3,4000,mme_total_score,1008.1938775510204,
-≥3,4000,mmmu_val_mmmu_acc,0.27778,
-≥3,4000,mmstar_average,0.25611290572758977,
-≥3,4000,ocrbench_ocrbench_accuracy,0.462,
-≥3,4000,seedbench_seed_all,0.39733185102834906,
-≥3,4000,textvqa_val_exact_match,0.46621999999999997,0.006799457981763631
-≥3,5000,ai2d_exact_match,0.3442357512953368,0.008551327504046387
-≥3,5000,average,0.4034839586685592,
-≥3,5000,average_rank,2.4,
-≥3,5000,chartqa_relaxed_overall,0.5544,0.009942625323290008
-≥3,5000,docvqa_val_anls,0.5567727758893183,0.006173642024037381
-≥3,5000,infovqa_val_anls,0.21638639427926507,0.006559084868006158
-≥3,5000,mme_total_score,1074.1284513805522,
-≥3,5000,mmmu_val_mmmu_acc,0.26778,
-≥3,5000,mmstar_average,0.3009278216170371,
-≥3,5000,ocrbench_ocrbench_accuracy,0.482,
-≥3,5000,seedbench_seed_all,0.4471928849360756,
-≥3,5000,textvqa_val_exact_match,0.46165999999999996,0.006793381991893107
-≥3,6000,ai2d_exact_match,0.36819948186528495,0.008680870162409787
-≥3,6000,average,0.41987173897944946,
-≥3,6000,average_rank,2.2,
-≥3,6000,chartqa_relaxed_overall,0.5636,0.009920755241100424
-≥3,6000,docvqa_val_anls,0.5766507662420887,0.006104661016322198
-≥3,6000,infovqa_val_anls,0.2209691160904877,0.0066290878786102805
-≥3,6000,mme_total_score,1088.6353541416568,
-≥3,6000,mmmu_val_mmmu_acc,0.29778,
-≥3,6000,mmstar_average,0.2960442855054549,
-≥3,6000,ocrbench_ocrbench_accuracy,0.496,
-≥3,6000,seedbench_seed_all,0.48360200111172874,
-≥3,6000,textvqa_val_exact_match,0.476,0.006791614329821814
-≥3,7000,ai2d_exact_match,0.3905440414507772,0.008780876258359173
-≥3,7000,average,0.4305333557001585,
-≥3,7000,average_rank,2.4,
-≥3,7000,chartqa_relaxed_overall,0.5744,0.009890651444389179
-≥3,7000,docvqa_val_anls,0.5943945047786826,0.006168637154272831
-≥3,7000,infovqa_val_anls,0.23015651757384684,0.006652654324068369
-≥3,7000,mme_total_score,1024.3486394557824,
-≥3,7000,mmmu_val_mmmu_acc,0.29,
-≥3,7000,mmstar_average,0.3086297067032336,
-≥3,7000,ocrbench_ocrbench_accuracy,0.496,
-≥3,7000,seedbench_seed_all,0.49577543079488606,
-≥3,7000,textvqa_val_exact_match,0.4949,0.006791673090238732
-≥3,8000,ai2d_exact_match,0.39863989637305697,0.008812301996070583
-≥3,8000,average,0.43894563539556736,
-≥3,8000,average_rank,2.4,
-≥3,8000,chartqa_relaxed_overall,0.5812,0.009869224115088964
-≥3,8000,docvqa_val_anls,0.597896936397571,0.006178924858305047
-≥3,8000,infovqa_val_anls,0.23624667779429379,0.006701812126185011
-≥3,8000,mme_total_score,1087.3003201280512,
-≥3,8000,mmmu_val_mmmu_acc,0.30444,
-≥3,8000,mmstar_average,0.3179238728089695,
-≥3,8000,ocrbench_ocrbench_accuracy,0.52,
-≥3,8000,seedbench_seed_all,0.5060033351862145,
-≥3,8000,textvqa_val_exact_match,0.48816000000000004,0.006805617250862191
-≥3,9000,ai2d_exact_match,0.4073834196891192,0.008843420154535594
-≥3,9000,average,0.4380819691649286,
-≥3,9000,average_rank,2.8,
-≥3,9000,chartqa_relaxed_overall,0.5892,0.009841548985529353
-≥3,9000,docvqa_val_anls,0.5926801961513722,0.00607014347283834
-≥3,9000,infovqa_val_anls,0.22884227739619317,0.006587321958723987
-≥3,9000,mme_total_score,960.1394557823129,
-≥3,9000,mmmu_val_mmmu_acc,0.29222,
-≥3,9000,mmstar_average,0.3023124740503409,
-≥3,9000,ocrbench_ocrbench_accuracy,0.516,
-≥3,9000,seedbench_seed_all,0.5108393551973318,
-≥3,9000,textvqa_val_exact_match,0.50326,0.006787480273097782
-≥3,10000,ai2d_exact_match,0.42487046632124353,0.008896983637113786
-≥3,10000,average,0.45376975700130806,
-≥3,10000,average_rank,2.5,
-≥3,10000,chartqa_relaxed_overall,0.592,0.009831228876620145
-≥3,10000,docvqa_val_anls,0.6288940533515488,0.006078026262812974
-≥3,10000,infovqa_val_anls,0.2639557991160976,0.007015193539901653
-≥3,10000,mme_total_score,1135.5116046418568,
-≥3,10000,mmmu_val_mmmu_acc,0.29556,
-≥3,10000,mmstar_average,0.3171165325775241,
-≥3,10000,ocrbench_ocrbench_accuracy,0.53,
-≥3,10000,seedbench_seed_all,0.5157309616453586,
-≥3,10000,textvqa_val_exact_match,0.5158,0.0067831610812991135
-≥3,11000,ai2d_exact_match,0.4271373056994819,0.008903088856242218
-≥3,11000,average,0.4507656942256156,
-≥3,11000,average_rank,3.1,
-≥3,11000,chartqa_relaxed_overall,0.6008,0.00979663889573671
-≥3,11000,docvqa_val_anls,0.6266233612884972,0.006097228164879785
-≥3,11000,infovqa_val_anls,0.23605295775343718,0.006674753327687541
-≥3,11000,mme_total_score,1115.0593237294918,
-≥3,11000,mmmu_val_mmmu_acc,0.27889,
-≥3,11000,mmstar_average,0.3244509807099135,
-≥3,11000,ocrbench_ocrbench_accuracy,0.524,
-≥3,11000,seedbench_seed_all,0.5219566425792107,
-≥3,11000,textvqa_val_exact_match,0.5169799999999999,0.006776837095888084
-≥3,12000,ai2d_exact_match,0.42843264248704666,0.008906491762178372
-≥3,12000,average,0.4596080978908205,
-≥3,12000,average_rank,2.6,
-≥3,12000,chartqa_relaxed_overall,0.6048,0.009779828322460816
-≥3,12000,docvqa_val_anls,0.6391083009950597,0.006038971765674556
-≥3,12000,infovqa_val_anls,0.24141834493583503,0.006794485284013245
-≥3,12000,mme_total_score,1183.3176270508202,
-≥3,12000,mmmu_val_mmmu_acc,0.28444,
-≥3,12000,mmstar_average,0.3293224419601992,
-≥3,12000,ocrbench_ocrbench_accuracy,0.555,
-≥3,12000,seedbench_seed_all,0.528071150639244,
-≥3,12000,textvqa_val_exact_match,0.5258799999999999,0.006773951756875811
-≥3,13000,ai2d_exact_match,0.43458549222797926,0.008921805911548515
-≥3,13000,average,0.4623863039639755,
-≥3,13000,average_rank,2.7,
-≥3,13000,chartqa_relaxed_overall,0.6108,0.00975332737879659
-≥3,13000,docvqa_val_anls,0.6376374898768016,0.006015671277879292
-≥3,13000,infovqa_val_anls,0.24710671614089955,0.006756961641692092
-≥3,13000,mme_total_score,1261.84493797519,
-≥3,13000,mmmu_val_mmmu_acc,0.28889,
-≥3,13000,mmstar_average,0.3264133242561134,
-≥3,13000,ocrbench_ocrbench_accuracy,0.553,
-≥3,13000,seedbench_seed_all,0.5306837131739855,
-≥3,13000,textvqa_val_exact_match,0.5323599999999999,0.0067627001192260856
-≥3,14000,ai2d_exact_match,0.4381476683937824,0.008930032335354969
-≥3,14000,average,0.4678786302971554,
-≥3,14000,average_rank,2.8,
-≥3,14000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-≥3,14000,docvqa_val_anls,0.6523739582747238,0.006065891171788989
-≥3,14000,infovqa_val_anls,0.2541881734588241,0.006851623469491799
-≥3,14000,mme_total_score,1188.5243097238895,
-≥3,14000,mmmu_val_mmmu_acc,0.30333,
-≥3,14000,mmstar_average,0.3360144984503474,
-≥3,14000,ocrbench_ocrbench_accuracy,0.544,
-≥3,14000,seedbench_seed_all,0.5320733740967204,
-≥3,14000,textvqa_val_exact_match,0.54038,0.006754155375986593
-≥3,15000,ai2d_exact_match,0.4420336787564767,0.008938473522297184
-≥3,15000,average,0.4717225541426424,
-≥3,15000,average_rank,2.6,
-≥3,15000,chartqa_relaxed_overall,0.6204,0.009707689307588963
-≥3,15000,docvqa_val_anls,0.6657062061222615,0.005987913582977679
-≥3,15000,infovqa_val_anls,0.2547770182395889,0.00697535381427897
-≥3,15000,mme_total_score,1150.081532613045,
-≥3,15000,mmmu_val_mmmu_acc,0.29889,
-≥3,15000,mmstar_average,0.32974187627218104,
-≥3,15000,ocrbench_ocrbench_accuracy,0.556,
-≥3,15000,seedbench_seed_all,0.533574207893274,
-≥3,15000,textvqa_val_exact_match,0.54438,0.006740769296908389
-≥3,16000,ai2d_exact_match,0.44397668393782386,0.008942485993062323
-≥3,16000,average,0.4725329505079693,
-≥3,16000,average_rank,2.7,
-≥3,16000,chartqa_relaxed_overall,0.6136,0.009740429476494075
-≥3,16000,docvqa_val_anls,0.6627356411508976,0.00599828184206493
-≥3,16000,infovqa_val_anls,0.25144929243788827,0.006859545868541458
-≥3,16000,mme_total_score,1189.4136654661866,
-≥3,16000,mmmu_val_mmmu_acc,0.30556,
-≥3,16000,mmstar_average,0.32828609880164517,
-≥3,16000,ocrbench_ocrbench_accuracy,0.565,
-≥3,16000,seedbench_seed_all,0.5359088382434686,
-≥3,16000,textvqa_val_exact_match,0.54628,0.006755557699551266
-≥3,17000,ai2d_exact_match,0.4423575129533679,0.008939151893135124
-≥3,17000,average,0.47219284094380815,
-≥3,17000,average_rank,2.9,
-≥3,17000,chartqa_relaxed_overall,0.6196,0.009711645711462604
-≥3,17000,docvqa_val_anls,0.6671354152323413,0.005979986643812461
-≥3,17000,infovqa_val_anls,0.26085018558007095,0.006930202483417548
-≥3,17000,mme_total_score,1181.9268707482993,
-≥3,17000,mmmu_val_mmmu_acc,0.29667,
-≥3,17000,mmstar_average,0.3246494808541184,
-≥3,17000,ocrbench_ocrbench_accuracy,0.556,
-≥3,17000,seedbench_seed_all,0.5353529738743746,
-≥3,17000,textvqa_val_exact_match,0.5471199999999999,0.006741055517194408
-≥3,18000,ai2d_exact_match,0.44624352331606215,0.0089469921763539
-≥3,18000,average,0.47727537354972976,
-≥3,18000,average_rank,2.8,
-≥3,18000,chartqa_relaxed_overall,0.6212,0.009703704898413913
-≥3,18000,docvqa_val_anls,0.6676971859833172,0.005968624246725931
-≥3,18000,infovqa_val_anls,0.2614701461784385,0.006943538426265278
-≥3,18000,mme_total_score,1133.047819127651,
-≥3,18000,mmmu_val_mmmu_acc,0.30444,
-≥3,18000,mmstar_average,0.3242292852357318,
-≥3,18000,ocrbench_ocrbench_accuracy,0.582,
-≥3,18000,seedbench_seed_all,0.5367982212340189,
-≥3,18000,textvqa_val_exact_match,0.5513999999999999,0.006735687188133017
-≥3,19000,ai2d_exact_match,0.4520725388601036,0.008957715852675527
-≥3,19000,average,0.4762675915069992,
-≥3,19000,average_rank,3.0,
-≥3,19000,chartqa_relaxed_overall,0.6216,0.009701702181065136
-≥3,19000,docvqa_val_anls,0.6679273632688325,0.00596194457686321
-≥3,19000,infovqa_val_anls,0.25211534311880446,0.006837669178934141
-≥3,19000,mme_total_score,1168.6077430972389,
-≥3,19000,mmmu_val_mmmu_acc,0.30111,
-≥3,19000,mmstar_average,0.334229548576509,
-≥3,19000,ocrbench_ocrbench_accuracy,0.566,
-≥3,19000,seedbench_seed_all,0.5363535297387437,
-≥3,19000,textvqa_val_exact_match,0.555,0.006737661257130932
-≥3,20000,ai2d_exact_match,0.4566062176165803,0.008965198879336198
-≥3,20000,average,0.4782761612786655,
-≥3,20000,average_rank,2.7,
-≥3,20000,chartqa_relaxed_overall,0.6268,0.009675026948726469
-≥3,20000,docvqa_val_anls,0.6699567897644018,0.005975453790424837
-≥3,20000,infovqa_val_anls,0.2594904076423186,0.006910668664574003
-≥3,20000,mme_total_score,1194.4682873149259,
-≥3,20000,mmmu_val_mmmu_acc,0.30667,
-≥3,20000,mmstar_average,0.3291890626103143,
-≥3,20000,ocrbench_ocrbench_accuracy,0.571,
-≥3,20000,seedbench_seed_all,0.5353529738743746,
-≥3,20000,textvqa_val_exact_match,0.54942,0.0067426571472292
-≥4,1000,ai2d_exact_match,0.266839378238342,0.007960790788435024
-≥4,1000,average,0.28718938224797474,
-≥4,1000,average_rank,2.8,
-≥4,1000,chartqa_relaxed_overall,0.3824,0.009721414421746647
-≥4,1000,docvqa_val_anls,0.3742280929549393,0.005897617626003216
-≥4,1000,infovqa_val_anls,0.18767733564942402,0.006495529242061099
-≥4,1000,mme_total_score,970.0657262905162,
-≥4,1000,mmmu_val_mmmu_acc,0.24667,
-≥4,1000,mmstar_average,0.20409674845299178,
-≥4,1000,ocrbench_ocrbench_accuracy,0.324,
-≥4,1000,seedbench_seed_all,0.2471928849360756,
-≥4,1000,textvqa_val_exact_match,0.3516,0.006519815150594346
-≥4,2000,ai2d_exact_match,0.2700777202072539,0.007991243694641088
-≥4,2000,average,0.32538295993176786,
-≥4,2000,average_rank,2.8,
-≥4,2000,chartqa_relaxed_overall,0.476,0.009990471651004463
-≥4,2000,docvqa_val_anls,0.45055679456484166,0.006087636141467791
-≥4,2000,infovqa_val_anls,0.21184608413063888,0.006740983882332282
-≥4,2000,mme_total_score,1065.059423769508,
-≥4,2000,mmmu_val_mmmu_acc,0.25444,
-≥4,2000,mmstar_average,0.20479630173942967,
-≥4,2000,ocrbench_ocrbench_accuracy,0.404,
-≥4,2000,seedbench_seed_all,0.2535297387437465,
-≥4,2000,textvqa_val_exact_match,0.4032,0.00669032914742019
-≥4,3000,ai2d_exact_match,0.26813471502590674,0.007973037037795191
-≥4,3000,average,0.3429973351943505,
-≥4,3000,average_rank,3.6,
-≥4,3000,chartqa_relaxed_overall,0.5052,0.010001459677380663
-≥4,3000,docvqa_val_anls,0.4883627712637139,0.006123671768321872
-≥4,3000,infovqa_val_anls,0.2020989926298624,0.006492359244043468
-≥4,3000,mme_total_score,1028.0742296918768,
-≥4,3000,mmmu_val_mmmu_acc,0.24444,
-≥4,3000,mmstar_average,0.23755500197641968,
-≥4,3000,ocrbench_ocrbench_accuracy,0.417,
-≥4,3000,seedbench_seed_all,0.2961645358532518,
-≥4,3000,textvqa_val_exact_match,0.42802000000000007,0.006729073636571477
-≥4,4000,ai2d_exact_match,0.297279792746114,0.008226320033454882
-≥4,4000,average,0.37640705986204226,
-≥4,4000,average_rank,3.0,
-≥4,4000,chartqa_relaxed_overall,0.5328,0.009980456292330589
-≥4,4000,docvqa_val_anls,0.5114700599486628,0.006120071866795458
-≥4,4000,infovqa_val_anls,0.20557836945629954,0.006329851460183733
-≥4,4000,mme_total_score,1074.640656262505,
-≥4,4000,mmmu_val_mmmu_acc,0.25889,
-≥4,4000,mmstar_average,0.24011275407256244,
-≥4,4000,ocrbench_ocrbench_accuracy,0.489,
-≥4,4000,seedbench_seed_all,0.40261256253474154,
-≥4,4000,textvqa_val_exact_match,0.44992,0.006773387223162055
-≥4,5000,ai2d_exact_match,0.32998704663212436,0.008462949140760363
-≥4,5000,average,0.3995227518308942,
-≥4,5000,average_rank,2.8,
-≥4,5000,chartqa_relaxed_overall,0.55,0.009951864943131942
-≥4,5000,docvqa_val_anls,0.5627332434349699,0.006167596088104117
-≥4,5000,infovqa_val_anls,0.20676909019266723,0.0063195922615256655
-≥4,5000,mme_total_score,1081.3841536614646,
-≥4,5000,mmmu_val_mmmu_acc,0.26667,
-≥4,5000,mmstar_average,0.26742033896981504,
-≥4,5000,ocrbench_ocrbench_accuracy,0.49,
-≥4,5000,seedbench_seed_all,0.4530850472484714,
-≥4,5000,textvqa_val_exact_match,0.46903999999999996,0.006785801728684695
-≥4,6000,ai2d_exact_match,0.35654145077720206,0.008620788425978479
-≥4,6000,average,0.41458714913417777,
-≥4,6000,average_rank,2.8,
-≥4,6000,chartqa_relaxed_overall,0.5632,0.009921778100334079
-≥4,6000,docvqa_val_anls,0.5818014224607982,0.006182490179642956
-≥4,6000,infovqa_val_anls,0.2145391217079547,0.006472934595237677
-≥4,6000,mme_total_score,1132.2886154461785,
-≥4,6000,mmmu_val_mmmu_acc,0.26667,
-≥4,6000,mmstar_average,0.28714914548287923,
-≥4,6000,ocrbench_ocrbench_accuracy,0.499,
-≥4,6000,seedbench_seed_all,0.47376320177876596,
-≥4,6000,textvqa_val_exact_match,0.48862,0.006787319991169747
-≥4,7000,ai2d_exact_match,0.38471502590673573,0.008756678690415541
-≥4,7000,average,0.42592935170009355,
-≥4,7000,average_rank,3.1,
-≥4,7000,chartqa_relaxed_overall,0.5804,0.009871844677005952
-≥4,7000,docvqa_val_anls,0.5710623718792285,0.006078423874650784
-≥4,7000,infovqa_val_anls,0.22007869704137703,0.006475129444868969
-≥4,7000,mme_total_score,1041.2597038815525,
-≥4,7000,mmmu_val_mmmu_acc,0.28444,
-≥4,7000,mmstar_average,0.3026487819798931,
-≥4,7000,ocrbench_ocrbench_accuracy,0.502,
-≥4,7000,seedbench_seed_all,0.4947192884936076,
-≥4,7000,textvqa_val_exact_match,0.4933,0.006785560460724908
-≥4,8000,ai2d_exact_match,0.3915155440414508,0.008784780895708938
-≥4,8000,average,0.43659006376695136,
-≥4,8000,average_rank,3.0,
-≥4,8000,chartqa_relaxed_overall,0.5736,0.009893046292521752
-≥4,8000,docvqa_val_anls,0.6079864136742988,0.006139878520335163
-≥4,8000,infovqa_val_anls,0.23243402779245617,0.006686893363455147
-≥4,8000,mme_total_score,1108.9173669467787,
-≥4,8000,mmmu_val_mmmu_acc,0.28,
-≥4,8000,mmstar_average,0.3276025817239844,
-≥4,8000,ocrbench_ocrbench_accuracy,0.508,
-≥4,8000,seedbench_seed_all,0.5016120066703724,
-≥4,8000,textvqa_val_exact_match,0.50656,0.006805281452749051
-≥4,9000,ai2d_exact_match,0.39248704663212436,0.008788649010397578
-≥4,9000,average,0.4379212821083599,
-≥4,9000,average_rank,2.9,
-≥4,9000,chartqa_relaxed_overall,0.5844,0.009858475126140203
-≥4,9000,docvqa_val_anls,0.6225000882770518,0.00610983265425905
-≥4,9000,infovqa_val_anls,0.2357319670089269,0.006735352134813103
-≥4,9000,mme_total_score,1054.3165266106444,
-≥4,9000,mmmu_val_mmmu_acc,0.28556,
-≥4,9000,mmstar_average,0.30919474945291153,
-≥4,9000,ocrbench_ocrbench_accuracy,0.496,
-≥4,9000,seedbench_seed_all,0.5078376876042245,
-≥4,9000,textvqa_val_exact_match,0.50758,0.0067866133191798106
-≥4,10000,ai2d_exact_match,0.4177461139896373,0.008876547725654098
-≥4,10000,average,0.4482945169324334,
-≥4,10000,average_rank,3.0,
-≥4,10000,chartqa_relaxed_overall,0.5872,0.009848718845878486
-≥4,10000,docvqa_val_anls,0.6178172719068701,0.006018237392964321
-≥4,10000,infovqa_val_anls,0.24180220451279583,0.006673139519957623
-≥4,10000,mme_total_score,1143.5380152060825,
-≥4,10000,mmmu_val_mmmu_acc,0.29667,
-≥4,10000,mmstar_average,0.31635030378359796,
-≥4,10000,ocrbench_ocrbench_accuracy,0.524,
-≥4,10000,seedbench_seed_all,0.5165647581989995,
-≥4,10000,textvqa_val_exact_match,0.5165,0.006796704277648658
-≥4,11000,ai2d_exact_match,0.41515544041450775,0.00886864516657515
-≥4,11000,average,0.45134109009976725,
-≥4,11000,average_rank,2.5,
-≥4,11000,chartqa_relaxed_overall,0.5956,0.009817474681589429
-≥4,11000,docvqa_val_anls,0.629269001239484,0.00608373788497042
-≥4,11000,infovqa_val_anls,0.24324006994727237,0.006777064540159464
-≥4,11000,mme_total_score,1228.8085234093637,
-≥4,11000,mmmu_val_mmmu_acc,0.28333,
-≥4,11000,mmstar_average,0.3288790569397762,
-≥4,11000,ocrbench_ocrbench_accuracy,0.522,
-≥4,11000,seedbench_seed_all,0.525236242356865,
-≥4,11000,textvqa_val_exact_match,0.5193599999999999,0.0067761804436039675
-≥4,12000,ai2d_exact_match,0.4183937823834197,0.008878484004260249
-≥4,12000,average,0.45687238598965646,
-≥4,12000,average_rank,3.3,
-≥4,12000,chartqa_relaxed_overall,0.5988,0.0098047885010856
-≥4,12000,docvqa_val_anls,0.6281800356608191,0.005956403319187123
-≥4,12000,infovqa_val_anls,0.242249391011484,0.006664412716854741
-≥4,12000,mme_total_score,1051.548619447779,
-≥4,12000,mmmu_val_mmmu_acc,0.28,
-≥4,12000,mmstar_average,0.32638661949265274,
-≥4,12000,ocrbench_ocrbench_accuracy,0.553,
-≥4,12000,seedbench_seed_all,0.5309616453585325,
-≥4,12000,textvqa_val_exact_match,0.53388,0.006762808309810877
-≥4,13000,ai2d_exact_match,0.4323186528497409,0.008916326937351901
-≥4,13000,average,0.46134498058034357,
-≥4,13000,average_rank,3.1,
-≥4,13000,chartqa_relaxed_overall,0.5948,0.009820578470976232
-≥4,13000,docvqa_val_anls,0.6459204882256453,0.006047391420582867
-≥4,13000,infovqa_val_anls,0.24395762124162781,0.006787945348887751
-≥4,13000,mme_total_score,1195.637755102041,
-≥4,13000,mmmu_val_mmmu_acc,0.29556,
-≥4,13000,mmstar_average,0.329867095702076,
-≥4,13000,ocrbench_ocrbench_accuracy,0.542,
-≥4,13000,seedbench_seed_all,0.5337409672040022,
-≥4,13000,textvqa_val_exact_match,0.53394,0.006767804364428913
-≥4,14000,ai2d_exact_match,0.4319948186528497,0.008915528710615492
-≥4,14000,average,0.4668148142530245,
-≥4,14000,average_rank,2.7,
-≥4,14000,chartqa_relaxed_overall,0.6076,0.009767653701044555
-≥4,14000,docvqa_val_anls,0.6561789267585798,0.005953346874132679
-≥4,14000,infovqa_val_anls,0.24945371957223306,0.006769327490532885
-≥4,14000,mme_total_score,1259.298019207683,
-≥4,14000,mmmu_val_mmmu_acc,0.30111,
-≥4,14000,mmstar_average,0.32172026573936097,
-≥4,14000,ocrbench_ocrbench_accuracy,0.55,
-≥4,14000,seedbench_seed_all,0.5360755975541968,
-≥4,14000,textvqa_val_exact_match,0.5472000000000001,0.006748951153204005
-≥4,15000,ai2d_exact_match,0.44624352331606215,0.008946992176353898
-≥4,15000,average,0.46662671868754135,
-≥4,15000,average_rank,2.9,
-≥4,15000,chartqa_relaxed_overall,0.6044,0.009781540134915584
-≥4,15000,docvqa_val_anls,0.6622581274446402,0.005962189435141322
-≥4,15000,infovqa_val_anls,0.2534140745372918,0.006885986461871116
-≥4,15000,mme_total_score,1200.2537014805923,
-≥4,15000,mmmu_val_mmmu_acc,0.29,
-≥4,15000,mmstar_average,0.3198168607331238,
-≥4,15000,ocrbench_ocrbench_accuracy,0.538,
-≥4,15000,seedbench_seed_all,0.5381878821567537,
-≥4,15000,textvqa_val_exact_match,0.54732,0.006746470669416614
-≥4,16000,ai2d_exact_match,0.43911917098445596,0.008932194723472647
-≥4,16000,average,0.46812785270927354,
-≥4,16000,average_rank,3.0,
-≥4,16000,chartqa_relaxed_overall,0.6108,0.00975332737879659
-≥4,16000,docvqa_val_anls,0.6699643513666329,0.005944732124585459
-≥4,16000,infovqa_val_anls,0.2589072217280723,0.006864729360775582
-≥4,16000,mme_total_score,1239.2577030812326,
-≥4,16000,mmmu_val_mmmu_acc,0.28444,
-≥4,16000,mmstar_average,0.3155913699930164,
-≥4,16000,ocrbench_ocrbench_accuracy,0.547,
-≥4,16000,seedbench_seed_all,0.535408560311284,
-≥4,16000,textvqa_val_exact_match,0.55192,0.006727935474062503
-≥4,17000,ai2d_exact_match,0.44591968911917096,0.00894635996642554
-≥4,17000,average,0.4711902865454063,
-≥4,17000,average_rank,2.9,
-≥4,17000,chartqa_relaxed_overall,0.6092,0.009760545645634788
-≥4,17000,docvqa_val_anls,0.6630256300679175,0.005926991608870499
-≥4,17000,infovqa_val_anls,0.2604941623528308,0.0069459226352746855
-≥4,17000,mme_total_score,1231.9475790316128,
-≥4,17000,mmmu_val_mmmu_acc,0.28667,
-≥4,17000,mmstar_average,0.3281863880858027,
-≥4,17000,ocrbench_ocrbench_accuracy,0.559,
-≥4,17000,seedbench_seed_all,0.5380767092829349,
-≥4,17000,textvqa_val_exact_match,0.55014,0.00673464677421427
-≥4,18000,ai2d_exact_match,0.44527202072538863,0.008945084019331404
-≥4,18000,average,0.4730863890198541,
-≥4,18000,average_rank,3.1,
-≥4,18000,chartqa_relaxed_overall,0.6148,0.00973479791861169
-≥4,18000,docvqa_val_anls,0.6724670614264582,0.0059283840951577715
-≥4,18000,infovqa_val_anls,0.2591524677671406,0.006860568910244235
-≥4,18000,mme_total_score,1230.187074829932,
-≥4,18000,mmmu_val_mmmu_acc,0.28222,
-≥4,18000,mmstar_average,0.3313130996754855,
-≥4,18000,ocrbench_ocrbench_accuracy,0.559,
-≥4,18000,seedbench_seed_all,0.5391328515842134,
-≥4,18000,textvqa_val_exact_match,0.55442,0.0067378017419973775
-≥4,19000,ai2d_exact_match,0.4475388601036269,0.008949482610884277
-≥4,19000,average,0.4748981492546839,
-≥4,19000,average_rank,3.0,
-≥4,19000,chartqa_relaxed_overall,0.614,0.009738559226822298
-≥4,19000,docvqa_val_anls,0.6780110114952748,0.005954038851856335
-≥4,19000,infovqa_val_anls,0.2592553130284412,0.0068947091925615645
-≥4,19000,mme_total_score,1280.6934773909566,
-≥4,19000,mmmu_val_mmmu_acc,0.29778,
-≥4,19000,mmstar_average,0.33015385627459537,
-≥4,19000,ocrbench_ocrbench_accuracy,0.55,
-≥4,19000,seedbench_seed_all,0.5397443023902168,
-≥4,19000,textvqa_val_exact_match,0.5576000000000001,0.00671993150976252
-≥4,20000,ai2d_exact_match,0.45077720207253885,0.008955440137395838
-≥4,20000,average,0.47750231781976243,
-≥4,20000,average_rank,2.7,
-≥4,20000,chartqa_relaxed_overall,0.6204,0.009707689307588963
-≥4,20000,docvqa_val_anls,0.673153386104693,0.005945073379634221
-≥4,20000,infovqa_val_anls,0.2604945747241511,0.006917780880359967
-≥4,20000,mme_total_score,1348.6498599439776,
-≥4,20000,mmmu_val_mmmu_acc,0.29222,
-≥4,20000,mmstar_average,0.32618642565880246,
-≥4,20000,ocrbench_ocrbench_accuracy,0.569,
-≥4,20000,seedbench_seed_all,0.5406892718176765,
-≥4,20000,textvqa_val_exact_match,0.5646,0.006722023885782034
-≥5,1000,ai2d_exact_match,0.27396373056994816,0.008027076080717028
-≥5,1000,average,0.26438200891802877,
-≥5,1000,average_rank,3.0,
-≥5,1000,chartqa_relaxed_overall,0.2832,0.00901285729603301
-≥5,1000,docvqa_val_anls,0.32055326545515606,0.0056245129740867565
-≥5,1000,infovqa_val_anls,0.15327397474830004,0.005916826112508726
-≥5,1000,mme_total_score,1087.6624649859943,
-≥5,1000,mmmu_val_mmmu_acc,0.29778,
-≥5,1000,mmstar_average,0.26060215117868224,
-≥5,1000,ocrbench_ocrbench_accuracy,0.259,
-≥5,1000,seedbench_seed_all,0.2649249583101723,
-≥5,1000,textvqa_val_exact_match,0.26614,0.006037548383085275
-≥5,2000,ai2d_exact_match,0.26392487046632124,0.007932917099101329
-≥5,2000,average,0.2929576826335877,
-≥5,2000,average_rank,3.3,
-≥5,2000,chartqa_relaxed_overall,0.3824,0.009721414421746647
-≥5,2000,docvqa_val_anls,0.3929824030686217,0.005977850940256623
-≥5,2000,infovqa_val_anls,0.15895135963621443,0.005878593482981634
-≥5,2000,mme_total_score,1073.4139655862346,
-≥5,2000,mmmu_val_mmmu_acc,0.27333,
-≥5,2000,mmstar_average,0.25335477956948643,
-≥5,2000,ocrbench_ocrbench_accuracy,0.301,
-≥5,2000,seedbench_seed_all,0.26831573096164535,
-≥5,2000,textvqa_val_exact_match,0.34236,0.006479253215027554
-≥5,3000,ai2d_exact_match,0.2600388601036269,0.007895056974601723
-≥5,3000,average,0.3126381365493242,
-≥5,3000,average_rank,3.9,
-≥5,3000,chartqa_relaxed_overall,0.4324,0.009910165515884228
-≥5,3000,docvqa_val_anls,0.4366357263318607,0.00610598785442012
-≥5,3000,infovqa_val_anls,0.17846201123654198,0.006273305639193489
-≥5,3000,mme_total_score,1164.5565226090434,
-≥5,3000,mmmu_val_mmmu_acc,0.28778,
-≥5,3000,mmstar_average,0.25130117268378377,
-≥5,3000,ocrbench_ocrbench_accuracy,0.344,
-≥5,3000,seedbench_seed_all,0.2858254585881045,
-≥5,3000,textvqa_val_exact_match,0.3373,0.006457064405451384
-≥5,4000,ai2d_exact_match,0.25647668393782386,0.007859644922870104
-≥5,4000,average,0.3300809923443584,
-≥5,4000,average_rank,4.3,
-≥5,4000,chartqa_relaxed_overall,0.4428,0.009936335154498413
-≥5,4000,docvqa_val_anls,0.4736486989184438,0.006240863735639683
-≥5,4000,infovqa_val_anls,0.19267658764675277,0.006512420811238904
-≥5,4000,mme_total_score,1218.2668067226891,
-≥5,4000,mmmu_val_mmmu_acc,0.26889,
-≥5,4000,mmstar_average,0.22297093502644408,
-≥5,4000,ocrbench_ocrbench_accuracy,0.379,
-≥5,4000,seedbench_seed_all,0.322846025569761,
-≥5,4000,textvqa_val_exact_match,0.41142,0.006712445761838313
-≥5,5000,ai2d_exact_match,0.25161917098445596,0.007810248924722509
-≥5,5000,average,0.3420574749713038,
-≥5,5000,average_rank,4.2,
-≥5,5000,chartqa_relaxed_overall,0.4488,0.009949423119365426
-≥5,5000,docvqa_val_anls,0.4973120888104521,0.00627054301371889
-≥5,5000,infovqa_val_anls,0.20687122924296383,0.006767419172429617
-≥5,5000,mme_total_score,1285.299119647859,
-≥5,5000,mmmu_val_mmmu_acc,0.26778,
-≥5,5000,mmstar_average,0.24681232878335083,
-≥5,5000,ocrbench_ocrbench_accuracy,0.392,
-≥5,5000,seedbench_seed_all,0.3604224569205114,
-≥5,5000,textvqa_val_exact_match,0.4069,0.00670861230775927
-≥5,6000,ai2d_exact_match,0.2704015544041451,0.00799425923314582
-≥5,6000,average,0.35916516291601697,
-≥5,6000,average_rank,4.4,
-≥5,6000,chartqa_relaxed_overall,0.4844,0.009997131241172205
-≥5,6000,docvqa_val_anls,0.5108154498847224,0.0062636540505031655
-≥5,6000,infovqa_val_anls,0.20262763630072025,0.0066138397079363274
-≥5,6000,mme_total_score,1273.862545018007,
-≥5,6000,mmmu_val_mmmu_acc,0.27444,
-≥5,6000,mmstar_average,0.2588150329919745,
-≥5,6000,ocrbench_ocrbench_accuracy,0.403,
-≥5,6000,seedbench_seed_all,0.4082267926625903,
-≥5,6000,textvqa_val_exact_match,0.41976,0.006731520716318925
-≥5,7000,ai2d_exact_match,0.31994818652849744,0.008395421656067303
-≥5,7000,average,0.3723337802797541,
-≥5,7000,average_rank,4.5,
-≥5,7000,chartqa_relaxed_overall,0.476,0.009990471651004463
-≥5,7000,docvqa_val_anls,0.5291779466505276,0.006267960743408816
-≥5,7000,infovqa_val_anls,0.20957812087727798,0.006721757004150909
-≥5,7000,mme_total_score,1327.2439975990396,
-≥5,7000,mmmu_val_mmmu_acc,0.27222,
-≥5,7000,mmstar_average,0.29354698358099446,
-≥5,7000,ocrbench_ocrbench_accuracy,0.403,
-≥5,7000,seedbench_seed_all,0.42301278488048916,
-≥5,7000,textvqa_val_exact_match,0.42452,0.006734688198055274
-≥5,8000,ai2d_exact_match,0.30958549222797926,0.008321027166750249
-≥5,8000,average,0.37926040717793597,
-≥5,8000,average_rank,4.5,
-≥5,8000,chartqa_relaxed_overall,0.5136,0.009998299975543861
-≥5,8000,docvqa_val_anls,0.5386485557171258,0.006250093887872433
-≥5,8000,infovqa_val_anls,0.21347817313272946,0.006767638253739939
-≥5,8000,mme_total_score,1351.172769107643,
-≥5,8000,mmmu_val_mmmu_acc,0.27667,
-≥5,8000,mmstar_average,0.27077818615838667,
-≥5,8000,ocrbench_ocrbench_accuracy,0.406,
-≥5,8000,seedbench_seed_all,0.4538632573652029,
-≥5,8000,textvqa_val_exact_match,0.43072,0.00674498000523754
-≥5,9000,ai2d_exact_match,0.32642487046632124,0.00843949241376102
-≥5,9000,average,0.3915431470529602,
-≥5,9000,average_rank,4.4,
-≥5,9000,chartqa_relaxed_overall,0.5196,0.009994312908659929
-≥5,9000,docvqa_val_anls,0.5447526718541965,0.006277223186340111
-≥5,9000,infovqa_val_anls,0.22534586447558344,0.006943394394173722
-≥5,9000,mme_total_score,1380.0509203681472,
-≥5,9000,mmmu_val_mmmu_acc,0.28222,
-≥5,9000,mmstar_average,0.2981132324115024,
-≥5,9000,ocrbench_ocrbench_accuracy,0.42,
-≥5,9000,seedbench_seed_all,0.45703168426903834,
-≥5,9000,textvqa_val_exact_match,0.4504,0.0067806462400486975
-≥5,10000,ai2d_exact_match,0.3121761658031088,0.008340079044408505
-≥5,10000,average,0.3945344056050298,
-≥5,10000,average_rank,4.4,
-≥5,10000,chartqa_relaxed_overall,0.524,0.009990471651004463
-≥5,10000,docvqa_val_anls,0.5476477162524015,0.006282119242898783
-≥5,10000,infovqa_val_anls,0.2268357982996008,0.007080273138697436
-≥5,10000,mme_total_score,1385.6108443377352,
-≥5,10000,mmmu_val_mmmu_acc,0.29222,
-≥5,10000,mmstar_average,0.29882846925636025,
-≥5,10000,ocrbench_ocrbench_accuracy,0.43,
-≥5,10000,seedbench_seed_all,0.4627015008337966,
-≥5,10000,textvqa_val_exact_match,0.4564,0.006792248149691337
-≥5,11000,ai2d_exact_match,0.3403497409326425,0.008528080007639036
-≥5,11000,average,0.40311924614292627,
-≥5,11000,average_rank,4.2,
-≥5,11000,chartqa_relaxed_overall,0.5404,0.009969297405349211
-≥5,11000,docvqa_val_anls,0.5698821874786791,0.006251823346664307
-≥5,11000,infovqa_val_anls,0.22660700332356035,0.006919487246988994
-≥5,11000,mme_total_score,1358.4087635054022,
-≥5,11000,mmmu_val_mmmu_acc,0.28778,
-≥5,11000,mmstar_average,0.28965012568597354,
-≥5,11000,ocrbench_ocrbench_accuracy,0.436,
-≥5,11000,seedbench_seed_all,0.4714841578654808,
-≥5,11000,textvqa_val_exact_match,0.46592,0.006784225516827446
-≥5,12000,ai2d_exact_match,0.342940414507772,0.008543648986216495
-≥5,12000,average,0.4128131018529697,
-≥5,12000,average_rank,4.3,
-≥5,12000,chartqa_relaxed_overall,0.5548,0.009941746291659784
-≥5,12000,docvqa_val_anls,0.578981486161722,0.00625708617478689
-≥5,12000,infovqa_val_anls,0.2380032381589791,0.007080943870134072
-≥5,12000,mme_total_score,1390.3039215686274,
-≥5,12000,mmmu_val_mmmu_acc,0.28222,
-≥5,12000,mmstar_average,0.3060607822951693,
-≥5,12000,ocrbench_ocrbench_accuracy,0.472,
-≥5,12000,seedbench_seed_all,0.46559199555308506,
-≥5,12000,textvqa_val_exact_match,0.47472,0.006773519058221244
-≥5,13000,ai2d_exact_match,0.33678756476683935,0.008506208807020252
-≥5,13000,average,0.41416266738683244,
-≥5,13000,average_rank,4.5,
-≥5,13000,chartqa_relaxed_overall,0.5564,0.009938164963872337
-≥5,13000,docvqa_val_anls,0.5882749499950303,0.0062089530468064
-≥5,13000,infovqa_val_anls,0.2250291831460855,0.007008754051627638
-≥5,13000,mme_total_score,1463.7286914765905,
-≥5,13000,mmmu_val_mmmu_acc,0.28222,
-≥5,13000,mmstar_average,0.32070873992428756,
-≥5,13000,ocrbench_ocrbench_accuracy,0.475,
-≥5,13000,seedbench_seed_all,0.4624235686492496,
-≥5,13000,textvqa_val_exact_match,0.48062,0.006792356759039414
-≥5,14000,ai2d_exact_match,0.35103626943005184,0.008590489143063932
-≥5,14000,average,0.4197541703337554,
-≥5,14000,average_rank,4.4,
-≥5,14000,chartqa_relaxed_overall,0.5644,0.00991868984106597
-≥5,14000,docvqa_val_anls,0.5968397354218249,0.006216108072191749
-≥5,14000,infovqa_val_anls,0.23493831065135024,0.00713715521281919
-≥5,14000,mme_total_score,1381.4046618647458,
-≥5,14000,mmmu_val_mmmu_acc,0.28778,
-≥5,14000,mmstar_average,0.3178569306745569,
-≥5,14000,ocrbench_ocrbench_accuracy,0.465,
-≥5,14000,seedbench_seed_all,0.46931628682601445,
-≥5,14000,textvqa_val_exact_match,0.49062,0.0067877549928948315
-≥5,15000,ai2d_exact_match,0.3448834196891192,0.008555140353607656
-≥5,15000,average,0.4156222682362929,
-≥5,15000,average_rank,4.5,
-≥5,15000,chartqa_relaxed_overall,0.5544,0.009942625323290008
-≥5,15000,docvqa_val_anls,0.5981327465682499,0.0062119027314077434
-≥5,15000,infovqa_val_anls,0.2430496253387209,0.007241165402150032
-≥5,15000,mme_total_score,1405.2406962785115,
-≥5,15000,mmmu_val_mmmu_acc,0.27667,
-≥5,15000,mmstar_average,0.30769549523760537,
-≥5,15000,ocrbench_ocrbench_accuracy,0.462,
-≥5,15000,seedbench_seed_all,0.4724291272929405,
-≥5,15000,textvqa_val_exact_match,0.48134,0.006785688616050607
-≥5,16000,ai2d_exact_match,0.3555699481865285,0.008615532040064747
-≥5,16000,average,0.41928937760980056,
-≥5,16000,average_rank,4.6,
-≥5,16000,chartqa_relaxed_overall,0.556,0.00993907007952043
-≥5,16000,docvqa_val_anls,0.5950015990375694,0.006217949166028718
-≥5,16000,infovqa_val_anls,0.2429016453664355,0.007192121794741783
-≥5,16000,mme_total_score,1444.7096838735495,
-≥5,16000,mmmu_val_mmmu_acc,0.27222,
-≥5,16000,mmstar_average,0.29597997743741594,
-≥5,16000,ocrbench_ocrbench_accuracy,0.484,
-≥5,16000,seedbench_seed_all,0.4802112284602557,
-≥5,16000,textvqa_val_exact_match,0.49172000000000005,0.006790781344017229
-≥5,17000,ai2d_exact_match,0.35783678756476683,0.008627736835305362
-≥5,17000,average,0.4243671877798907,
-≥5,17000,average_rank,4.2,
-≥5,17000,chartqa_relaxed_overall,0.566,0.00991448025705367
-≥5,17000,docvqa_val_anls,0.6011648636453683,0.006202633675401635
-≥5,17000,infovqa_val_anls,0.24233190899997978,0.007185211142139982
-≥5,17000,mme_total_score,1383.0262104841936,
-≥5,17000,mmmu_val_mmmu_acc,0.29778,
-≥5,17000,mmstar_average,0.30487588800790116,
-≥5,17000,ocrbench_ocrbench_accuracy,0.48,
-≥5,17000,seedbench_seed_all,0.48343524180100056,
-≥5,17000,textvqa_val_exact_match,0.48588000000000003,0.006793096079908642
-≥5,18000,ai2d_exact_match,0.3484455958549223,0.008575797499263314
-≥5,18000,average,0.4229679292209723,
-≥5,18000,average_rank,4.4,
-≥5,18000,chartqa_relaxed_overall,0.5564,0.009938164963872337
-≥5,18000,docvqa_val_anls,0.6015112951191799,0.006202182626672507
-≥5,18000,infovqa_val_anls,0.2406225801562843,0.007159684093951319
-≥5,18000,mme_total_score,1388.7428971588636,
-≥5,18000,mmmu_val_mmmu_acc,0.29444,
-≥5,18000,mmstar_average,0.3048242431646457,
-≥5,18000,ocrbench_ocrbench_accuracy,0.489,
-≥5,18000,seedbench_seed_all,0.48176764869371874,
-≥5,18000,textvqa_val_exact_match,0.4897,0.006784304485905058
-≥5,19000,ai2d_exact_match,0.3552461139896373,0.00861377131101951
-≥5,19000,average,0.4271521214095191,
-≥5,19000,average_rank,4.4,
-≥5,19000,chartqa_relaxed_overall,0.564,0.009919725822025206
-≥5,19000,docvqa_val_anls,0.6030864459750552,0.006186369284106836
-≥5,19000,infovqa_val_anls,0.24933668460761893,0.007278561320407618
-≥5,19000,mme_total_score,1420.4112645058024,
-≥5,19000,mmmu_val_mmmu_acc,0.28889,
-≥5,19000,mmstar_average,0.3146239893029105,
-≥5,19000,ocrbench_ocrbench_accuracy,0.495,
-≥5,19000,seedbench_seed_all,0.48254585881045026,
-≥5,19000,textvqa_val_exact_match,0.49163999999999997,0.006786164784802775
-≥5,20000,ai2d_exact_match,0.3630181347150259,0.008654846701304475
-≥5,20000,average,0.4295614849660391,
-≥5,20000,average_rank,4.6,
-≥5,20000,chartqa_relaxed_overall,0.566,0.00991448025705367
-≥5,20000,docvqa_val_anls,0.6104819342838989,0.006177273769345363
-≥5,20000,infovqa_val_anls,0.24655527159214874,0.007266841528312276
-≥5,20000,mme_total_score,1413.0101040416166,
-≥5,20000,mmmu_val_mmmu_acc,0.28444,
-≥5,20000,mmstar_average,0.32507494461467334,
-≥5,20000,ocrbench_ocrbench_accuracy,0.499,
-≥5,20000,seedbench_seed_all,0.4775430794886048,
-≥5,20000,textvqa_val_exact_match,0.4939399999999999,0.006784796384004054
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5218781e5f018891311410d684785a3c661ca3cd25d2ac62bf45e6bb7d69e78
+size 63268

app/src/content/assets/data/internal_deduplication.csv

@@ -1,729 +1,3 @@
-run,step,metric,value,stderr
-Baseline,300,ai2d_exact_match,0.2551813471502591,0.007846598309236504
-Baseline,300,average,0.1836384379377178,
-Baseline,300,average_rank,1.4444444444444444,
-Baseline,300,chartqa_relaxed_overall,0.1328,0.006788526912302523
-Baseline,300,docvqa_val_anls,0.1503143424142802,0.004151727384820528
-Baseline,300,infovqa_val_anls,0.11374396685909084,0.005163280990095591
-Baseline,300,mme_total_score,691.1952781112445,
-Baseline,300,mmmu_val_mmmu_acc,0.26556,
-Baseline,300,mmstar_average,0.2859278470781123,
-Baseline,300,ocrbench_ocrbench_accuracy,0.149,
-Baseline,300,textvqa_val_exact_match,0.11657999999999999,0.004405144921606561
-Baseline,1500,ai2d_exact_match,0.27525906735751293,0.008038849490577982
-Baseline,1500,average,0.318819844462715,
-Baseline,1500,average_rank,1.2222222222222223,
-Baseline,1500,chartqa_relaxed_overall,0.374,0.009679208378267924
-Baseline,1500,docvqa_val_anls,0.437411196849637,0.0061765544267728045
-Baseline,1500,infovqa_val_anls,0.21582289145457856,0.006873661480889723
-Baseline,1500,mme_total_score,1066.704581832733,
-Baseline,1500,mmmu_val_mmmu_acc,0.24,
-Baseline,1500,mmstar_average,0.23474560003999134,
-Baseline,1500,ocrbench_ocrbench_accuracy,0.411,
-Baseline,1500,textvqa_val_exact_match,0.36232000000000003,0.006579840604488538
-Baseline,2700,ai2d_exact_match,0.27849740932642486,0.008067913113285858
-Baseline,2700,average,0.36471172748595665,
-Baseline,2700,average_rank,1.4444444444444444,
-Baseline,2700,chartqa_relaxed_overall,0.4624,0.00997367964766694
-Baseline,2700,docvqa_val_anls,0.4953558755845657,0.006275075768152338
-Baseline,2700,infovqa_val_anls,0.20975551937756792,0.006468441430093479
-Baseline,2700,mme_total_score,1172.469887955182,
-Baseline,2700,mmmu_val_mmmu_acc,0.27111,
-Baseline,2700,mmstar_average,0.2503150155990948,
-Baseline,2700,ocrbench_ocrbench_accuracy,0.486,
-Baseline,2700,textvqa_val_exact_match,0.46426000000000006,0.006792330795207658
-Baseline,3900,ai2d_exact_match,0.35038860103626945,0.008586842325753156
-Baseline,3900,average,0.398537125609502,
-Baseline,3900,average_rank,1.4444444444444444,
-Baseline,3900,chartqa_relaxed_overall,0.4948,0.010001459677380663
-Baseline,3900,docvqa_val_anls,0.5407649774017467,0.00626354456311192
-Baseline,3900,infovqa_val_anls,0.22943878312324553,0.006664668392753554
-Baseline,3900,mme_total_score,1168.9393757503,
-Baseline,3900,mmmu_val_mmmu_acc,0.27,
-Baseline,3900,mmstar_average,0.3015046433147543,
-Baseline,3900,ocrbench_ocrbench_accuracy,0.517,
-Baseline,3900,textvqa_val_exact_match,0.4844,0.006794038548018284
-Baseline,5100,ai2d_exact_match,0.3898963730569948,0.008778252852376944
-Baseline,5100,average,0.42767475240113806,
-Baseline,5100,average_rank,1.2222222222222223,
-Baseline,5100,chartqa_relaxed_overall,0.5264,0.009988048880946633
-Baseline,5100,docvqa_val_anls,0.5781350651939515,0.006244324391533268
-Baseline,5100,infovqa_val_anls,0.2546269175216946,0.007112814176935012
-Baseline,5100,mme_total_score,1185.1023409363747,
-Baseline,5100,mmmu_val_mmmu_acc,0.29222,
-Baseline,5100,mmstar_average,0.33637966343646347,
-Baseline,5100,ocrbench_ocrbench_accuracy,0.533,
-Baseline,5100,textvqa_val_exact_match,0.51074,0.0068004249599511925
-Baseline,6300,ai2d_exact_match,0.41515544041450775,0.00886864516657515
-Baseline,6300,average,0.43890688312888254,
-Baseline,6300,average_rank,1.4444444444444444,
-Baseline,6300,chartqa_relaxed_overall,0.5388,0.0099718403035556
-Baseline,6300,docvqa_val_anls,0.6024512173813115,0.006190216536053702
-Baseline,6300,infovqa_val_anls,0.2548412895443468,0.007030638027408485
-Baseline,6300,mme_total_score,1187.329431772709,
-Baseline,6300,mmmu_val_mmmu_acc,0.30667,
-Baseline,6300,mmstar_average,0.3500771176908943,
-Baseline,6300,ocrbench_ocrbench_accuracy,0.516,
-Baseline,6300,textvqa_val_exact_match,0.52726,0.006770298802059908
-Baseline,7500,ai2d_exact_match,0.42972797927461137,0.008909832364541428
-Baseline,7500,average,0.44878537461255386,
-Baseline,7500,average_rank,1.3333333333333333,
-Baseline,7500,chartqa_relaxed_overall,0.5728,0.009895414680177737
-Baseline,7500,docvqa_val_anls,0.6164034078362094,0.006122657396260068
-Baseline,7500,infovqa_val_anls,0.25244937386016403,0.006941949044716374
-Baseline,7500,mme_total_score,1282.560024009604,
-Baseline,7500,mmmu_val_mmmu_acc,0.29667,
-Baseline,7500,mmstar_average,0.3339722359294459,
-Baseline,7500,ocrbench_ocrbench_accuracy,0.558,
-Baseline,7500,textvqa_val_exact_match,0.5302600000000001,0.0067524799649562395
-Baseline,8700,ai2d_exact_match,0.44527202072538863,0.008945084019331404
-Baseline,8700,average,0.4558942646480554,
-Baseline,8700,average_rank,1.5555555555555556,
-Baseline,8700,chartqa_relaxed_overall,0.5852,0.009855721084488851
-Baseline,8700,docvqa_val_anls,0.6221835109907441,0.006147036255020746
-Baseline,8700,infovqa_val_anls,0.25900127209441604,0.006885435292484948
-Baseline,8700,mme_total_score,1182.047919167667,
-Baseline,8700,mmmu_val_mmmu_acc,0.30333,
-Baseline,8700,mmstar_average,0.3299073133738943,
-Baseline,8700,ocrbench_ocrbench_accuracy,0.559,
-Baseline,8700,textvqa_val_exact_match,0.54326,0.0067297527736521565
-Baseline,9900,ai2d_exact_match,0.4520725388601036,0.008957715852675529
-Baseline,9900,average,0.4655685311713072,
-Baseline,9900,average_rank,1.5555555555555556,
-Baseline,9900,chartqa_relaxed_overall,0.5888,0.009842996384797287
-Baseline,9900,docvqa_val_anls,0.6443822232919176,0.006072644236356477
-Baseline,9900,infovqa_val_anls,0.2707219279967856,0.007060292176646616
-Baseline,9900,mme_total_score,1293.4631852741097,
-Baseline,9900,mmmu_val_mmmu_acc,0.30444,
-Baseline,9900,mmstar_average,0.34327155922165065,
-Baseline,9900,ocrbench_ocrbench_accuracy,0.557,
-Baseline,9900,textvqa_val_exact_match,0.56386,0.006703146016110842
-Baseline,11100,ai2d_exact_match,0.4494818652849741,0.008953103134587198
-Baseline,11100,average,0.471077301321738,
-Baseline,11100,average_rank,1.6666666666666667,
-Baseline,11100,chartqa_relaxed_overall,0.5948,0.009820578470976232
-Baseline,11100,docvqa_val_anls,0.657973309294109,0.006015458191652746
-Baseline,11100,infovqa_val_anls,0.29696232573726855,0.007574623301736419
-Baseline,11100,mme_total_score,1338.3029211684673,
-Baseline,11100,mmmu_val_mmmu_acc,0.29667,
-Baseline,11100,mmstar_average,0.3394909102575524,
-Baseline,11100,ocrbench_ocrbench_accuracy,0.565,
-Baseline,11100,textvqa_val_exact_match,0.56824,0.006679879088496093
-Baseline,12300,ai2d_exact_match,0.4676165803108808,0.008980259712600086
-Baseline,12300,average,0.47342294699365395,
-Baseline,12300,average_rank,1.5555555555555556,
-Baseline,12300,chartqa_relaxed_overall,0.598,0.009808000752013664
-Baseline,12300,docvqa_val_anls,0.6588847758219586,0.00602421968017162
-Baseline,12300,infovqa_val_anls,0.2830975650419957,0.007216197962807829
-Baseline,12300,mme_total_score,1269.7461984793918,
-Baseline,12300,mmmu_val_mmmu_acc,0.28333,
-Baseline,12300,mmstar_average,0.3693946547743964,
-Baseline,12300,ocrbench_ocrbench_accuracy,0.559,
-Baseline,12300,textvqa_val_exact_match,0.5680599999999999,0.006686980665598219
-Baseline,13500,ai2d_exact_match,0.47085492227979275,0.008983852707691612
-Baseline,13500,average,0.48226394524672617,
-Baseline,13500,average_rank,1.5555555555555556,
-Baseline,13500,chartqa_relaxed_overall,0.618,0.009719474639861454
-Baseline,13500,docvqa_val_anls,0.6663692127257962,0.005978102603390597
-Baseline,13500,infovqa_val_anls,0.32051341945189793,0.007779116582967409
-Baseline,13500,mme_total_score,1202.768607442977,
-Baseline,13500,mmmu_val_mmmu_acc,0.28,
-Baseline,13500,mmstar_average,0.35477400751632243,
-Baseline,13500,ocrbench_ocrbench_accuracy,0.569,
-Baseline,13500,textvqa_val_exact_match,0.5785999999999999,0.006676145758177908
-Baseline,14700,ai2d_exact_match,0.46567357512953367,0.008977921602780724
-Baseline,14700,average,0.48621829332317545,
-Baseline,14700,average_rank,1.5555555555555556,
-Baseline,14700,chartqa_relaxed_overall,0.6296,0.0096601689190934
-Baseline,14700,docvqa_val_anls,0.6810941724065047,0.005910647813959628
-Baseline,14700,infovqa_val_anls,0.3016034504434661,0.007417514325399065
-Baseline,14700,mme_total_score,1281.9612845138056,
-Baseline,14700,mmmu_val_mmmu_acc,0.29778,
-Baseline,14700,mmstar_average,0.365895148605899,
-Baseline,14700,ocrbench_ocrbench_accuracy,0.562,
-Baseline,14700,textvqa_val_exact_match,0.5861,0.006642001297519238
-Baseline,15900,ai2d_exact_match,0.48186528497409326,0.008993233105757854
-Baseline,15900,average,0.48999290982002447,
-Baseline,15900,average_rank,1.5,
-Baseline,15900,chartqa_relaxed_overall,0.64,0.009601920576192066
-Baseline,15900,docvqa_val_anls,0.6858324657211811,0.00589619582327283
-Baseline,15900,infovqa_val_anls,0.2913749730393032,0.007302812648430173
-Baseline,15900,mme_total_score,1296.9955982392958,
-Baseline,15900,mmmu_val_mmmu_acc,0.29111,
-Baseline,15900,mmstar_average,0.35848055482561814,
-Baseline,15900,ocrbench_ocrbench_accuracy,0.581,
-Baseline,15900,textvqa_val_exact_match,0.59028,0.006635865524726405
-Baseline,17100,ai2d_exact_match,0.4740932642487047,0.008987066275159845
-Baseline,17100,average,0.4931189092163302,
-Baseline,17100,average_rank,1.7777777777777777,
-Baseline,17100,chartqa_relaxed_overall,0.644,0.009578219924326623
-Baseline,17100,docvqa_val_anls,0.6847803896363295,0.005919128355709122
-Baseline,17100,infovqa_val_anls,0.3018247984331409,0.007408081810180743
-Baseline,17100,mme_total_score,1262.8012204881952,
-Baseline,17100,mmmu_val_mmmu_acc,0.28444,
-Baseline,17100,mmstar_average,0.36583282141246676,
-Baseline,17100,ocrbench_ocrbench_accuracy,0.588,
-Baseline,17100,textvqa_val_exact_match,0.6019800000000001,0.0065905009567234045
-Baseline,18300,ai2d_exact_match,0.4876943005181347,0.008996428218289523
-Baseline,18300,average,0.5004883767088391,
-Baseline,18300,average_rank,1.5,
-Baseline,18300,chartqa_relaxed_overall,0.652,0.00952862623294433
-Baseline,18300,docvqa_val_anls,0.6975218894019752,0.005845051202995877
-Baseline,18300,infovqa_val_anls,0.3185079040699619,0.007608667971660477
-Baseline,18300,mme_total_score,1310.265706282513,
-Baseline,18300,mmmu_val_mmmu_acc,0.29556,
-Baseline,18300,mmstar_average,0.36108291968064027,
-Baseline,18300,ocrbench_ocrbench_accuracy,0.588,
-Baseline,18300,textvqa_val_exact_match,0.60354,0.006611280926348344
-Baseline,19500,ai2d_exact_match,0.47765544041450775,0.00899016344465196
-Baseline,19500,average,0.5040547762672563,
-Baseline,19500,average_rank,1.4444444444444444,
-Baseline,19500,chartqa_relaxed_overall,0.6552,0.009507962165354631
-Baseline,19500,docvqa_val_anls,0.7041825239698998,0.005808767160221614
-Baseline,19500,infovqa_val_anls,0.3209241432627218,0.007605560217474187
-Baseline,19500,mme_total_score,1295.3964585834333,
-Baseline,19500,mmmu_val_mmmu_acc,0.30333,
-Baseline,19500,mmstar_average,0.35936610249092044,
-Baseline,19500,ocrbench_ocrbench_accuracy,0.604,
-Baseline,19500,textvqa_val_exact_match,0.60778,0.006595164407254131
-Baseline,20700,ai2d_exact_match,0.49190414507772023,0.008997974381217105
-Baseline,20700,average,0.5348651598748863,
-Baseline,20700,average_rank,1.25,
-Baseline,20700,chartqa_relaxed_overall,0.6472,0.009558734841217527
-Baseline,20700,docvqa_val_anls,0.70377508713271,0.005815829966103309
-Baseline,20700,infovqa_val_anls,0.31228879567103124,0.0074592773891107925
-Baseline,20700,mme_total_score,1267.3561424569828,
-Baseline,20700,mmstar_average,0.36086809124274183,
-Baseline,20700,ocrbench_ocrbench_accuracy,0.605,
-Baseline,20700,textvqa_val_exact_match,0.62302,0.006536647571369781
-Baseline,21900,ai2d_exact_match,0.49125647668393785,0.008997778057794698
-Baseline,21900,average,0.5035549318138456,
-Baseline,21900,average_rank,1.4444444444444444,
-Baseline,21900,chartqa_relaxed_overall,0.6556,0.009505345687488459
-Baseline,21900,docvqa_val_anls,0.7044656227681543,0.005797355786446792
-Baseline,21900,infovqa_val_anls,0.3214548388700204,0.007656455061893302
-Baseline,21900,mme_total_score,1270.262104841937,
-Baseline,21900,mmmu_val_mmmu_acc,0.28111,
-Baseline,21900,mmstar_average,0.36167251618865237,
-Baseline,21900,ocrbench_ocrbench_accuracy,0.597,
-Baseline,21900,textvqa_val_exact_match,0.61588,0.006563701818052925
-Baseline,23100,ai2d_exact_match,0.49319948186528495,0.008998321712163856
-Baseline,23100,average,0.5385543058304301,
-Baseline,23100,average_rank,1.5,
-Baseline,23100,chartqa_relaxed_overall,0.6592,0.009481461028833927
-Baseline,23100,docvqa_val_anls,0.7121972356483652,0.005769225218375019
-Baseline,23100,infovqa_val_anls,0.31967136620122777,0.007611618366213475
-Baseline,23100,mme_total_score,1318.2786114445778,
-Baseline,23100,mmstar_average,0.3630320570981325,
-Baseline,23100,ocrbench_ocrbench_accuracy,0.602,
-Baseline,23100,textvqa_val_exact_match,0.62058,0.006524799408523169
-Baseline,24300,ai2d_exact_match,0.49255181347150256,0.008998155599035915
-Baseline,24300,average,0.5094308504545716,
-Baseline,24300,average_rank,1.5555555555555556,
-Baseline,24300,chartqa_relaxed_overall,0.6704,0.009403239035659185
-Baseline,24300,docvqa_val_anls,0.7177853964151442,0.005720014481294498
-Baseline,24300,infovqa_val_anls,0.31972012794378407,0.007606738233281323
-Baseline,24300,mme_total_score,1306.592336934774,
-Baseline,24300,mmmu_val_mmmu_acc,0.29778,
-Baseline,24300,mmstar_average,0.37076946580614156,
-Baseline,24300,ocrbench_ocrbench_accuracy,0.59,
-Baseline,24300,textvqa_val_exact_match,0.6164400000000001,0.006543401905866729
-Baseline,25500,ai2d_exact_match,0.501619170984456,0.008999106932714636
-Baseline,25500,average,0.5486249165918439,
-Baseline,25500,average_rank,1.625,
-Baseline,25500,chartqa_relaxed_overall,0.6752,0.00936787525721462
-Baseline,25500,docvqa_val_anls,0.7137288248520355,0.0057597420625403505
-Baseline,25500,infovqa_val_anls,0.34135511904919924,0.0077802284678825705
-Baseline,25500,mme_total_score,1323.6883753501402,
-Baseline,25500,mmstar_average,0.369071301257217,
-Baseline,25500,ocrbench_ocrbench_accuracy,0.619,
-Baseline,25500,textvqa_val_exact_match,0.6204,0.00653548089294892
-Baseline,26700,ai2d_exact_match,0.4990284974093264,0.008999137132137064
-Baseline,26700,average,0.5171016246428288,
-Baseline,26700,average_rank,1.4444444444444444,
-Baseline,26700,chartqa_relaxed_overall,0.6712,0.009397422445513864
-Baseline,26700,docvqa_val_anls,0.7233130041233962,0.005709000608468465
-Baseline,26700,infovqa_val_anls,0.34093933218960265,0.007871398735359877
-Baseline,26700,mme_total_score,1290.1798719487797,
-Baseline,26700,mmmu_val_mmmu_acc,0.29889,
-Baseline,26700,mmstar_average,0.3681821634203056,
-Baseline,26700,ocrbench_ocrbench_accuracy,0.602,
-Baseline,26700,textvqa_val_exact_match,0.63326,0.006491932186699375
-Baseline,27900,ai2d_exact_match,0.49773316062176165,0.008999061633391479
-Baseline,27900,average,0.5456332793229398,
-Baseline,27900,average_rank,1.625,
-Baseline,27900,chartqa_relaxed_overall,0.6756,0.009364877808842454
-Baseline,27900,docvqa_val_anls,0.7132690678246167,0.00575358310740901
-Baseline,27900,infovqa_val_anls,0.3362338249924974,0.007684149470716349
-Baseline,27900,mme_total_score,1267.1172468987595,
-Baseline,27900,mmstar_average,0.3725169018217032,
-Baseline,27900,ocrbench_ocrbench_accuracy,0.599,
-Baseline,27900,textvqa_val_exact_match,0.62508,0.006518059200340837
-Baseline,29100,ai2d_exact_match,0.5019430051813472,0.008999086170553228
-Baseline,29100,average,0.5238317316407767,
-Baseline,29100,average_rank,1.0,
-Baseline,29100,chartqa_relaxed_overall,0.6828,0.009309582768982347
-Baseline,29100,docvqa_val_anls,0.7233823673869951,0.005705166797815572
-Baseline,29100,infovqa_val_anls,0.34214735285161113,0.007759163899965965
-Baseline,29100,mme_total_score,1321.8040216086433,
-Baseline,29100,mmmu_val_mmmu_acc,0.31222,
-Baseline,29100,mmstar_average,0.3709411277062599,
-Baseline,29100,ocrbench_ocrbench_accuracy,0.622,
-Baseline,29100,textvqa_val_exact_match,0.6352199999999999,0.00647159073314463
-Baseline,30300,ai2d_exact_match,0.5055051813471503,0.008998608627616667
-Baseline,30300,average,0.5497034826600226,
-Baseline,30300,average_rank,1.375,
-Baseline,30300,chartqa_relaxed_overall,0.6784,0.009343676884347384
-Baseline,30300,docvqa_val_anls,0.7227075209990185,0.005720573311731873
-Baseline,30300,infovqa_val_anls,0.33249900926543363,0.007751325884024483
-Baseline,30300,mme_total_score,1290.3790516206482,
-Baseline,30300,mmstar_average,0.36331266700855536,
-Baseline,30300,ocrbench_ocrbench_accuracy,0.612,
-Baseline,30300,textvqa_val_exact_match,0.6335,0.006488911402865572
-Baseline,31500,ai2d_exact_match,0.4993523316062176,0.008999146569435543
-Baseline,31500,average,0.5220721222554265,
-Baseline,31500,average_rank,1.5555555555555556,
-Baseline,31500,chartqa_relaxed_overall,0.6872,0.009274528060677767
-Baseline,31500,docvqa_val_anls,0.732681296661989,0.005643494305560718
-Baseline,31500,infovqa_val_anls,0.34453436089995576,0.007841367492503165
-Baseline,31500,mme_total_score,1304.8996598639455,
-Baseline,31500,mmmu_val_mmmu_acc,0.29444,
-Baseline,31500,mmstar_average,0.37192898887525,
-Baseline,31500,ocrbench_ocrbench_accuracy,0.61,
-Baseline,31500,textvqa_val_exact_match,0.63644,0.006473052244580776
-Baseline,32700,ai2d_exact_match,0.49870466321243523,0.00899912391990207
-Baseline,32700,average,0.5546837276191249,
-Baseline,32700,average_rank,1.5,
-Baseline,32700,chartqa_relaxed_overall,0.68,0.009331389496316869
-Baseline,32700,docvqa_val_anls,0.7278962076951819,0.005686137433507678
-Baseline,32700,infovqa_val_anls,0.3359004823603636,0.007743137801806592
-Baseline,32700,mme_total_score,1329.2223889555821,
-Baseline,32700,mmstar_average,0.3761847400658931,
-Baseline,32700,ocrbench_ocrbench_accuracy,0.626,
-Baseline,32700,textvqa_val_exact_match,0.6381000000000001,0.006469625121275727
-Baseline,33900,ai2d_exact_match,0.5019430051813472,0.00899908617055323
-Baseline,33900,average,0.5185104134885045,
-Baseline,33900,average_rank,1.5555555555555556,
-Baseline,33900,chartqa_relaxed_overall,0.6784,0.009343676884347384
-Baseline,33900,docvqa_val_anls,0.7328401883203162,0.005641229328683336
-Baseline,33900,infovqa_val_anls,0.33727943427582574,0.0077500601420040695
-Baseline,33900,mme_total_score,1330.3196278511405,
-Baseline,33900,mmmu_val_mmmu_acc,0.28,
-Baseline,33900,mmstar_average,0.3640006801305467,
-Baseline,33900,ocrbench_ocrbench_accuracy,0.617,
-Baseline,33900,textvqa_val_exact_match,0.63662,0.006467562214018388
-Baseline,35100,ai2d_exact_match,0.5029145077720207,0.008999001233939133
-Baseline,35100,average,0.5522905800868071,
-Baseline,35100,average_rank,1.625,
-Baseline,35100,chartqa_relaxed_overall,0.68,0.009331389496316869
-Baseline,35100,docvqa_val_anls,0.7269648828481717,0.005683622810231662
-Baseline,35100,infovqa_val_anls,0.33846207838337145,0.00774681529996113
-Baseline,35100,mme_total_score,1299.1129451780712,
-Baseline,35100,mmstar_average,0.36183259160408615,
-Baseline,35100,ocrbench_ocrbench_accuracy,0.616,
-Baseline,35100,textvqa_val_exact_match,0.63986,0.0064564830453322595
-Baseline,36300,ai2d_exact_match,0.501619170984456,0.008999106932714636
-Baseline,36300,average,0.5203510175588769,
-Baseline,36300,average_rank,1.4444444444444444,
-Baseline,36300,chartqa_relaxed_overall,0.6808,0.009325198535746702
-Baseline,36300,docvqa_val_anls,0.7270212281583848,0.0056833541878296414
-Baseline,36300,infovqa_val_anls,0.3340392024865933,0.007611756166885497
-Baseline,36300,mme_total_score,1280.1442577030812,
-Baseline,36300,mmmu_val_mmmu_acc,0.30111,
-Baseline,36300,mmstar_average,0.36247853884158143,
-Baseline,36300,ocrbench_ocrbench_accuracy,0.615,
-Baseline,36300,textvqa_val_exact_match,0.64074,0.0064493076522863105
-Baseline,37500,ai2d_exact_match,0.5074481865284974,0.008998155599035891
-Baseline,37500,average,0.5599086924183005,
-Baseline,37500,average_rank,1.25,
-Baseline,37500,chartqa_relaxed_overall,0.69,0.009251715392027472
-Baseline,37500,docvqa_val_anls,0.7338638293909314,0.005628628195159443
-Baseline,37500,infovqa_val_anls,0.35075945776545553,0.007880392253956911
-Baseline,37500,mme_total_score,1308.0833333333333,
-Baseline,37500,mmstar_average,0.37624937324321944,
-Baseline,37500,ocrbench_ocrbench_accuracy,0.622,
-Baseline,37500,textvqa_val_exact_match,0.63904,0.006478670412520058
-Baseline,38700,ai2d_exact_match,0.5,0.008999154119267315
-Baseline,38700,average,0.5225140432328732,
-Baseline,38700,average_rank,1.5555555555555556,
-Baseline,38700,chartqa_relaxed_overall,0.6832,0.009306435832216308
-Baseline,38700,docvqa_val_anls,0.73088808708227,0.00563114482117092
-Baseline,38700,infovqa_val_anls,0.3478216232204623,0.00789714223139076
-Baseline,38700,mme_total_score,1277.5526210484195,
-Baseline,38700,mmmu_val_mmmu_acc,0.28667,
-Baseline,38700,mmstar_average,0.3681926355602532,
-Baseline,38700,ocrbench_ocrbench_accuracy,0.624,
-Baseline,38700,textvqa_val_exact_match,0.6393399999999999,0.00647079957419683
-Baseline,39900,ai2d_exact_match,0.5058290155440415,0.008998542562369288
-Baseline,39900,average,0.5567573845010034,
-Baseline,39900,average_rank,1.375,
-Baseline,39900,chartqa_relaxed_overall,0.6788,0.00934061683451043
-Baseline,39900,docvqa_val_anls,0.7307115103048833,0.005666517404544185
-Baseline,39900,infovqa_val_anls,0.3519024541637205,0.007911172051974351
-Baseline,39900,mme_total_score,1294.3033213285314,
-Baseline,39900,mmstar_average,0.36969871149437833,
-Baseline,39900,ocrbench_ocrbench_accuracy,0.619,
-Baseline,39900,textvqa_val_exact_match,0.6413599999999999,0.006448549204074314
-Internal Deduplication,300,ai2d_exact_match,0.2503238341968912,0.007796858242572104
-Internal Deduplication,300,average,0.19412722789194248,
-Internal Deduplication,300,average_rank,1.5555555555555556,
-Internal Deduplication,300,chartqa_relaxed_overall,0.1412,0.0069659481604092775
-Internal Deduplication,300,docvqa_val_anls,0.15637861297756628,0.004267695603476823
-Internal Deduplication,300,infovqa_val_anls,0.1042887841127396,0.005046536381262501
-Internal Deduplication,300,mme_total_score,598.6149459783913,
-Internal Deduplication,300,mmmu_val_mmmu_acc,0.26556,
-Internal Deduplication,300,mmstar_average,0.2694265918483427,
-Internal Deduplication,300,ocrbench_ocrbench_accuracy,0.167,
-Internal Deduplication,300,textvqa_val_exact_match,0.19884000000000002,0.005492264002465154
-Internal Deduplication,1500,ai2d_exact_match,0.27299222797927464,0.008018190192865413
-Internal Deduplication,1500,average,0.31955460499150806,
-Internal Deduplication,1500,average_rank,1.7777777777777777,
-Internal Deduplication,1500,chartqa_relaxed_overall,0.3708,0.00966231277258432
-Internal Deduplication,1500,docvqa_val_anls,0.42768709568231533,0.006154040400291129
-Internal Deduplication,1500,infovqa_val_anls,0.2099303690224102,0.00676857279363082
-Internal Deduplication,1500,mme_total_score,992.9132653061225,
-Internal Deduplication,1500,mmmu_val_mmmu_acc,0.26889,
-Internal Deduplication,1500,mmstar_average,0.21057714724806412,
-Internal Deduplication,1500,ocrbench_ocrbench_accuracy,0.404,
-Internal Deduplication,1500,textvqa_val_exact_match,0.39155999999999996,0.006665511164780805
-Internal Deduplication,2700,ai2d_exact_match,0.295660621761658,0.008213332656949247
-Internal Deduplication,2700,average,0.36762151428382045,
-Internal Deduplication,2700,average_rank,1.5555555555555556,
-Internal Deduplication,2700,chartqa_relaxed_overall,0.4752,0.009989689762981844
-Internal Deduplication,2700,docvqa_val_anls,0.5094800317043119,0.006254649346492251
-Internal Deduplication,2700,infovqa_val_anls,0.20719401979989327,0.006520807933324386
-Internal Deduplication,2700,mme_total_score,1071.3925570228091,
-Internal Deduplication,2700,mmmu_val_mmmu_acc,0.27,
-Internal Deduplication,2700,mmstar_average,0.2397774410047003,
-Internal Deduplication,2700,ocrbench_ocrbench_accuracy,0.494,
-Internal Deduplication,2700,textvqa_val_exact_match,0.44965999999999995,0.006770608917152268
-Internal Deduplication,3900,ai2d_exact_match,0.35751295336787564,0.008626006165018857
-Internal Deduplication,3900,average,0.40092708598125315,
-Internal Deduplication,3900,average_rank,1.5555555555555556,
-Internal Deduplication,3900,chartqa_relaxed_overall,0.5108,0.009999667061284322
-Internal Deduplication,3900,docvqa_val_anls,0.5404721998847206,0.0062378368939630035
-Internal Deduplication,3900,infovqa_val_anls,0.22349780573998537,0.006643570027298634
-Internal Deduplication,3900,mme_total_score,1134.516706682673,
-Internal Deduplication,3900,mmmu_val_mmmu_acc,0.29111,
-Internal Deduplication,3900,mmstar_average,0.27976372885744333,
-Internal Deduplication,3900,ocrbench_ocrbench_accuracy,0.51,
-Internal Deduplication,3900,textvqa_val_exact_match,0.49426000000000003,0.006797576913163843
-Internal Deduplication,5100,ai2d_exact_match,0.38827720207253885,0.008771623130477878
-Internal Deduplication,5100,average,0.4219485735226934,
-Internal Deduplication,5100,average_rank,1.7777777777777777,
-Internal Deduplication,5100,chartqa_relaxed_overall,0.5236,0.009990852959439592
-Internal Deduplication,5100,docvqa_val_anls,0.5747949496010799,0.006245322873999332
-Internal Deduplication,5100,infovqa_val_anls,0.2283558074433608,0.006643505571541433
-Internal Deduplication,5100,mme_total_score,1120.3775510204082,
-Internal Deduplication,5100,mmmu_val_mmmu_acc,0.27444,
-Internal Deduplication,5100,mmstar_average,0.32262062906456745,
-Internal Deduplication,5100,ocrbench_ocrbench_accuracy,0.546,
-Internal Deduplication,5100,textvqa_val_exact_match,0.5175,0.006791610648074506
-Internal Deduplication,6300,ai2d_exact_match,0.3947538860103627,0.008797532848529212
-Internal Deduplication,6300,average,0.4392913905300591,
-Internal Deduplication,6300,average_rank,1.5555555555555556,
-Internal Deduplication,6300,chartqa_relaxed_overall,0.554,0.009943497838271193
-Internal Deduplication,6300,docvqa_val_anls,0.6054354573141266,0.006148692369883667
-Internal Deduplication,6300,infovqa_val_anls,0.2479668172159887,0.006849066135124891
-Internal Deduplication,6300,mme_total_score,1120.747699079632,
-Internal Deduplication,6300,mmmu_val_mmmu_acc,0.28222,
-Internal Deduplication,6300,mmstar_average,0.33081496369999497,
-Internal Deduplication,6300,ocrbench_ocrbench_accuracy,0.562,
-Internal Deduplication,6300,textvqa_val_exact_match,0.53714,0.00675218797787041
-Internal Deduplication,7500,ai2d_exact_match,0.4368523316062176,0.008927095061184939
-Internal Deduplication,7500,average,0.4484625925841701,
-Internal Deduplication,7500,average_rank,1.6666666666666667,
-Internal Deduplication,7500,chartqa_relaxed_overall,0.5716,0.009898917689756362
-Internal Deduplication,7500,docvqa_val_anls,0.6158904129878224,0.006156668221029065
-Internal Deduplication,7500,infovqa_val_anls,0.2491041330885082,0.006950914810318631
-Internal Deduplication,7500,mme_total_score,1182.0997398959585,
-Internal Deduplication,7500,mmmu_val_mmmu_acc,0.30222,
-Internal Deduplication,7500,mmstar_average,0.3126938629908125,
-Internal Deduplication,7500,ocrbench_ocrbench_accuracy,0.554,
-Internal Deduplication,7500,textvqa_val_exact_match,0.5453399999999999,0.006743052026354684
-Internal Deduplication,8700,ai2d_exact_match,0.43555699481865284,0.008924095913829722
-Internal Deduplication,8700,average,0.4610890710492869,
-Internal Deduplication,8700,average_rank,1.4444444444444444,
-Internal Deduplication,8700,chartqa_relaxed_overall,0.5856,0.009854334029231191
-Internal Deduplication,8700,docvqa_val_anls,0.6337792662388687,0.006121292484093459
-Internal Deduplication,8700,infovqa_val_anls,0.3014589775424448,0.007723778532370607
-Internal Deduplication,8700,mme_total_score,1146.702080832333,
-Internal Deduplication,8700,mmmu_val_mmmu_acc,0.28111,
-Internal Deduplication,8700,mmstar_average,0.34138732979432873,
-Internal Deduplication,8700,ocrbench_ocrbench_accuracy,0.554,
-Internal Deduplication,8700,textvqa_val_exact_match,0.5558200000000001,0.006722310868494742
-Internal Deduplication,9900,ai2d_exact_match,0.4530440414507772,0.008959382447335284
-Internal Deduplication,9900,average,0.4640919637505932,
-Internal Deduplication,9900,average_rank,1.4444444444444444,
-Internal Deduplication,9900,chartqa_relaxed_overall,0.596,0.009815912634917984
-Internal Deduplication,9900,docvqa_val_anls,0.6449581300442709,0.006031449307242489
-Internal Deduplication,9900,infovqa_val_anls,0.2651241729320676,0.007027677036596941
-Internal Deduplication,9900,mme_total_score,1198.2277911164465,
-Internal Deduplication,9900,mmmu_val_mmmu_acc,0.28,
-Internal Deduplication,9900,mmstar_average,0.33564936557763,
-Internal Deduplication,9900,ocrbench_ocrbench_accuracy,0.571,
-Internal Deduplication,9900,textvqa_val_exact_match,0.5669599999999999,0.0067004067615447065
-Internal Deduplication,11100,ai2d_exact_match,0.4566062176165803,0.008965198879336196
-Internal Deduplication,11100,average,0.4745786301209996,
-Internal Deduplication,11100,average_rank,1.3333333333333333,
-Internal Deduplication,11100,chartqa_relaxed_overall,0.608,0.00976588700628918
-Internal Deduplication,11100,docvqa_val_anls,0.6596743239996393,0.005996833864420919
-Internal Deduplication,11100,infovqa_val_anls,0.30142039609988674,0.0075421730872732295
-Internal Deduplication,11100,mme_total_score,1136.5589235694279,
-Internal Deduplication,11100,mmmu_val_mmmu_acc,0.29,
-Internal Deduplication,11100,mmstar_average,0.32532810325189065,
-Internal Deduplication,11100,ocrbench_ocrbench_accuracy,0.586,
-Internal Deduplication,11100,textvqa_val_exact_match,0.5696,0.00669753233570974
-Internal Deduplication,12300,ai2d_exact_match,0.47085492227979275,0.0089838527076916
-Internal Deduplication,12300,average,0.47675266119609205,
-Internal Deduplication,12300,average_rank,1.4444444444444444,
-Internal Deduplication,12300,chartqa_relaxed_overall,0.6024,0.009789996609470577
-Internal Deduplication,12300,docvqa_val_anls,0.6541921314490913,0.0059901948837693935
-Internal Deduplication,12300,infovqa_val_anls,0.26890492643687214,0.0068929334847927185
-Internal Deduplication,12300,mme_total_score,1180.1697679071628,
-Internal Deduplication,12300,mmmu_val_mmmu_acc,0.30111,
-Internal Deduplication,12300,mmstar_average,0.3420593094029801,
-Internal Deduplication,12300,ocrbench_ocrbench_accuracy,0.588,
-Internal Deduplication,12300,textvqa_val_exact_match,0.5865000000000001,0.006650353031162167
-Internal Deduplication,13500,ai2d_exact_match,0.4689119170984456,0.008981742470016596
-Internal Deduplication,13500,average,0.477194042186954,
-Internal Deduplication,13500,average_rank,1.4444444444444444,
-Internal Deduplication,13500,chartqa_relaxed_overall,0.6076,0.009767653701044555
-Internal Deduplication,13500,docvqa_val_anls,0.6669529256090054,0.005964340335624923
-Internal Deduplication,13500,infovqa_val_anls,0.28048200541677026,0.00715533754622952
-Internal Deduplication,13500,mme_total_score,1205.548119247699,
-Internal Deduplication,13500,mmmu_val_mmmu_acc,0.28556,
-Internal Deduplication,13500,mmstar_average,0.3358454893714108,
-Internal Deduplication,13500,ocrbench_ocrbench_accuracy,0.589,
-Internal Deduplication,13500,textvqa_val_exact_match,0.5832,0.006654352566675162
-Internal Deduplication,14700,ai2d_exact_match,0.47733160621761656,0.008989900821900263
-Internal Deduplication,14700,average,0.4884023663438535,
-Internal Deduplication,14700,average_rank,1.4444444444444444,
-Internal Deduplication,14700,chartqa_relaxed_overall,0.6304,0.009655859891905061
-Internal Deduplication,14700,docvqa_val_anls,0.6801802838124448,0.005922660123416213
-Internal Deduplication,14700,infovqa_val_anls,0.306442807638199,0.007585813874676366
-Internal Deduplication,14700,mme_total_score,1141.5065026010404,
-Internal Deduplication,14700,mmmu_val_mmmu_acc,0.28556,
-Internal Deduplication,14700,mmstar_average,0.3313042330825678,
-Internal Deduplication,14700,ocrbench_ocrbench_accuracy,0.601,
-Internal Deduplication,14700,textvqa_val_exact_match,0.595,0.006618682753560443
-Internal Deduplication,15900,ai2d_exact_match,0.48737046632124353,0.0089962828388782
-Internal Deduplication,15900,average,0.5203517701538484,
-Internal Deduplication,15900,average_rank,1.5,
-Internal Deduplication,15900,chartqa_relaxed_overall,0.6268,0.009675026948726469
-Internal Deduplication,15900,docvqa_val_anls,0.6832159326200654,0.005900840845629961
-Internal Deduplication,15900,infovqa_val_anls,0.3152545751330662,0.007651477632904633
-Internal Deduplication,15900,mme_total_score,1225.4948979591836,
-Internal Deduplication,15900,mmstar_average,0.32764141700256333,
-Internal Deduplication,15900,ocrbench_ocrbench_accuracy,0.603,
-Internal Deduplication,15900,textvqa_val_exact_match,0.5991799999999999,0.006605224547149299
-Internal Deduplication,17100,ai2d_exact_match,0.47636010362694303,0.008989090232793597
-Internal Deduplication,17100,average,0.4961663419392575,
-Internal Deduplication,17100,average_rank,1.2222222222222223,
-Internal Deduplication,17100,chartqa_relaxed_overall,0.6464,0.009563650001989001
-Internal Deduplication,17100,docvqa_val_anls,0.6927261914773173,0.005861047908265113
-Internal Deduplication,17100,infovqa_val_anls,0.3154358494585615,0.00763456160506387
-Internal Deduplication,17100,mme_total_score,1286.2750100040016,
-Internal Deduplication,17100,mmmu_val_mmmu_acc,0.29889,
-Internal Deduplication,17100,mmstar_average,0.34921859095123836,
-Internal Deduplication,17100,ocrbench_ocrbench_accuracy,0.587,
-Internal Deduplication,17100,textvqa_val_exact_match,0.6033,0.006602767700613255
-Internal Deduplication,18300,ai2d_exact_match,0.4786269430051813,0.008990928596702264
-Internal Deduplication,18300,average,0.5266473503807093,
-Internal Deduplication,18300,average_rank,1.5,
-Internal Deduplication,18300,chartqa_relaxed_overall,0.6552,0.009507962165354631
-Internal Deduplication,18300,docvqa_val_anls,0.6989798369115747,0.00583327960847754
-Internal Deduplication,18300,infovqa_val_anls,0.31662733272229215,0.00758318378302427
-Internal Deduplication,18300,mme_total_score,1217.9891956782712,
-Internal Deduplication,18300,mmstar_average,0.3360973400259174,
-Internal Deduplication,18300,ocrbench_ocrbench_accuracy,0.595,
-Internal Deduplication,18300,textvqa_val_exact_match,0.6060000000000001,0.006592108249887561
-Internal Deduplication,19500,ai2d_exact_match,0.4896373056994819,0.008997221155546277
-Internal Deduplication,19500,average,0.5003413312777834,
-Internal Deduplication,19500,average_rank,1.5555555555555556,
-Internal Deduplication,19500,chartqa_relaxed_overall,0.6508,0.009536252935404934
-Internal Deduplication,19500,docvqa_val_anls,0.7013552478733074,0.005824977752328648
-Internal Deduplication,19500,infovqa_val_anls,0.32620790060169225,0.007764453086996403
-Internal Deduplication,19500,mme_total_score,1299.4400760304122,
-Internal Deduplication,19500,mmmu_val_mmmu_acc,0.29556,
-Internal Deduplication,19500,mmstar_average,0.3368301960477849,
-Internal Deduplication,19500,ocrbench_ocrbench_accuracy,0.593,
-Internal Deduplication,19500,textvqa_val_exact_match,0.60934,0.006559905437723197
-Internal Deduplication,20700,ai2d_exact_match,0.4889896373056995,0.008996971954224612
-Internal Deduplication,20700,average,0.5296276786578733,
-Internal Deduplication,20700,average_rank,1.75,
-Internal Deduplication,20700,chartqa_relaxed_overall,0.6444,0.009575809858898698
-Internal Deduplication,20700,docvqa_val_anls,0.6989112987356239,0.00585808944665685
-Internal Deduplication,20700,infovqa_val_anls,0.3158264619814475,0.007568423570507376
-Internal Deduplication,20700,mme_total_score,1174.7768107242898,
-Internal Deduplication,20700,mmstar_average,0.33400635258234235,
-Internal Deduplication,20700,ocrbench_ocrbench_accuracy,0.614,
-Internal Deduplication,20700,textvqa_val_exact_match,0.6112599999999999,0.0065589363778955695
-Internal Deduplication,21900,ai2d_exact_match,0.4957901554404145,0.008998835133354702
-Internal Deduplication,21900,average,0.5035083877228906,
-Internal Deduplication,21900,average_rank,1.5555555555555556,
-Internal Deduplication,21900,chartqa_relaxed_overall,0.64,0.009601920576192066
-Internal Deduplication,21900,docvqa_val_anls,0.7037412472922321,0.005813532329025727
-Internal Deduplication,21900,infovqa_val_anls,0.3194560697014221,0.007649647661031666
-Internal Deduplication,21900,mme_total_score,1199.6734693877552,
-Internal Deduplication,21900,mmmu_val_mmmu_acc,0.30889,
-Internal Deduplication,21900,mmstar_average,0.33692962934905674,
-Internal Deduplication,21900,ocrbench_ocrbench_accuracy,0.603,
-Internal Deduplication,21900,textvqa_val_exact_match,0.6202599999999999,0.006539392877923941
-Internal Deduplication,23100,ai2d_exact_match,0.4944948186528497,0.008998608627616672
-Internal Deduplication,23100,average,0.5413853458503779,
-Internal Deduplication,23100,average_rank,1.5,
-Internal Deduplication,23100,chartqa_relaxed_overall,0.646,0.009566096595876119
-Internal Deduplication,23100,docvqa_val_anls,0.7101587999220607,0.005806193919644477
-Internal Deduplication,23100,infovqa_val_anls,0.336754873549068,0.007886540099947482
-Internal Deduplication,23100,mme_total_score,1316.6187474989997,
-Internal Deduplication,23100,mmstar_average,0.3476289288286667,
-Internal Deduplication,23100,ocrbench_ocrbench_accuracy,0.627,
-Internal Deduplication,23100,textvqa_val_exact_match,0.62766,0.006520482207447814
-Internal Deduplication,24300,ai2d_exact_match,0.4899611398963731,0.008997340090107673
-Internal Deduplication,24300,average,0.5100750686661266,
-Internal Deduplication,24300,average_rank,1.4444444444444444,
-Internal Deduplication,24300,chartqa_relaxed_overall,0.6516,0.009531175862679805
-Internal Deduplication,24300,docvqa_val_anls,0.7179021844889384,0.005742973360829408
-Internal Deduplication,24300,infovqa_val_anls,0.3358758923979091,0.007878017215252312
-Internal Deduplication,24300,mme_total_score,1409.844237695078,
-Internal Deduplication,24300,mmmu_val_mmmu_acc,0.28556,
-Internal Deduplication,24300,mmstar_average,0.3347613325457924,
-Internal Deduplication,24300,ocrbench_ocrbench_accuracy,0.634,
-Internal Deduplication,24300,textvqa_val_exact_match,0.63094,0.006498229657201687
-Internal Deduplication,25500,ai2d_exact_match,0.48607512953367876,0.008995663534025174
-Internal Deduplication,25500,average,0.5472398215745332,
-Internal Deduplication,25500,average_rank,1.375,
-Internal Deduplication,25500,chartqa_relaxed_overall,0.6536,0.0095183536193109
-Internal Deduplication,25500,docvqa_val_anls,0.7180940785000507,0.005735169057784404
-Internal Deduplication,25500,infovqa_val_anls,0.35632636677863483,0.008180298439903802
-Internal Deduplication,25500,mme_total_score,1376.716986794718,
-Internal Deduplication,25500,mmstar_average,0.3529231762093682,
-Internal Deduplication,25500,ocrbench_ocrbench_accuracy,0.633,
-Internal Deduplication,25500,textvqa_val_exact_match,0.63066,0.006504156647155582
-Internal Deduplication,26700,ai2d_exact_match,0.49255181347150256,0.008998155599035912
-Internal Deduplication,26700,average,0.516487110189266,
-Internal Deduplication,26700,average_rank,1.5555555555555556,
-Internal Deduplication,26700,chartqa_relaxed_overall,0.6644,0.009445885130487209
-Internal Deduplication,26700,docvqa_val_anls,0.7168133343849862,0.005756579734549226
-Internal Deduplication,26700,infovqa_val_anls,0.34371436472133005,0.008017561696940439
-Internal Deduplication,26700,mme_total_score,1409.4487795118048,
-Internal Deduplication,26700,mmmu_val_mmmu_acc,0.30222,
-Internal Deduplication,26700,mmstar_average,0.35023736893630925,
-Internal Deduplication,26700,ocrbench_ocrbench_accuracy,0.63,
-Internal Deduplication,26700,textvqa_val_exact_match,0.6319600000000001,0.006495302107669356
-Internal Deduplication,27900,ai2d_exact_match,0.4954663212435233,0.008998784170060767
-Internal Deduplication,27900,average,0.5488694312151498,
-Internal Deduplication,27900,average_rank,1.375,
-Internal Deduplication,27900,chartqa_relaxed_overall,0.6736,0.009379787213112317
-Internal Deduplication,27900,docvqa_val_anls,0.7224633461958828,0.005716176978314635
-Internal Deduplication,27900,infovqa_val_anls,0.35413809221269893,0.00811649922857756
-Internal Deduplication,27900,mme_total_score,1365.8970588235293,
-Internal Deduplication,27900,mmstar_average,0.33847825885394267,
-Internal Deduplication,27900,ocrbench_ocrbench_accuracy,0.623,
-Internal Deduplication,27900,textvqa_val_exact_match,0.6349400000000001,0.006474057612069333
-Internal Deduplication,29100,ai2d_exact_match,0.4957901554404145,0.008998835133354704
-Internal Deduplication,29100,average,0.5113797484193323,
-Internal Deduplication,29100,average_rank,2.0,
-Internal Deduplication,29100,chartqa_relaxed_overall,0.6604,0.009473364442136777
-Internal Deduplication,29100,docvqa_val_anls,0.716657704725735,0.005756925555640175
-Internal Deduplication,29100,infovqa_val_anls,0.3372271343716428,0.007828634509891694
-Internal Deduplication,29100,mme_total_score,1300.1049419767908,
-Internal Deduplication,29100,mmmu_val_mmmu_acc,0.29556,
-Internal Deduplication,29100,mmstar_average,0.33882299281686595,
-Internal Deduplication,29100,ocrbench_ocrbench_accuracy,0.613,
-Internal Deduplication,29100,textvqa_val_exact_match,0.6335799999999999,0.006486361946288509
-Internal Deduplication,30300,ai2d_exact_match,0.49676165803108807,0.008998965371572352
-Internal Deduplication,30300,average,0.5468368131516261,
-Internal Deduplication,30300,average_rank,1.625,
-Internal Deduplication,30300,chartqa_relaxed_overall,0.6608,0.009470650520873179
-Internal Deduplication,30300,docvqa_val_anls,0.7208981382284003,0.005745692168242118
-Internal Deduplication,30300,infovqa_val_anls,0.33146012551516996,0.007795838114372819
-Internal Deduplication,30300,mme_total_score,1330.1678671468587,
-Internal Deduplication,30300,mmstar_average,0.35709777028672485,
-Internal Deduplication,30300,ocrbench_ocrbench_accuracy,0.622,
-Internal Deduplication,30300,textvqa_val_exact_match,0.6388400000000001,0.006462092742178937
-Internal Deduplication,31500,ai2d_exact_match,0.4996761658031088,0.008999152231809677
-Internal Deduplication,31500,average,0.5161255997108974,
-Internal Deduplication,31500,average_rank,1.4444444444444444,
-Internal Deduplication,31500,chartqa_relaxed_overall,0.6624,0.009459719367730022
-Internal Deduplication,31500,docvqa_val_anls,0.7248827916963386,0.005715267948257416
-Internal Deduplication,31500,infovqa_val_anls,0.3462785194206036,0.007940616340604684
-Internal Deduplication,31500,mme_total_score,1388.7246898759504,
-Internal Deduplication,31500,mmmu_val_mmmu_acc,0.28556,
-Internal Deduplication,31500,mmstar_average,0.34634732076712815,
-Internal Deduplication,31500,ocrbench_ocrbench_accuracy,0.622,
-Internal Deduplication,31500,textvqa_val_exact_match,0.64186,0.006449237676913657
-Internal Deduplication,32700,ai2d_exact_match,0.4957901554404145,0.008998835133354704
-Internal Deduplication,32700,average,0.5500475012134611,
-Internal Deduplication,32700,average_rank,1.5,
-Internal Deduplication,32700,chartqa_relaxed_overall,0.6688,0.009414779829167153
-Internal Deduplication,32700,docvqa_val_anls,0.7263156273407247,0.00570514646941267
-Internal Deduplication,32700,infovqa_val_anls,0.3489756877198793,0.00798640336179305
-Internal Deduplication,32700,mme_total_score,1362.764905962385,
-Internal Deduplication,32700,mmstar_average,0.3385910379932094,
-Internal Deduplication,32700,ocrbench_ocrbench_accuracy,0.63,
-Internal Deduplication,32700,textvqa_val_exact_match,0.64186,0.006452586710386076
-Internal Deduplication,33900,ai2d_exact_match,0.4957901554404145,0.008998835133354704
-Internal Deduplication,33900,average,0.5160312203077811,
-Internal Deduplication,33900,average_rank,1.4444444444444444,
-Internal Deduplication,33900,chartqa_relaxed_overall,0.674,0.009376820884924869
-Internal Deduplication,33900,docvqa_val_anls,0.7257174511919398,0.005702388110070895
-Internal Deduplication,33900,infovqa_val_anls,0.3422539948680319,0.007936425119162906
-Internal Deduplication,33900,mme_total_score,1389.4628851540615,
-Internal Deduplication,33900,mmmu_val_mmmu_acc,0.28444,
-Internal Deduplication,33900,mmstar_average,0.34272816096186326,
-Internal Deduplication,33900,ocrbench_ocrbench_accuracy,0.619,
-Internal Deduplication,33900,textvqa_val_exact_match,0.64432,0.0064359794815068575
-Internal Deduplication,35100,ai2d_exact_match,0.49838082901554404,0.008999106932714645
-Internal Deduplication,35100,average,0.5533101842015907,
-Internal Deduplication,35100,average_rank,1.375,
-Internal Deduplication,35100,chartqa_relaxed_overall,0.6736,0.009379787213112317
-Internal Deduplication,35100,docvqa_val_anls,0.7278181728761878,0.005688301164010059
-Internal Deduplication,35100,infovqa_val_anls,0.351201318391893,0.008119188634171728
-Internal Deduplication,35100,mme_total_score,1411.3839535814327,
-Internal Deduplication,35100,mmstar_average,0.34205096912751043,
-Internal Deduplication,35100,ocrbench_ocrbench_accuracy,0.634,
-Internal Deduplication,35100,textvqa_val_exact_match,0.64612,0.006431209933771596
-Internal Deduplication,36300,ai2d_exact_match,0.49805699481865284,0.00899908617055324
-Internal Deduplication,36300,average,0.5195231205481649,
-Internal Deduplication,36300,average_rank,1.5555555555555556,
-Internal Deduplication,36300,chartqa_relaxed_overall,0.672,0.009391574983583366
-Internal Deduplication,36300,docvqa_val_anls,0.730916270863908,0.005660120362847363
-Internal Deduplication,36300,infovqa_val_anls,0.3412406587672079,0.007911958522422949
-Internal Deduplication,36300,mme_total_score,1367.637254901961,
-Internal Deduplication,36300,mmmu_val_mmmu_acc,0.29444,
-Internal Deduplication,36300,mmstar_average,0.34529103993555027,
-Internal Deduplication,36300,ocrbench_ocrbench_accuracy,0.634,
-Internal Deduplication,36300,textvqa_val_exact_match,0.6402399999999999,0.006461617365628822
-Internal Deduplication,37500,ai2d_exact_match,0.5019430051813472,0.008999086170553233
-Internal Deduplication,37500,average,0.5495836143474903,
-Internal Deduplication,37500,average_rank,1.75,
-Internal Deduplication,37500,chartqa_relaxed_overall,0.6756,0.009364877808842454
-Internal Deduplication,37500,docvqa_val_anls,0.7255309514873474,0.005687086085909167
-Internal Deduplication,37500,infovqa_val_anls,0.3366534174444908,0.007850461211973954
-Internal Deduplication,37500,mme_total_score,1364.8713485394157,
-Internal Deduplication,37500,mmstar_average,0.3467179263192468,
-Internal Deduplication,37500,ocrbench_ocrbench_accuracy,0.618,
-Internal Deduplication,37500,textvqa_val_exact_match,0.64264,0.0064540760066348676
-Internal Deduplication,38700,ai2d_exact_match,0.49708549222797926,0.008999001233939138
-Internal Deduplication,38700,average,0.5196671356527304,
-Internal Deduplication,38700,average_rank,1.4444444444444444,
-Internal Deduplication,38700,chartqa_relaxed_overall,0.6744,0.009373846787815587
-Internal Deduplication,38700,docvqa_val_anls,0.732080533728902,0.0056514543481841085
-Internal Deduplication,38700,infovqa_val_anls,0.34326469229313616,0.0079487702679686
-Internal Deduplication,38700,mme_total_score,1366.760604241697,
-Internal Deduplication,38700,mmmu_val_mmmu_acc,0.28778,
-Internal Deduplication,38700,mmstar_average,0.34458636697182526,
-Internal Deduplication,38700,ocrbench_ocrbench_accuracy,0.632,
-Internal Deduplication,38700,textvqa_val_exact_match,0.6461399999999999,0.00642093963319658
-Internal Deduplication,39900,ai2d_exact_match,0.4957901554404145,0.008998835133354702
-Internal Deduplication,39900,average,0.5516529838475074,
-Internal Deduplication,39900,average_rank,1.625,
-Internal Deduplication,39900,chartqa_relaxed_overall,0.6696,0.009409024811273465
-Internal Deduplication,39900,docvqa_val_anls,0.723701988394961,0.005721818793341698
-Internal Deduplication,39900,infovqa_val_anls,0.3483904533235705,0.007951328084102772
-Internal Deduplication,39900,mme_total_score,1403.717386954782,
-Internal Deduplication,39900,mmstar_average,0.34950828977360593,
-Internal Deduplication,39900,ocrbench_ocrbench_accuracy,0.629,
-Internal Deduplication,39900,textvqa_val_exact_match,0.64558,0.006428340177019748
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6b6bf0d84fe1bc67436c70f9a8d5919627e9c2bc9c3f931f4af80c01be22649
+size 47060

app/src/content/assets/data/relevance_filters.csv

@@ -1,1201 +1,3 @@
-run,step,metric,value,stderr
-Baseline,1000,ai2d_exact_match,0.2548575129533679,0.007843322436924496
-Baseline,1000,average,0.27120689295763617,
-Baseline,1000,average_rank,3.1,
-Baseline,1000,chartqa_relaxed_overall,0.3308,0.009411906161401973
-Baseline,1000,docvqa_val_anls,0.3528553494243383,0.005852289239342309
-Baseline,1000,infovqa_val_anls,0.17320578642581314,0.006297063452679795
-Baseline,1000,mme_total_score,977.4280712284914,
-Baseline,1000,mmmu_val_mmmu_acc,0.25222,
-Baseline,1000,mmstar_average,0.23215874078908072,
-Baseline,1000,ocrbench_ocrbench_accuracy,0.286,
-Baseline,1000,seedbench_seed_all,0.2563646470261256,
-Baseline,1000,textvqa_val_exact_match,0.3024,0.00628900296642181
-Baseline,2000,ai2d_exact_match,0.26295336787564766,0.007923526907377255
-Baseline,2000,average,0.3202068275596269,
-Baseline,2000,average_rank,2.9,
-Baseline,2000,chartqa_relaxed_overall,0.4688,0.009982508912777261
-Baseline,2000,docvqa_val_anls,0.4452261510942785,0.00614755494712251
-Baseline,2000,infovqa_val_anls,0.1820547866557169,0.006217861455795791
-Baseline,2000,mme_total_score,1049.3036214485794,
-Baseline,2000,mmmu_val_mmmu_acc,0.24556,
-Baseline,2000,mmstar_average,0.21305462434540698,
-Baseline,2000,ocrbench_ocrbench_accuracy,0.395,
-Baseline,2000,seedbench_seed_all,0.258532518065592,
-Baseline,2000,textvqa_val_exact_match,0.41068000000000005,0.006697862330024289
-Baseline,3000,ai2d_exact_match,0.25226683937823835,0.007816909588794397
-Baseline,3000,average,0.3507423834414229,
-Baseline,3000,average_rank,2.7,
-Baseline,3000,chartqa_relaxed_overall,0.5028,0.010001843767601082
-Baseline,3000,docvqa_val_anls,0.502653993831009,0.006267072346683124
-Baseline,3000,infovqa_val_anls,0.21728617578189535,0.006796941784959762
-Baseline,3000,mme_total_score,1170.2383953581434,
-Baseline,3000,mmmu_val_mmmu_acc,0.27556,
-Baseline,3000,mmstar_average,0.25432376938577683,
-Baseline,3000,ocrbench_ocrbench_accuracy,0.436,
-Baseline,3000,seedbench_seed_all,0.2792106725958866,
-Baseline,3000,textvqa_val_exact_match,0.43658,0.006766885462882726
-Baseline,4000,ai2d_exact_match,0.2645725388601036,0.007939149662089447
-Baseline,4000,average,0.36961781722974835,
-Baseline,4000,average_rank,3.7,
-Baseline,4000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-Baseline,4000,docvqa_val_anls,0.5374434618615119,0.0062905728113059655
-Baseline,4000,infovqa_val_anls,0.2287924838861707,0.006994568698639919
-Baseline,4000,mme_total_score,1155.203781512605,
-Baseline,4000,mmmu_val_mmmu_acc,0.25556,
-Baseline,4000,mmstar_average,0.2575590188757354,
-Baseline,4000,ocrbench_ocrbench_accuracy,0.453,
-Baseline,4000,seedbench_seed_all,0.33913285158421347,
-Baseline,4000,textvqa_val_exact_match,0.4593,0.006791695475025738
-Baseline,5000,ai2d_exact_match,0.3125,0.008342439145556371
-Baseline,5000,average,0.3974627910380972,
-Baseline,5000,average_rank,3.3,
-Baseline,5000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-Baseline,5000,docvqa_val_anls,0.552360266782429,0.006300308519952055
-Baseline,5000,infovqa_val_anls,0.23425555286643698,0.007002254622066442
-Baseline,5000,mme_total_score,1181.4653861544618,
-Baseline,5000,mmmu_val_mmmu_acc,0.26667,
-Baseline,5000,mmstar_average,0.29596648146165705,
-Baseline,5000,ocrbench_ocrbench_accuracy,0.462,
-Baseline,5000,seedbench_seed_all,0.43107281823235133,
-Baseline,5000,textvqa_val_exact_match,0.47354000000000007,0.0068172185364497985
-Baseline,6000,ai2d_exact_match,0.358160621761658,0.008629463221867162
-Baseline,6000,average,0.4161227404571003,
-Baseline,6000,average_rank,2.6,
-Baseline,6000,chartqa_relaxed_overall,0.5628,0.00992279440175477
-Baseline,6000,docvqa_val_anls,0.5747451497228876,0.00625495440870239
-Baseline,6000,infovqa_val_anls,0.22152017368968838,0.006604546680525351
-Baseline,6000,mme_total_score,1284.1648659463785,
-Baseline,6000,mmmu_val_mmmu_acc,0.27111,
-Baseline,6000,mmstar_average,0.2978489412854164,
-Baseline,6000,ocrbench_ocrbench_accuracy,0.495,
-Baseline,6000,seedbench_seed_all,0.4795997776542524,
-Baseline,6000,textvqa_val_exact_match,0.48432,0.006800535050670284
-Baseline,7000,ai2d_exact_match,0.3707901554404145,0.00869347755587734
-Baseline,7000,average,0.4291083177345374,
-Baseline,7000,average_rank,2.9,
-Baseline,7000,chartqa_relaxed_overall,0.5656,0.009915542506251351
-Baseline,7000,docvqa_val_anls,0.5940907049431567,0.006224236305767187
-Baseline,7000,infovqa_val_anls,0.2515675215816963,0.007105097396092786
-Baseline,7000,mme_total_score,1185.875650260104,
-Baseline,7000,mmmu_val_mmmu_acc,0.26556,
-Baseline,7000,mmstar_average,0.31372400960777047,
-Baseline,7000,ocrbench_ocrbench_accuracy,0.504,
-Baseline,7000,seedbench_seed_all,0.4964424680377988,
-Baseline,7000,textvqa_val_exact_match,0.5002,0.006794794025220267
-Baseline,8000,ai2d_exact_match,0.37759067357512954,0.008725299846043883
-Baseline,8000,average,0.43846759477995995,
-Baseline,8000,average_rank,3.2,
-Baseline,8000,chartqa_relaxed_overall,0.5832,0.009862556058385773
-Baseline,8000,docvqa_val_anls,0.6017336419437208,0.006231612198089698
-Baseline,8000,infovqa_val_anls,0.2449256624147254,0.006992518502948913
-Baseline,8000,mme_total_score,1199.2409963985594,
-Baseline,8000,mmmu_val_mmmu_acc,0.28111,
-Baseline,8000,mmstar_average,0.33512257186205047,
-Baseline,8000,ocrbench_ocrbench_accuracy,0.51,
-Baseline,8000,seedbench_seed_all,0.5024458032240133,
-Baseline,8000,textvqa_val_exact_match,0.51008,0.006796301690135059
-Baseline,9000,ai2d_exact_match,0.4067357512953368,0.008841214921078996
-Baseline,9000,average,0.4422510732201056,
-Baseline,9000,average_rank,3.2,
-Baseline,9000,chartqa_relaxed_overall,0.5912,0.009834211136815875
-Baseline,9000,docvqa_val_anls,0.6170968481662739,0.00617235763542544
-Baseline,9000,infovqa_val_anls,0.23537031288570615,0.00670318154156447
-Baseline,9000,mme_total_score,1231.5195078031213,
-Baseline,9000,mmmu_val_mmmu_acc,0.25889,
-Baseline,9000,mmstar_average,0.3216444898242951,
-Baseline,9000,ocrbench_ocrbench_accuracy,0.515,
-Baseline,9000,seedbench_seed_all,0.5120622568093385,
-Baseline,9000,textvqa_val_exact_match,0.52226,0.006792711289708482
-Baseline,10000,ai2d_exact_match,0.39993523316062174,0.008817096257082848
-Baseline,10000,average,0.4523875703250908,
-Baseline,10000,average_rank,2.9,
-Baseline,10000,chartqa_relaxed_overall,0.5996,0.00980154906867574
-Baseline,10000,docvqa_val_anls,0.6262613496433054,0.006147756371688175
-Baseline,10000,infovqa_val_anls,0.263290074230132,0.007186788766942786
-Baseline,10000,mme_total_score,1240.8218287314926,
-Baseline,10000,mmmu_val_mmmu_acc,0.28778,
-Baseline,10000,mmstar_average,0.32972717906018517,
-Baseline,10000,ocrbench_ocrbench_accuracy,0.517,
-Baseline,10000,seedbench_seed_all,0.5217342968315731,
-Baseline,10000,textvqa_val_exact_match,0.5261600000000001,0.006785774843600811
-Baseline,11000,ai2d_exact_match,0.422279792746114,0.008889771831066474
-Baseline,11000,average,0.4561398159525099,
-Baseline,11000,average_rank,3.0,
-Baseline,11000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-Baseline,11000,docvqa_val_anls,0.6373130149166712,0.006128022584995044
-Baseline,11000,infovqa_val_anls,0.24419378339723755,0.006897644885887063
-Baseline,11000,mme_total_score,1322.9488795518205,
-Baseline,11000,mmmu_val_mmmu_acc,0.27778,
-Baseline,11000,mmstar_average,0.3298563439522548,
-Baseline,11000,ocrbench_ocrbench_accuracy,0.521,
-Baseline,11000,seedbench_seed_all,0.5237354085603113,
-Baseline,11000,textvqa_val_exact_match,0.5387,0.006770851562852138
-Baseline,12000,ai2d_exact_match,0.42001295336787564,0.008883255931688034
-Baseline,12000,average,0.4582751140055433,
-Baseline,12000,average_rank,3.5,
-Baseline,12000,chartqa_relaxed_overall,0.618,0.009719474639861454
-Baseline,12000,docvqa_val_anls,0.6393961983751871,0.0061228747388476674
-Baseline,12000,infovqa_val_anls,0.24798874058574302,0.006855374548993139
-Baseline,12000,mme_total_score,1225.6453581432572,
-Baseline,12000,mmmu_val_mmmu_acc,0.27889,
-Baseline,12000,mmstar_average,0.34010867846816534,
-Baseline,12000,ocrbench_ocrbench_accuracy,0.512,
-Baseline,12000,seedbench_seed_all,0.5350194552529183,
-Baseline,12000,textvqa_val_exact_match,0.5330600000000001,0.006777713092109446
-Baseline,13000,ai2d_exact_match,0.4375,0.008928571428571428
-Baseline,13000,average,0.4692868662590049,
-Baseline,13000,average_rank,2.7,
-Baseline,13000,chartqa_relaxed_overall,0.6148,0.00973479791861169
-Baseline,13000,docvqa_val_anls,0.6511374872549951,0.006086953065248391
-Baseline,13000,infovqa_val_anls,0.24465055100441893,0.006808432538374664
-Baseline,13000,mme_total_score,1281.7122849139657,
-Baseline,13000,mmmu_val_mmmu_acc,0.28222,
-Baseline,13000,mmstar_average,0.3453069542917521,
-Baseline,13000,ocrbench_ocrbench_accuracy,0.549,
-Baseline,13000,seedbench_seed_all,0.5442468037798777,
-Baseline,13000,textvqa_val_exact_match,0.55472,0.0067416788982325
-Baseline,14000,ai2d_exact_match,0.4572538860103627,0.00896620675297095
-Baseline,14000,average,0.47352486841689195,
-Baseline,14000,average_rank,2.5,
-Baseline,14000,chartqa_relaxed_overall,0.6172,0.009723347231923635
-Baseline,14000,docvqa_val_anls,0.6502269393708169,0.006057950730638126
-Baseline,14000,infovqa_val_anls,0.25805460837190913,0.007037735231659539
-Baseline,14000,mme_total_score,1309.1444577831132,
-Baseline,14000,mmmu_val_mmmu_acc,0.28111,
-Baseline,14000,mmstar_average,0.34575818188776586,
-Baseline,14000,ocrbench_ocrbench_accuracy,0.551,
-Baseline,14000,seedbench_seed_all,0.5483602001111729,
-Baseline,14000,textvqa_val_exact_match,0.55276,0.006751206724612103
-Baseline,15000,ai2d_exact_match,0.45045336787564766,0.008954861634252399
-Baseline,15000,average,0.47878665012878824,
-Baseline,15000,average_rank,2.6,
-Baseline,15000,chartqa_relaxed_overall,0.612,0.009747841205275417
-Baseline,15000,docvqa_val_anls,0.6621413031955148,0.006056838050222495
-Baseline,15000,infovqa_val_anls,0.2706898598157733,0.007200315730154543
-Baseline,15000,mme_total_score,1384.2171868747498,
-Baseline,15000,mmmu_val_mmmu_acc,0.30222,
-Baseline,15000,mmstar_average,0.35408135695920684,
-Baseline,15000,ocrbench_ocrbench_accuracy,0.558,
-Baseline,15000,seedbench_seed_all,0.5411339633129516,
-Baseline,15000,textvqa_val_exact_match,0.5583600000000001,0.0067279027203879065
-Baseline,16000,ai2d_exact_match,0.45077720207253885,0.008955440137395838
-Baseline,16000,average,0.47665128022935843,
-Baseline,16000,average_rank,3.0,
-Baseline,16000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,16000,docvqa_val_anls,0.6709415729142987,0.005999818105621502
-Baseline,16000,infovqa_val_anls,0.26050032542402035,0.006997451875879188
-Baseline,16000,mme_total_score,1317.8491396558625,
-Baseline,16000,mmmu_val_mmmu_acc,0.27556,
-Baseline,16000,mmstar_average,0.33214333327093315,
-Baseline,16000,ocrbench_ocrbench_accuracy,0.56,
-Baseline,16000,seedbench_seed_all,0.5463590883824346,
-Baseline,16000,textvqa_val_exact_match,0.56158,0.006723854754867398
-Baseline,17000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-Baseline,17000,average,0.4777141780162423,
-Baseline,17000,average_rank,2.5,
-Baseline,17000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,17000,docvqa_val_anls,0.6796338519136422,0.005948761388267941
-Baseline,17000,infovqa_val_anls,0.28070956072505215,0.007298333094144192
-Baseline,17000,mme_total_score,1381.9161664665867,
-Baseline,17000,mmmu_val_mmmu_acc,0.27667,
-Baseline,17000,mmstar_average,0.3370289492329521,
-Baseline,17000,ocrbench_ocrbench_accuracy,0.519,
-Baseline,17000,seedbench_seed_all,0.5510283490828238,
-Baseline,17000,textvqa_val_exact_match,0.56416,0.006724830373229479
-Baseline,18000,ai2d_exact_match,0.46567357512953367,0.008977921602780726
-Baseline,18000,average,0.4819834595278701,
-Baseline,18000,average_rank,2.9,
-Baseline,18000,chartqa_relaxed_overall,0.6376,0.009615793331418735
-Baseline,18000,docvqa_val_anls,0.6775884603912571,0.005972234236435759
-Baseline,18000,infovqa_val_anls,0.27154318420389256,0.007164903131667027
-Baseline,18000,mme_total_score,1336.922769107643,
-Baseline,18000,mmmu_val_mmmu_acc,0.28667,
-Baseline,18000,mmstar_average,0.34482796716566916,
-Baseline,18000,ocrbench_ocrbench_accuracy,0.533,
-Baseline,18000,seedbench_seed_all,0.5543079488604781,
-Baseline,18000,textvqa_val_exact_match,0.5666399999999999,0.006713392287599574
-Baseline,19000,ai2d_exact_match,0.4682642487046632,0.008981008686994101
-Baseline,19000,average,0.4899006713916878,
-Baseline,19000,average_rank,2.7,
-Baseline,19000,chartqa_relaxed_overall,0.6444,0.009575809858898698
-Baseline,19000,docvqa_val_anls,0.678226526479947,0.005970619221588814
-Baseline,19000,infovqa_val_anls,0.26993847247278,0.0071348470764911525
-Baseline,19000,mme_total_score,1406.6628651460583,
-Baseline,19000,mmmu_val_mmmu_acc,0.28333,
-Baseline,19000,mmstar_average,0.356220913822775,
-Baseline,19000,ocrbench_ocrbench_accuracy,0.577,
-Baseline,19000,seedbench_seed_all,0.554585881045025,
-Baseline,19000,textvqa_val_exact_match,0.57714,0.0066918487914812905
-Baseline,20000,ai2d_exact_match,0.47571243523316065,0.00898853090258662
-Baseline,20000,average,0.4873169067639118,
-Baseline,20000,average_rank,3.1,
-Baseline,20000,chartqa_relaxed_overall,0.6336,0.009638338810708618
-Baseline,20000,docvqa_val_anls,0.6895214454380043,0.005896462073053767
-Baseline,20000,infovqa_val_anls,0.2655657550458317,0.007033265532032538
-Baseline,20000,mme_total_score,1324.6738695478193,
-Baseline,20000,mmmu_val_mmmu_acc,0.30111,
-Baseline,20000,mmstar_average,0.33806766134497995,
-Baseline,20000,ocrbench_ocrbench_accuracy,0.555,
-Baseline,20000,seedbench_seed_all,0.5587548638132296,
-Baseline,20000,textvqa_val_exact_match,0.56852,0.006720151338087659
-≥2,1000,ai2d_exact_match,0.2645725388601036,0.007939149662089442
-≥2,1000,average,0.2722931646460497,
-≥2,1000,average_rank,3.2,
-≥2,1000,chartqa_relaxed_overall,0.3664,0.009638338810708616
-≥2,1000,docvqa_val_anls,0.35825461497275807,0.005864292098743202
-≥2,1000,infovqa_val_anls,0.16722293767954274,0.0061333612650745235
-≥2,1000,mme_total_score,994.9906962785115,
-≥2,1000,mmmu_val_mmmu_acc,0.25111,
-≥2,1000,mmstar_average,0.2099224814637991,
-≥2,1000,ocrbench_ocrbench_accuracy,0.304,
-≥2,1000,seedbench_seed_all,0.24463590883824346,
-≥2,1000,textvqa_val_exact_match,0.28452000000000005,0.006179555914647949
-≥2,2000,ai2d_exact_match,0.2648963730569948,0.007942257693619753
-≥2,2000,average,0.3161289250086133,
-≥2,2000,average_rank,3.2,
-≥2,2000,chartqa_relaxed_overall,0.4476,0.00994692276581072
-≥2,2000,docvqa_val_anls,0.44553207035528164,0.006176982458046509
-≥2,2000,infovqa_val_anls,0.19690312157526974,0.00648399793536667
-≥2,2000,mme_total_score,1054.2768107242898,
-≥2,2000,mmmu_val_mmmu_acc,0.24778,
-≥2,2000,mmstar_average,0.20779488571532076,
-≥2,2000,ocrbench_ocrbench_accuracy,0.383,
-≥2,2000,seedbench_seed_all,0.2529738743746526,
-≥2,2000,textvqa_val_exact_match,0.39868,0.006677826756815335
-≥2,3000,ai2d_exact_match,0.2697538860103627,0.007988222765138163
-≥2,3000,average,0.34461871112110076,
-≥2,3000,average_rank,3.7,
-≥2,3000,chartqa_relaxed_overall,0.502,0.010001920583875201
-≥2,3000,docvqa_val_anls,0.4943706505276063,0.006276617082627261
-≥2,3000,infovqa_val_anls,0.21287605644341218,0.006682253709215569
-≥2,3000,mme_total_score,1162.2701080432173,
-≥2,3000,mmmu_val_mmmu_acc,0.25556,
-��2,3000,mmstar_average,0.21427247636922603,
-≥2,3000,ocrbench_ocrbench_accuracy,0.449,
-≥2,3000,seedbench_seed_all,0.2715953307392996,
-≥2,3000,textvqa_val_exact_match,0.43213999999999997,0.006742795943777913
-≥2,4000,ai2d_exact_match,0.27525906735751293,0.008038849490577975
-≥2,4000,average,0.37379440715652495,
-≥2,4000,average_rank,2.6,
-≥2,4000,chartqa_relaxed_overall,0.5356,0.009976616117083942
-≥2,4000,docvqa_val_anls,0.5415736777563739,0.006259488230977563
-≥2,4000,infovqa_val_anls,0.22392444384387208,0.00676041701311943
-≥2,4000,mme_total_score,1195.5438175270108,
-≥2,4000,mmmu_val_mmmu_acc,0.26667,
-≥2,4000,mmstar_average,0.2507897461569136,
-≥2,4000,ocrbench_ocrbench_accuracy,0.462,
-≥2,4000,seedbench_seed_all,0.34291272929405225,
-≥2,4000,textvqa_val_exact_match,0.46542,0.0067795602517745565
-≥2,5000,ai2d_exact_match,0.31055699481865284,0.008328207321163279
-≥2,5000,average,0.39445964778826137,
-≥2,5000,average_rank,3.3,
-≥2,5000,chartqa_relaxed_overall,0.552,0.00994776272300849
-≥2,5000,docvqa_val_anls,0.5556927230238289,0.006299299461817651
-≥2,5000,infovqa_val_anls,0.24261245038285142,0.007075738778751112
-≥2,5000,mme_total_score,1220.672168867547,
-≥2,5000,mmmu_val_mmmu_acc,0.27444,
-≥2,5000,mmstar_average,0.2522926162881413,
-≥2,5000,ocrbench_ocrbench_accuracy,0.467,
-≥2,5000,seedbench_seed_all,0.42768204558087825,
-≥2,5000,textvqa_val_exact_match,0.46785999999999994,0.006777889939974511
-≥2,6000,ai2d_exact_match,0.3325777202072539,0.008479663360791275
-≥2,6000,average,0.4101998600043759,
-≥2,6000,average_rank,3.7,
-≥2,6000,chartqa_relaxed_overall,0.5672,0.009911254067113462
-≥2,6000,docvqa_val_anls,0.5702012141050906,0.006263916894054504
-≥2,6000,infovqa_val_anls,0.21632587505016104,0.006473865748732477
-≥2,6000,mme_total_score,1313.7047819127652,
-≥2,6000,mmmu_val_mmmu_acc,0.28,
-≥2,6000,mmstar_average,0.28566177948176935,
-≥2,6000,ocrbench_ocrbench_accuracy,0.486,
-≥2,6000,seedbench_seed_all,0.4698721511951084,
-≥2,6000,textvqa_val_exact_match,0.48396000000000006,0.006801425994533192
-≥2,7000,ai2d_exact_match,0.35200777202072536,0.00859592682822483
-≥2,7000,average,0.4204955224344633,
-≥2,7000,average_rank,4.0,
-≥2,7000,chartqa_relaxed_overall,0.5712,0.00990007214980924
-≥2,7000,docvqa_val_anls,0.5850734578344774,0.006202520219850679
-≥2,7000,infovqa_val_anls,0.23449023638527144,0.0067906990453115955
-≥2,7000,mme_total_score,1247.423969587835,
-≥2,7000,mmmu_val_mmmu_acc,0.28444,
-≥2,7000,mmstar_average,0.29053864145068503,
-≥2,7000,ocrbench_ocrbench_accuracy,0.487,
-≥2,7000,seedbench_seed_all,0.48526959421901056,
-≥2,7000,textvqa_val_exact_match,0.49444000000000005,0.006796105847537853
-≥2,8000,ai2d_exact_match,0.3746761658031088,0.008711886524907496
-≥2,8000,average,0.43663916832315425,
-≥2,8000,average_rank,2.9,
-≥2,8000,chartqa_relaxed_overall,0.5816,0.00986790384075991
-≥2,8000,docvqa_val_anls,0.6028798426362394,0.006214872354058686
-≥2,8000,infovqa_val_anls,0.2535281850303886,0.0070045473889607445
-≥2,8000,mme_total_score,1300.5965386154462,
-≥2,8000,mmmu_val_mmmu_acc,0.27333,
-≥2,8000,mmstar_average,0.310944925107356,
-≥2,8000,ocrbench_ocrbench_accuracy,0.516,
-≥2,8000,seedbench_seed_all,0.5041133963312951,
-≥2,8000,textvqa_val_exact_match,0.51268,0.006798079603627737
-≥2,9000,ai2d_exact_match,0.3795336787564767,0.00873405559083709
-≥2,9000,average,0.43759974296352216,
-≥2,9000,average_rank,2.9,
-≥2,9000,chartqa_relaxed_overall,0.5884,0.009844437067525526
-≥2,9000,docvqa_val_anls,0.6175894644110065,0.0061700253612544395
-≥2,9000,infovqa_val_anls,0.24471327484068725,0.006934982517240646
-≥2,9000,mme_total_score,1258.1754701880752,
-≥2,9000,mmmu_val_mmmu_acc,0.27,
-≥2,9000,mmstar_average,0.2988526527658083,
-≥2,9000,ocrbench_ocrbench_accuracy,0.514,
-≥2,9000,seedbench_seed_all,0.5155086158977209,
-≥2,9000,textvqa_val_exact_match,0.5098,0.00680062068405066
-≥2,10000,ai2d_exact_match,0.407059585492228,0.008842319527489083
-≥2,10000,average,0.45127176699921406,
-≥2,10000,average_rank,3.1,
-≥2,10000,chartqa_relaxed_overall,0.5956,0.009817474681589429
-≥2,10000,docvqa_val_anls,0.6286443353240219,0.006128441640319587
-≥2,10000,infovqa_val_anls,0.25277210900180563,0.007055702724548255
-≥2,10000,mme_total_score,1320.1028411364546,
-≥2,10000,mmmu_val_mmmu_acc,0.27556,
-≥2,10000,mmstar_average,0.3429750538307907,
-≥2,10000,ocrbench_ocrbench_accuracy,0.523,
-≥2,10000,seedbench_seed_all,0.51467481934408,
-≥2,10000,textvqa_val_exact_match,0.5211600000000001,0.006783601870014644
-≥2,11000,ai2d_exact_match,0.41580310880829013,0.008870644443998564
-≥2,11000,average,0.4525862975952584,
-≥2,11000,average_rank,3.5,
-≥2,11000,chartqa_relaxed_overall,0.598,0.009808000752013664
-≥2,11000,docvqa_val_anls,0.6307438129106796,0.006133911991297053
-≥2,11000,infovqa_val_anls,0.25390014221903434,0.007050537280004977
-≥2,11000,mme_total_score,1302.5287114845937,
-≥2,11000,mmmu_val_mmmu_acc,0.29333,
-≥2,11000,mmstar_average,0.303972877343168,
-���2,11000,ocrbench_ocrbench_accuracy,0.523,
-≥2,11000,seedbench_seed_all,0.5281267370761534,
-≥2,11000,textvqa_val_exact_match,0.5264,0.006786826961404041
-≥2,12000,ai2d_exact_match,0.43426165803108807,0.008921034830887027
-≥2,12000,average,0.46342874141175217,
-≥2,12000,average_rank,2.7,
-≥2,12000,chartqa_relaxed_overall,0.6188,0.009715574144248037
-≥2,12000,docvqa_val_anls,0.6419729722202083,0.006094582531110984
-≥2,12000,infovqa_val_anls,0.24776952598966778,0.006784112219881613
-≥2,12000,mme_total_score,1255.4957983193276,
-≥2,12000,mmmu_val_mmmu_acc,0.27111,
-≥2,12000,mmstar_average,0.3424608032908198,
-≥2,12000,ocrbench_ocrbench_accuracy,0.541,
-≥2,12000,seedbench_seed_all,0.5306837131739855,
-≥2,12000,textvqa_val_exact_match,0.5428,0.006758192556691964
-≥2,13000,ai2d_exact_match,0.42843264248704666,0.008906491762178375
-≥2,13000,average,0.4611120038339278,
-≥2,13000,average_rank,3.8,
-≥2,13000,chartqa_relaxed_overall,0.606,0.00977465178546074
-≥2,13000,docvqa_val_anls,0.6433656711922792,0.0061086851054902285
-≥2,13000,infovqa_val_anls,0.2535479547381062,0.006989226376396767
-≥2,13000,mme_total_score,1360.003101240496,
-≥2,13000,mmmu_val_mmmu_acc,0.28556,
-≥2,13000,mmstar_average,0.3320394092229932,
-≥2,13000,ocrbench_ocrbench_accuracy,0.526,
-≥2,13000,seedbench_seed_all,0.5362423568649249,
-≥2,13000,textvqa_val_exact_match,0.53882,0.006765393974568386
-≥2,14000,ai2d_exact_match,0.44689119170984454,0.008948245073044956
-≥2,14000,average,0.47130833654714216,
-≥2,14000,average_rank,2.8,
-≥2,14000,chartqa_relaxed_overall,0.6216,0.009701702181065136
-≥2,14000,docvqa_val_anls,0.6619108814388047,0.006015398975274413
-≥2,14000,infovqa_val_anls,0.2567040650730957,0.006986745571340195
-≥2,14000,mme_total_score,1310.3628451380553,
-≥2,14000,mmmu_val_mmmu_acc,0.28333,
-≥2,14000,mmstar_average,0.3315916867003111,
-≥2,14000,ocrbench_ocrbench_accuracy,0.547,
-≥2,14000,seedbench_seed_all,0.5409672040022234,
-≥2,14000,textvqa_val_exact_match,0.55178,0.006748546131944198
-≥2,15000,ai2d_exact_match,0.4523963730569948,0.00895827521082005
-≥2,15000,average,0.4720211465604895,
-≥2,15000,average_rank,3.5,
-≥2,15000,chartqa_relaxed_overall,0.62,0.009709671008043154
-≥2,15000,docvqa_val_anls,0.6679183447758706,0.005982903367170995
-≥2,15000,infovqa_val_anls,0.24815705436683513,0.006864270716284432
-≥2,15000,mme_total_score,1236.2534013605443,
-≥2,15000,mmmu_val_mmmu_acc,0.29889,
-≥2,15000,mmstar_average,0.3351456007635487,
-≥2,15000,ocrbench_ocrbench_accuracy,0.527,
-≥2,15000,seedbench_seed_all,0.5453029460811561,
-≥2,15000,textvqa_val_exact_match,0.55338,0.006735012041373013
-≥2,16000,ai2d_exact_match,0.44624352331606215,0.008946992176353898
-≥2,16000,average,0.4766960932538844,
-≥2,16000,average_rank,3.2,
-≥2,16000,chartqa_relaxed_overall,0.612,0.009747841205275417
-≥2,16000,docvqa_val_anls,0.6754589054855508,0.005966817690473989
-≥2,16000,infovqa_val_anls,0.27323519213464514,0.007206289716945655
-≥2,16000,mme_total_score,1305.906762705082,
-≥2,16000,mmmu_val_mmmu_acc,0.29,
-≥2,16000,mmstar_average,0.34328884147265926,
-≥2,16000,ocrbench_ocrbench_accuracy,0.555,
-≥2,16000,seedbench_seed_all,0.5410783768760422,
-≥2,16000,textvqa_val_exact_match,0.55396,0.00674076785464787
-≥2,17000,ai2d_exact_match,0.4485103626943005,0.008951310133709686
-≥2,17000,average,0.4803744475549501,
-≥2,17000,average_rank,3.3,
-≥2,17000,chartqa_relaxed_overall,0.6352,0.009629406741314642
-≥2,17000,docvqa_val_anls,0.6735387256928971,0.006001868055856522
-≥2,17000,infovqa_val_anls,0.2713449738427,0.007231154690666275
-≥2,17000,mme_total_score,1302.8314325730291,
-≥2,17000,mmmu_val_mmmu_acc,0.28667,
-≥2,17000,mmstar_average,0.33631999578132954,
-≥2,17000,ocrbench_ocrbench_accuracy,0.571,
-≥2,17000,seedbench_seed_all,0.542745969983324,
-≥2,17000,textvqa_val_exact_match,0.5580400000000001,0.006741465801458199
-≥2,18000,ai2d_exact_match,0.46113989637305697,0.008971933568013592
-≥2,18000,average,0.48745721111983964,
-≥2,18000,average_rank,2.6,
-≥2,18000,chartqa_relaxed_overall,0.6276,0.009670817229291067
-≥2,18000,docvqa_val_anls,0.6812777947859573,0.005935773909547658
-≥2,18000,infovqa_val_anls,0.27095882924867687,0.007164605404977649
-≥2,18000,mme_total_score,1289.7513005202081,
-≥2,18000,mmmu_val_mmmu_acc,0.31556,
-≥2,18000,mmstar_average,0.35401030852022664,
-≥2,18000,ocrbench_ocrbench_accuracy,0.564,
-≥2,18000,seedbench_seed_all,0.5505280711506393,
-≥2,18000,textvqa_val_exact_match,0.5620400000000001,0.00673487040527694
-≥2,19000,ai2d_exact_match,0.4698834196891192,0.008982814668850815
-≥2,19000,average,0.48664836716175586,
-≥2,19000,average_rank,3.2,
-≥2,19000,chartqa_relaxed_overall,0.6276,0.009670817229291067
-≥2,19000,docvqa_val_anls,0.6838077764263535,0.005944136929785695
-≥2,19000,infovqa_val_anls,0.26757170067350106,0.007096398035000058
-≥2,19000,mme_total_score,1310.4946978791518,
-≥2,19000,mmmu_val_mmmu_acc,0.29444,
-≥2,19000,mmstar_average,0.365800601107629,
-≥2,19000,ocrbench_ocrbench_accuracy,0.559,
-≥2,19000,seedbench_seed_all,0.5532518065591996,
-≥2,19000,textvqa_val_exact_match,0.55848,0.006735717623117797
-≥2,20000,ai2d_exact_match,0.4727979274611399,0.008985826352357515
-≥2,20000,average,0.4887875980209429,
-≥2,20000,average_rank,3.4,
-≥2,20000,chartqa_relaxed_overall,0.6392,0.00960657371300514
-≥2,20000,docvqa_val_anls,0.6828620051596259,0.005923332769971399
-≥2,20000,infovqa_val_anls,0.2701274975234547,0.007055868134029247
-≥2,20000,mme_total_score,1323.9108643457382,
-≥2,20000,mmmu_val_mmmu_acc,0.30222,
-≥2,20000,mmstar_average,0.33931189145504953,
-≥2,20000,ocrbench_ocrbench_accuracy,0.57,
-≥2,20000,seedbench_seed_all,0.5563090605892163,
-≥2,20000,textvqa_val_exact_match,0.56626,0.0067178082936069205
-≥3,1000,ai2d_exact_match,0.2691062176165803,0.007982164708643914
-≥3,1000,average,0.27573784261835144,
-≥3,1000,average_rank,2.8,
-≥3,1000,chartqa_relaxed_overall,0.352,0.009553790345406665
-≥3,1000,docvqa_val_anls,0.3425840937939014,0.005755186508181206
-≥3,1000,infovqa_val_anls,0.1714752271538445,0.006218691549786442
-≥3,1000,mme_total_score,1013.1872749099639,
-≥3,1000,mmmu_val_mmmu_acc,0.24778,
-≥3,1000,mmstar_average,0.2075589805205699,
-≥3,1000,ocrbench_ocrbench_accuracy,0.324,
-≥3,1000,seedbench_seed_all,0.24891606448026682,
-≥3,1000,textvqa_val_exact_match,0.31822,0.006368399926474836
-≥3,2000,ai2d_exact_match,0.25647668393782386,0.007859644922870102
-≥3,2000,average,0.32059377128504934,
-≥3,2000,average_rank,2.8,
-≥3,2000,chartqa_relaxed_overall,0.4628,0.009974279848861338
-≥3,2000,docvqa_val_anls,0.4518369496978485,0.00619300217721929
-≥3,2000,infovqa_val_anls,0.21204013425009277,0.006820894774458214
-≥3,2000,mme_total_score,1118.8858543417368,
-≥3,2000,mmmu_val_mmmu_acc,0.25222,
-≥3,2000,mmstar_average,0.20454842826555975,
-≥3,2000,ocrbench_ocrbench_accuracy,0.376,
-≥3,2000,seedbench_seed_all,0.25514174541411894,
-≥3,2000,textvqa_val_exact_match,0.41428000000000004,0.006714956027174666
-≥3,3000,ai2d_exact_match,0.25259067357512954,0.007820231277456426
-≥3,3000,average,0.35341646277484595,
-≥3,3000,average_rank,2.4,
-≥3,3000,chartqa_relaxed_overall,0.5208,0.00999334232158103
-≥3,3000,docvqa_val_anls,0.49758866181984457,0.00626460182861003
-≥3,3000,infovqa_val_anls,0.21333414080666746,0.0067509043256437935
-≥3,3000,mme_total_score,1165.3744497799119,
-≥3,3000,mmmu_val_mmmu_acc,0.26,
-≥3,3000,mmstar_average,0.2652435492500152,
-≥3,3000,ocrbench_ocrbench_accuracy,0.442,
-≥3,3000,seedbench_seed_all,0.29205113952195666,
-≥3,3000,textvqa_val_exact_match,0.43714,0.006763850531672249
-≥3,4000,ai2d_exact_match,0.28303108808290156,0.008107723290508887
-≥3,4000,average,0.37496255619498237,
-≥3,4000,average_rank,3.4,
-≥3,4000,chartqa_relaxed_overall,0.5412,0.009967987174315731
-≥3,4000,docvqa_val_anls,0.5296261512617491,0.006274192303767133
-≥3,4000,infovqa_val_anls,0.2050381576936679,0.006416570814061769
-≥3,4000,mme_total_score,1119.7681072428973,
-≥3,4000,mmmu_val_mmmu_acc,0.25556,
-≥3,4000,mmstar_average,0.24897141082880767,
-≥3,4000,ocrbench_ocrbench_accuracy,0.47,
-≥3,4000,seedbench_seed_all,0.3811561978877154,
-≥3,4000,textvqa_val_exact_match,0.46007999999999993,0.006793769924125808
-≥3,5000,ai2d_exact_match,0.3248056994818653,0.008428647470081763
-≥3,5000,average,0.3977887563101667,
-≥3,5000,average_rank,2.8,
-≥3,5000,chartqa_relaxed_overall,0.5544,0.009942625323290008
-≥3,5000,docvqa_val_anls,0.553669449701632,0.006282439058750721
-≥3,5000,infovqa_val_anls,0.20821650889148954,0.006430552192683275
-≥3,5000,mme_total_score,1326.9777911164465,
-≥3,5000,mmmu_val_mmmu_acc,0.26444,
-≥3,5000,mmstar_average,0.279759822424129,
-≥3,5000,ocrbench_ocrbench_accuracy,0.487,
-≥3,5000,seedbench_seed_all,0.43718732629238466,
-≥3,5000,textvqa_val_exact_match,0.47062,0.0067917147023207275
-≥3,6000,ai2d_exact_match,0.3536269430051813,0.008604903043803527
-≥3,6000,average,0.41524300122458385,
-≥3,6000,average_rank,3.1,
-≥3,6000,chartqa_relaxed_overall,0.568,0.009909070383761948
-≥3,6000,docvqa_val_anls,0.5722640243712676,0.00625854154899254
-≥3,6000,infovqa_val_anls,0.2204869348964998,0.00662088578415522
-≥3,6000,mme_total_score,1270.3575430172068,
-≥3,6000,mmmu_val_mmmu_acc,0.26556,
-≥3,6000,mmstar_average,0.2958896090262379,
-≥3,6000,ocrbench_ocrbench_accuracy,0.497,
-≥3,6000,seedbench_seed_all,0.47909949972206783,
-≥3,6000,textvqa_val_exact_match,0.48526,0.006795924028171543
-≥3,7000,ai2d_exact_match,0.3805051813471503,0.00873837769131663
-≥3,7000,average,0.42920372592352884,
-≥3,7000,average_rank,2.7,
-≥3,7000,chartqa_relaxed_overall,0.5728,0.009895414680177737
-≥3,7000,docvqa_val_anls,0.5922749765517075,0.006249497802747461
-≥3,7000,infovqa_val_anls,0.23025261139769496,0.006777932440928761
-≥3,7000,mme_total_score,1289.3664465786314,
-≥3,7000,mmmu_val_mmmu_acc,0.27111,
-≥3,7000,mmstar_average,0.3153601470057574,
-≥3,7000,ocrbench_ocrbench_accuracy,0.498,
-≥3,7000,seedbench_seed_all,0.4991106170094497,
-≥3,7000,textvqa_val_exact_match,0.50342,0.006801949281110862
-≥3,8000,ai2d_exact_match,0.39799222797927464,0.008809880751131852
-≥3,8000,average,0.438180751977588,
-≥3,8000,average_rank,2.4,
-≥3,8000,chartqa_relaxed_overall,0.5844,0.009858475126140203
-≥3,8000,docvqa_val_anls,0.6044755547364623,0.006202062618138765
-≥3,8000,infovqa_val_anls,0.21693088745597935,0.006529416377309533
-≥3,8000,mme_total_score,1187.3639455782313,
-≥3,8000,mmmu_val_mmmu_acc,0.28667,
-≥3,8000,mmstar_average,0.31735843114519735,
-≥3,8000,ocrbench_ocrbench_accuracy,0.506,
-≥3,8000,seedbench_seed_all,0.5193996664813786,
-≥3,8000,textvqa_val_exact_match,0.5104,0.0067972647853171315
-≥3,9000,ai2d_exact_match,0.407059585492228,0.008842319527489083
-≥3,9000,average,0.44395606448032265,
-≥3,9000,average_rank,3.0,
-≥3,9000,chartqa_relaxed_overall,0.598,0.009808000752013664
-≥3,9000,docvqa_val_anls,0.6107522318987826,0.006184930065074595
-≥3,9000,infovqa_val_anls,0.2347778400526839,0.0067525186273140235
-≥3,9000,mme_total_score,1195.0110044017606,
-≥3,9000,mmmu_val_mmmu_acc,0.28222,
-≥3,9000,mmstar_average,0.3264280968647572,
-≥3,9000,ocrbench_ocrbench_accuracy,0.521,
-≥3,9000,seedbench_seed_all,0.5162868260144525,
-≥3,9000,textvqa_val_exact_match,0.4990799999999999,0.00679372222366579
-≥3,10000,ai2d_exact_match,0.41580310880829013,0.008870644443998564
-≥3,10000,average,0.4524021135685592,
-≥3,10000,average_rank,2.5,
-≥3,10000,chartqa_relaxed_overall,0.5992,0.00980317218424473
-≥3,10000,docvqa_val_anls,0.6291907180725226,0.0061343676879221844
-≥3,10000,infovqa_val_anls,0.2282836442456148,0.006711844883510513
-≥3,10000,mme_total_score,1326.8972589035614,
-≥3,10000,mmmu_val_mmmu_acc,0.30111,
-≥3,10000,mmstar_average,0.3402582102457474,
-≥3,10000,ocrbench_ocrbench_accuracy,0.522,
-≥3,10000,seedbench_seed_all,0.5240133407448583,
-≥3,10000,textvqa_val_exact_match,0.51176,0.006789754092169055
-≥3,11000,ai2d_exact_match,0.42389896373056996,0.008894308540753343
-≥3,11000,average,0.45530296075039445,
-≥3,11000,average_rank,3.3,
-≥3,11000,chartqa_relaxed_overall,0.5992,0.00980317218424473
-≥3,11000,docvqa_val_anls,0.637004884118944,0.0060952660672868655
-≥3,11000,infovqa_val_anls,0.24182483065748125,0.006800414154487266
-≥3,11000,mme_total_score,1229.9441776710685,
-≥3,11000,mmmu_val_mmmu_acc,0.28556,
-≥3,11000,mmstar_average,0.3210406141609519,
-≥3,11000,ocrbench_ocrbench_accuracy,0.532,
-≥3,11000,seedbench_seed_all,0.5272373540856031,
-≥3,11000,textvqa_val_exact_match,0.52996,0.006774485841130848
-≥3,12000,ai2d_exact_match,0.4378238341968912,0.008929303814062614
-≥3,12000,average,0.4603808175211579,
-≥3,12000,average_rank,2.8,
-≥3,12000,chartqa_relaxed_overall,0.6036,0.009784943231599163
-≥3,12000,docvqa_val_anls,0.6425836471445318,0.006082856374953106
-≥3,12000,infovqa_val_anls,0.23921346499497054,0.00674373988949671
-≥3,12000,mme_total_score,1253.4613845538215,
-≥3,12000,mmmu_val_mmmu_acc,0.28,
-≥3,12000,mmstar_average,0.3402058443723711,
-≥3,12000,ocrbench_ocrbench_accuracy,0.533,
-≥3,12000,seedbench_seed_all,0.5370205669816565,
-≥3,12000,textvqa_val_exact_match,0.52998,0.006788538632972067
-≥3,13000,ai2d_exact_match,0.4410621761658031,0.0089364152923413
-≥3,13000,average,0.46617815773624777,
-≥3,13000,average_rank,2.8,
-≥3,13000,chartqa_relaxed_overall,0.6116,0.009749676839741497
-≥3,13000,docvqa_val_anls,0.6435913615068958,0.006093449845266186
-≥3,13000,infovqa_val_anls,0.24655403627027533,0.0068431739840280935
-≥3,13000,mme_total_score,1338.6154461784713,
-≥3,13000,mmmu_val_mmmu_acc,0.29556,
-≥3,13000,mmstar_average,0.33746561777886447,
-≥3,13000,ocrbench_ocrbench_accuracy,0.543,
-≥3,13000,seedbench_seed_all,0.5384102279043913,
-≥3,13000,textvqa_val_exact_match,0.5383600000000001,0.006773985492742893
-≥3,14000,ai2d_exact_match,0.4426813471502591,0.008939826412531762
-≥3,14000,average,0.46514162030247774,
-≥3,14000,average_rank,3.6,
-≥3,14000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-≥3,14000,docvqa_val_anls,0.6522898002805984,0.006013616663077038
-≥3,14000,infovqa_val_anls,0.23824160343368236,0.006685403314320424
-≥3,14000,mme_total_score,1290.797318927571,
-≥3,14000,mmmu_val_mmmu_acc,0.29111,
-≥3,14000,mmstar_average,0.34665083130189556,
-≥3,14000,ocrbench_ocrbench_accuracy,0.533,
-≥3,14000,seedbench_seed_all,0.5418010005558643,
-≥3,14000,textvqa_val_exact_match,0.5300999999999999,0.006785072250248203
-≥3,15000,ai2d_exact_match,0.4536917098445596,0.00896047438220532
-≥3,15000,average,0.47760694744777243,
-≥3,15000,average_rank,2.9,
-≥3,15000,chartqa_relaxed_overall,0.612,0.009747841205275417
-≥3,15000,docvqa_val_anls,0.6656498012528964,0.006035466987037702
-≥3,15000,infovqa_val_anls,0.2625991131461808,0.007063916588796129
-≥3,15000,mme_total_score,1285.4465786314527,
-≥3,15000,mmmu_val_mmmu_acc,0.30222,
-≥3,15000,mmstar_average,0.3502185231309507,
-≥3,15000,ocrbench_ocrbench_accuracy,0.558,
-≥3,15000,seedbench_seed_all,0.5500833796553641,
-≥3,15000,textvqa_val_exact_match,0.544,0.0067575389652278954
-≥3,16000,ai2d_exact_match,0.4689119170984456,0.008981742470016596
-≥3,16000,average,0.4804309718902879,
-≥3,16000,average_rank,2.5,
-≥3,16000,chartqa_relaxed_overall,0.6204,0.009707689307588963
-≥3,16000,docvqa_val_anls,0.6742164965149466,0.0059800657435710326
-≥3,16000,infovqa_val_anls,0.2633355771988975,0.00704601997176055
-≥3,16000,mme_total_score,1288.4584833933575,
-≥3,16000,mmmu_val_mmmu_acc,0.29556,
-≥3,16000,mmstar_average,0.3443487528651147,
-≥3,16000,ocrbench_ocrbench_accuracy,0.55,
-≥3,16000,seedbench_seed_all,0.5508060033351863,
-≥3,16000,textvqa_val_exact_match,0.5563,0.006742548063668376
-≥3,17000,ai2d_exact_match,0.45595854922279794,0.008964175733819342
-≥3,17000,average,0.4809373657329622,
-≥3,17000,average_rank,3.3,
-≥3,17000,chartqa_relaxed_overall,0.6204,0.009707689307588963
-≥3,17000,docvqa_val_anls,0.6739488016448908,0.005975889304414765
-≥3,17000,infovqa_val_anls,0.2580649809644441,0.007031141926644411
-≥3,17000,mme_total_score,1230.4375750300119,
-≥3,17000,mmmu_val_mmmu_acc,0.29444,
-≥3,17000,mmstar_average,0.3444925534276732,
-≥3,17000,ocrbench_ocrbench_accuracy,0.578,
-≥3,17000,seedbench_seed_all,0.5565314063368538,
-≥3,17000,textvqa_val_exact_match,0.5466,0.006752985159298985
-≥3,18000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-≥3,18000,average,0.48088758936650067,
-≥3,18000,average_rank,3.5,
-≥3,18000,chartqa_relaxed_overall,0.6252,0.009683361554563506
-≥3,18000,docvqa_val_anls,0.675384499731014,0.005997750609265588
-≥3,18000,infovqa_val_anls,0.2579974692510198,0.0070128299378415275
-≥3,18000,mme_total_score,1234.843237294918,
-≥3,18000,mmmu_val_mmmu_acc,0.3,
-≥3,18000,mmstar_average,0.3363850750308216,
-≥3,18000,ocrbench_ocrbench_accuracy,0.566,
-≥3,18000,seedbench_seed_all,0.5558643690939411,
-≥3,18000,textvqa_val_exact_match,0.55196,0.006755291146330729
-≥3,19000,ai2d_exact_match,0.4634067357512953,0.008975020819363737
-≥3,19000,average,0.4861360634692545,
-≥3,19000,average_rank,3.3,
-≥3,19000,chartqa_relaxed_overall,0.6312,0.009651522406019766
-≥3,19000,docvqa_val_anls,0.6819220996842664,0.005927423649467908
-≥3,19000,infovqa_val_anls,0.26277439983326806,0.007102707331042042
-≥3,19000,mme_total_score,1337.9653861544616,
-≥3,19000,mmmu_val_mmmu_acc,0.29889,
-≥3,19000,mmstar_average,0.34778832316957964,
-≥3,19000,ocrbench_ocrbench_accuracy,0.574,
-≥3,19000,seedbench_seed_all,0.5614230127848805,
-≥3,19000,textvqa_val_exact_match,0.55382,0.006743039020727005
-≥3,20000,ai2d_exact_match,0.4841321243523316,0.008994621193008031
-≥3,20000,average,0.4916087790351852,
-≥3,20000,average_rank,2.3,
-≥3,20000,chartqa_relaxed_overall,0.638,0.009613499245701268
-≥3,20000,docvqa_val_anls,0.6839168937073106,0.005936410873687919
-≥3,20000,infovqa_val_anls,0.25441216838205727,0.006890877173562315
-≥3,20000,mme_total_score,1330.3037214885953,
-≥3,20000,mmmu_val_mmmu_acc,0.31,
-≥3,20000,mmstar_average,0.35052721898280503,
-≥3,20000,ocrbench_ocrbench_accuracy,0.572,
-≥3,20000,seedbench_seed_all,0.5630906058921623,
-≥3,20000,textvqa_val_exact_match,0.5684000000000001,0.00672360984783302
-≥4,1000,ai2d_exact_match,0.26360103626943004,0.00792979255467583
-≥4,1000,average,0.26922373369534647,
-≥4,1000,average_rank,3.3,
-≥4,1000,chartqa_relaxed_overall,0.3488,0.009533718094861256
-≥4,1000,docvqa_val_anls,0.3599045480096881,0.005885735735631119
-≥4,1000,infovqa_val_anls,0.17148252623256244,0.0061724612150041895
-≥4,1000,mme_total_score,1104.3533413365346,
-≥4,1000,mmmu_val_mmmu_acc,0.24,
-≥4,1000,mmstar_average,0.21109041770474804,
-≥4,1000,ocrbench_ocrbench_accuracy,0.29,
-≥4,1000,seedbench_seed_all,0.24313507504168982,
-≥4,1000,textvqa_val_exact_match,0.295,0.006241441429527609
-≥4,2000,ai2d_exact_match,0.26295336787564766,0.007923526907377255
-≥4,2000,average,0.3192621308996215,
-≥4,2000,average_rank,2.9,
-≥4,2000,chartqa_relaxed_overall,0.4644,0.009976616117083942
-≥4,2000,docvqa_val_anls,0.44610634422212336,0.006125661837378556
-≥4,2000,infovqa_val_anls,0.19012118870963063,0.006420072608935975
-≥4,2000,mme_total_score,1052.5613245298118,
-≥4,2000,mmmu_val_mmmu_acc,0.23889,
-≥4,2000,mmstar_average,0.22088912220303317,
-≥4,2000,ocrbench_ocrbench_accuracy,0.389,
-≥4,2000,seedbench_seed_all,0.262479155086159,
-≥4,2000,textvqa_val_exact_match,0.39852,0.006693677836929181
-≥4,3000,ai2d_exact_match,0.2545336787564767,0.007840040862810524
-≥4,3000,average,0.34899183633853254,
-≥4,3000,average_rank,3.1,
-≥4,3000,chartqa_relaxed_overall,0.5144,0.009997851710018818
-≥4,3000,docvqa_val_anls,0.5122633926443586,0.006250170224123374
-≥4,3000,infovqa_val_anls,0.21839296983497156,0.006786311152255019
-≥4,3000,mme_total_score,1148.9873949579833,
-≥4,3000,mmmu_val_mmmu_acc,0.24667,
-≥4,3000,mmstar_average,0.23884910949080793,
-≥4,3000,ocrbench_ocrbench_accuracy,0.426,
-≥4,3000,seedbench_seed_all,0.29927737632017787,
-≥4,3000,textvqa_val_exact_match,0.43054,0.006761938068430401
-≥4,4000,ai2d_exact_match,0.2814119170984456,0.00809362228799086
-≥4,4000,average,0.3808723899304912,
-≥4,4000,average_rank,2.3,
-≥4,4000,chartqa_relaxed_overall,0.536,0.009976041728231964
-≥4,4000,docvqa_val_anls,0.5444976153718191,0.006262351643342788
-≥4,4000,infovqa_val_anls,0.22943118895386538,0.006865542219383826
-≥4,4000,mme_total_score,1161.4330732292917,
-≥4,4000,mmmu_val_mmmu_acc,0.26889,
-≥4,4000,mmstar_average,0.2546319608241094,
-≥4,4000,ocrbench_ocrbench_accuracy,0.459,
-≥4,4000,seedbench_seed_all,0.39988882712618123,
-≥4,4000,textvqa_val_exact_match,0.4541,0.006780990662644609
-≥4,5000,ai2d_exact_match,0.31573834196891193,0.00836578020190971
-≥4,5000,average,0.4004212057382194,
-≥4,5000,average_rank,2.7,
-≥4,5000,chartqa_relaxed_overall,0.5544,0.009942625323290008
-≥4,5000,docvqa_val_anls,0.556855142418819,0.006267140081468451
-≥4,5000,infovqa_val_anls,0.23435340618373432,0.006883129487757931
-≥4,5000,mme_total_score,1145.157863145258,
-≥4,5000,mmmu_val_mmmu_acc,0.26556,
-≥4,5000,mmstar_average,0.2888277743020811,
-≥4,5000,ocrbench_ocrbench_accuracy,0.475,
-≥4,5000,seedbench_seed_all,0.445136186770428,
-≥4,5000,textvqa_val_exact_match,0.46792,0.0067973094238147356
-≥4,6000,ai2d_exact_match,0.38471502590673573,0.008756678690415541
-≥4,6000,average,0.42131977921781544,
-≥4,6000,average_rank,3.0,
-≥4,6000,chartqa_relaxed_overall,0.556,0.00993907007952043
-≥4,6000,docvqa_val_anls,0.5727106862384739,0.006269180765398416
-≥4,6000,infovqa_val_anls,0.2310709838980833,0.006744459748098398
-≥4,6000,mme_total_score,1139.8311324529811,
-≥4,6000,mmmu_val_mmmu_acc,0.27,
-≥4,6000,mmstar_average,0.30779610290926424,
-≥4,6000,ocrbench_ocrbench_accuracy,0.492,
-≥4,6000,seedbench_seed_all,0.4933852140077821,
-≥4,6000,textvqa_val_exact_match,0.4841999999999999,0.006796772117869219
-≥4,7000,ai2d_exact_match,0.39281088082901555,0.008789930274160654
-≥4,7000,average,0.42891500537341953,
-≥4,7000,average_rank,2.9,
-≥4,7000,chartqa_relaxed_overall,0.576,0.009885782289560632
-≥4,7000,docvqa_val_anls,0.5907488324071782,0.006231156163373406
-≥4,7000,infovqa_val_anls,0.24013816441297325,0.006930097636315065
-≥4,7000,mme_total_score,1162.137755102041,
-≥4,7000,mmmu_val_mmmu_acc,0.27556,
-≥4,7000,mmstar_average,0.29752599783778977,
-≥4,7000,ocrbench_ocrbench_accuracy,0.504,
-≥4,7000,seedbench_seed_all,0.5001111728738188,
-≥4,7000,textvqa_val_exact_match,0.48333999999999994,0.006805450147517214
-≥4,8000,ai2d_exact_match,0.4164507772020725,0.008872627955954676
-≥4,8000,average,0.43574351275219425,
-≥4,8000,average_rank,3.5,
-≥4,8000,chartqa_relaxed_overall,0.5808,0.009870537726284339
-≥4,8000,docvqa_val_anls,0.6057226019616091,0.0061946427553956785
-≥4,8000,infovqa_val_anls,0.2476713069705094,0.006953489019987495
-≥4,8000,mme_total_score,1170.280612244898,
-≥4,8000,mmmu_val_mmmu_acc,0.26778,
-≥4,8000,mmstar_average,0.30520454953605713,
-≥4,8000,ocrbench_ocrbench_accuracy,0.496,
-≥4,8000,seedbench_seed_all,0.5082823790994997,
-≥4,8000,textvqa_val_exact_match,0.49378,0.006806491606223952
-≥4,9000,ai2d_exact_match,0.42357512953367876,0.008893409023558714
-≥4,9000,average,0.441337144868937,
-≥4,9000,average_rank,3.4,
-≥4,9000,chartqa_relaxed_overall,0.578,0.00987954665846924
-≥4,9000,docvqa_val_anls,0.6243353881540346,0.006123815047404004
-≥4,9000,infovqa_val_anls,0.2437398253282973,0.00692277294272151
-≥4,9000,mme_total_score,1255.001700680272,
-≥4,9000,mmmu_val_mmmu_acc,0.26778,
-≥4,9000,mmstar_average,0.31167080905344985,
-≥4,9000,ocrbench_ocrbench_accuracy,0.512,
-≥4,9000,seedbench_seed_all,0.5116731517509727,
-≥4,9000,textvqa_val_exact_match,0.49926000000000004,0.006799642454386958
-≥4,10000,ai2d_exact_match,0.44462435233160624,0.00894379269709736
-≥4,10000,average,0.4536388119594498,
-≥4,10000,average_rank,3.6,
-≥4,10000,chartqa_relaxed_overall,0.5992,0.00980317218424473
-≥4,10000,docvqa_val_anls,0.6264595846035441,0.006147505656275056
-≥4,10000,infovqa_val_anls,0.2598110483089896,0.00706252458320144
-≥4,10000,mme_total_score,1192.952080832333,
-≥4,10000,mmmu_val_mmmu_acc,0.28556,
-≥4,10000,mmstar_average,0.3186673407344323,
-≥4,10000,ocrbench_ocrbench_accuracy,0.52,
-≥4,10000,seedbench_seed_all,0.5205669816564759,
-≥4,10000,textvqa_val_exact_match,0.5078600000000001,0.006802447996107573
-≥4,11000,ai2d_exact_match,0.4536917098445596,0.008960474382205324
-≥4,11000,average,0.46152725733636885,
-≥4,11000,average_rank,2.3,
-≥4,11000,chartqa_relaxed_overall,0.6004,0.009798282427824488
-≥4,11000,docvqa_val_anls,0.6401993666501584,0.0060898160255800525
-≥4,11000,infovqa_val_anls,0.2552761209118603,0.007046581941151624
-≥4,11000,mme_total_score,1246.6340536214486,
-≥4,11000,mmmu_val_mmmu_acc,0.28,
-≥4,11000,mmstar_average,0.3347344054467562,
-≥4,11000,ocrbench_ocrbench_accuracy,0.533,
-≥4,11000,seedbench_seed_all,0.5306837131739855,
-≥4,11000,textvqa_val_exact_match,0.5257599999999999,0.006772980077619183
-≥4,12000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-≥4,12000,average,0.46100484234717837,
-≥4,12000,average_rank,3.7,
-≥4,12000,chartqa_relaxed_overall,0.5956,0.009817474681589429
-≥4,12000,docvqa_val_anls,0.6409268162702743,0.006097072959583667
-≥4,12000,infovqa_val_anls,0.26230050824120466,0.007170670588017343
-≥4,12000,mme_total_score,1168.390556222489,
-≥4,12000,mmmu_val_mmmu_acc,0.26889,
-≥4,12000,mmstar_average,0.3293674421306994,
-≥4,12000,ocrbench_ocrbench_accuracy,0.538,
-≥4,12000,seedbench_seed_all,0.5314619232907171,
-≥4,12000,textvqa_val_exact_match,0.5233,0.006791483405661084
-≥4,13000,ai2d_exact_match,0.46081606217616583,0.008971477299154906
-≥4,13000,average,0.46897968661537504,
-≥4,13000,average_rank,3.0,
-≥4,13000,chartqa_relaxed_overall,0.6084,0.00976411343463736
-≥4,13000,docvqa_val_anls,0.6557097904355208,0.006045284321472833
-≥4,13000,infovqa_val_anls,0.25716935409374025,0.007037968981507592
-≥4,13000,mme_total_score,1214.4760904361744,
-≥4,13000,mmmu_val_mmmu_acc,0.27444,
-≥4,13000,mmstar_average,0.35062705343328215,
-≥4,13000,ocrbench_ocrbench_accuracy,0.542,
-≥4,13000,seedbench_seed_all,0.5388549193996665,
-≥4,13000,textvqa_val_exact_match,0.5328,0.006772208248489718
-≥4,14000,ai2d_exact_match,0.4637305699481865,0.008975446629055962
-≥4,14000,average,0.46882712562329804,
-≥4,14000,average_rank,3.4,
-≥4,14000,chartqa_relaxed_overall,0.6052,0.009778109662477129
-≥4,14000,docvqa_val_anls,0.6600293980607723,0.006003818486747537
-≥4,14000,infovqa_val_anls,0.2604896578960276,0.0070806001081496605
-≥4,14000,mme_total_score,1180.2360944377751,
-≥4,14000,mmmu_val_mmmu_acc,0.29889,
-≥4,14000,mmstar_average,0.3370405135985262,
-≥4,14000,ocrbench_ocrbench_accuracy,0.532,
-≥4,14000,seedbench_seed_all,0.5311839911061701,
-≥4,14000,textvqa_val_exact_match,0.53088,0.006765681045393848
-≥4,15000,ai2d_exact_match,0.469559585492228,0.008982461065390123
-≥4,15000,average,0.47678210727691706,
-≥4,15000,average_rank,3.0,
-≥4,15000,chartqa_relaxed_overall,0.6228,0.009695651925812239
-≥4,15000,docvqa_val_anls,0.668732849209273,0.006002172541493102
-≥4,15000,infovqa_val_anls,0.2541377129865746,0.006911037097155498
-≥4,15000,mme_total_score,1198.8395358143257,
-≥4,15000,mmmu_val_mmmu_acc,0.28111,
-≥4,15000,mmstar_average,0.3574887121899482,
-≥4,15000,ocrbench_ocrbench_accuracy,0.558,
-≥4,15000,seedbench_seed_all,0.5421901056142301,
-≥4,15000,textvqa_val_exact_match,0.53702,0.0067620891069120025
-≥4,16000,ai2d_exact_match,0.4689119170984456,0.00898174247001659
-≥4,16000,average,0.47623501147363423,
-≥4,16000,average_rank,3.7,
-≥4,16000,chartqa_relaxed_overall,0.6184,0.009717527882093043
-≥4,16000,docvqa_val_anls,0.664711612332228,0.006033753206179003
-≥4,16000,infovqa_val_anls,0.26137627968800997,0.0069587136315641595
-≥4,16000,mme_total_score,1223.327631052421,
-≥4,16000,mmmu_val_mmmu_acc,0.27778,
-≥4,16000,mmstar_average,0.3532221312757646,
-≥4,16000,ocrbench_ocrbench_accuracy,0.545,
-≥4,16000,seedbench_seed_all,0.5476931628682602,
-≥4,16000,textvqa_val_exact_match,0.54902,0.006730591957147508
-≥4,17000,ai2d_exact_match,0.47830310880829013,0.008990677331728418
-≥4,17000,average,0.4815150623543914,
-≥4,17000,average_rank,2.8,
-≥4,17000,chartqa_relaxed_overall,0.6208,0.009705700605814084
-≥4,17000,docvqa_val_anls,0.6784945768946954,0.005958779114256312
-≥4,17000,infovqa_val_anls,0.27415576971914574,0.007211057524316044
-≥4,17000,mme_total_score,1267.6510604241696,
-≥4,17000,mmmu_val_mmmu_acc,0.27889,
-≥4,17000,mmstar_average,0.35485659715149337,
-≥4,17000,ocrbench_ocrbench_accuracy,0.55,
-≥4,17000,seedbench_seed_all,0.5479155086158978,
-≥4,17000,textvqa_val_exact_match,0.5502199999999999,0.006738803500215962
-≥4,18000,ai2d_exact_match,0.4795984455958549,0.008991659681159872
-≥4,18000,average,0.4839656525796875,
-≥4,18000,average_rank,3.1,
-≥4,18000,chartqa_relaxed_overall,0.6228,0.009695651925812239
-≥4,18000,docvqa_val_anls,0.680615041882376,0.005957029786047422
-≥4,18000,infovqa_val_anls,0.27507992619170296,0.007267921800589956
-≥4,18000,mme_total_score,1226.5048019207684,
-≥4,18000,mmmu_val_mmmu_acc,0.28111,
-≥4,18000,mmstar_average,0.35607565298805366,
-≥4,18000,ocrbench_ocrbench_accuracy,0.555,
-≥4,18000,seedbench_seed_all,0.5532518065591996,
-≥4,18000,textvqa_val_exact_match,0.55216,0.006730239676654988
-≥4,19000,ai2d_exact_match,0.4734455958549223,0.008986453895645547
-≥4,19000,average,0.485443851233213,
-≥4,19000,average_rank,3.0,
-≥4,19000,chartqa_relaxed_overall,0.6276,0.009670817229291067
-≥4,19000,docvqa_val_anls,0.690884348495626,0.005908240141234498
-≥4,19000,infovqa_val_anls,0.2676836840845966,0.007165567282387595
-≥4,19000,mme_total_score,1323.2516006402561,
-≥4,19000,mmmu_val_mmmu_acc,0.28556,
-≥4,19000,mmstar_average,0.33406913716627346,
-≥4,19000,ocrbench_ocrbench_accuracy,0.584,
-≥4,19000,seedbench_seed_all,0.5414118954974986,
-≥4,19000,textvqa_val_exact_match,0.56434,0.006692191716171407
-≥4,20000,ai2d_exact_match,0.4876943005181347,0.008996428218289526
-≥4,20000,average,0.4906341423361293,
-≥4,20000,average_rank,3.3,
-≥4,20000,chartqa_relaxed_overall,0.6284,0.009666579183001631
-≥4,20000,docvqa_val_anls,0.6887236251150223,0.005918556723502163
-≥4,20000,infovqa_val_anls,0.2809124119459898,0.007354611102020885
-≥4,20000,mme_total_score,1254.5532212885155,
-≥4,20000,mmmu_val_mmmu_acc,0.29333,
-≥4,20000,mmstar_average,0.34736535367392096,
-≥4,20000,ocrbench_ocrbench_accuracy,0.572,
-≥4,20000,seedbench_seed_all,0.5508615897720957,
-≥4,20000,textvqa_val_exact_match,0.56642,0.00672606309106159
-≥5,1000,ai2d_exact_match,0.26327720207253885,0.007926662492947056
-≥5,1000,average,0.27709006947371073,
-≥5,1000,average_rank,2.6,
-≥5,1000,chartqa_relaxed_overall,0.3412,0.009484144853461517
-≥5,1000,docvqa_val_anls,0.36296241117667905,0.005852839558467308
-≥5,1000,infovqa_val_anls,0.17994878830754762,0.006336933369747534
-≥5,1000,mme_total_score,968.375450180072,
-≥5,1000,mmmu_val_mmmu_acc,0.26667,
-≥5,1000,mmstar_average,0.22684359669162246,
-≥5,1000,ocrbench_ocrbench_accuracy,0.301,
-≥5,1000,seedbench_seed_all,0.25152862701500833,
-≥5,1000,textvqa_val_exact_match,0.30038,0.006282823083071704
-≥5,2000,ai2d_exact_match,0.27331606217616583,0.008021157484423327
-≥5,2000,average,0.318491261297989,
-≥5,2000,average_rank,3.2,
-≥5,2000,chartqa_relaxed_overall,0.4524,0.009956573172519544
-≥5,2000,docvqa_val_anls,0.4578740641673747,0.006180081722767688
-≥5,2000,infovqa_val_anls,0.1919057230410833,0.006401757863597739
-≥5,2000,mme_total_score,1031.2603041216487,
-≥5,2000,mmmu_val_mmmu_acc,0.24667,
-≥5,2000,mmstar_average,0.21129996032951712,
-≥5,2000,ocrbench_ocrbench_accuracy,0.383,
-≥5,2000,seedbench_seed_all,0.25597554196775985,
-≥5,2000,textvqa_val_exact_match,0.39398,0.0066750028503822015
-≥5,3000,ai2d_exact_match,0.2661917098445596,0.007954634970279373
-≥5,3000,average,0.3470898411915701,
-≥5,3000,average_rank,3.1,
-≥5,3000,chartqa_relaxed_overall,0.4888,0.009999490983443667
-≥5,3000,docvqa_val_anls,0.5063663265388635,0.006269377896147078
-≥5,3000,infovqa_val_anls,0.2002412084672373,0.006449644926640854
-≥5,3000,mme_total_score,1176.8578431372548,
-≥5,3000,mmmu_val_mmmu_acc,0.25889,
-≥5,3000,mmstar_average,0.2226891646728035,
-≥5,3000,ocrbench_ocrbench_accuracy,0.422,
-≥5,3000,seedbench_seed_all,0.32229016120066706,
-≥5,3000,textvqa_val_exact_match,0.43633999999999995,0.006743513614961789
-≥5,4000,ai2d_exact_match,0.32091968911917096,0.008402150106895235
-≥5,4000,average,0.38454946481840957,
-≥5,4000,average_rank,3.0,
-≥5,4000,chartqa_relaxed_overall,0.5244,0.009990083919101193
-≥5,4000,docvqa_val_anls,0.5408182220870532,0.0062304604635426315
-≥5,4000,infovqa_val_anls,0.21034975209325477,0.006529781109938355
-≥5,4000,mme_total_score,1186.4263705482194,
-≥5,4000,mmmu_val_mmmu_acc,0.26556,
-≥5,4000,mmstar_average,0.26918979355147643,
-≥5,4000,ocrbench_ocrbench_accuracy,0.452,
-≥5,4000,seedbench_seed_all,0.4339077265147304,
-≥5,4000,textvqa_val_exact_match,0.4438,0.006776008770579609
-≥5,5000,ai2d_exact_match,0.3494170984455959,0.008581339503665948
-≥5,5000,average,0.4053929772745627,
-≥5,5000,average_rank,2.9,
-≥5,5000,chartqa_relaxed_overall,0.546,0.009959582185560013
-≥5,5000,docvqa_val_anls,0.5611769594797935,0.006252030837783964
-≥5,5000,infovqa_val_anls,0.2283202771889911,0.006874345513158979
-≥5,5000,mme_total_score,1179.6603641456581,
-≥5,5000,mmmu_val_mmmu_acc,0.27556,
-≥5,5000,mmstar_average,0.28276518409209217,
-≥5,5000,ocrbench_ocrbench_accuracy,0.464,
-≥5,5000,seedbench_seed_all,0.4750972762645914,
-≥5,5000,textvqa_val_exact_match,0.4662,0.0067984671677640855
-≥5,6000,ai2d_exact_match,0.3636658031088083,0.008658158841882573
-≥5,6000,average,0.41623598541202544,
-≥5,6000,average_rank,2.6,
-≥5,6000,chartqa_relaxed_overall,0.5584,0.009933541468098847
-≥5,6000,docvqa_val_anls,0.5839255211800125,0.006223251970774856
-≥5,6000,infovqa_val_anls,0.23899504944949723,0.007013133491201096
-≥5,6000,mme_total_score,1252.7314925970388,
-≥5,6000,mmmu_val_mmmu_acc,0.27222,
-≥5,6000,mmstar_average,0.3101670336024846,
-≥5,6000,ocrbench_ocrbench_accuracy,0.473,
-≥5,6000,seedbench_seed_all,0.49483046136742637,
-≥5,6000,textvqa_val_exact_match,0.45092,0.006772193384764505
-≥5,7000,ai2d_exact_match,0.42033678756476683,0.008884198538329093
-≥5,7000,average,0.4338560588435303,
-≥5,7000,average_rank,2.5,
-≥5,7000,chartqa_relaxed_overall,0.5692,0.00990574548014469
-≥5,7000,docvqa_val_anls,0.5924368390904757,0.006231022369252223
-≥5,7000,infovqa_val_anls,0.23945153983485024,0.007006534034576772
-≥5,7000,mme_total_score,1315.113445378151,
-≥5,7000,mmmu_val_mmmu_acc,0.3,
-≥5,7000,mmstar_average,0.31063340423564356,
-≥5,7000,ocrbench_ocrbench_accuracy,0.488,
-≥5,7000,seedbench_seed_all,0.5067259588660367,
-≥5,7000,textvqa_val_exact_match,0.47791999999999996,0.006793800546466833
-≥5,8000,ai2d_exact_match,0.42908031088082904,0.008908169846895226
-≥5,8000,average,0.43778255861533233,
-≥5,8000,average_rank,3.0,
-≥5,8000,chartqa_relaxed_overall,0.5752,0.009888230116554488
-≥5,8000,docvqa_val_anls,0.6032859006895523,0.006193925022795706
-≥5,8000,infovqa_val_anls,0.24493490021598546,0.007008771158507111
-≥5,8000,mme_total_score,1304.6824729891955,
-≥5,8000,mmmu_val_mmmu_acc,0.28667,
-≥5,8000,mmstar_average,0.31703546216629863,
-≥5,8000,ocrbench_ocrbench_accuracy,0.487,
-≥5,8000,seedbench_seed_all,0.5096164535853251,
-≥5,8000,textvqa_val_exact_match,0.48722,0.006804659800386776
-≥5,9000,ai2d_exact_match,0.42940414507772023,0.008909003051055709
-≥5,9000,average,0.44649777930382,
-≥5,9000,average_rank,2.5,
-≥5,9000,chartqa_relaxed_overall,0.5792,0.009875725592704212
-≥5,9000,docvqa_val_anls,0.6158422097964253,0.00617698110304048
-≥5,9000,infovqa_val_anls,0.24039717009699607,0.0068877247346275485
-≥5,9000,mme_total_score,1379.7254901960782,
-≥5,9000,mmmu_val_mmmu_acc,0.29889,
-≥5,9000,mmstar_average,0.3280690123874737,
-≥5,9000,ocrbench_ocrbench_accuracy,0.513,
-≥5,9000,seedbench_seed_all,0.5234574763757643,
-≥5,9000,textvqa_val_exact_match,0.4902200000000001,0.006801597067199211
-≥5,10000,ai2d_exact_match,0.45012953367875647,0.00895427929990258
-≥5,10000,average,0.4555663389491801,
-≥5,10000,average_rank,2.9,
-≥5,10000,chartqa_relaxed_overall,0.5844,0.009858475126140203
-≥5,10000,docvqa_val_anls,0.6189420793161403,0.006040465868816934
-≥5,10000,infovqa_val_anls,0.24850918819779613,0.007091394184737253
-≥5,10000,mme_total_score,1235.7704081632655,
-≥5,10000,mmmu_val_mmmu_acc,0.27667,
-≥5,10000,mmstar_average,0.34675895640940496,
-≥5,10000,ocrbench_ocrbench_accuracy,0.528,
-≥5,10000,seedbench_seed_all,0.5291272929405225,
-≥5,10000,textvqa_val_exact_match,0.51756,0.006786717998284417
-≥5,11000,ai2d_exact_match,0.4566062176165803,0.008965198879336196
-≥5,11000,average,0.458748059148796,
-≥5,11000,average_rank,2.9,
-≥5,11000,chartqa_relaxed_overall,0.5916,0.0098327233755248
-≥5,11000,docvqa_val_anls,0.633602507666147,0.006134122729213928
-≥5,11000,infovqa_val_anls,0.2621320066294427,0.007275786683175354
-≥5,11000,mme_total_score,1326.4276710684273,
-≥5,11000,mmmu_val_mmmu_acc,0.27667,
-≥5,11000,mmstar_average,0.34479339575773355,
-≥5,11000,ocrbench_ocrbench_accuracy,0.517,
-≥5,11000,seedbench_seed_all,0.5311284046692607,
-≥5,11000,textvqa_val_exact_match,0.5152000000000001,0.006786619456012555
-≥5,12000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-≥5,12000,average,0.4644995480385772,
-≥5,12000,average_rank,2.3,
-≥5,12000,chartqa_relaxed_overall,0.596,0.009815912634917984
-≥5,12000,docvqa_val_anls,0.6453485539631237,0.006065269954977215
-≥5,12000,infovqa_val_anls,0.2685572578806166,0.007278550841020009
-≥5,12000,mme_total_score,1374.9406762705082,
-≥5,12000,mmmu_val_mmmu_acc,0.28444,
-≥5,12000,mmstar_average,0.35205377405882654,
-≥5,12000,ocrbench_ocrbench_accuracy,0.519,
-≥5,12000,seedbench_seed_all,0.5350194552529183,
-≥5,12000,textvqa_val_exact_match,0.52088,0.006777757204160069
-≥5,13000,ai2d_exact_match,0.4640544041450777,0.008975868633841907
-≥5,13000,average,0.4696984757423332,
-≥5,13000,average_rank,2.7,
-≥5,13000,chartqa_relaxed_overall,0.608,0.00976588700628918
-≥5,13000,docvqa_val_anls,0.6599237778239753,0.006035894149838363
-≥5,13000,infovqa_val_anls,0.25759117282312316,0.007107246020667877
-≥5,13000,mme_total_score,1326.0453181272508,
-≥5,13000,mmmu_val_mmmu_acc,0.28667,
-≥5,13000,mmstar_average,0.35252858336464304,
-≥5,13000,ocrbench_ocrbench_accuracy,0.533,
-≥5,13000,seedbench_seed_all,0.5330183435241801,
-≥5,13000,textvqa_val_exact_match,0.5325,0.006770636476998357
-≥5,14000,ai2d_exact_match,0.4689119170984456,0.00898174247001659
-≥5,14000,average,0.47293227498131896,
-≥5,14000,average_rank,2.7,
-≥5,14000,chartqa_relaxed_overall,0.614,0.009738559226822298
-≥5,14000,docvqa_val_anls,0.6583491716485876,0.0060256160547597325
-≥5,14000,infovqa_val_anls,0.26613522559599984,0.0071532088405842145
-≥5,14000,mme_total_score,1278.5425170068027,
-≥5,14000,mmmu_val_mmmu_acc,0.28,
-≥5,14000,mmstar_average,0.35624004153386235,
-≥5,14000,ocrbench_ocrbench_accuracy,0.55,
-≥5,14000,seedbench_seed_all,0.5454141189549749,
-≥5,14000,textvqa_val_exact_match,0.5173399999999999,0.006787096420087393
-≥5,15000,ai2d_exact_match,0.4740932642487047,0.008987066275159846
-≥5,15000,average,0.47568039073709784,
-≥5,15000,average_rank,3.0,
-≥5,15000,chartqa_relaxed_overall,0.602,0.00979166741164548
-≥5,15000,docvqa_val_anls,0.6649825816931088,0.006012202194059076
-≥5,15000,infovqa_val_anls,0.2659187859072639,0.007233849219121225
-≥5,15000,mme_total_score,1301.498799519808,
-≥5,15000,mmmu_val_mmmu_acc,0.30333,
-≥5,15000,mmstar_average,0.363574304462402,
-≥5,15000,ocrbench_ocrbench_accuracy,0.536,
-≥5,15000,seedbench_seed_all,0.5402445803224013,
-≥5,15000,textvqa_val_exact_match,0.53098,0.006774896882281907
-≥5,16000,ai2d_exact_match,0.47538860103626945,0.008988245555188545
-≥5,16000,average,0.48103362013771567,
-≥5,16000,average_rank,2.6,
-≥5,16000,chartqa_relaxed_overall,0.6172,0.009723347231923635
-≥5,16000,docvqa_val_anls,0.6661394800733964,0.006000339067695713
-≥5,16000,infovqa_val_anls,0.27200681388207976,0.007361243845813883
-≥5,16000,mme_total_score,1312.4185674269709,
-≥5,16000,mmmu_val_mmmu_acc,0.30667,
-≥5,16000,mmstar_average,0.352673072573432,
-≥5,16000,ocrbench_ocrbench_accuracy,0.553,
-≥5,16000,seedbench_seed_all,0.5483046136742635,
-≥5,16000,textvqa_val_exact_match,0.53792,0.0067618902203356104
-≥5,17000,ai2d_exact_match,0.4740932642487047,0.008987066275159846
-≥5,17000,average,0.4842246444979549,
-≥5,17000,average_rank,3.1,
-≥5,17000,chartqa_relaxed_overall,0.6252,0.009683361554563506
-≥5,17000,docvqa_val_anls,0.6727784028551866,0.005982986502554192
-≥5,17000,infovqa_val_anls,0.273461783643309,0.00736211121641681
-≥5,17000,mme_total_score,1256.561224489796,
-≥5,17000,mmmu_val_mmmu_acc,0.31889,
-≥5,17000,mmstar_average,0.35664172938975786,
-≥5,17000,ocrbench_ocrbench_accuracy,0.545,
-≥5,17000,seedbench_seed_all,0.549916620344636,
-≥5,17000,textvqa_val_exact_match,0.5420400000000001,0.006760567190239792
-≥5,18000,ai2d_exact_match,0.4802461139896373,0.008992128148477658
-≥5,18000,average,0.48392876207158253,
-≥5,18000,average_rank,2.9,
-≥5,18000,chartqa_relaxed_overall,0.6252,0.009683361554563506
-≥5,18000,docvqa_val_anls,0.68034033548242,0.005889534044935538
-≥5,18000,infovqa_val_anls,0.28015930560506613,0.007380855727131182
-≥5,18000,mme_total_score,1380.5266106442577,
-≥5,18000,mmmu_val_mmmu_acc,0.3,
-≥5,18000,mmstar_average,0.34877922919246646,
-≥5,18000,ocrbench_ocrbench_accuracy,0.549,
-≥5,18000,seedbench_seed_all,0.5529738743746526,
-≥5,18000,textvqa_val_exact_match,0.5386599999999999,0.0067648675941745775
-≥5,19000,ai2d_exact_match,0.4805699481865285,0.008992356706334513
-≥5,19000,average,0.49271643602329757,
-≥5,19000,average_rank,2.8,
-≥5,19000,chartqa_relaxed_overall,0.6248,0.009685427559111736
-≥5,19000,docvqa_val_anls,0.6825000217737053,0.005934471601355602
-≥5,19000,infovqa_val_anls,0.2841253071402532,0.007403930662950274
-≥5,19000,mme_total_score,1261.751700680272,
-≥5,19000,mmmu_val_mmmu_acc,0.32,
-≥5,19000,mmstar_average,0.3611420745688909,
-≥5,19000,ocrbench_ocrbench_accuracy,0.572,
-≥5,19000,seedbench_seed_all,0.5550305725403002,
-≥5,19000,textvqa_val_exact_match,0.5542799999999999,0.006739897741383979
-≥5,20000,ai2d_exact_match,0.4844559585492228,0.008994804366753555
-≥5,20000,average,0.49543136618963995,
-≥5,20000,average_rank,2.9,
-≥5,20000,chartqa_relaxed_overall,0.638,0.009613499245701268
-≥5,20000,docvqa_val_anls,0.688451623661496,0.005905200575549553
-≥5,20000,infovqa_val_anls,0.2789607789162199,0.007289443671361681
-≥5,20000,mme_total_score,1296.043617446979,
-≥5,20000,mmmu_val_mmmu_acc,0.3,
-≥5,20000,mmstar_average,0.3804272197382418,
-≥5,20000,ocrbench_ocrbench_accuracy,0.577,
-≥5,20000,seedbench_seed_all,0.5560867148415787,
-≥5,20000,textvqa_val_exact_match,0.5555,0.006734970078953051
+version https://git-lfs.github.com/spec/v1
+oid sha256:69acb8bc0b80b2c664d821b1c06d67af315e67d8a706cf9e5d351e4468392cc6
+size 63236

app/src/content/assets/data/remove_ch.csv

@@ -1,455 +1,3 @@
-run,step,metric,value,stderr
-Baseline,1000,ai2d_exact_match,0.2548575129533679,0.007843322436924496
-Baseline,1000,average,0.27120689295763617,
-Baseline,1000,average_rank,1.7,
-Baseline,1000,chartqa_relaxed_overall,0.3308,0.009411906161401973
-Baseline,1000,docvqa_val_anls,0.3528553494243383,0.005852289239342309
-Baseline,1000,infovqa_val_anls,0.17320578642581314,0.006297063452679795
-Baseline,1000,mme_total_score,977.4280712284914,
-Baseline,1000,mmmu_val_mmmu_acc,0.25222,
-Baseline,1000,mmstar_average,0.23215874078908072,
-Baseline,1000,ocrbench_ocrbench_accuracy,0.286,
-Baseline,1000,seedbench_seed_all,0.2563646470261256,
-Baseline,1000,textvqa_val_exact_match,0.3024,0.00628900296642181
-Baseline,2000,ai2d_exact_match,0.26295336787564766,0.007923526907377255
-Baseline,2000,average,0.3202068275596269,
-Baseline,2000,average_rank,1.5,
-Baseline,2000,chartqa_relaxed_overall,0.4688,0.009982508912777261
-Baseline,2000,docvqa_val_anls,0.4452261510942785,0.00614755494712251
-Baseline,2000,infovqa_val_anls,0.1820547866557169,0.006217861455795791
-Baseline,2000,mme_total_score,1049.3036214485794,
-Baseline,2000,mmmu_val_mmmu_acc,0.24556,
-Baseline,2000,mmstar_average,0.21305462434540698,
-Baseline,2000,ocrbench_ocrbench_accuracy,0.395,
-Baseline,2000,seedbench_seed_all,0.258532518065592,
-Baseline,2000,textvqa_val_exact_match,0.41068000000000005,0.006697862330024289
-Baseline,3000,ai2d_exact_match,0.25226683937823835,0.007816909588794397
-Baseline,3000,average,0.3507423834414229,
-Baseline,3000,average_rank,1.6,
-Baseline,3000,chartqa_relaxed_overall,0.5028,0.010001843767601082
-Baseline,3000,docvqa_val_anls,0.502653993831009,0.006267072346683124
-Baseline,3000,infovqa_val_anls,0.21728617578189535,0.006796941784959762
-Baseline,3000,mme_total_score,1170.2383953581434,
-Baseline,3000,mmmu_val_mmmu_acc,0.27556,
-Baseline,3000,mmstar_average,0.25432376938577683,
-Baseline,3000,ocrbench_ocrbench_accuracy,0.436,
-Baseline,3000,seedbench_seed_all,0.2792106725958866,
-Baseline,3000,textvqa_val_exact_match,0.43658,0.006766885462882726
-Baseline,4000,ai2d_exact_match,0.2645725388601036,0.007939149662089447
-Baseline,4000,average,0.36961781722974835,
-Baseline,4000,average_rank,1.6,
-Baseline,4000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-Baseline,4000,docvqa_val_anls,0.5374434618615119,0.0062905728113059655
-Baseline,4000,infovqa_val_anls,0.2287924838861707,0.006994568698639919
-Baseline,4000,mme_total_score,1155.203781512605,
-Baseline,4000,mmmu_val_mmmu_acc,0.25556,
-Baseline,4000,mmstar_average,0.2575590188757354,
-Baseline,4000,ocrbench_ocrbench_accuracy,0.453,
-Baseline,4000,seedbench_seed_all,0.33913285158421347,
-Baseline,4000,textvqa_val_exact_match,0.4593,0.006791695475025738
-Baseline,5000,ai2d_exact_match,0.3125,0.008342439145556371
-Baseline,5000,average,0.3974627910380972,
-Baseline,5000,average_rank,1.6,
-Baseline,5000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-Baseline,5000,docvqa_val_anls,0.552360266782429,0.006300308519952055
-Baseline,5000,infovqa_val_anls,0.23425555286643698,0.007002254622066442
-Baseline,5000,mme_total_score,1181.4653861544618,
-Baseline,5000,mmmu_val_mmmu_acc,0.26667,
-Baseline,5000,mmstar_average,0.29596648146165705,
-Baseline,5000,ocrbench_ocrbench_accuracy,0.462,
-Baseline,5000,seedbench_seed_all,0.43107281823235133,
-Baseline,5000,textvqa_val_exact_match,0.47354000000000007,0.0068172185364497985
-Baseline,6000,ai2d_exact_match,0.358160621761658,0.008629463221867162
-Baseline,6000,average,0.4161227404571003,
-Baseline,6000,average_rank,1.7,
-Baseline,6000,chartqa_relaxed_overall,0.5628,0.00992279440175477
-Baseline,6000,docvqa_val_anls,0.5747451497228876,0.00625495440870239
-Baseline,6000,infovqa_val_anls,0.22152017368968838,0.006604546680525351
-Baseline,6000,mme_total_score,1284.1648659463785,
-Baseline,6000,mmmu_val_mmmu_acc,0.27111,
-Baseline,6000,mmstar_average,0.2978489412854164,
-Baseline,6000,ocrbench_ocrbench_accuracy,0.495,
-Baseline,6000,seedbench_seed_all,0.4795997776542524,
-Baseline,6000,textvqa_val_exact_match,0.48432,0.006800535050670284
-Baseline,7000,ai2d_exact_match,0.3707901554404145,0.00869347755587734
-Baseline,7000,average,0.4291083177345374,
-Baseline,7000,average_rank,1.6,
-Baseline,7000,chartqa_relaxed_overall,0.5656,0.009915542506251351
-Baseline,7000,docvqa_val_anls,0.5940907049431567,0.006224236305767187
-Baseline,7000,infovqa_val_anls,0.2515675215816963,0.007105097396092786
-Baseline,7000,mme_total_score,1185.875650260104,
-Baseline,7000,mmmu_val_mmmu_acc,0.26556,
-Baseline,7000,mmstar_average,0.31372400960777047,
-Baseline,7000,ocrbench_ocrbench_accuracy,0.504,
-Baseline,7000,seedbench_seed_all,0.4964424680377988,
-Baseline,7000,textvqa_val_exact_match,0.5002,0.006794794025220267
-Baseline,8000,ai2d_exact_match,0.37759067357512954,0.008725299846043883
-Baseline,8000,average,0.43846759477995995,
-Baseline,8000,average_rank,1.8,
-Baseline,8000,chartqa_relaxed_overall,0.5832,0.009862556058385773
-Baseline,8000,docvqa_val_anls,0.6017336419437208,0.006231612198089698
-Baseline,8000,infovqa_val_anls,0.2449256624147254,0.006992518502948913
-Baseline,8000,mme_total_score,1199.2409963985594,
-Baseline,8000,mmmu_val_mmmu_acc,0.28111,
-Baseline,8000,mmstar_average,0.33512257186205047,
-Baseline,8000,ocrbench_ocrbench_accuracy,0.51,
-Baseline,8000,seedbench_seed_all,0.5024458032240133,
-Baseline,8000,textvqa_val_exact_match,0.51008,0.006796301690135059
-Baseline,9000,ai2d_exact_match,0.4067357512953368,0.008841214921078996
-Baseline,9000,average,0.4422510732201056,
-Baseline,9000,average_rank,1.8,
-Baseline,9000,chartqa_relaxed_overall,0.5912,0.009834211136815875
-Baseline,9000,docvqa_val_anls,0.6170968481662739,0.00617235763542544
-Baseline,9000,infovqa_val_anls,0.23537031288570615,0.00670318154156447
-Baseline,9000,mme_total_score,1231.5195078031213,
-Baseline,9000,mmmu_val_mmmu_acc,0.25889,
-Baseline,9000,mmstar_average,0.3216444898242951,
-Baseline,9000,ocrbench_ocrbench_accuracy,0.515,
-Baseline,9000,seedbench_seed_all,0.5120622568093385,
-Baseline,9000,textvqa_val_exact_match,0.52226,0.006792711289708482
-Baseline,10000,ai2d_exact_match,0.39993523316062174,0.008817096257082848
-Baseline,10000,average,0.4523875703250908,
-Baseline,10000,average_rank,1.7,
-Baseline,10000,chartqa_relaxed_overall,0.5996,0.00980154906867574
-Baseline,10000,docvqa_val_anls,0.6262613496433054,0.006147756371688175
-Baseline,10000,infovqa_val_anls,0.263290074230132,0.007186788766942786
-Baseline,10000,mme_total_score,1240.8218287314926,
-Baseline,10000,mmmu_val_mmmu_acc,0.28778,
-Baseline,10000,mmstar_average,0.32972717906018517,
-Baseline,10000,ocrbench_ocrbench_accuracy,0.517,
-Baseline,10000,seedbench_seed_all,0.5217342968315731,
-Baseline,10000,textvqa_val_exact_match,0.5261600000000001,0.006785774843600811
-Baseline,11000,ai2d_exact_match,0.422279792746114,0.008889771831066474
-Baseline,11000,average,0.4561398159525099,
-Baseline,11000,average_rank,1.7,
-Baseline,11000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-Baseline,11000,docvqa_val_anls,0.6373130149166712,0.006128022584995044
-Baseline,11000,infovqa_val_anls,0.24419378339723755,0.006897644885887063
-Baseline,11000,mme_total_score,1322.9488795518205,
-Baseline,11000,mmmu_val_mmmu_acc,0.27778,
-Baseline,11000,mmstar_average,0.3298563439522548,
-Baseline,11000,ocrbench_ocrbench_accuracy,0.521,
-Baseline,11000,seedbench_seed_all,0.5237354085603113,
-Baseline,11000,textvqa_val_exact_match,0.5387,0.006770851562852138
-Baseline,12000,ai2d_exact_match,0.42001295336787564,0.008883255931688034
-Baseline,12000,average,0.4582751140055433,
-Baseline,12000,average_rank,1.7,
-Baseline,12000,chartqa_relaxed_overall,0.618,0.009719474639861454
-Baseline,12000,docvqa_val_anls,0.6393961983751871,0.0061228747388476674
-Baseline,12000,infovqa_val_anls,0.24798874058574302,0.006855374548993139
-Baseline,12000,mme_total_score,1225.6453581432572,
-Baseline,12000,mmmu_val_mmmu_acc,0.27889,
-Baseline,12000,mmstar_average,0.34010867846816534,
-Baseline,12000,ocrbench_ocrbench_accuracy,0.512,
-Baseline,12000,seedbench_seed_all,0.5350194552529183,
-Baseline,12000,textvqa_val_exact_match,0.5330600000000001,0.006777713092109446
-Baseline,13000,ai2d_exact_match,0.4375,0.008928571428571428
-Baseline,13000,average,0.4692868662590049,
-Baseline,13000,average_rank,1.4,
-Baseline,13000,chartqa_relaxed_overall,0.6148,0.00973479791861169
-Baseline,13000,docvqa_val_anls,0.6511374872549951,0.006086953065248391
-Baseline,13000,infovqa_val_anls,0.24465055100441893,0.006808432538374664
-Baseline,13000,mme_total_score,1281.7122849139657,
-Baseline,13000,mmmu_val_mmmu_acc,0.28222,
-Baseline,13000,mmstar_average,0.3453069542917521,
-Baseline,13000,ocrbench_ocrbench_accuracy,0.549,
-Baseline,13000,seedbench_seed_all,0.5442468037798777,
-Baseline,13000,textvqa_val_exact_match,0.55472,0.0067416788982325
-Baseline,14000,ai2d_exact_match,0.4572538860103627,0.00896620675297095
-Baseline,14000,average,0.47352486841689195,
-Baseline,14000,average_rank,1.3,
-Baseline,14000,chartqa_relaxed_overall,0.6172,0.009723347231923635
-Baseline,14000,docvqa_val_anls,0.6502269393708169,0.006057950730638126
-Baseline,14000,infovqa_val_anls,0.25805460837190913,0.007037735231659539
-Baseline,14000,mme_total_score,1309.1444577831132,
-Baseline,14000,mmmu_val_mmmu_acc,0.28111,
-Baseline,14000,mmstar_average,0.34575818188776586,
-Baseline,14000,ocrbench_ocrbench_accuracy,0.551,
-Baseline,14000,seedbench_seed_all,0.5483602001111729,
-Baseline,14000,textvqa_val_exact_match,0.55276,0.006751206724612103
-Baseline,15000,ai2d_exact_match,0.45045336787564766,0.008954861634252399
-Baseline,15000,average,0.47878665012878824,
-Baseline,15000,average_rank,1.2,
-Baseline,15000,chartqa_relaxed_overall,0.612,0.009747841205275417
-Baseline,15000,docvqa_val_anls,0.6621413031955148,0.006056838050222495
-Baseline,15000,infovqa_val_anls,0.2706898598157733,0.007200315730154543
-Baseline,15000,mme_total_score,1384.2171868747498,
-Baseline,15000,mmmu_val_mmmu_acc,0.30222,
-Baseline,15000,mmstar_average,0.35408135695920684,
-Baseline,15000,ocrbench_ocrbench_accuracy,0.558,
-Baseline,15000,seedbench_seed_all,0.5411339633129516,
-Baseline,15000,textvqa_val_exact_match,0.5583600000000001,0.0067279027203879065
-Baseline,16000,ai2d_exact_match,0.45077720207253885,0.008955440137395838
-Baseline,16000,average,0.47665128022935843,
-Baseline,16000,average_rank,1.5,
-Baseline,16000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,16000,docvqa_val_anls,0.6709415729142987,0.005999818105621502
-Baseline,16000,infovqa_val_anls,0.26050032542402035,0.006997451875879188
-Baseline,16000,mme_total_score,1317.8491396558625,
-Baseline,16000,mmmu_val_mmmu_acc,0.27556,
-Baseline,16000,mmstar_average,0.33214333327093315,
-Baseline,16000,ocrbench_ocrbench_accuracy,0.56,
-Baseline,16000,seedbench_seed_all,0.5463590883824346,
-Baseline,16000,textvqa_val_exact_match,0.56158,0.006723854754867398
-Baseline,17000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-Baseline,17000,average,0.4777141780162423,
-Baseline,17000,average_rank,1.2,
-Baseline,17000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Baseline,17000,docvqa_val_anls,0.6796338519136422,0.005948761388267941
-Baseline,17000,infovqa_val_anls,0.28070956072505215,0.007298333094144192
-Baseline,17000,mme_total_score,1381.9161664665867,
-Baseline,17000,mmmu_val_mmmu_acc,0.27667,
-Baseline,17000,mmstar_average,0.3370289492329521,
-Baseline,17000,ocrbench_ocrbench_accuracy,0.519,
-Baseline,17000,seedbench_seed_all,0.5510283490828238,
-Baseline,17000,textvqa_val_exact_match,0.56416,0.006724830373229479
-Baseline,18000,ai2d_exact_match,0.46567357512953367,0.008977921602780726
-Baseline,18000,average,0.4819834595278701,
-Baseline,18000,average_rank,1.1,
-Baseline,18000,chartqa_relaxed_overall,0.6376,0.009615793331418735
-Baseline,18000,docvqa_val_anls,0.6775884603912571,0.005972234236435759
-Baseline,18000,infovqa_val_anls,0.27154318420389256,0.007164903131667027
-Baseline,18000,mme_total_score,1336.922769107643,
-Baseline,18000,mmmu_val_mmmu_acc,0.28667,
-Baseline,18000,mmstar_average,0.34482796716566916,
-Baseline,18000,ocrbench_ocrbench_accuracy,0.533,
-Baseline,18000,seedbench_seed_all,0.5543079488604781,
-Baseline,18000,textvqa_val_exact_match,0.5666399999999999,0.006713392287599574
-Baseline,19000,ai2d_exact_match,0.4682642487046632,0.008981008686994101
-Baseline,19000,average,0.4899006713916878,
-Baseline,19000,chartqa_relaxed_overall,0.6444,0.009575809858898698
-Baseline,19000,docvqa_val_anls,0.678226526479947,0.005970619221588814
-Baseline,19000,infovqa_val_anls,0.26993847247278,0.0071348470764911525
-Baseline,19000,mme_total_score,1406.6628651460583,
-Baseline,19000,mmmu_val_mmmu_acc,0.28333,
-Baseline,19000,mmstar_average,0.356220913822775,
-Baseline,19000,ocrbench_ocrbench_accuracy,0.577,
-Baseline,19000,seedbench_seed_all,0.554585881045025,
-Baseline,19000,textvqa_val_exact_match,0.57714,0.0066918487914812905
-Baseline,20000,ai2d_exact_match,0.47571243523316065,0.00898853090258662
-Baseline,20000,average,0.4873169067639118,
-Baseline,20000,chartqa_relaxed_overall,0.6336,0.009638338810708618
-Baseline,20000,docvqa_val_anls,0.6895214454380043,0.005896462073053767
-Baseline,20000,infovqa_val_anls,0.2655657550458317,0.007033265532032538
-Baseline,20000,mme_total_score,1324.6738695478193,
-Baseline,20000,mmmu_val_mmmu_acc,0.30111,
-Baseline,20000,mmstar_average,0.33806766134497995,
-Baseline,20000,ocrbench_ocrbench_accuracy,0.555,
-Baseline,20000,seedbench_seed_all,0.5587548638132296,
-Baseline,20000,textvqa_val_exact_match,0.56852,0.006720151338087659
-Remove Multilingual Data,1000,ai2d_exact_match,0.2619818652849741,0.007914086941902855
-Remove Multilingual Data,1000,average,0.29340443385847137,
-Remove Multilingual Data,1000,average_rank,1.3,
-Remove Multilingual Data,1000,chartqa_relaxed_overall,0.3736,0.009677121197436144
-Remove Multilingual Data,1000,docvqa_val_anls,0.403140100303888,0.006111323163666132
-Remove Multilingual Data,1000,infovqa_val_anls,0.1764617576183696,0.006251319736392345
-Remove Multilingual Data,1000,mme_total_score,979.3045218087235,
-Remove Multilingual Data,1000,mmmu_val_mmmu_acc,0.25222,
-Remove Multilingual Data,1000,mmstar_average,0.2073057646207335,
-Remove Multilingual Data,1000,ocrbench_ocrbench_accuracy,0.333,
-Remove Multilingual Data,1000,seedbench_seed_all,0.2507504168982768,
-Remove Multilingual Data,1000,textvqa_val_exact_match,0.38218,0.006631325992355026
-Remove Multilingual Data,2000,ai2d_exact_match,0.25291450777202074,0.007823547213659585
-Remove Multilingual Data,2000,average,0.32254499165624334,
-Remove Multilingual Data,2000,average_rank,1.5,
-Remove Multilingual Data,2000,chartqa_relaxed_overall,0.4692,0.009983005968307607
-Remove Multilingual Data,2000,docvqa_val_anls,0.472590835723597,0.006255090657185791
-Remove Multilingual Data,2000,infovqa_val_anls,0.19402428600531574,0.006415305613638088
-Remove Multilingual Data,2000,mme_total_score,1067.5286114445778,
-Remove Multilingual Data,2000,mmmu_val_mmmu_acc,0.24444,
-Remove Multilingual Data,2000,mmstar_average,0.20544885849586278,
-Remove Multilingual Data,2000,ocrbench_ocrbench_accuracy,0.409,
-Remove Multilingual Data,2000,seedbench_seed_all,0.2555864369093941,
-Remove Multilingual Data,2000,textvqa_val_exact_match,0.3997,0.006677042652231296
-Remove Multilingual Data,3000,ai2d_exact_match,0.2658678756476684,0.00795154886571598
-Remove Multilingual Data,3000,average,0.35383248024337044,
-Remove Multilingual Data,3000,average_rank,1.4,
-Remove Multilingual Data,3000,chartqa_relaxed_overall,0.536,0.009976041728231964
-Remove Multilingual Data,3000,docvqa_val_anls,0.5115050780592246,0.006297134520533815
-Remove Multilingual Data,3000,infovqa_val_anls,0.1959317380528948,0.006353999153527862
-Remove Multilingual Data,3000,mme_total_score,1055.7074829931971,
-Remove Multilingual Data,3000,mmmu_val_mmmu_acc,0.26,
-Remove Multilingual Data,3000,mmstar_average,0.2325690534433309,
-Remove Multilingual Data,3000,ocrbench_ocrbench_accuracy,0.449,
-Remove Multilingual Data,3000,seedbench_seed_all,0.28943857698721515,
-Remove Multilingual Data,3000,textvqa_val_exact_match,0.44418,0.0067730052591185854
-Remove Multilingual Data,4000,ai2d_exact_match,0.2856217616580311,0.008130016747303466
-Remove Multilingual Data,4000,average,0.3775873253769421,
-Remove Multilingual Data,4000,average_rank,1.4,
-Remove Multilingual Data,4000,chartqa_relaxed_overall,0.55,0.009951864943131942
-Remove Multilingual Data,4000,docvqa_val_anls,0.5339851175847934,0.0062957385772197255
-Remove Multilingual Data,4000,infovqa_val_anls,0.20750676546327357,0.006369425500899887
-Remove Multilingual Data,4000,mme_total_score,1228.202280912365,
-Remove Multilingual Data,4000,mmmu_val_mmmu_acc,0.27111,
-Remove Multilingual Data,4000,mmstar_average,0.24655460164079995,
-Remove Multilingual Data,4000,ocrbench_ocrbench_accuracy,0.456,
-Remove Multilingual Data,4000,seedbench_seed_all,0.3898276820455809,
-Remove Multilingual Data,4000,textvqa_val_exact_match,0.45768000000000003,0.006781666588703993
-Remove Multilingual Data,5000,ai2d_exact_match,0.3121761658031088,0.008340079044408505
-Remove Multilingual Data,5000,average,0.3976192139479395,
-Remove Multilingual Data,5000,average_rank,1.4,
-Remove Multilingual Data,5000,chartqa_relaxed_overall,0.5684,0.009907968668564455
-Remove Multilingual Data,5000,docvqa_val_anls,0.5611339219828478,0.006260862186673622
-Remove Multilingual Data,5000,infovqa_val_anls,0.21913407408993218,0.006638320670102091
-Remove Multilingual Data,5000,mme_total_score,1219.2377951180472,
-Remove Multilingual Data,5000,mmmu_val_mmmu_acc,0.29444,
-Remove Multilingual Data,5000,mmstar_average,0.23556637343877926,
-Remove Multilingual Data,5000,ocrbench_ocrbench_accuracy,0.472,
-Remove Multilingual Data,5000,seedbench_seed_all,0.4443023902167871,
-Remove Multilingual Data,5000,textvqa_val_exact_match,0.47142,0.006807048104779351
-Remove Multilingual Data,6000,ai2d_exact_match,0.35200777202072536,0.008595926828224822
-Remove Multilingual Data,6000,average,0.42451996443270734,
-Remove Multilingual Data,6000,average_rank,1.3,
-Remove Multilingual Data,6000,chartqa_relaxed_overall,0.5744,0.009890651444389179
-Remove Multilingual Data,6000,docvqa_val_anls,0.5825552977560686,0.006257174245982806
-Remove Multilingual Data,6000,infovqa_val_anls,0.252828230577843,0.007149939162213116
-Remove Multilingual Data,6000,mme_total_score,1216.607643057223,
-Remove Multilingual Data,6000,mmmu_val_mmmu_acc,0.30222,
-Remove Multilingual Data,6000,mmstar_average,0.2807390632529032,
-Remove Multilingual Data,6000,ocrbench_ocrbench_accuracy,0.497,
-Remove Multilingual Data,6000,seedbench_seed_all,0.484769316286826,
-Remove Multilingual Data,6000,textvqa_val_exact_match,0.49416000000000004,0.006798707477504303
-Remove Multilingual Data,7000,ai2d_exact_match,0.3801813471502591,0.008736941116932581
-Remove Multilingual Data,7000,average,0.428085510128325,
-Remove Multilingual Data,7000,average_rank,1.4,
-Remove Multilingual Data,7000,chartqa_relaxed_overall,0.5796,0.009874438607593145
-Remove Multilingual Data,7000,docvqa_val_anls,0.5966369586509165,0.006224801729990067
-Remove Multilingual Data,7000,infovqa_val_anls,0.23354910759447625,0.006817906701297544
-Remove Multilingual Data,7000,mme_total_score,1188.1020408163265,
-Remove Multilingual Data,7000,mmmu_val_mmmu_acc,0.27556,
-Remove Multilingual Data,7000,mmstar_average,0.292518909276783,
-Remove Multilingual Data,7000,ocrbench_ocrbench_accuracy,0.503,
-Remove Multilingual Data,7000,seedbench_seed_all,0.48988326848249025,
-Remove Multilingual Data,7000,textvqa_val_exact_match,0.5018400000000001,0.006795274684043781
-Remove Multilingual Data,8000,ai2d_exact_match,0.3863341968911917,0.008763532923326706
-Remove Multilingual Data,8000,average,0.4413787447198958,
-Remove Multilingual Data,8000,average_rank,1.2,
-Remove Multilingual Data,8000,chartqa_relaxed_overall,0.5964,0.009814343815957088
-Remove Multilingual Data,8000,docvqa_val_anls,0.603351366738696,0.006235087701254087
-Remove Multilingual Data,8000,infovqa_val_anls,0.25307646024963104,0.007198626238671866
-Remove Multilingual Data,8000,mme_total_score,1261.5517206882753,
-Remove Multilingual Data,8000,mmmu_val_mmmu_acc,0.29556,
-Remove Multilingual Data,8000,mmstar_average,0.30595531673183934,
-Remove Multilingual Data,8000,ocrbench_ocrbench_accuracy,0.505,
-Remove Multilingual Data,8000,seedbench_seed_all,0.5124513618677042,
-Remove Multilingual Data,8000,textvqa_val_exact_match,0.51428,0.006792322389925977
-Remove Multilingual Data,9000,ai2d_exact_match,0.3908678756476684,0.008782181865213609
-Remove Multilingual Data,9000,average,0.4483393474436153,
-Remove Multilingual Data,9000,average_rank,1.2,
-Remove Multilingual Data,9000,chartqa_relaxed_overall,0.6008,0.00979663889573671
-Remove Multilingual Data,9000,docvqa_val_anls,0.6206417157518567,0.006160046717594884
-Remove Multilingual Data,9000,infovqa_val_anls,0.2517144366407357,0.007092352700671051
-Remove Multilingual Data,9000,mme_total_score,1270.4974989995999,
-Remove Multilingual Data,9000,mmmu_val_mmmu_acc,0.29333,
-Remove Multilingual Data,9000,mmstar_average,0.32657768650091523,
-Remove Multilingual Data,9000,ocrbench_ocrbench_accuracy,0.52,
-Remove Multilingual Data,9000,seedbench_seed_all,0.5163424124513619,
-Remove Multilingual Data,9000,textvqa_val_exact_match,0.51478,0.006772730933446224
-Remove Multilingual Data,10000,ai2d_exact_match,0.41450777202072536,0.008866630113019596
-Remove Multilingual Data,10000,average,0.45448389614950035,
-Remove Multilingual Data,10000,average_rank,1.3,
-Remove Multilingual Data,10000,chartqa_relaxed_overall,0.6068,0.009771166474772143
-Remove Multilingual Data,10000,docvqa_val_anls,0.6232449599819007,0.006177718712473361
-Remove Multilingual Data,10000,infovqa_val_anls,0.23737546748097776,0.006778926597473845
-Remove Multilingual Data,10000,mme_total_score,1276.3549419767905,
-Remove Multilingual Data,10000,mmmu_val_mmmu_acc,0.29889,
-Remove Multilingual Data,10000,mmstar_average,0.3130758097195978,
-Remove Multilingual Data,10000,ocrbench_ocrbench_accuracy,0.539,
-Remove Multilingual Data,10000,seedbench_seed_all,0.5219010561423013,
-Remove Multilingual Data,10000,textvqa_val_exact_match,0.53556,0.00676001751827386
-Remove Multilingual Data,11000,ai2d_exact_match,0.41904145077720206,0.008880404559123601
-Remove Multilingual Data,11000,average,0.4609227111862355,
-Remove Multilingual Data,11000,average_rank,1.3,
-Remove Multilingual Data,11000,chartqa_relaxed_overall,0.6108,0.00975332737879659
-Remove Multilingual Data,11000,docvqa_val_anls,0.6387481065492241,0.006094036395159673
-Remove Multilingual Data,11000,infovqa_val_anls,0.25052436731474453,0.006993658213921465
-Remove Multilingual Data,11000,mme_total_score,1258.2553021208482,
-Remove Multilingual Data,11000,mmmu_val_mmmu_acc,0.28,
-Remove Multilingual Data,11000,mmstar_average,0.3213557456291676,
-Remove Multilingual Data,11000,ocrbench_ocrbench_accuracy,0.561,
-Remove Multilingual Data,11000,seedbench_seed_all,0.526514730405781,
-Remove Multilingual Data,11000,textvqa_val_exact_match,0.54032,0.0067608876222200335
-Remove Multilingual Data,12000,ai2d_exact_match,0.41353626943005184,0.00886357792887845
-Remove Multilingual Data,12000,average,0.46149948562642984,
-Remove Multilingual Data,12000,average_rank,1.3,
-Remove Multilingual Data,12000,chartqa_relaxed_overall,0.622,0.009699692449425671
-Remove Multilingual Data,12000,docvqa_val_anls,0.6481870346272672,0.0060803752132680255
-Remove Multilingual Data,12000,infovqa_val_anls,0.25116762340113796,0.006993814336062128
-Remove Multilingual Data,12000,mme_total_score,1256.7357943177271,
-Remove Multilingual Data,12000,mmmu_val_mmmu_acc,0.28222,
-Remove Multilingual Data,12000,mmstar_average,0.311104865636332,
-Remove Multilingual Data,12000,ocrbench_ocrbench_accuracy,0.547,
-Remove Multilingual Data,12000,seedbench_seed_all,0.5312395775430795,
-Remove Multilingual Data,12000,textvqa_val_exact_match,0.54704,0.006750774938661079
-Remove Multilingual Data,13000,ai2d_exact_match,0.42810880829015546,0.008905646879422012
-Remove Multilingual Data,13000,average,0.4658949593838579,
-Remove Multilingual Data,13000,average_rank,1.6,
-Remove Multilingual Data,13000,chartqa_relaxed_overall,0.622,0.009699692449425671
-Remove Multilingual Data,13000,docvqa_val_anls,0.6461697403304425,0.006072036108570188
-Remove Multilingual Data,13000,infovqa_val_anls,0.2635164421127001,0.007102540516236264
-Remove Multilingual Data,13000,mme_total_score,1295.0039015606244,
-Remove Multilingual Data,13000,mmmu_val_mmmu_acc,0.29,
-Remove Multilingual Data,13000,mmstar_average,0.3296444797414335,
-Remove Multilingual Data,13000,ocrbench_ocrbench_accuracy,0.54,
-Remove Multilingual Data,13000,seedbench_seed_all,0.5312951639799889,
-Remove Multilingual Data,13000,textvqa_val_exact_match,0.54232,0.006771571040376891
-Remove Multilingual Data,14000,ai2d_exact_match,0.42487046632124353,0.008896983637113786
-Remove Multilingual Data,14000,average,0.46755416993970794,
-Remove Multilingual Data,14000,average_rank,1.7,
-Remove Multilingual Data,14000,chartqa_relaxed_overall,0.6256,0.009681288495793083
-Remove Multilingual Data,14000,docvqa_val_anls,0.6470833619171145,0.006119244473927763
-Remove Multilingual Data,14000,infovqa_val_anls,0.2541720455309047,0.007006172199083197
-Remove Multilingual Data,14000,mme_total_score,1262.1793717486994,
-Remove Multilingual Data,14000,mmmu_val_mmmu_acc,0.28556,
-Remove Multilingual Data,14000,mmstar_average,0.327544946405174,
-Remove Multilingual Data,14000,ocrbench_ocrbench_accuracy,0.559,
-Remove Multilingual Data,14000,seedbench_seed_all,0.5380767092829349,
-Remove Multilingual Data,14000,textvqa_val_exact_match,0.5460799999999999,0.006754587449305995
-Remove Multilingual Data,15000,ai2d_exact_match,0.42908031088082904,0.00890816984689523
-Remove Multilingual Data,15000,average,0.4720258172705174,
-Remove Multilingual Data,15000,average_rank,1.8,
-Remove Multilingual Data,15000,chartqa_relaxed_overall,0.626,0.009679208378267924
-Remove Multilingual Data,15000,docvqa_val_anls,0.655881547989144,0.006058079036611966
-Remove Multilingual Data,15000,infovqa_val_anls,0.2538472956751567,0.006929926842577286
-Remove Multilingual Data,15000,mme_total_score,1283.2800120048018,
-Remove Multilingual Data,15000,mmmu_val_mmmu_acc,0.29,
-Remove Multilingual Data,15000,mmstar_average,0.3309383426349411,
-Remove Multilingual Data,15000,ocrbench_ocrbench_accuracy,0.572,
-Remove Multilingual Data,15000,seedbench_seed_all,0.5407448582545858,
-Remove Multilingual Data,15000,textvqa_val_exact_match,0.54974,0.006738090742441116
-Remove Multilingual Data,16000,ai2d_exact_match,0.42940414507772023,0.008909003051055714
-Remove Multilingual Data,16000,average,0.476926180401357,
-Remove Multilingual Data,16000,average_rank,1.5,
-Remove Multilingual Data,16000,chartqa_relaxed_overall,0.626,0.009679208378267924
-Remove Multilingual Data,16000,docvqa_val_anls,0.6622394005833824,0.006046858134280091
-Remove Multilingual Data,16000,infovqa_val_anls,0.2633356312454137,0.007137388413784386
-Remove Multilingual Data,16000,mme_total_score,1328.4599839935972,
-Remove Multilingual Data,16000,mmmu_val_mmmu_acc,0.29556,
-Remove Multilingual Data,16000,mmstar_average,0.33932578522709744,
-Remove Multilingual Data,16000,ocrbench_ocrbench_accuracy,0.578,
-Remove Multilingual Data,16000,seedbench_seed_all,0.5431906614785992,
-Remove Multilingual Data,16000,textvqa_val_exact_match,0.55528,0.006733817132847886
-Remove Multilingual Data,17000,ai2d_exact_match,0.42940414507772023,0.008909003051055712
-Remove Multilingual Data,17000,average,0.4732087844936434,
-Remove Multilingual Data,17000,average_rank,1.8,
-Remove Multilingual Data,17000,chartqa_relaxed_overall,0.6264,0.009677121197436144
-Remove Multilingual Data,17000,docvqa_val_anls,0.661817176575324,0.0060368801840957114
-Remove Multilingual Data,17000,infovqa_val_anls,0.25584519300448166,0.007033162778192734
-Remove Multilingual Data,17000,mme_total_score,1270.766606642657,
-Remove Multilingual Data,17000,mmmu_val_mmmu_acc,0.28,
-Remove Multilingual Data,17000,mmstar_average,0.3233592606268431,
-Remove Multilingual Data,17000,ocrbench_ocrbench_accuracy,0.58,
-Remove Multilingual Data,17000,seedbench_seed_all,0.5439132851584213,
-Remove Multilingual Data,17000,textvqa_val_exact_match,0.5581400000000001,0.006731048171116916
-Remove Multilingual Data,18000,ai2d_exact_match,0.4368523316062176,0.008927095061184944
-Remove Multilingual Data,18000,average,0.4769341122300441,
-Remove Multilingual Data,18000,average_rank,1.9,
-Remove Multilingual Data,18000,chartqa_relaxed_overall,0.636,0.009624897685803465
-Remove Multilingual Data,18000,docvqa_val_anls,0.671397164123935,0.006004837667492473
-Remove Multilingual Data,18000,infovqa_val_anls,0.2570865428675732,0.007022334730795061
-Remove Multilingual Data,18000,mme_total_score,1330.2323929571828,
-Remove Multilingual Data,18000,mmmu_val_mmmu_acc,0.28444,
-Remove Multilingual Data,18000,mmstar_average,0.3272633338962395,
-Remove Multilingual Data,18000,ocrbench_ocrbench_accuracy,0.579,
-Remove Multilingual Data,18000,seedbench_seed_all,0.5457476375764313,
-Remove Multilingual Data,18000,textvqa_val_exact_match,0.55462,0.0067429981999808505
+version https://git-lfs.github.com/spec/v1
+oid sha256:869fc4724af7e9c868b6024f472f9ae0f6468b74ef61db101438f80610828abb
+size 28837

app/src/content/assets/data/s25_ratings.csv

@@ -1,1189 +1,3 @@
-run,step,metric,value,stderr
-≥1,1000,ai2d_exact_match,0.48283678756476683,0.00899385068939683
-≥1,1000,average,0.4841740613238066,
-≥1,1000,average_rank,2.4,
-≥1,1000,chartqa_relaxed_overall,0.6328,0.00964276190429159
-≥1,1000,docvqa_val_anls,0.6709958484393396,0.006009113294340719
-≥1,1000,infovqa_val_anls,0.2911610792718508,0.007480963558334323
-≥1,1000,mme_total_score,1300.6441576630652,
-≥1,1000,mmmu_val_mmmu_acc,0.28111,
-≥1,1000,mmstar_average,0.34899099672724077,
-≥1,1000,ocrbench_ocrbench_accuracy,0.53,
-≥1,1000,seedbench_seed_all,0.5613118399110617,
-≥1,1000,textvqa_val_exact_match,0.5583600000000001,0.006733787259646062
-≥1,2000,ai2d_exact_match,0.4834844559585492,0.008994243503406855
-≥1,2000,average,0.4870755750428875,
-≥1,2000,average_rank,2.0,
-≥1,2000,chartqa_relaxed_overall,0.6296,0.0096601689190934
-≥1,2000,docvqa_val_anls,0.6827112292156415,0.005909694544631059
-≥1,2000,infovqa_val_anls,0.26248215166111283,0.006999241957900095
-≥1,2000,mme_total_score,1316.5322128851542,
-≥1,2000,mmmu_val_mmmu_acc,0.29556,
-≥1,2000,mmstar_average,0.351185684854186,
-≥1,2000,ocrbench_ocrbench_accuracy,0.557,
-≥1,2000,seedbench_seed_all,0.5579766536964981,
-≥1,2000,textvqa_val_exact_match,0.5636800000000001,0.006720565803631728
-≥1,3000,ai2d_exact_match,0.47085492227979275,0.008983852707691605
-≥1,3000,average,0.48291385198510484,
-≥1,3000,average_rank,2.7,
-≥1,3000,chartqa_relaxed_overall,0.6416,0.00959252743718011
-≥1,3000,docvqa_val_anls,0.680081009037435,0.005963713977526521
-≥1,3000,infovqa_val_anls,0.2758757523314467,0.007145074435929658
-≥1,3000,mme_total_score,1338.268607442977,
-≥1,3000,mmmu_val_mmmu_acc,0.26889,
-≥1,3000,mmstar_average,0.34908867626840856,
-≥1,3000,ocrbench_ocrbench_accuracy,0.542,
-≥1,3000,seedbench_seed_all,0.5577543079488605,
-≥1,3000,textvqa_val_exact_match,0.56008,0.00674696843305253
-≥1,4000,ai2d_exact_match,0.48218911917098445,0.008993442748995703
-≥1,4000,average,0.49172515123492716,
-≥1,4000,average_rank,2.3,
-≥1,4000,chartqa_relaxed_overall,0.6488,0.009548816468986266
-≥1,4000,docvqa_val_anls,0.6902890941626307,0.005912204920631156
-≥1,4000,infovqa_val_anls,0.26986279043614175,0.007091114226807192
-≥1,4000,mme_total_score,1322.6090436174468,
-≥1,4000,mmmu_val_mmmu_acc,0.31,
-≥1,4000,mmstar_average,0.35470222226954573,
-≥1,4000,ocrbench_ocrbench_accuracy,0.542,
-≥1,4000,seedbench_seed_all,0.5576431350750417,
-≥1,4000,textvqa_val_exact_match,0.57004,0.006721660198430491
-≥1,5000,ai2d_exact_match,0.48704663212435234,0.008996133680935945
-≥1,5000,average,0.4922453953675835,
-≥1,5000,average_rank,2.3,
-≥1,5000,chartqa_relaxed_overall,0.6524,0.009526069199715017
-≥1,5000,docvqa_val_anls,0.7021575420936199,0.005829944728253253
-≥1,5000,infovqa_val_anls,0.2714850202382579,0.0071017460136769345
-≥1,5000,mme_total_score,1372.0063025210084,
-≥1,5000,mmmu_val_mmmu_acc,0.28444,
-≥1,5000,mmstar_average,0.34918092027225467,
-≥1,5000,ocrbench_ocrbench_accuracy,0.553,
-≥1,5000,seedbench_seed_all,0.5571984435797666,
-≥1,5000,textvqa_val_exact_match,0.5733,0.0066972526186883305
-≥1,6000,ai2d_exact_match,0.4838082901554404,0.008994434238637761
-≥1,6000,average,0.4949352825546263,
-≥1,6000,average_rank,2.3,
-≥1,6000,chartqa_relaxed_overall,0.6484,0.009551307082635064
-≥1,6000,docvqa_val_anls,0.7034964362890477,0.00583650860725618
-≥1,6000,infovqa_val_anls,0.2724245614355471,0.0071074877022118095
-≥1,6000,mme_total_score,1406.1297519007603,
-≥1,6000,mmmu_val_mmmu_acc,0.30333,
-≥1,6000,mmstar_average,0.3537726186468994,
-≥1,6000,ocrbench_ocrbench_accuracy,0.551,
-≥1,6000,seedbench_seed_all,0.5621456364647026,
-≥1,6000,textvqa_val_exact_match,0.57604,0.006696965995935035
-≥1,7000,ai2d_exact_match,0.49158031088082904,0.008997878107766406
-≥1,7000,average,0.5010900439307898,
-≥1,7000,average_rank,1.9,
-≥1,7000,chartqa_relaxed_overall,0.6564,0.009500090351500593
-≥1,7000,docvqa_val_anls,0.7105997601562098,0.005781434620670767
-≥1,7000,infovqa_val_anls,0.29338120425035286,0.007415977951206446
-≥1,7000,mme_total_score,1362.5676270508204,
-≥1,7000,mmmu_val_mmmu_acc,0.30778,
-≥1,7000,mmstar_average,0.34667048751606516,
-≥1,7000,ocrbench_ocrbench_accuracy,0.555,
-≥1,7000,seedbench_seed_all,0.569538632573652,
-≥1,7000,textvqa_val_exact_match,0.57886,0.006701104464206482
-≥1,8000,ai2d_exact_match,0.48704663212435234,0.008996133680935945
-≥1,8000,average,0.5012874693126343,
-≥1,8000,average_rank,2.4,
-≥1,8000,chartqa_relaxed_overall,0.66,0.009476070829586857
-≥1,8000,docvqa_val_anls,0.7013710839567656,0.00584567154399218
-≥1,8000,infovqa_val_anls,0.2843596286067672,0.00726326016667778
-≥1,8000,mme_total_score,1366.6049419767905,
-≥1,8000,mmmu_val_mmmu_acc,0.29778,
-≥1,8000,mmstar_average,0.3726316801263804,
-≥1,8000,ocrbench_ocrbench_accuracy,0.568,
-≥1,8000,seedbench_seed_all,0.5647581989994441,
-≥1,8000,textvqa_val_exact_match,0.5756399999999999,0.006701275960583923
-≥1,9000,ai2d_exact_match,0.5080958549222798,0.008997974381217102
-≥1,9000,average,0.5049424624827252,
-≥1,9000,average_rank,1.9,
-≥1,9000,chartqa_relaxed_overall,0.6644,0.009445885130487209
-≥1,9000,docvqa_val_anls,0.7114743939854425,0.005784207378273765
-≥1,9000,infovqa_val_anls,0.27927629692536604,0.007234508289873752
-≥1,9000,mme_total_score,1385.721988795518,
-≥1,9000,mmmu_val_mmmu_acc,0.30333,
-≥1,9000,mmstar_average,0.35371044141416225,
-≥1,9000,ocrbench_ocrbench_accuracy,0.572,
-≥1,9000,seedbench_seed_all,0.5673151750972762,
-≥1,9000,textvqa_val_exact_match,0.58488,0.006674247990391685
-≥1,10000,ai2d_exact_match,0.5006476683937824,0.008999146569435552
-≥1,10000,average,0.5082439013030791,
-≥1,10000,average_rank,2.1,
-≥1,10000,chartqa_relaxed_overall,0.66,0.009476070829586857
-≥1,10000,docvqa_val_anls,0.7160888537676756,0.005756158349745215
-≥1,10000,infovqa_val_anls,0.29920594326668903,0.0074179476099996864
-≥1,10000,mme_total_score,1331.7510004001601,
-≥1,10000,mmmu_val_mmmu_acc,0.31222,
-≥1,10000,mmstar_average,0.34770435280317685,
-≥1,10000,ocrbench_ocrbench_accuracy,0.572,
-≥1,10000,seedbench_seed_all,0.5709282934963869,
-≥1,10000,textvqa_val_exact_match,0.5954,0.006639803114330983
-≥1,11000,ai2d_exact_match,0.506800518134715,0.008998321712163856
-≥1,11000,average,0.5113045470128461,
-≥1,11000,average_rank,2.4,
-≥1,11000,chartqa_relaxed_overall,0.6648,0.009443095510537233
-≥1,11000,docvqa_val_anls,0.7219007936057111,0.005738025679608452
-≥1,11000,infovqa_val_anls,0.2919206859707748,0.007295238934448537
-≥1,11000,mme_total_score,1423.2838135254103,
-≥1,11000,mmmu_val_mmmu_acc,0.32,
-≥1,11000,mmstar_average,0.34837257743331856,
-≥1,11000,ocrbench_ocrbench_accuracy,0.584,
-≥1,11000,seedbench_seed_all,0.567426347971095,
-≥1,11000,textvqa_val_exact_match,0.5965199999999999,0.006637830223651069
-≥1,12000,ai2d_exact_match,0.4957901554404145,0.0089988351333547
-≥1,12000,average,0.5133063005116858,
-≥1,12000,average_rank,2.0,
-≥1,12000,chartqa_relaxed_overall,0.6752,0.00936787525721462
-≥1,12000,docvqa_val_anls,0.7317458509080867,0.005677899397993261
-≥1,12000,infovqa_val_anls,0.30244398410320705,0.0074372299260171675
-≥1,12000,mme_total_score,1358.8711484593837,
-≥1,12000,mmmu_val_mmmu_acc,0.30222,
-≥1,12000,mmstar_average,0.36151764800560426,
-≥1,12000,ocrbench_ocrbench_accuracy,0.571,
-≥1,12000,seedbench_seed_all,0.5743190661478599,
-≥1,12000,textvqa_val_exact_match,0.6055199999999998,0.006601107546780982
-≥1,13000,ai2d_exact_match,0.5029145077720207,0.008999001233939133
-≥1,13000,average,0.5113232076887448,
-≥1,13000,average_rank,2.2,
-≥1,13000,chartqa_relaxed_overall,0.6764,0.009358859508536295
-≥1,13000,docvqa_val_anls,0.7299154645021083,0.005686391180628681
-≥1,13000,infovqa_val_anls,0.28296895663700367,0.007106598521793854
-≥1,13000,mme_total_score,1461.5425170068027,
-≥1,13000,mmmu_val_mmmu_acc,0.28444,
-≥1,13000,mmstar_average,0.3679555656349867,
-≥1,13000,ocrbench_ocrbench_accuracy,0.575,
-≥1,13000,seedbench_seed_all,0.5738743746525847,
-≥1,13000,textvqa_val_exact_match,0.60844,0.006603822784953804
-≥1,14000,ai2d_exact_match,0.508419689119171,0.00899787810776641
-≥1,14000,average,0.5204248423941521,
-≥1,14000,average_rank,1.5,
-≥1,14000,chartqa_relaxed_overall,0.6748,0.009370864914387439
-≥1,14000,docvqa_val_anls,0.7348023413497262,0.005658144612389036
-≥1,14000,infovqa_val_anls,0.30339204212390886,0.007452040139655917
-≥1,14000,mme_total_score,1421.6612645058024,
-≥1,14000,mmmu_val_mmmu_acc,0.32333,
-≥1,14000,mmstar_average,0.3578816768256025,
-≥1,14000,ocrbench_ocrbench_accuracy,0.59,
-≥1,14000,seedbench_seed_all,0.5760978321289605,
-≥1,14000,textvqa_val_exact_match,0.6151,0.006568548330143662
-≥1,15000,ai2d_exact_match,0.5123056994818653,0.008996428218289524
-≥1,15000,average,0.518135626255078,
-≥1,15000,average_rank,1.8,
-≥1,15000,chartqa_relaxed_overall,0.6768,0.009355838641547569
-≥1,15000,docvqa_val_anls,0.7406818231641893,0.00561534943093856
-≥1,15000,infovqa_val_anls,0.2993680664172523,0.007344080406067735
-≥1,15000,mme_total_score,1410.685474189676,
-≥1,15000,mmmu_val_mmmu_acc,0.31778,
-≥1,15000,mmstar_average,0.34818335740471335,
-≥1,15000,ocrbench_ocrbench_accuracy,0.581,
-≥1,15000,seedbench_seed_all,0.575041689827682,
-≥1,15000,textvqa_val_exact_match,0.61206,0.006579602534644686
-≥1,16000,ai2d_exact_match,0.5148963730569949,0.008995159373289019
-≥1,16000,average,0.5188529848530237,
-≥1,16000,average_rank,2.2,
-≥1,16000,chartqa_relaxed_overall,0.6768,0.009355838641547569
-≥1,16000,docvqa_val_anls,0.7381040832460759,0.005632273383411858
-≥1,16000,infovqa_val_anls,0.30209162600532213,0.007372809699325085
-≥1,16000,mme_total_score,1390.1362545018007,
-≥1,16000,mmmu_val_mmmu_acc,0.31111,
-≥1,16000,mmstar_average,0.35327018992913145,
-≥1,16000,ocrbench_ocrbench_accuracy,0.581,
-≥1,16000,seedbench_seed_all,0.5762645914396887,
-≥1,16000,textvqa_val_exact_match,0.6161399999999999,0.006566896139347796
-≥1,17000,ai2d_exact_match,0.5148963730569949,0.008995159373289019
-≥1,17000,average,0.5197229023161958,
-≥1,17000,average_rank,2.4,
-≥1,17000,chartqa_relaxed_overall,0.6808,0.009325198535746702
-≥1,17000,docvqa_val_anls,0.7415371461870564,0.005606416638789011
-≥1,17000,infovqa_val_anls,0.31757741607819345,0.0075605614362149656
-≥1,17000,mme_total_score,1349.7522008803521,
-≥1,17000,mmmu_val_mmmu_acc,0.29556,
-≥1,17000,mmstar_average,0.3467129398314668,
-≥1,17000,ocrbench_ocrbench_accuracy,0.589,
-≥1,17000,seedbench_seed_all,0.5760422456920511,
-≥1,17000,textvqa_val_exact_match,0.6153799999999999,0.0065759668329423305
-≥1,18000,ai2d_exact_match,0.5113341968911918,0.008996841687150462
-≥1,18000,average,0.5217542622446647,
-≥1,18000,average_rank,2.1,
-≥1,18000,chartqa_relaxed_overall,0.686,0.00928418431696466
-≥1,18000,docvqa_val_anls,0.7485976064804745,0.005545760483304357
-≥1,18000,infovqa_val_anls,0.3079394168596966,0.007506515528281936
-≥1,18000,mme_total_score,1386.236494597839,
-≥1,18000,mmmu_val_mmmu_acc,0.30889,
-≥1,18000,mmstar_average,0.36329690094894107,
-≥1,18000,ocrbench_ocrbench_accuracy,0.58,
-≥1,18000,seedbench_seed_all,0.5744302390216787,
-≥1,18000,textvqa_val_exact_match,0.6153,0.006569673821646289
-≥1,19000,ai2d_exact_match,0.5116580310880829,0.008996707642249475
-≥1,19000,average,0.5243525940235553,
-≥1,19000,average_rank,1.6,
-≥1,19000,chartqa_relaxed_overall,0.6896,0.009254998541285659
-≥1,19000,docvqa_val_anls,0.7410075109051968,0.005624845495160182
-≥1,19000,infovqa_val_anls,0.31451986671246684,0.00754441993362511
-≥1,19000,mme_total_score,1379.0539215686274,
-≥1,19000,mmmu_val_mmmu_acc,0.30889,
-≥1,19000,mmstar_average,0.36379458008546134,
-≥1,19000,ocrbench_ocrbench_accuracy,0.594,
-≥1,19000,seedbench_seed_all,0.5780433574207893,
-≥1,19000,textvqa_val_exact_match,0.61766,0.006552511881896322
-≥2,1000,ai2d_exact_match,0.47765544041450775,0.00899016344465196
-≥2,1000,average,0.48208320918746633,
-≥2,1000,average_rank,2.7,
-≥2,1000,chartqa_relaxed_overall,0.626,0.009679208378267924
-≥2,1000,docvqa_val_anls,0.6830886615719474,0.005941664313882304
-≥2,1000,infovqa_val_anls,0.2636626226113445,0.007012099858086531
-≥2,1000,mme_total_score,1394.7869147659064,
-≥2,1000,mmmu_val_mmmu_acc,0.28111,
-≥2,1000,mmstar_average,0.3621500124529322,
-≥2,1000,ocrbench_ocrbench_accuracy,0.53,
-≥2,1000,seedbench_seed_all,0.5518621456364647,
-≥2,1000,textvqa_val_exact_match,0.5632199999999999,0.006735793977260649
-≥2,2000,ai2d_exact_match,0.47506476683937826,0.00898795641911507
-≥2,2000,average,0.48647523098478523,
-≥2,2000,average_rank,2.4,
-≥2,2000,chartqa_relaxed_overall,0.6392,0.00960657371300514
-≥2,2000,docvqa_val_anls,0.6776161818000301,0.005964335785163625
-≥2,2000,infovqa_val_anls,0.28064001553745443,0.007228333231022024
-≥2,2000,mme_total_score,1262.5283113245298,
-≥2,2000,mmmu_val_mmmu_acc,0.29556,
-≥2,2000,mmstar_average,0.3433600502059375,
-≥2,2000,ocrbench_ocrbench_accuracy,0.562,
-≥2,2000,seedbench_seed_all,0.5489160644802669,
-≥2,2000,textvqa_val_exact_match,0.55592,0.006741845534884587
-≥2,3000,ai2d_exact_match,0.4854274611398964,0.00899533120652686
-≥2,3000,average,0.4892979098475977,
-≥2,3000,average_rank,2.0,
-≥2,3000,chartqa_relaxed_overall,0.642,0.009590161024476605
-≥2,3000,docvqa_val_anls,0.682810147307377,0.005940269120275799
-≥2,3000,infovqa_val_anls,0.27552490540828095,0.007240182675336717
-≥2,3000,mme_total_score,1310.3195278111243,
-≥2,3000,mmmu_val_mmmu_acc,0.29667,
-≥2,3000,mmstar_average,0.33383353302741087,
-≥2,3000,ocrbench_ocrbench_accuracy,0.56,
-≥2,3000,seedbench_seed_all,0.5592551417454141,
-≥2,3000,textvqa_val_exact_match,0.56816,0.00671355771938026
-≥2,4000,ai2d_exact_match,0.4838082901554404,0.008994434238637763
-≥2,4000,average,0.49195026536834224,
-≥2,4000,average_rank,2.2,
-≥2,4000,chartqa_relaxed_overall,0.6428,0.009585406407993486
-≥2,4000,docvqa_val_anls,0.6936982319965624,0.005883844142208432
-≥2,4000,infovqa_val_anls,0.26951374340713585,0.007112166845409044
-≥2,4000,mme_total_score,1301.329931972789,
-≥2,4000,mmmu_val_mmmu_acc,0.30667,
-≥2,4000,mmstar_average,0.34946626950413445,
-≥2,4000,ocrbench_ocrbench_accuracy,0.547,
-≥2,4000,seedbench_seed_all,0.5645358532518066,
-≥2,4000,textvqa_val_exact_match,0.5700599999999999,0.006712416151142391
-≥2,5000,ai2d_exact_match,0.4802461139896373,0.008992128148477658
-≥2,5000,average,0.4911460216363542,
-≥2,5000,average_rank,2.6,
-≥2,5000,chartqa_relaxed_overall,0.6592,0.009481461028833927
-≥2,5000,docvqa_val_anls,0.6952750329046061,0.005874374530558489
-≥2,5000,infovqa_val_anls,0.2792676155726946,0.007321946399777712
-≥2,5000,mme_total_score,1246.5271108443376,
-≥2,5000,mmmu_val_mmmu_acc,0.30667,
-≥2,5000,mmstar_average,0.3273375111929903,
-≥2,5000,ocrbench_ocrbench_accuracy,0.544,
-≥2,5000,seedbench_seed_all,0.5642579210672596,
-≥2,5000,textvqa_val_exact_match,0.56406,0.006733849732986717
-≥2,6000,ai2d_exact_match,0.47636010362694303,0.0089890902327936
-≥2,6000,average,0.49370635223913606,
-≥2,6000,average_rank,2.4,
-≥2,6000,chartqa_relaxed_overall,0.6576,0.00949215130381674
-≥2,6000,docvqa_val_anls,0.6979936603307108,0.005857650960456797
-≥2,6000,infovqa_val_anls,0.2848576580974239,0.007220288614025636
-≥2,6000,mme_total_score,1257.9977991196479,
-≥2,6000,mmmu_val_mmmu_acc,0.28889,
-≥2,6000,mmstar_average,0.3386087219715212,
-≥2,6000,ocrbench_ocrbench_accuracy,0.555,
-≥2,6000,seedbench_seed_all,0.5646470261256253,
-≥2,6000,textvqa_val_exact_match,0.5794000000000001,0.0066913139768320015
-≥2,7000,ai2d_exact_match,0.49125647668393785,0.008997778057794696
-≥2,7000,average,0.49923190517534066,
-≥2,7000,average_rank,2.4,
-≥2,7000,chartqa_relaxed_overall,0.6564,0.009500090351500593
-≥2,7000,docvqa_val_anls,0.7050049130392773,0.005832016517791021
-≥2,7000,infovqa_val_anls,0.27630514531293887,0.007147131752819133
-≥2,7000,mme_total_score,1298.6506602641057,
-≥2,7000,mmmu_val_mmmu_acc,0.30667,
-≥2,7000,mmstar_average,0.35103185667809866,
-≥2,7000,ocrbench_ocrbench_accuracy,0.561,
-≥2,7000,seedbench_seed_all,0.5657587548638132,
-≥2,7000,textvqa_val_exact_match,0.5796600000000001,0.006695268643186835
-≥2,8000,ai2d_exact_match,0.4948186528497409,0.008998670917263325
-≥2,8000,average,0.5019054681854818,
-≥2,8000,average_rank,1.7,
-≥2,8000,chartqa_relaxed_overall,0.6528,0.009523504757028414
-≥2,8000,docvqa_val_anls,0.7073923991601945,0.005811715016078567
-≥2,8000,infovqa_val_anls,0.2893855968120429,0.007315932200378898
-≥2,8000,mme_total_score,1294.7393957583033,
-≥2,8000,mmmu_val_mmmu_acc,0.31444,
-≥2,8000,mmstar_average,0.35566192560333365,
-≥2,8000,ocrbench_ocrbench_accuracy,0.543,
-≥2,8000,seedbench_seed_all,0.5711506392440244,
-≥2,8000,textvqa_val_exact_match,0.5885,0.006652668757748281
-≥2,9000,ai2d_exact_match,0.4961139896373057,0.008998882321332237
-≥2,9000,average,0.5033958878673905,
-≥2,9000,average_rank,1.8,
-≥2,9000,chartqa_relaxed_overall,0.6652,0.009440298284094473
-≥2,9000,docvqa_val_anls,0.706747911546142,0.005822953083156574
-≥2,9000,infovqa_val_anls,0.2960318229790583,0.007315313753711981
-≥2,9000,mme_total_score,1284.486194477791,
-≥2,9000,mmmu_val_mmmu_acc,0.31111,
-≥2,9000,mmstar_average,0.3461876713132692,
-≥2,9000,ocrbench_ocrbench_accuracy,0.551,
-≥2,9000,seedbench_seed_all,0.5688715953307393,
-≥2,9000,textvqa_val_exact_match,0.5893,0.006649446971666576
-≥2,10000,ai2d_exact_match,0.4954663212435233,0.008998784170060763
-≥2,10000,average,0.5062630509259689,
-≥2,10000,average_rank,2.5,
-≥2,10000,chartqa_relaxed_overall,0.668,0.009420504145710235
-≥2,10000,docvqa_val_anls,0.722875937910498,0.005715570269767272
-≥2,10000,infovqa_val_anls,0.28155653174519985,0.007182472403759747
-≥2,10000,mme_total_score,1304.360544217687,
-≥2,10000,mmmu_val_mmmu_acc,0.31556,
-≥2,10000,mmstar_average,0.34845583808486047,
-≥2,10000,ocrbench_ocrbench_accuracy,0.564,
-≥2,10000,seedbench_seed_all,0.5670928293496387,
-≥2,10000,textvqa_val_exact_match,0.59336,0.006650836699676301
-≥2,11000,ai2d_exact_match,0.5093911917098446,0.008997566627779879
-≥2,11000,average,0.5121996275740728,
-≥2,11000,average_rank,2.1,
-≥2,11000,chartqa_relaxed_overall,0.6692,0.009411906161401973
-≥2,11000,docvqa_val_anls,0.7205703696519083,0.005737270521428796
-≥2,11000,infovqa_val_anls,0.30697732217578644,0.007486340094072884
-≥2,11000,mme_total_score,1312.018607442977,
-≥2,11000,mmmu_val_mmmu_acc,0.30889,
-≥2,11000,mmstar_average,0.34270221710271187,
-≥2,11000,ocrbench_ocrbench_accuracy,0.574,
-≥2,11000,seedbench_seed_all,0.5739855475264035,
-≥2,11000,textvqa_val_exact_match,0.6040800000000001,0.00661203558088616
-≥2,12000,ai2d_exact_match,0.5123056994818653,0.008996428218289528
-≥2,12000,average,0.5150951619345675,
-≥2,12000,average_rank,2.3,
-≥2,12000,chartqa_relaxed_overall,0.6672,0.00942619781683542
-≥2,12000,docvqa_val_anls,0.726550362704052,0.005691891264118933
-≥2,12000,infovqa_val_anls,0.3008889889078986,0.007362325835960529
-≥2,12000,mme_total_score,1224.6687675070027,
-≥2,12000,mmmu_val_mmmu_acc,0.31444,
-≥2,12000,mmstar_average,0.35781468591706916,
-≥2,12000,ocrbench_ocrbench_accuracy,0.58,
-≥2,12000,seedbench_seed_all,0.5740967204002223,
-≥2,12000,textvqa_val_exact_match,0.60256,0.006618961505423797
-≥2,13000,ai2d_exact_match,0.5080958549222798,0.0089979743812171
-≥2,13000,average,0.5180586542380377,
-≥2,13000,average_rank,1.4,
-≥2,13000,chartqa_relaxed_overall,0.6752,0.00936787525721462
-≥2,13000,docvqa_val_anls,0.726059208019786,0.0056904102427854444
-≥2,13000,infovqa_val_anls,0.3067653345076983,0.007414171368476549
-≥2,13000,mme_total_score,1241.2817126850741,
-≥2,13000,mmmu_val_mmmu_acc,0.31778,
-≥2,13000,mmstar_average,0.35994731281597653,
-≥2,13000,ocrbench_ocrbench_accuracy,0.582,
-≥2,13000,seedbench_seed_all,0.5763201778765981,
-≥2,13000,textvqa_val_exact_match,0.61036,0.006605638574142127
-≥2,14000,ai2d_exact_match,0.5055051813471503,0.008998608627616667
-≥2,14000,average,0.5187199474947337,
-≥2,14000,average_rank,2.1,
-≥2,14000,chartqa_relaxed_overall,0.6788,0.00934061683451043
-≥2,14000,docvqa_val_anls,0.7306315173289623,0.005670445587318404
-≥2,14000,infovqa_val_anls,0.30084936045159133,0.007340699586893536
-≥2,14000,mme_total_score,1266.9314725890356,
-≥2,14000,mmmu_val_mmmu_acc,0.32,
-≥2,14000,mmstar_average,0.360779371604499,
-≥2,14000,ocrbench_ocrbench_accuracy,0.587,
-≥2,14000,seedbench_seed_all,0.5733740967204002,
-≥2,14000,textvqa_val_exact_match,0.61154,0.006582281592745273
-≥2,15000,ai2d_exact_match,0.5077720207253886,0.008998066878268323
-≥2,15000,average,0.5182417002827931,
-≥2,15000,average_rank,2.2,
-≥2,15000,chartqa_relaxed_overall,0.6732,0.009382745779746297
-≥2,15000,docvqa_val_anls,0.7366238053330653,0.005647248266865468
-≥2,15000,infovqa_val_anls,0.30893362163842225,0.007385953320794889
-≥2,15000,mme_total_score,1280.3160264105643,
-≥2,15000,mmmu_val_mmmu_acc,0.31778,
-≥2,15000,mmstar_average,0.3597603073218589,
-≥2,15000,ocrbench_ocrbench_accuracy,0.571,
-≥2,15000,seedbench_seed_all,0.5739855475264035,
-≥2,15000,textvqa_val_exact_match,0.61512,0.006574049037248568
-≥2,16000,ai2d_exact_match,0.5055051813471503,0.008998608627616667
-≥2,16000,average,0.5226694963682967,
-≥2,16000,average_rank,1.9,
-≥2,16000,chartqa_relaxed_overall,0.6844,0.009296947310365735
-≥2,16000,docvqa_val_anls,0.7369050997741022,0.00564381681657765
-≥2,16000,infovqa_val_anls,0.2990672453595873,0.007260058695111045
-≥2,16000,mme_total_score,1231.8950580232092,
-≥2,16000,mmmu_val_mmmu_acc,0.32333,
-≥2,16000,mmstar_average,0.3660943054808571,
-≥2,16000,ocrbench_ocrbench_accuracy,0.601,
-≥2,16000,seedbench_seed_all,0.5785436353529739,
-≥2,16000,textvqa_val_exact_match,0.6091799999999999,0.006589463538554954
-≥2,17000,ai2d_exact_match,0.5097150259067358,0.008997455247470535
-≥2,17000,average,0.5231030271400094,
-≥2,17000,average_rank,1.5,
-≥2,17000,chartqa_relaxed_overall,0.6844,0.009296947310365735
-≥2,17000,docvqa_val_anls,0.7407178352725541,0.005609117579860497
-≥2,17000,infovqa_val_anls,0.30677928223689904,0.007423923972542159
-≥2,17000,mme_total_score,1251.8118247298921,
-≥2,17000,mmmu_val_mmmu_acc,0.31333,
-≥2,17000,mmstar_average,0.35755470618019386,
-≥2,17000,ocrbench_ocrbench_accuracy,0.595,
-≥2,17000,seedbench_seed_all,0.5787103946637021,
-≥2,17000,textvqa_val_exact_match,0.6217199999999999,0.006547657801423109
-≥2,18000,ai2d_exact_match,0.5129533678756477,0.008996133680935945
-≥2,18000,average,0.520551210243477,
-≥2,18000,average_rank,2.1,
-≥2,18000,chartqa_relaxed_overall,0.6796,0.009334473148259746
-≥2,18000,docvqa_val_anls,0.7420992559479452,0.005605162069925204
-≥2,18000,infovqa_val_anls,0.30026388587258485,0.007302705356586967
-≥2,18000,mme_total_score,1243.8207282913165,
-≥2,18000,mmmu_val_mmmu_acc,0.31111,
-≥2,18000,mmstar_average,0.3520362724339696,
-≥2,18000,ocrbench_ocrbench_accuracy,0.591,
-≥2,18000,seedbench_seed_all,0.576598110061145,
-≥2,18000,textvqa_val_exact_match,0.6193,0.006553540400299342
-≥2,19000,ai2d_exact_match,0.508419689119171,0.008997878107766411
-≥2,19000,average,0.523370364263479,
-≥2,19000,average_rank,2.1,
-≥2,19000,chartqa_relaxed_overall,0.6852,0.009290581788240476
-≥2,19000,docvqa_val_anls,0.7378793056289451,0.005630284657853331
-≥2,19000,infovqa_val_anls,0.29852452208029057,0.007300069652856512
-≥2,19000,mme_total_score,1273.484593837535,
-≥2,19000,mmmu_val_mmmu_acc,0.31778,
-≥2,19000,mmstar_average,0.3583181328603031,
-≥2,19000,ocrbench_ocrbench_accuracy,0.609,
-≥2,19000,seedbench_seed_all,0.5769316286826014,
-≥2,19000,textvqa_val_exact_match,0.6182799999999999,0.0065560479462046795
-≥2,20000,ai2d_exact_match,0.5132772020725389,0.008995980744276042
-≥2,20000,average,0.5252790448062622,
-≥2,20000,average_rank,1.1,
-≥2,20000,chartqa_relaxed_overall,0.6808,0.009325198535746702
-≥2,20000,docvqa_val_anls,0.7417425674578729,0.0056064333517934105
-≥2,20000,infovqa_val_anls,0.3091382953917658,0.007408396253875713
-≥2,20000,mme_total_score,1276.3417366946778,
-≥2,20000,mmmu_val_mmmu_acc,0.31778,
-≥2,20000,mmstar_average,0.35941177079666153,
-≥2,20000,ocrbench_ocrbench_accuracy,0.607,
-≥2,20000,seedbench_seed_all,0.5788215675375209,
-≥2,20000,textvqa_val_exact_match,0.6195400000000001,0.0065546800414733606
-≥3,1000,ai2d_exact_match,0.46696891191709844,0.008979495543032526
-≥3,1000,average,0.4819077497875202,
-≥3,1000,average_rank,2.6,
-≥3,1000,chartqa_relaxed_overall,0.6376,0.009615793331418735
-≥3,1000,docvqa_val_anls,0.6765375416572318,0.00595906808496784
-≥3,1000,infovqa_val_anls,0.28562874655210324,0.007377482443151623
-≥3,1000,mme_total_score,1210.921368547419,
-≥3,1000,mmmu_val_mmmu_acc,0.28556,
-≥3,1000,mmstar_average,0.342259005993489,
-≥3,1000,ocrbench_ocrbench_accuracy,0.534,
-≥3,1000,seedbench_seed_all,0.5559755419677599,
-≥3,1000,textvqa_val_exact_match,0.5526399999999999,0.006746058696867995
-≥3,2000,ai2d_exact_match,0.4685880829015544,0.008981377477192708
-≥3,2000,average,0.48620065133730717,
-≥3,2000,average_rank,2.0,
-≥3,2000,chartqa_relaxed_overall,0.6356,0.009627155802808046
-≥3,2000,docvqa_val_anls,0.6718354763369633,0.005996528203070324
-≥3,2000,infovqa_val_anls,0.26419815798743335,0.006939135175774486
-≥3,2000,mme_total_score,1264.654161664666,
-≥3,2000,mmmu_val_mmmu_acc,0.30333,
-≥3,2000,mmstar_average,0.3562263182394967,
-≥3,2000,ocrbench_ocrbench_accuracy,0.551,
-≥3,2000,seedbench_seed_all,0.5580878265703169,
-≥3,2000,textvqa_val_exact_match,0.56694,0.0067100232609457085
-≥3,3000,ai2d_exact_match,0.4838082901554404,0.008994434238637763
-≥3,3000,average,0.48597261570869915,
-≥3,3000,average_rank,3.0,
-≥3,3000,chartqa_relaxed_overall,0.6316,0.009649342979082627
-≥3,3000,docvqa_val_anls,0.6746316657514325,0.005965125654000594
-≥3,3000,infovqa_val_anls,0.26946459224600977,0.007089931445596614
-≥3,3000,mme_total_score,1247.7741096438576,
-≥3,3000,mmmu_val_mmmu_acc,0.28556,
-≥3,3000,mmstar_average,0.3458825563160156,
-≥3,3000,ocrbench_ocrbench_accuracy,0.562,
-≥3,3000,seedbench_seed_all,0.5555864369093941,
-≥3,3000,textvqa_val_exact_match,0.56522,0.006727876573231477
-≥3,4000,ai2d_exact_match,0.48575129533678757,0.008995499260034972
-≥3,4000,average,0.49355357269641903,
-≥3,4000,average_rank,2.2,
-≥3,4000,chartqa_relaxed_overall,0.6548,0.009510571191350932
-≥3,4000,docvqa_val_anls,0.6853328262496681,0.0059320222320751875
-≥3,4000,infovqa_val_anls,0.2850385340966683,0.007361799302921674
-≥3,4000,mme_total_score,1288.7305922368948,
-≥3,4000,mmmu_val_mmmu_acc,0.30111,
-≥3,4000,mmstar_average,0.357958492470139,
-≥3,4000,ocrbench_ocrbench_accuracy,0.541,
-≥3,4000,seedbench_seed_all,0.5598110061145081,
-≥3,4000,textvqa_val_exact_match,0.57118,0.006705227329084893
-≥3,5000,ai2d_exact_match,0.4727979274611399,0.008985826352357517
-≥3,5000,average,0.4915808423458039,
-≥3,5000,average_rank,2.6,
-≥3,5000,chartqa_relaxed_overall,0.6516,0.009531175862679805
-≥3,5000,docvqa_val_anls,0.6805544343770252,0.005954062592926349
-≥3,5000,infovqa_val_anls,0.2790745100628044,0.007226853744230138
-≥3,5000,mme_total_score,1234.2862144857945,
-≥3,5000,mmmu_val_mmmu_acc,0.30889,
-≥3,5000,mmstar_average,0.3515137442307206,
-≥3,5000,ocrbench_ocrbench_accuracy,0.548,
-≥3,5000,seedbench_seed_all,0.5665369649805447,
-≥3,5000,textvqa_val_exact_match,0.56526,0.006737603842695726
-≥3,6000,ai2d_exact_match,0.4834844559585492,0.008994243503406857
-≥3,6000,average,0.4916502418219912,
-≥3,6000,average_rank,2.8,
-≥3,6000,chartqa_relaxed_overall,0.6504,0.009538780390203614
-≥3,6000,docvqa_val_anls,0.6884045774843457,0.005915343845415068
-≥3,6000,infovqa_val_anls,0.27942328823789453,0.007164390448746867
-≥3,6000,mme_total_score,1169.1683673469388,
-≥3,6000,mmmu_val_mmmu_acc,0.28333,
-≥3,6000,mmstar_average,0.3409248964069589,
-≥3,6000,ocrbench_ocrbench_accuracy,0.564,
-≥3,6000,seedbench_seed_all,0.5649249583101723,
-≥3,6000,textvqa_val_exact_match,0.5699599999999999,0.006704305275108255
-≥3,7000,ai2d_exact_match,0.49158031088082904,0.008997878107766406
-≥3,7000,average,0.498429728288751,
-≥3,7000,average_rank,2.5,
-≥3,7000,chartqa_relaxed_overall,0.6468,0.009561196085649289
-≥3,7000,docvqa_val_anls,0.6934235036732116,0.005908575911274035
-≥3,7000,infovqa_val_anls,0.29038240983122426,0.0073217194111741745
-≥3,7000,mme_total_score,1180.5045018007202,
-≥3,7000,mmmu_val_mmmu_acc,0.31111,
-≥3,7000,mmstar_average,0.3501487176509592,
-≥3,7000,ocrbench_ocrbench_accuracy,0.562,
-≥3,7000,seedbench_seed_all,0.5647026125625347,
-≥3,7000,textvqa_val_exact_match,0.57572,0.00668387845238326
-≥3,8000,ai2d_exact_match,0.5048575129533679,0.008998729431386472
-≥3,8000,average,0.4984949624992469,
-≥3,8000,average_rank,2.8,
-≥3,8000,chartqa_relaxed_overall,0.6472,0.009558734841217527
-≥3,8000,docvqa_val_anls,0.7000334929155309,0.005878854074791644
-≥3,8000,infovqa_val_anls,0.286719889854365,0.0073233352192073635
-≥3,8000,mme_total_score,1136.111644657863,
-≥3,8000,mmmu_val_mmmu_acc,0.28778,
-≥3,8000,mmstar_average,0.33112430039975294,
-≥3,8000,ocrbench_ocrbench_accuracy,0.578,
-≥3,8000,seedbench_seed_all,0.5710394663702056,
-≥3,8000,textvqa_val_exact_match,0.5797000000000001,0.006692483833971778
-≥3,9000,ai2d_exact_match,0.4944948186528497,0.00899860862761667
-≥3,9000,average,0.5022809828687513,
-≥3,9000,average_rank,2.8,
-≥3,9000,chartqa_relaxed_overall,0.6648,0.009443095510537233
-≥3,9000,docvqa_val_anls,0.7066412322864666,0.005811056629671494
-≥3,9000,infovqa_val_anls,0.2915189250095514,0.007376511883779376
-≥3,9000,mme_total_score,1097.9659863945578,
-≥3,9000,mmmu_val_mmmu_acc,0.3,
-≥3,9000,mmstar_average,0.34971925063698756,
-≥3,9000,ocrbench_ocrbench_accuracy,0.565,
-≥3,9000,seedbench_seed_all,0.5663146192329072,
-≥3,9000,textvqa_val_exact_match,0.58204,0.006677395090979731
-≥3,10000,ai2d_exact_match,0.49287564766839376,0.008998240543632312
-≥3,10000,average,0.5094325810245673,
-≥3,10000,average_rank,2.2,
-≥3,10000,chartqa_relaxed_overall,0.6704,0.009403239035659185
-≥3,10000,docvqa_val_anls,0.7142047579734908,0.005771728801461397
-≥3,10000,infovqa_val_anls,0.2964737261567996,0.007512514632225057
-≥3,10000,mme_total_score,1149.6209483793518,
-≥3,10000,mmmu_val_mmmu_acc,0.30778,
-≥3,10000,mmstar_average,0.3527466682951291,
-≥3,10000,ocrbench_ocrbench_accuracy,0.577,
-≥3,10000,seedbench_seed_all,0.5703724291272929,
-≥3,10000,textvqa_val_exact_match,0.6030399999999999,0.006618920886575133
-≥3,11000,ai2d_exact_match,0.506800518134715,0.008998321712163861
-≥3,11000,average,0.5127105840130626,
-≥3,11000,average_rank,2.3,
-≥3,11000,chartqa_relaxed_overall,0.6676,0.009423354808471266
-≥3,11000,docvqa_val_anls,0.7155651550295605,0.005774638250173171
-≥3,11000,infovqa_val_anls,0.2960078107648859,0.007491292300444957
-≥3,11000,mme_total_score,1091.2908163265306,
-≥3,11000,mmmu_val_mmmu_acc,0.31,
-≥3,11000,mmstar_average,0.3487291874190849,
-≥3,11000,ocrbench_ocrbench_accuracy,0.597,
-≥3,11000,seedbench_seed_all,0.5746525847693162,
-≥3,11000,textvqa_val_exact_match,0.59804,0.006635181746369987
-≥3,12000,ai2d_exact_match,0.5045336787564767,0.008998784170060779
-≥3,12000,average,0.5136574673989756,
-≥3,12000,average_rank,2.5,
-≥3,12000,chartqa_relaxed_overall,0.6648,0.009443095510537233
-≥3,12000,docvqa_val_anls,0.7173866974813923,0.005773853880330729
-≥3,12000,infovqa_val_anls,0.31948469442993455,0.007793312195447671
-≥3,12000,mme_total_score,1082.547619047619,
-≥3,12000,mmmu_val_mmmu_acc,0.29889,
-≥3,12000,mmstar_average,0.3472872054060228,
-≥3,12000,ocrbench_ocrbench_accuracy,0.593,
-≥3,12000,seedbench_seed_all,0.5748749305169538,
-≥3,12000,textvqa_val_exact_match,0.6026600000000001,0.006626535072978538
-≥3,13000,ai2d_exact_match,0.4996761658031088,0.008999152231809674
-≥3,13000,average,0.5115591424915379,
-≥3,13000,average_rank,3.0,
-≥3,13000,chartqa_relaxed_overall,0.668,0.009420504145710235
-≥3,13000,docvqa_val_anls,0.7201586562486062,0.005765862770757432
-≥3,13000,infovqa_val_anls,0.30087605763050673,0.007444543350447085
-≥3,13000,mme_total_score,1142.0209083633454,
-≥3,13000,mmmu_val_mmmu_acc,0.31333,
-≥3,13000,mmstar_average,0.35413412647702824,
-≥3,13000,ocrbench_ocrbench_accuracy,0.568,
-≥3,13000,seedbench_seed_all,0.5750972762645914,
-≥3,13000,textvqa_val_exact_match,0.60476,0.0066167835724745445
-≥3,14000,ai2d_exact_match,0.5051813471502591,0.008998670917263325
-≥3,14000,average,0.512283584996583,
-≥3,14000,average_rank,2.9,
-≥3,14000,chartqa_relaxed_overall,0.6748,0.009370864914387439
-≥3,14000,docvqa_val_anls,0.7235575236423071,0.0057268410738261786
-≥3,14000,infovqa_val_anls,0.30893243437607226,0.007712373578271492
-≥3,14000,mme_total_score,1159.9943977591035,
-≥3,14000,mmmu_val_mmmu_acc,0.29667,
-≥3,14000,mmstar_average,0.3421543616905478,
-≥3,14000,ocrbench_ocrbench_accuracy,0.576,
-≥3,14000,seedbench_seed_all,0.5778765981100611,
-≥3,14000,textvqa_val_exact_match,0.6053799999999999,0.006612545370071516
-≥3,15000,ai2d_exact_match,0.501619170984456,0.00899910693271464
-≥3,15000,average,0.5157692661333466,
-≥3,15000,average_rank,2.6,
-≥3,15000,chartqa_relaxed_overall,0.6836,0.009303280948921504
-≥3,15000,docvqa_val_anls,0.7289675184474169,0.005688711489562826
-≥3,15000,infovqa_val_anls,0.31447779168584217,0.0076280570930290885
-≥3,15000,mme_total_score,1129.2125850340135,
-≥3,15000,mmmu_val_mmmu_acc,0.31222,
-≥3,15000,mmstar_average,0.35035142103070877,
-≥3,15000,ocrbench_ocrbench_accuracy,0.563,
-≥3,15000,seedbench_seed_all,0.5774874930516953,
-≥3,15000,textvqa_val_exact_match,0.6102,0.006593260666562748
-≥3,16000,ai2d_exact_match,0.506800518134715,0.00899832171216386
-≥3,16000,average,0.5182958246289815,
-≥3,16000,average_rank,2.5,
-≥3,16000,chartqa_relaxed_overall,0.674,0.009376820884924869
-≥3,16000,docvqa_val_anls,0.7332718536740643,0.005664165532854214
-≥3,16000,infovqa_val_anls,0.3097055695251213,0.007564531791761635
-≥3,16000,mme_total_score,1158.8010204081631,
-≥3,16000,mmmu_val_mmmu_acc,0.30889,
-≥3,16000,mmstar_average,0.3535555364692335,
-≥3,16000,ocrbench_ocrbench_accuracy,0.588,
-≥3,16000,seedbench_seed_all,0.5780989438576987,
-≥3,16000,textvqa_val_exact_match,0.61234,0.006584482968555135
-≥3,17000,ai2d_exact_match,0.4990284974093264,0.008999137132137064
-≥3,17000,average,0.517538300624539,
-≥3,17000,average_rank,2.8,
-≥3,17000,chartqa_relaxed_overall,0.6736,0.009379787213112317
-≥3,17000,docvqa_val_anls,0.7343487873475517,0.005650745093023672
-≥3,17000,infovqa_val_anls,0.30023060019445785,0.007383738588396597
-≥3,17000,mme_total_score,1158.095238095238,
-≥3,17000,mmmu_val_mmmu_acc,0.31222,
-≥3,17000,mmstar_average,0.3493043581903593,
-≥3,17000,ocrbench_ocrbench_accuracy,0.594,
-≥3,17000,seedbench_seed_all,0.5784324624791551,
-≥3,17000,textvqa_val_exact_match,0.61668,0.0065583044906102304
-≥3,18000,ai2d_exact_match,0.5058290155440415,0.008998542562369287
-≥3,18000,average,0.5182210734972332,
-≥3,18000,average_rank,2.5,
-≥3,18000,chartqa_relaxed_overall,0.674,0.009376820884924869
-≥3,18000,docvqa_val_anls,0.7287326909630594,0.005700735629180951
-≥3,18000,infovqa_val_anls,0.30100700787702633,0.007386740457934267
-≥3,18000,mme_total_score,1175.5579231692677,
-≥3,18000,mmmu_val_mmmu_acc,0.32,
-≥3,18000,mmstar_average,0.34714462691309605,
-≥3,18000,ocrbench_ocrbench_accuracy,0.6,
-≥3,18000,seedbench_seed_all,0.5773763201778765,
-≥3,18000,textvqa_val_exact_match,0.6099,0.006589801445917723
-≥3,19000,ai2d_exact_match,0.5045336787564767,0.008998784170060777
-≥3,19000,average,0.5187824665863345,
-≥3,19000,average_rank,2.7,
-≥3,19000,chartqa_relaxed_overall,0.6768,0.009355838641547569
-≥3,19000,docvqa_val_anls,0.7340665543774125,0.005662673189593881
-≥3,19000,infovqa_val_anls,0.3094998838176309,0.007498739242965892
-≥3,19000,mme_total_score,1173.1207482993198,
-≥3,19000,mmmu_val_mmmu_acc,0.30444,
-≥3,19000,mmstar_average,0.34505224352615843,
-≥3,19000,ocrbench_ocrbench_accuracy,0.597,
-≥3,19000,seedbench_seed_all,0.5777098387993329,
-≥3,19000,textvqa_val_exact_match,0.6199399999999999,0.0065535844523310115
-≥3,20000,ai2d_exact_match,0.4944948186528497,0.008998608627616674
-≥3,20000,average,0.5158935311436484,
-≥3,20000,average_rank,2.2,
-≥3,20000,chartqa_relaxed_overall,0.6788,0.00934061683451043
-≥3,20000,docvqa_val_anls,0.7330651042103438,0.0056772111451400455
-≥3,20000,infovqa_val_anls,0.2964558374276726,0.007412691037826716
-≥3,20000,mme_total_score,1203.7891156462586,
-≥3,20000,mmmu_val_mmmu_acc,0.31556,
-≥3,20000,mmstar_average,0.3448737131648378,
-≥3,20000,ocrbench_ocrbench_accuracy,0.592,
-≥3,20000,seedbench_seed_all,0.5741523068371317,
-≥3,20000,textvqa_val_exact_match,0.6136400000000001,0.006578650759020563
-≥4,1000,ai2d_exact_match,0.46599740932642486,0.008978320789223164
-≥4,1000,average,0.4810433130994131,
-≥4,1000,average_rank,3.0,
-≥4,1000,chartqa_relaxed_overall,0.6364,0.009622632385247222
-≥4,1000,docvqa_val_anls,0.6731681544556957,0.005980246808815758
-≥4,1000,infovqa_val_anls,0.273064875980351,0.007121239402495689
-≥4,1000,mme_total_score,1069.875850340136,
-≥4,1000,mmmu_val_mmmu_acc,0.28889,
-≥4,1000,mmstar_average,0.35232408630345313,
-≥4,1000,ocrbench_ocrbench_accuracy,0.54,
-≥4,1000,seedbench_seed_all,0.5455252918287937,
-≥4,1000,textvqa_val_exact_match,0.5540200000000001,0.006743431077169729
-≥4,2000,ai2d_exact_match,0.4579015544041451,0.00896719935987288
-≥4,2000,average,0.4733427752805117,
-≥4,2000,average_rank,4.1,
-≥4,2000,chartqa_relaxed_overall,0.6368,0.009620359896064799
-≥4,2000,docvqa_val_anls,0.6685623057181342,0.006022846398992095
-≥4,2000,infovqa_val_anls,0.2586347697028306,0.006939507684848232
-≥4,2000,mme_total_score,1037.0391156462586,
-≥4,2000,mmmu_val_mmmu_acc,0.27778,
-≥4,2000,mmstar_average,0.3426833682664769,
-≥4,2000,ocrbench_ocrbench_accuracy,0.517,
-≥4,2000,seedbench_seed_all,0.5533629794330184,
-≥4,2000,textvqa_val_exact_match,0.5473600000000001,0.006769325729654826
-≥4,3000,ai2d_exact_match,0.4724740932642487,0.008985506893308395
-≥4,3000,average,0.48486620292260835,
-≥4,3000,average_rank,3.1,
-≥4,3000,chartqa_relaxed_overall,0.648,0.009553790345406665
-≥4,3000,docvqa_val_anls,0.6797920414745026,0.0059259219910189455
-≥4,3000,infovqa_val_anls,0.25291991664683544,0.0068990348571168
-≥4,3000,mme_total_score,989.6139455782312,
-≥4,3000,mmmu_val_mmmu_acc,0.31889,
-≥4,3000,mmstar_average,0.359381486980145,
-≥4,3000,ocrbench_ocrbench_accuracy,0.528,
-≥4,3000,seedbench_seed_all,0.5529182879377432,
-≥4,3000,textvqa_val_exact_match,0.55142,0.006751052663282407
-≥4,4000,ai2d_exact_match,0.48704663212435234,0.008996133680935945
-≥4,4000,average,0.4833844903828087,
-≥4,4000,average_rank,3.6,
-≥4,4000,chartqa_relaxed_overall,0.634,0.00963611653607192
-≥4,4000,docvqa_val_anls,0.6872369707367743,0.005902275856072045
-≥4,4000,infovqa_val_anls,0.26951247528968925,0.007084476663871501
-≥4,4000,mme_total_score,943.8639455782313,
-≥4,4000,mmmu_val_mmmu_acc,0.28556,
-≥4,4000,mmstar_average,0.3561252135601649,
-≥4,4000,ocrbench_ocrbench_accuracy,0.525,
-≥4,4000,seedbench_seed_all,0.5544191217342969,
-≥4,4000,textvqa_val_exact_match,0.55156,0.006755726552211068
-≥4,5000,ai2d_exact_match,0.4944948186528497,0.008998608627616672
-≥4,5000,average,0.4902778679880179,
-≥4,5000,average_rank,3.2,
-≥4,5000,chartqa_relaxed_overall,0.6524,0.009526069199715017
-≥4,5000,docvqa_val_anls,0.6838821393578449,0.005934519981948664
-≥4,5000,infovqa_val_anls,0.2885173111410286,0.007387917761485684
-≥4,5000,mme_total_score,877.7568027210884,
-≥4,5000,mmmu_val_mmmu_acc,0.28222,
-≥4,5000,mmstar_average,0.3491170485770135,
-≥4,5000,ocrbench_ocrbench_accuracy,0.543,
-≥4,5000,seedbench_seed_all,0.5610894941634241,
-≥4,5000,textvqa_val_exact_match,0.55778,0.006740043023304169
-≥4,6000,ai2d_exact_match,0.47830310880829013,0.008990677331728418
-≥4,6000,average,0.49160704402561856,
-≥4,6000,average_rank,3.2,
-≥4,6000,chartqa_relaxed_overall,0.6524,0.009526069199715017
-≥4,6000,docvqa_val_anls,0.6895610098990497,0.005895883993977457
-≥4,6000,infovqa_val_anls,0.29445466931250164,0.007468796422091737
-≥4,6000,mme_total_score,959.8639455782312,
-≥4,6000,mmmu_val_mmmu_acc,0.29889,
-≥4,6000,mmstar_average,0.33644817130133137,
-≥4,6000,ocrbench_ocrbench_accuracy,0.56,
-≥4,6000,seedbench_seed_all,0.5555864369093941,
-≥4,6000,textvqa_val_exact_match,0.5588199999999999,0.006728260950578821
-≥4,7000,ai2d_exact_match,0.5006476683937824,0.008999146569435549
-≥4,7000,average,0.4896016595164798,
-≥4,7000,average_rank,3.4,
-≥4,7000,chartqa_relaxed_overall,0.6572,0.009494805133851454
-≥4,7000,docvqa_val_anls,0.6893686651094205,0.0058969034940001145
-≥4,7000,infovqa_val_anls,0.2859893612299588,0.00729316403263038
-≥4,7000,mme_total_score,927.2312925170069,
-≥4,7000,mmmu_val_mmmu_acc,0.29222,
-≥4,7000,mmstar_average,0.3472936989473972,
-≥4,7000,ocrbench_ocrbench_accuracy,0.519,
-≥4,7000,seedbench_seed_all,0.5559755419677599,
-≥4,7000,textvqa_val_exact_match,0.55872,0.0067301301064875444
-≥4,8000,ai2d_exact_match,0.4731217616580311,0.008986142019669732
-≥4,8000,average,0.492078815307747,
-≥4,8000,average_rank,3.5,
-≥4,8000,chartqa_relaxed_overall,0.6676,0.009423354808471266
-≥4,8000,docvqa_val_anls,0.6925495561792242,0.005900020554879468
-≥4,8000,infovqa_val_anls,0.2810222429209379,0.007207972787105912
-≥4,8000,mme_total_score,848.2908163265306,
-≥4,8000,mmmu_val_mmmu_acc,0.31333,
-≥4,8000,mmstar_average,0.350192703081569,
-≥4,8000,ocrbench_ocrbench_accuracy,0.529,
-≥4,8000,seedbench_seed_all,0.5595330739299611,
-≥4,8000,textvqa_val_exact_match,0.56236,0.006739267736625781
-≥4,9000,ai2d_exact_match,0.48737046632124353,0.0089962828388782
-≥4,9000,average,0.49234565866208857,
-≥4,9000,average_rank,4.1,
-≥4,9000,chartqa_relaxed_overall,0.6608,0.009470650520873179
-≥4,9000,docvqa_val_anls,0.6999407172900073,0.0058399608509493465
-≥4,9000,infovqa_val_anls,0.28057597856713984,0.0072085582760555555
-≥4,9000,mme_total_score,971.6003401360543,
-≥4,9000,mmmu_val_mmmu_acc,0.28111,
-≥4,9000,mmstar_average,0.3444424817337138,
-≥4,9000,ocrbench_ocrbench_accuracy,0.545,
-≥4,9000,seedbench_seed_all,0.5603112840466926,
-≥4,9000,textvqa_val_exact_match,0.5715600000000001,0.006710949310502175
-≥4,10000,ai2d_exact_match,0.5009715025906736,0.008999137132137068
-≥4,10000,average,0.5030450627246211,
-≥4,10000,average_rank,3.3,
-≥4,10000,chartqa_relaxed_overall,0.666,0.009434680984649817
-≥4,10000,docvqa_val_anls,0.7128440324276674,0.005793211438464534
-≥4,10000,infovqa_val_anls,0.28379375750066616,0.007201019014370097
-≥4,10000,mme_total_score,823.7772108843537,
-≥4,10000,mmmu_val_mmmu_acc,0.30444,
-≥4,10000,mmstar_average,0.35617504910097153,
-≥4,10000,ocrbench_ocrbench_accuracy,0.563,
-≥4,10000,seedbench_seed_all,0.562201222901612,
-≥4,10000,textvqa_val_exact_match,0.57798,0.00669581889824864
-≥4,11000,ai2d_exact_match,0.4899611398963731,0.008997340090107678
-≥4,11000,average,0.5043945508574572,
-≥4,11000,average_rank,3.7,
-≥4,11000,chartqa_relaxed_overall,0.6684,0.009417645821601513
-≥4,11000,docvqa_val_anls,0.718360308980877,0.00573640855634517
-≥4,11000,infovqa_val_anls,0.3061911172660032,0.007586892248142986
-≥4,11000,mme_total_score,913.9846938775511,
-≥4,11000,mmmu_val_mmmu_acc,0.30444,
-≥4,11000,mmstar_average,0.3441847617795319,
-≥4,11000,ocrbench_ocrbench_accuracy,0.572,
-≥4,11000,seedbench_seed_all,0.5605336297943302,
-≥4,11000,textvqa_val_exact_match,0.5754799999999999,0.006700024775058468
-≥4,12000,ai2d_exact_match,0.48737046632124353,0.0089962828388782
-≥4,12000,average,0.5040020270755444,
-≥4,12000,average_rank,3.7,
-≥4,12000,chartqa_relaxed_overall,0.6708,0.009400334595970852
-≥4,12000,docvqa_val_anls,0.7119962267424205,0.0057890771916119035
-≥4,12000,infovqa_val_anls,0.29271378410211696,0.007308133874246768
-≥4,12000,mme_total_score,857.7363945578231,
-≥4,12000,mmmu_val_mmmu_acc,0.31333,
-≥4,12000,mmstar_average,0.3366375608443022,
-≥4,12000,ocrbench_ocrbench_accuracy,0.578,
-≥4,12000,seedbench_seed_all,0.5663702056698166,
-≥4,12000,textvqa_val_exact_match,0.5788,0.006686093984573812
-≥4,13000,ai2d_exact_match,0.5029145077720207,0.008999001233939135
-≥4,13000,average,0.5025324527027837,
-≥4,13000,average_rank,3.8,
-≥4,13000,chartqa_relaxed_overall,0.6736,0.009379787213112317
-≥4,13000,docvqa_val_anls,0.7115068932890629,0.0057865061972425
-≥4,13000,infovqa_val_anls,0.28657766964072817,0.007222563686487699
-≥4,13000,mme_total_score,912.2363945578231,
-≥4,13000,mmmu_val_mmmu_acc,0.30222,
-≥4,13000,mmstar_average,0.35323329267271303,
-≥4,13000,ocrbench_ocrbench_accuracy,0.548,
-≥4,13000,seedbench_seed_all,0.5634797109505281,
-≥4,13000,textvqa_val_exact_match,0.58126,0.006685319826323647
-≥4,14000,ai2d_exact_match,0.5029145077720207,0.008999001233939133
-≥4,14000,average,0.5048464815785578,
-≥4,14000,average_rank,3.7,
-≥4,14000,chartqa_relaxed_overall,0.6836,0.009303280948921504
-≥4,14000,docvqa_val_anls,0.7158797575412708,0.005776895411277372
-≥4,14000,infovqa_val_anls,0.2977244895971059,0.007409958547797003
-≥4,14000,mme_total_score,863.687074829932,
-≥4,14000,mmmu_val_mmmu_acc,0.30111,
-≥4,14000,mmstar_average,0.33994823410485003,
-≥4,14000,ocrbench_ocrbench_accuracy,0.562,
-≥4,14000,seedbench_seed_all,0.5584213451917732,
-≥4,14000,textvqa_val_exact_match,0.58202,0.0066807687023343965
-≥4,15000,ai2d_exact_match,0.5123056994818653,0.008996428218289531
-≥4,15000,average,0.5109092566320045,
-≥4,15000,average_rank,3.5,
-≥4,15000,chartqa_relaxed_overall,0.6712,0.009397422445513864
-≥4,15000,docvqa_val_anls,0.7188356324043049,0.005760252125758746
-≥4,15000,infovqa_val_anls,0.31301984081498224,0.007566633771439808
-≥4,15000,mme_total_score,910.8588435374149,
-≥4,15000,mmmu_val_mmmu_acc,0.31333,
-≥4,15000,mmstar_average,0.3405171175316349,
-≥4,15000,ocrbench_ocrbench_accuracy,0.57,
-≥4,15000,seedbench_seed_all,0.5630350194552529,
-≥4,15000,textvqa_val_exact_match,0.59594,0.006638698497713893
-≥4,16000,ai2d_exact_match,0.5035621761658031,0.008998925734053562
-≥4,16000,average,0.5129618260818141,
-≥4,16000,average_rank,3.5,
-≥4,16000,chartqa_relaxed_overall,0.6816,0.00931897598051042
-≥4,16000,docvqa_val_anls,0.721094250093947,0.005753477697941139
-≥4,16000,infovqa_val_anls,0.3169075222245947,0.007639057821423446
-≥4,16000,mme_total_score,900.3299319727892,
-≥4,16000,mmmu_val_mmmu_acc,0.30222,
-≥4,16000,mmstar_average,0.34176931782507797,
-≥4,16000,ocrbench_ocrbench_accuracy,0.588,
-≥4,16000,seedbench_seed_all,0.5657031684269038,
-≥4,16000,textvqa_val_exact_match,0.5958,0.006635034041762488
-≥4,17000,ai2d_exact_match,0.49190414507772023,0.008997974381217109
-≥4,17000,average,0.5093728538878098,
-≥4,17000,average_rank,3.7,
-≥4,17000,chartqa_relaxed_overall,0.68,0.009331389496316869
-≥4,17000,docvqa_val_anls,0.7210491309814,0.005753367994292813
-≥4,17000,infovqa_val_anls,0.3201561983029552,0.007662267005009952
-≥4,17000,mme_total_score,877.8401360544218,
-≥4,17000,mmmu_val_mmmu_acc,0.30778,
-≥4,17000,mmstar_average,0.3348906353085911,
-≥4,17000,ocrbench_ocrbench_accuracy,0.573,
-≥4,17000,seedbench_seed_all,0.564035575319622,
-≥4,17000,textvqa_val_exact_match,0.59154,0.006655985735352941
-≥4,18000,ai2d_exact_match,0.49028497409326427,0.008997455247470554
-≥4,18000,average,0.5099416307525485,
-≥4,18000,average_rank,3.7,
-≥4,18000,chartqa_relaxed_overall,0.6788,0.00934061683451043
-≥4,18000,docvqa_val_anls,0.7282528158071215,0.00570007403218014
-≥4,18000,infovqa_val_anls,0.3087200968720397,0.007513490264469946
-≥4,18000,mme_total_score,929.9506802721088,
-≥4,18000,mmmu_val_mmmu_acc,0.30111,
-≥4,18000,mmstar_average,0.342890936748704,
-≥4,18000,ocrbench_ocrbench_accuracy,0.585,
-≥4,18000,seedbench_seed_all,0.5645358532518066,
-≥4,18000,textvqa_val_exact_match,0.5898800000000001,0.006662761859703513
-≥4,19000,ai2d_exact_match,0.49417098445595853,0.008998542562369278
-≥4,19000,average,0.5124245876024062,
-≥4,19000,average_rank,3.7,
-≥4,19000,chartqa_relaxed_overall,0.6752,0.00936787525721462
-≥4,19000,docvqa_val_anls,0.7321651331177514,0.005674418458926489
-≥4,19000,infovqa_val_anls,0.3128382816486564,0.007545062449451713
-≥4,19000,mme_total_score,920.5612244897959,
-≥4,19000,mmmu_val_mmmu_acc,0.31444,
-≥4,19000,mmstar_average,0.3381960053749425,
-≥4,19000,ocrbench_ocrbench_accuracy,0.581,
-≥4,19000,seedbench_seed_all,0.5635908838243469,
-≥4,19000,textvqa_val_exact_match,0.60022,0.0066236821295251325
-≥4,20000,ai2d_exact_match,0.4993523316062176,0.008999146569435543
-≥4,20000,average,0.5097536365259775,
-≥4,20000,average_rank,2.9,
-≥4,20000,chartqa_relaxed_overall,0.6788,0.00934061683451043
-≥4,20000,docvqa_val_anls,0.7257805691640822,0.005714530309266441
-≥4,20000,infovqa_val_anls,0.3115295213783156,0.007581035362425172
-≥4,20000,mme_total_score,936.8911564625851,
-≥4,20000,mmmu_val_mmmu_acc,0.29333,
-≥4,20000,mmstar_average,0.342179144828651,
-≥4,20000,ocrbench_ocrbench_accuracy,0.572,
-≥4,20000,seedbench_seed_all,0.5640911617565314,
-≥4,20000,textvqa_val_exact_match,0.6007199999999999,0.00662859592800733
-≥5,1000,ai2d_exact_match,0.46275906735751293,0.008974157783087492
-≥5,1000,average,0.46601067306382465,
-≥5,1000,average_rank,4.3,
-≥5,1000,chartqa_relaxed_overall,0.586,0.009852940280589808
-≥5,1000,docvqa_val_anls,0.6587979311295683,0.006033428065938081
-≥5,1000,infovqa_val_anls,0.26573226652787757,0.007027770857338852
-≥5,1000,mme_total_score,1141.8704481792718,
-≥5,1000,mmmu_val_mmmu_acc,0.29111,
-≥5,1000,mmstar_average,0.3326633517590184,
-≥5,1000,ocrbench_ocrbench_accuracy,0.512,
-≥5,1000,seedbench_seed_all,0.5481934408004447,
-≥5,1000,textvqa_val_exact_match,0.53684,0.0067933638823904985
-≥5,2000,ai2d_exact_match,0.46729274611398963,0.008979879527453428
-≥5,2000,average,0.46843615619784085,
-≥5,2000,average_rank,4.5,
-≥5,2000,chartqa_relaxed_overall,0.6232,0.009693621125059844
-≥5,2000,docvqa_val_anls,0.6576303662245503,0.0060380542666198
-≥5,2000,infovqa_val_anls,0.2544768002153279,0.006980921578600097
-≥5,2000,mme_total_score,1121.454081632653,
-≥5,2000,mmmu_val_mmmu_acc,0.28333,
-≥5,2000,mmstar_average,0.3471972386408189,
-≥5,2000,ocrbench_ocrbench_accuracy,0.517,
-≥5,2000,seedbench_seed_all,0.544858254585881,
-≥5,2000,textvqa_val_exact_match,0.52094,0.006790900275023118
-≥5,3000,ai2d_exact_match,0.405440414507772,0.00883675667187808
-≥5,3000,average,0.46118026257153605,
-≥5,3000,average_rank,4.2,
-≥5,3000,chartqa_relaxed_overall,0.6156,0.009731008838409575
-≥5,3000,docvqa_val_anls,0.6431483265654762,0.0060571462869005105
-≥5,3000,infovqa_val_anls,0.25688718356638174,0.007171420821325129
-≥5,3000,mme_total_score,1082.7074829931973,
-≥5,3000,mmmu_val_mmmu_acc,0.29778,
-≥5,3000,mmstar_average,0.3516979671312099,
-≥5,3000,ocrbench_ocrbench_accuracy,0.521,
-≥5,3000,seedbench_seed_all,0.547248471372985,
-≥5,3000,textvqa_val_exact_match,0.51182,0.006815757362882421
-≥5,4000,ai2d_exact_match,0.4491580310880829,0.008952509302111547
-≥5,4000,average,0.4646276743863569,
-≥5,4000,average_rank,4.7,
-≥5,4000,chartqa_relaxed_overall,0.626,0.009679208378267924
-≥5,4000,docvqa_val_anls,0.6457409563970327,0.006096190550822001
-≥5,4000,infovqa_val_anls,0.2657314142312884,0.007188343779485259
-≥5,4000,mme_total_score,1068.4183673469388,
-≥5,4000,mmmu_val_mmmu_acc,0.30333,
-≥5,4000,mmstar_average,0.33033606075691685,
-≥5,4000,ocrbench_ocrbench_accuracy,0.501,
-≥5,4000,seedbench_seed_all,0.546692607003891,
-≥5,4000,textvqa_val_exact_match,0.5136599999999999,0.006800789000270868
-≥5,5000,ai2d_exact_match,0.4630829015544041,0.008974591204222938
-≥5,5000,average,0.47175640838182836,
-≥5,5000,average_rank,4.3,
-≥5,5000,chartqa_relaxed_overall,0.6016,0.009793331391099473
-≥5,5000,docvqa_val_anls,0.6583943642704193,0.006028435004183156
-≥5,5000,infovqa_val_anls,0.28445442343834715,0.007395809557151278
-≥5,5000,mme_total_score,1063.6232492997199,
-≥5,5000,mmmu_val_mmmu_acc,0.30111,
-≥5,5000,mmstar_average,0.34898828745177285,
-≥5,5000,ocrbench_ocrbench_accuracy,0.524,
-≥5,5000,seedbench_seed_all,0.5438576987215119,
-≥5,5000,textvqa_val_exact_match,0.52032,0.006801255099919928
-≥5,6000,ai2d_exact_match,0.41936528497409326,0.008881358943343104
-≥5,6000,average,0.4607787848869989,
-≥5,6000,average_rank,4.3,
-≥5,6000,chartqa_relaxed_overall,0.5688,0.009906860368095493
-≥5,6000,docvqa_val_anls,0.6530464526768891,0.006064278476677726
-≥5,6000,infovqa_val_anls,0.2838075612518576,0.007411753553258339
-≥5,6000,mme_total_score,1102.3075230092036,
-≥5,6000,mmmu_val_mmmu_acc,0.30222,
-≥5,6000,mmstar_average,0.3384709546298998,
-≥5,6000,ocrbench_ocrbench_accuracy,0.514,
-≥5,6000,seedbench_seed_all,0.5458588104502501,
-≥5,6000,textvqa_val_exact_match,0.52144,0.006795447071398616
-≥5,7000,ai2d_exact_match,0.44689119170984454,0.008948245073044946
-≥5,7000,average,0.46361553646961884,
-≥5,7000,average_rank,4.8,
-≥5,7000,chartqa_relaxed_overall,0.596,0.009815912634917984
-≥5,7000,docvqa_val_anls,0.6473018376832792,0.00607167873881633
-≥5,7000,infovqa_val_anls,0.2701993608610082,0.007205660851186524
-≥5,7000,mme_total_score,1018.4163665466186,
-≥5,7000,mmmu_val_mmmu_acc,0.30556,
-≥5,7000,mmstar_average,0.33545236293074815,
-≥5,7000,ocrbench_ocrbench_accuracy,0.512,
-≥5,7000,seedbench_seed_all,0.5431350750416898,
-≥5,7000,textvqa_val_exact_match,0.516,0.006822412261202951
-≥5,8000,ai2d_exact_match,0.4488341968911917,0.008951911635408226
-≥5,8000,average,0.4668616879585074,
-≥5,8000,average_rank,4.6,
-≥5,8000,chartqa_relaxed_overall,0.6072,0.00976941352263433
-≥5,8000,docvqa_val_anls,0.6519934800658986,0.006080604378776126
-≥5,8000,infovqa_val_anls,0.2785842294592336,0.0074156607313128845
-≥5,8000,mme_total_score,1057.0833333333333,
-≥5,8000,mmmu_val_mmmu_acc,0.30333,
-≥5,8000,mmstar_average,0.3378731184509322,
-≥5,8000,ocrbench_ocrbench_accuracy,0.518,
-≥5,8000,seedbench_seed_all,0.5403001667593107,
-≥5,8000,textvqa_val_exact_match,0.51564,0.006799847473666819
-≥5,9000,ai2d_exact_match,0.39345854922279794,0.008792480650628204
-≥5,9000,average,0.459912532971243,
-≥5,9000,average_rank,4.4,
-≥5,9000,chartqa_relaxed_overall,0.6084,0.00976411343463736
-≥5,9000,docvqa_val_anls,0.6541887939771373,0.006063084097609983
-≥5,9000,infovqa_val_anls,0.27276949319611876,0.007319733478874126
-≥5,9000,mme_total_score,1123.0184073629453,
-≥5,9000,mmmu_val_mmmu_acc,0.32333,
-≥5,9000,mmstar_average,0.3247860715180074,
-≥5,9000,ocrbench_ocrbench_accuracy,0.509,
-≥5,9000,seedbench_seed_all,0.5397998888271262,
-≥5,9000,textvqa_val_exact_match,0.51348,0.006813467735926963
-≥5,10000,ai2d_exact_match,0.4326424870466321,0.008917121282993509
-≥5,10000,average,0.46134428795967075,
-≥5,10000,average_rank,4.9,
-≥5,10000,chartqa_relaxed_overall,0.6072,0.00976941352263433
-≥5,10000,docvqa_val_anls,0.651687815510166,0.006071913532526164
-≥5,10000,infovqa_val_anls,0.27997237091892013,0.007395864137910542
-≥5,10000,mme_total_score,1022.3228291316527,
-≥5,10000,mmmu_val_mmmu_acc,0.28889,
-≥5,10000,mmstar_average,0.329809486810568,
-≥5,10000,ocrbench_ocrbench_accuracy,0.511,
-≥5,10000,seedbench_seed_all,0.5375764313507504,
-≥5,10000,textvqa_val_exact_match,0.51332,0.006823388252580171
-≥5,11000,ai2d_exact_match,0.4268134715025907,0.008902228386480452
-≥5,11000,average,0.46104097512732234,
-≥5,11000,average_rank,4.5,
-≥5,11000,chartqa_relaxed_overall,0.6012,0.0097949885513097
-≥5,11000,docvqa_val_anls,0.644837445168982,0.006085623472495874
-≥5,11000,infovqa_val_anls,0.2640855729780956,0.007198720155523597
-≥5,11000,mme_total_score,1039.019507803121,
-≥5,11000,mmmu_val_mmmu_acc,0.30889,
-≥5,11000,mmstar_average,0.3483796516991238,
-≥5,11000,ocrbench_ocrbench_accuracy,0.509,
-≥5,11000,seedbench_seed_all,0.5367426347971095,
-≥5,11000,textvqa_val_exact_match,0.50942,0.00682319308775463
-≥5,12000,ai2d_exact_match,0.3944300518134715,0.008796275864065532
-≥5,12000,average,0.4536626915651331,
-≥5,12000,average_rank,4.5,
-≥5,12000,chartqa_relaxed_overall,0.5772,0.009882060820012199
-≥5,12000,docvqa_val_anls,0.6559090016447592,0.00604562177320508
-≥5,12000,infovqa_val_anls,0.2673016323091914,0.0072722156919221015
-≥5,12000,mme_total_score,1023.3735494197679,
-≥5,12000,mmmu_val_mmmu_acc,0.31778,
-≥5,12000,mmstar_average,0.3313831269791424,
-≥5,12000,ocrbench_ocrbench_accuracy,0.505,
-≥5,12000,seedbench_seed_all,0.5327404113396331,
-≥5,12000,textvqa_val_exact_match,0.50122,0.006832030272732221
-≥5,13000,ai2d_exact_match,0.40867875647668395,0.00884778289870742
-≥5,13000,average,0.45776989353761316,
-≥5,13000,average_rank,4.6,
-≥5,13000,chartqa_relaxed_overall,0.5908,0.009835692163550793
-≥5,13000,docvqa_val_anls,0.6503688245286325,0.0060676446684505315
-≥5,13000,infovqa_val_anls,0.2636657235502622,0.007162177374827191
-≥5,13000,mme_total_score,1002.4256702681073,
-≥5,13000,mmmu_val_mmmu_acc,0.31556,
-≥5,13000,mmstar_average,0.3443129801956691,
-≥5,13000,ocrbench_ocrbench_accuracy,0.512,
-≥5,13000,seedbench_seed_all,0.5329627570872707,
-≥5,13000,textvqa_val_exact_match,0.50158,0.006823401826251807
-≥5,14000,ai2d_exact_match,0.41483160621761656,0.008867639612484149
-≥5,14000,average,0.45268439675941724,
-≥5,14000,average_rank,4.8,
-≥5,14000,chartqa_relaxed_overall,0.588,0.009845871036662436
-≥5,14000,docvqa_val_anls,0.6498549577427524,0.006073551423686328
-≥5,14000,infovqa_val_anls,0.2661623211050356,0.00731739457874179
-≥5,14000,mme_total_score,1034.9393757503,
-≥5,14000,mmmu_val_mmmu_acc,0.3,
-≥5,14000,mmstar_average,0.3342054606442816,
-≥5,14000,ocrbench_ocrbench_accuracy,0.494,
-≥5,14000,seedbench_seed_all,0.5294052251250695,
-≥5,14000,textvqa_val_exact_match,0.4977,0.006830920457365827
-≥5,15000,ai2d_exact_match,0.42001295336787564,0.008883255931688048
-≥5,15000,average,0.4570450291018434,
-≥5,15000,average_rank,4.9,
-≥5,15000,chartqa_relaxed_overall,0.59,0.009838634025503496
-≥5,15000,docvqa_val_anls,0.6475057079650752,0.006081599544786637
-≥5,15000,infovqa_val_anls,0.26732840510253686,0.007267222145742162
-≥5,15000,mme_total_score,1033.4811924769908,
-≥5,15000,mmmu_val_mmmu_acc,0.30667,
-≥5,15000,mmstar_average,0.33017343172346,
-≥5,15000,ocrbench_ocrbench_accuracy,0.516,
-≥5,15000,seedbench_seed_all,0.5345747637576431,
-≥5,15000,textvqa_val_exact_match,0.5011399999999999,0.006833438318727342
-≥5,16000,ai2d_exact_match,0.41353626943005184,0.008863577928878446
-≥5,16000,average,0.45298319741394405,
-≥5,16000,average_rank,4.9,
-≥5,16000,chartqa_relaxed_overall,0.5928,0.00982821965366181
-≥5,16000,docvqa_val_anls,0.6444827949953511,0.006083163064354419
-≥5,16000,infovqa_val_anls,0.27176255535031313,0.0073933278275316846
-≥5,16000,mme_total_score,1004.6780712284915,
-≥5,16000,mmmu_val_mmmu_acc,0.30111,
-≥5,16000,mmstar_average,0.32864449435945237,
-≥5,16000,ocrbench_ocrbench_accuracy,0.502,
-≥5,16000,seedbench_seed_all,0.526792662590328,
-≥5,16000,textvqa_val_exact_match,0.49572000000000005,0.006835033273947625
-≥5,17000,ai2d_exact_match,0.4112694300518135,0.008856317823411107
-≥5,17000,average,0.4529560838437233,
-≥5,17000,average_rank,4.6,
-≥5,17000,chartqa_relaxed_overall,0.5876,0.009847298295140926
-≥5,17000,docvqa_val_anls,0.6389774022522821,0.00612389508858012
-≥5,17000,infovqa_val_anls,0.2806511079053113,0.007508796510654168
-≥5,17000,mme_total_score,995.327831132453,
-≥5,17000,mmmu_val_mmmu_acc,0.31333,
-≥5,17000,mmstar_average,0.33458844306670454,
-≥5,17000,ocrbench_ocrbench_accuracy,0.496,
-≥5,17000,seedbench_seed_all,0.5230683713173986,
-≥5,17000,textvqa_val_exact_match,0.49112,0.006832742230852753
-≥5,18000,ai2d_exact_match,0.41936528497409326,0.008881358943343104
-≥5,18000,average,0.4506952703715631,
-≥5,18000,average_rank,4.6,
-≥5,18000,chartqa_relaxed_overall,0.5752,0.009888230116554488
-≥5,18000,docvqa_val_anls,0.6393690836463973,0.006115883377355433
-≥5,18000,infovqa_val_anls,0.26588334023973736,0.007337010225614936
-≥5,18000,mme_total_score,989.2097839135654,
-≥5,18000,mmmu_val_mmmu_acc,0.31333,
-≥5,18000,mmstar_average,0.32322974671841465,
-≥5,18000,ocrbench_ocrbench_accuracy,0.498,
-≥5,18000,seedbench_seed_all,0.5279599777654252,
-≥5,18000,textvqa_val_exact_match,0.49391999999999997,0.006830895911063903
-≥5,19000,ai2d_exact_match,0.3954015544041451,0.008800034697838395
-≥5,19000,average,0.44423744725800945,
-≥5,19000,average_rank,4.9,
-≥5,19000,chartqa_relaxed_overall,0.5744,0.009890651444389179
-≥5,19000,docvqa_val_anls,0.6275859067200067,0.006146304949422434
-≥5,19000,infovqa_val_anls,0.27001013621966435,0.00741081345045112
-≥5,19000,mme_total_score,1012.671468587435,
-≥5,19000,mmmu_val_mmmu_acc,0.30222,
-≥5,19000,mmstar_average,0.33172139573813564,
-≥5,19000,ocrbench_ocrbench_accuracy,0.489,
-≥5,19000,seedbench_seed_all,0.5244580322401334,
-≥5,19000,textvqa_val_exact_match,0.48334000000000005,0.006839754771120511
-≥5,20000,ai2d_exact_match,0.3950777202072539,0.00879878579254534
-≥5,20000,average,0.44700580037620813,
-≥5,20000,average_rank,3.8,
-≥5,20000,chartqa_relaxed_overall,0.5824,0.009865243291986469
-≥5,20000,docvqa_val_anls,0.635044358086249,0.006123826440768213
-≥5,20000,infovqa_val_anls,0.2648967410637257,0.0073547743128100345
-≥5,20000,mme_total_score,1015.2638055222089,
-≥5,20000,mmmu_val_mmmu_acc,0.31111,
-≥5,20000,mmstar_average,0.33540590765288064,
-≥5,20000,ocrbench_ocrbench_accuracy,0.485,
-≥5,20000,seedbench_seed_all,0.5234574763757643,
-≥5,20000,textvqa_val_exact_match,0.49065999999999993,0.0068247980522276805
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca22654a0302da0ca335420b0a89cd770cea560b11f2a9f9f25927877d7ed231
+size 61626

app/src/content/assets/data/ss_vs_s1.csv

@@ -1,481 +1,3 @@
-run,step,metric,value,stderr
-Single Stage,1000,ai2d_exact_match,0.2548575129533679,0.007843322436924496
-Single Stage,1000,average,0.27120689295763617,
-Single Stage,1000,average_rank,2.0,
-Single Stage,1000,chartqa_relaxed_overall,0.3308,0.009411906161401973
-Single Stage,1000,docvqa_val_anls,0.3528553494243383,0.005852289239342309
-Single Stage,1000,infovqa_val_anls,0.17320578642581314,0.006297063452679795
-Single Stage,1000,mme_total_score,977.4280712284914,
-Single Stage,1000,mmmu_val_mmmu_acc,0.25222,
-Single Stage,1000,mmstar_average,0.23215874078908072,
-Single Stage,1000,ocrbench_ocrbench_accuracy,0.286,
-Single Stage,1000,seedbench_seed_all,0.2563646470261256,
-Single Stage,1000,textvqa_val_exact_match,0.3024,0.00628900296642181
-Single Stage,2000,ai2d_exact_match,0.26295336787564766,0.007923526907377255
-Single Stage,2000,average,0.3202068275596269,
-Single Stage,2000,average_rank,1.8,
-Single Stage,2000,chartqa_relaxed_overall,0.4688,0.009982508912777261
-Single Stage,2000,docvqa_val_anls,0.4452261510942785,0.00614755494712251
-Single Stage,2000,infovqa_val_anls,0.1820547866557169,0.006217861455795791
-Single Stage,2000,mme_total_score,1049.3036214485794,
-Single Stage,2000,mmmu_val_mmmu_acc,0.24556,
-Single Stage,2000,mmstar_average,0.21305462434540698,
-Single Stage,2000,ocrbench_ocrbench_accuracy,0.395,
-Single Stage,2000,seedbench_seed_all,0.258532518065592,
-Single Stage,2000,textvqa_val_exact_match,0.41068000000000005,0.006697862330024289
-Single Stage,3000,ai2d_exact_match,0.25226683937823835,0.007816909588794397
-Single Stage,3000,average,0.3507423834414229,
-Single Stage,3000,average_rank,1.7,
-Single Stage,3000,chartqa_relaxed_overall,0.5028,0.010001843767601082
-Single Stage,3000,docvqa_val_anls,0.502653993831009,0.006267072346683124
-Single Stage,3000,infovqa_val_anls,0.21728617578189535,0.006796941784959762
-Single Stage,3000,mme_total_score,1170.2383953581434,
-Single Stage,3000,mmmu_val_mmmu_acc,0.27556,
-Single Stage,3000,mmstar_average,0.25432376938577683,
-Single Stage,3000,ocrbench_ocrbench_accuracy,0.436,
-Single Stage,3000,seedbench_seed_all,0.2792106725958866,
-Single Stage,3000,textvqa_val_exact_match,0.43658,0.006766885462882726
-Single Stage,4000,ai2d_exact_match,0.2645725388601036,0.007939149662089447
-Single Stage,4000,average,0.36961781722974835,
-Single Stage,4000,average_rank,1.8,
-Single Stage,4000,chartqa_relaxed_overall,0.5312,0.009982508912777261
-Single Stage,4000,docvqa_val_anls,0.5374434618615119,0.0062905728113059655
-Single Stage,4000,infovqa_val_anls,0.2287924838861707,0.006994568698639919
-Single Stage,4000,mme_total_score,1155.203781512605,
-Single Stage,4000,mmmu_val_mmmu_acc,0.25556,
-Single Stage,4000,mmstar_average,0.2575590188757354,
-Single Stage,4000,ocrbench_ocrbench_accuracy,0.453,
-Single Stage,4000,seedbench_seed_all,0.33913285158421347,
-Single Stage,4000,textvqa_val_exact_match,0.4593,0.006791695475025738
-Single Stage,5000,ai2d_exact_match,0.3125,0.008342439145556371
-Single Stage,5000,average,0.3974627910380972,
-Single Stage,5000,average_rank,1.8,
-Single Stage,5000,chartqa_relaxed_overall,0.5488,0.00995424828018316
-Single Stage,5000,docvqa_val_anls,0.552360266782429,0.006300308519952055
-Single Stage,5000,infovqa_val_anls,0.23425555286643698,0.007002254622066442
-Single Stage,5000,mme_total_score,1181.4653861544618,
-Single Stage,5000,mmmu_val_mmmu_acc,0.26667,
-Single Stage,5000,mmstar_average,0.29596648146165705,
-Single Stage,5000,ocrbench_ocrbench_accuracy,0.462,
-Single Stage,5000,seedbench_seed_all,0.43107281823235133,
-Single Stage,5000,textvqa_val_exact_match,0.47354000000000007,0.0068172185364497985
-Single Stage,6000,ai2d_exact_match,0.358160621761658,0.008629463221867162
-Single Stage,6000,average,0.4161227404571003,
-Single Stage,6000,average_rank,1.6,
-Single Stage,6000,chartqa_relaxed_overall,0.5628,0.00992279440175477
-Single Stage,6000,docvqa_val_anls,0.5747451497228876,0.00625495440870239
-Single Stage,6000,infovqa_val_anls,0.22152017368968838,0.006604546680525351
-Single Stage,6000,mme_total_score,1284.1648659463785,
-Single Stage,6000,mmmu_val_mmmu_acc,0.27111,
-Single Stage,6000,mmstar_average,0.2978489412854164,
-Single Stage,6000,ocrbench_ocrbench_accuracy,0.495,
-Single Stage,6000,seedbench_seed_all,0.4795997776542524,
-Single Stage,6000,textvqa_val_exact_match,0.48432,0.006800535050670284
-Single Stage,7000,ai2d_exact_match,0.3707901554404145,0.00869347755587734
-Single Stage,7000,average,0.4291083177345374,
-Single Stage,7000,average_rank,1.6,
-Single Stage,7000,chartqa_relaxed_overall,0.5656,0.009915542506251351
-Single Stage,7000,docvqa_val_anls,0.5940907049431567,0.006224236305767187
-Single Stage,7000,infovqa_val_anls,0.2515675215816963,0.007105097396092786
-Single Stage,7000,mme_total_score,1185.875650260104,
-Single Stage,7000,mmmu_val_mmmu_acc,0.26556,
-Single Stage,7000,mmstar_average,0.31372400960777047,
-Single Stage,7000,ocrbench_ocrbench_accuracy,0.504,
-Single Stage,7000,seedbench_seed_all,0.4964424680377988,
-Single Stage,7000,textvqa_val_exact_match,0.5002,0.006794794025220267
-Single Stage,8000,ai2d_exact_match,0.37759067357512954,0.008725299846043883
-Single Stage,8000,average,0.43846759477995995,
-Single Stage,8000,average_rank,1.5,
-Single Stage,8000,chartqa_relaxed_overall,0.5832,0.009862556058385773
-Single Stage,8000,docvqa_val_anls,0.6017336419437208,0.006231612198089698
-Single Stage,8000,infovqa_val_anls,0.2449256624147254,0.006992518502948913
-Single Stage,8000,mme_total_score,1199.2409963985594,
-Single Stage,8000,mmmu_val_mmmu_acc,0.28111,
-Single Stage,8000,mmstar_average,0.33512257186205047,
-Single Stage,8000,ocrbench_ocrbench_accuracy,0.51,
-Single Stage,8000,seedbench_seed_all,0.5024458032240133,
-Single Stage,8000,textvqa_val_exact_match,0.51008,0.006796301690135059
-Single Stage,9000,ai2d_exact_match,0.4067357512953368,0.008841214921078996
-Single Stage,9000,average,0.4422510732201056,
-Single Stage,9000,average_rank,1.6,
-Single Stage,9000,chartqa_relaxed_overall,0.5912,0.009834211136815875
-Single Stage,9000,docvqa_val_anls,0.6170968481662739,0.00617235763542544
-Single Stage,9000,infovqa_val_anls,0.23537031288570615,0.00670318154156447
-Single Stage,9000,mme_total_score,1231.5195078031213,
-Single Stage,9000,mmmu_val_mmmu_acc,0.25889,
-Single Stage,9000,mmstar_average,0.3216444898242951,
-Single Stage,9000,ocrbench_ocrbench_accuracy,0.515,
-Single Stage,9000,seedbench_seed_all,0.5120622568093385,
-Single Stage,9000,textvqa_val_exact_match,0.52226,0.006792711289708482
-Single Stage,10000,ai2d_exact_match,0.39993523316062174,0.008817096257082848
-Single Stage,10000,average,0.4523875703250908,
-Single Stage,10000,average_rank,1.3,
-Single Stage,10000,chartqa_relaxed_overall,0.5996,0.00980154906867574
-Single Stage,10000,docvqa_val_anls,0.6262613496433054,0.006147756371688175
-Single Stage,10000,infovqa_val_anls,0.263290074230132,0.007186788766942786
-Single Stage,10000,mme_total_score,1240.8218287314926,
-Single Stage,10000,mmmu_val_mmmu_acc,0.28778,
-Single Stage,10000,mmstar_average,0.32972717906018517,
-Single Stage,10000,ocrbench_ocrbench_accuracy,0.517,
-Single Stage,10000,seedbench_seed_all,0.5217342968315731,
-Single Stage,10000,textvqa_val_exact_match,0.5261600000000001,0.006785774843600811
-Single Stage,11000,ai2d_exact_match,0.422279792746114,0.008889771831066474
-Single Stage,11000,average,0.4561398159525099,
-Single Stage,11000,average_rank,1.2,
-Single Stage,11000,chartqa_relaxed_overall,0.6104,0.009755142291143075
-Single Stage,11000,docvqa_val_anls,0.6373130149166712,0.006128022584995044
-Single Stage,11000,infovqa_val_anls,0.24419378339723755,0.006897644885887063
-Single Stage,11000,mme_total_score,1322.9488795518205,
-Single Stage,11000,mmmu_val_mmmu_acc,0.27778,
-Single Stage,11000,mmstar_average,0.3298563439522548,
-Single Stage,11000,ocrbench_ocrbench_accuracy,0.521,
-Single Stage,11000,seedbench_seed_all,0.5237354085603113,
-Single Stage,11000,textvqa_val_exact_match,0.5387,0.006770851562852138
-Single Stage,12000,ai2d_exact_match,0.42001295336787564,0.008883255931688034
-Single Stage,12000,average,0.4582751140055433,
-Single Stage,12000,average_rank,1.4,
-Single Stage,12000,chartqa_relaxed_overall,0.618,0.009719474639861454
-Single Stage,12000,docvqa_val_anls,0.6393961983751871,0.0061228747388476674
-Single Stage,12000,infovqa_val_anls,0.24798874058574302,0.006855374548993139
-Single Stage,12000,mme_total_score,1225.6453581432572,
-Single Stage,12000,mmmu_val_mmmu_acc,0.27889,
-Single Stage,12000,mmstar_average,0.34010867846816534,
-Single Stage,12000,ocrbench_ocrbench_accuracy,0.512,
-Single Stage,12000,seedbench_seed_all,0.5350194552529183,
-Single Stage,12000,textvqa_val_exact_match,0.5330600000000001,0.006777713092109446
-Single Stage,13000,ai2d_exact_match,0.4375,0.008928571428571428
-Single Stage,13000,average,0.4692868662590049,
-Single Stage,13000,average_rank,1.2,
-Single Stage,13000,chartqa_relaxed_overall,0.6148,0.00973479791861169
-Single Stage,13000,docvqa_val_anls,0.6511374872549951,0.006086953065248391
-Single Stage,13000,infovqa_val_anls,0.24465055100441893,0.006808432538374664
-Single Stage,13000,mme_total_score,1281.7122849139657,
-Single Stage,13000,mmmu_val_mmmu_acc,0.28222,
-Single Stage,13000,mmstar_average,0.3453069542917521,
-Single Stage,13000,ocrbench_ocrbench_accuracy,0.549,
-Single Stage,13000,seedbench_seed_all,0.5442468037798777,
-Single Stage,13000,textvqa_val_exact_match,0.55472,0.0067416788982325
-Single Stage,14000,ai2d_exact_match,0.4572538860103627,0.00896620675297095
-Single Stage,14000,average,0.47352486841689195,
-Single Stage,14000,average_rank,1.4,
-Single Stage,14000,chartqa_relaxed_overall,0.6172,0.009723347231923635
-Single Stage,14000,docvqa_val_anls,0.6502269393708169,0.006057950730638126
-Single Stage,14000,infovqa_val_anls,0.25805460837190913,0.007037735231659539
-Single Stage,14000,mme_total_score,1309.1444577831132,
-Single Stage,14000,mmmu_val_mmmu_acc,0.28111,
-Single Stage,14000,mmstar_average,0.34575818188776586,
-Single Stage,14000,ocrbench_ocrbench_accuracy,0.551,
-Single Stage,14000,seedbench_seed_all,0.5483602001111729,
-Single Stage,14000,textvqa_val_exact_match,0.55276,0.006751206724612103
-Single Stage,15000,ai2d_exact_match,0.45045336787564766,0.008954861634252399
-Single Stage,15000,average,0.47878665012878824,
-Single Stage,15000,average_rank,1.2,
-Single Stage,15000,chartqa_relaxed_overall,0.612,0.009747841205275417
-Single Stage,15000,docvqa_val_anls,0.6621413031955148,0.006056838050222495
-Single Stage,15000,infovqa_val_anls,0.2706898598157733,0.007200315730154543
-Single Stage,15000,mme_total_score,1384.2171868747498,
-Single Stage,15000,mmmu_val_mmmu_acc,0.30222,
-Single Stage,15000,mmstar_average,0.35408135695920684,
-Single Stage,15000,ocrbench_ocrbench_accuracy,0.558,
-Single Stage,15000,seedbench_seed_all,0.5411339633129516,
-Single Stage,15000,textvqa_val_exact_match,0.5583600000000001,0.0067279027203879065
-Single Stage,16000,ai2d_exact_match,0.45077720207253885,0.008955440137395838
-Single Stage,16000,average,0.47665128022935843,
-Single Stage,16000,average_rank,1.3,
-Single Stage,16000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Single Stage,16000,docvqa_val_anls,0.6709415729142987,0.005999818105621502
-Single Stage,16000,infovqa_val_anls,0.26050032542402035,0.006997451875879188
-Single Stage,16000,mme_total_score,1317.8491396558625,
-Single Stage,16000,mmmu_val_mmmu_acc,0.27556,
-Single Stage,16000,mmstar_average,0.33214333327093315,
-Single Stage,16000,ocrbench_ocrbench_accuracy,0.56,
-Single Stage,16000,seedbench_seed_all,0.5463590883824346,
-Single Stage,16000,textvqa_val_exact_match,0.56158,0.006723854754867398
-Single Stage,17000,ai2d_exact_match,0.45919689119170987,0.008969138793675545
-Single Stage,17000,average,0.4777141780162423,
-Single Stage,17000,average_rank,1.3,
-Single Stage,17000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Single Stage,17000,docvqa_val_anls,0.6796338519136422,0.005948761388267941
-Single Stage,17000,infovqa_val_anls,0.28070956072505215,0.007298333094144192
-Single Stage,17000,mme_total_score,1381.9161664665867,
-Single Stage,17000,mmmu_val_mmmu_acc,0.27667,
-Single Stage,17000,mmstar_average,0.3370289492329521,
-Single Stage,17000,ocrbench_ocrbench_accuracy,0.519,
-Single Stage,17000,seedbench_seed_all,0.5510283490828238,
-Single Stage,17000,textvqa_val_exact_match,0.56416,0.006724830373229479
-Single Stage,18000,ai2d_exact_match,0.46567357512953367,0.008977921602780726
-Single Stage,18000,average,0.4819834595278701,
-Single Stage,18000,average_rank,1.3,
-Single Stage,18000,chartqa_relaxed_overall,0.6376,0.009615793331418735
-Single Stage,18000,docvqa_val_anls,0.6775884603912571,0.005972234236435759
-Single Stage,18000,infovqa_val_anls,0.27154318420389256,0.007164903131667027
-Single Stage,18000,mme_total_score,1336.922769107643,
-Single Stage,18000,mmmu_val_mmmu_acc,0.28667,
-Single Stage,18000,mmstar_average,0.34482796716566916,
-Single Stage,18000,ocrbench_ocrbench_accuracy,0.533,
-Single Stage,18000,seedbench_seed_all,0.5543079488604781,
-Single Stage,18000,textvqa_val_exact_match,0.5666399999999999,0.006713392287599574
-Single Stage,19000,ai2d_exact_match,0.4682642487046632,0.008981008686994101
-Single Stage,19000,average,0.4899006713916878,
-Single Stage,19000,average_rank,1.1,
-Single Stage,19000,chartqa_relaxed_overall,0.6444,0.009575809858898698
-Single Stage,19000,docvqa_val_anls,0.678226526479947,0.005970619221588814
-Single Stage,19000,infovqa_val_anls,0.26993847247278,0.0071348470764911525
-Single Stage,19000,mme_total_score,1406.6628651460583,
-Single Stage,19000,mmmu_val_mmmu_acc,0.28333,
-Single Stage,19000,mmstar_average,0.356220913822775,
-Single Stage,19000,ocrbench_ocrbench_accuracy,0.577,
-Single Stage,19000,seedbench_seed_all,0.554585881045025,
-Single Stage,19000,textvqa_val_exact_match,0.57714,0.0066918487914812905
-Single Stage,20000,ai2d_exact_match,0.47571243523316065,0.00898853090258662
-Single Stage,20000,average,0.4873169067639118,
-Single Stage,20000,average_rank,1.2,
-Single Stage,20000,chartqa_relaxed_overall,0.6336,0.009638338810708618
-Single Stage,20000,docvqa_val_anls,0.6895214454380043,0.005896462073053767
-Single Stage,20000,infovqa_val_anls,0.2655657550458317,0.007033265532032538
-Single Stage,20000,mme_total_score,1324.6738695478193,
-Single Stage,20000,mmmu_val_mmmu_acc,0.30111,
-Single Stage,20000,mmstar_average,0.33806766134497995,
-Single Stage,20000,ocrbench_ocrbench_accuracy,0.555,
-Single Stage,20000,seedbench_seed_all,0.5587548638132296,
-Single Stage,20000,textvqa_val_exact_match,0.56852,0.006720151338087659
-Two Stage,1000,ai2d_exact_match,0.25906735751295334,0.007885466610693084
-Two Stage,1000,average,0.31368848609084204,
-Two Stage,1000,average_rank,1.0,
-Two Stage,1000,chartqa_relaxed_overall,0.4436,0.009938164963872337
-Two Stage,1000,docvqa_val_anls,0.42857906272393714,0.00617017051120098
-Two Stage,1000,infovqa_val_anls,0.19144447578161194,0.006593728313201272
-Two Stage,1000,mme_total_score,998.7869147659063,
-Two Stage,1000,mmmu_val_mmmu_acc,0.25889,
-Two Stage,1000,mmstar_average,0.2467637945300377,
-Two Stage,1000,ocrbench_ocrbench_accuracy,0.368,
-Two Stage,1000,seedbench_seed_all,0.25703168426903833,
-Two Stage,1000,textvqa_val_exact_match,0.36982,0.006597131039140386
-Two Stage,2000,ai2d_exact_match,0.26327720207253885,0.007926662492947052
-Two Stage,2000,average,0.3358130433652279,
-Two Stage,2000,average_rank,1.2,
-Two Stage,2000,chartqa_relaxed_overall,0.4992,0.010001987797631107
-Two Stage,2000,docvqa_val_anls,0.4932752040405314,0.006286364089099095
-Two Stage,2000,infovqa_val_anls,0.19095428252193772,0.006391194919224349
-Two Stage,2000,mme_total_score,1062.8957583033214,
-Two Stage,2000,mmmu_val_mmmu_acc,0.23333,
-Two Stage,2000,mmstar_average,0.22051867830573926,
-Two Stage,2000,ocrbench_ocrbench_accuracy,0.435,
-Two Stage,2000,seedbench_seed_all,0.2556420233463035,
-Two Stage,2000,textvqa_val_exact_match,0.43112,0.006756288819146318
-Two Stage,3000,ai2d_exact_match,0.2655440414507772,0.007948457289013515
-Two Stage,3000,average,0.3636919255920759,
-Two Stage,3000,average_rank,1.3,
-Two Stage,3000,chartqa_relaxed_overall,0.5348,0.009977745545085072
-Two Stage,3000,docvqa_val_anls,0.5283823835512687,0.006261305725762883
-Two Stage,3000,infovqa_val_anls,0.2064005153919739,0.00660395026420985
-Two Stage,3000,mme_total_score,1152.5195078031213,
-Two Stage,3000,mmmu_val_mmmu_acc,0.26667,
-Two Stage,3000,mmstar_average,0.26072557614922737,
-Two Stage,3000,ocrbench_ocrbench_accuracy,0.455,
-Two Stage,3000,seedbench_seed_all,0.29666481378543635,
-Two Stage,3000,textvqa_val_exact_match,0.45903999999999995,0.006792178031860127
-Two Stage,4000,ai2d_exact_match,0.30343264248704666,0.008274550183857863
-Two Stage,4000,average,0.386738207804619,
-Two Stage,4000,average_rank,1.2,
-Two Stage,4000,chartqa_relaxed_overall,0.5464,0.00995883966107287
-Two Stage,4000,docvqa_val_anls,0.5513347609587042,0.006295149714671814
-Two Stage,4000,infovqa_val_anls,0.209061566918142,0.006630816594060217
-Two Stage,4000,mme_total_score,1092.9095638255303,
-Two Stage,4000,mmmu_val_mmmu_acc,0.26889,
-Two Stage,4000,mmstar_average,0.26686799048357046,
-Two Stage,4000,ocrbench_ocrbench_accuracy,0.477,
-Two Stage,4000,seedbench_seed_all,0.38643690939410785,
-Two Stage,4000,textvqa_val_exact_match,0.47121999999999997,0.006809171409434235
-Two Stage,5000,ai2d_exact_match,0.34617875647668395,0.008562713351618975
-Two Stage,5000,average,0.41048271276999254,
-Two Stage,5000,average_rank,1.2,
-Two Stage,5000,chartqa_relaxed_overall,0.5568,0.009937253322797029
-Two Stage,5000,docvqa_val_anls,0.5616928036954175,0.006281333847375657
-Two Stage,5000,infovqa_val_anls,0.21417615930558564,0.006470237976804916
-Two Stage,5000,mme_total_score,1113.2024809923969,
-Two Stage,5000,mmmu_val_mmmu_acc,0.28889,
-Two Stage,5000,mmstar_average,0.3048769900603613,
-Two Stage,5000,ocrbench_ocrbench_accuracy,0.501,
-Two Stage,5000,seedbench_seed_all,0.4454697053918844,
-Two Stage,5000,textvqa_val_exact_match,0.47525999999999996,0.006811465752181289
-Two Stage,6000,ai2d_exact_match,0.3853626943005181,0.008759432661868542
-Two Stage,6000,average,0.4256324408073156,
-Two Stage,6000,average_rank,1.4,
-Two Stage,6000,chartqa_relaxed_overall,0.574,0.009891852177211218
-Two Stage,6000,docvqa_val_anls,0.5959624206334873,0.006223948314975518
-Two Stage,6000,infovqa_val_anls,0.21910870056052556,0.00650522330852698
-Two Stage,6000,mme_total_score,1166.5228091236495,
-Two Stage,6000,mmmu_val_mmmu_acc,0.28333,
-Two Stage,6000,mmstar_average,0.28797389940888596,
-Two Stage,6000,ocrbench_ocrbench_accuracy,0.512,
-Two Stage,6000,seedbench_seed_all,0.4776542523624236,
-Two Stage,6000,textvqa_val_exact_match,0.4953,0.006792791061270795
-Two Stage,7000,ai2d_exact_match,0.3915155440414508,0.008784780895708935
-Two Stage,7000,average,0.4301306852910006,
-Two Stage,7000,average_rank,1.4,
-Two Stage,7000,chartqa_relaxed_overall,0.5776,0.009880807059104824
-Two Stage,7000,docvqa_val_anls,0.5986163103423551,0.0062031909815058375
-Two Stage,7000,infovqa_val_anls,0.22133856274121264,0.006604073748499083
-Two Stage,7000,mme_total_score,1191.3954581832734,
-Two Stage,7000,mmmu_val_mmmu_acc,0.28667,
-Two Stage,7000,mmstar_average,0.2999043663917079,
-Two Stage,7000,ocrbench_ocrbench_accuracy,0.501,
-Two Stage,7000,seedbench_seed_all,0.48449138410227904,
-Two Stage,7000,textvqa_val_exact_match,0.51004,0.006807782962299279
-Two Stage,8000,ai2d_exact_match,0.4106217616580311,0.008854207883828033
-Two Stage,8000,average,0.4460743520389214,
-Two Stage,8000,average_rank,1.5,
-Two Stage,8000,chartqa_relaxed_overall,0.6044,0.009781540134915584
-Two Stage,8000,docvqa_val_anls,0.6026263625222106,0.006221681650022778
-Two Stage,8000,infovqa_val_anls,0.25653488200256863,0.007114496312902602
-Two Stage,8000,mme_total_score,1122.452581032413,
-Two Stage,8000,mmmu_val_mmmu_acc,0.30556,
-Two Stage,8000,mmstar_average,0.3287554228678711,
-Two Stage,8000,ocrbench_ocrbench_accuracy,0.502,
-Two Stage,8000,seedbench_seed_all,0.4953307392996109,
-Two Stage,8000,textvqa_val_exact_match,0.5088400000000001,0.006790286627123755
-Two Stage,9000,ai2d_exact_match,0.40900259067357514,0.00884886365109852
-Two Stage,9000,average,0.4448373661618862,
-Two Stage,9000,average_rank,1.4,
-Two Stage,9000,chartqa_relaxed_overall,0.602,0.00979166741164548
-Two Stage,9000,docvqa_val_anls,0.6230206474600885,0.006150742264825986
-Two Stage,9000,infovqa_val_anls,0.22695214706156083,0.0066522293148095326
-Two Stage,9000,mme_total_score,1123.2771108443376,
-Two Stage,9000,mmmu_val_mmmu_acc,0.28444,
-Two Stage,9000,mmstar_average,0.31337399530900006,
-Two Stage,9000,ocrbench_ocrbench_accuracy,0.516,
-Two Stage,9000,seedbench_seed_all,0.5044469149527515,
-Two Stage,9000,textvqa_val_exact_match,0.5243,0.006775919466531711
-Two Stage,10000,ai2d_exact_match,0.4167746113989637,0.008873613803189363
-Two Stage,10000,average,0.45019708387432694,
-Two Stage,10000,average_rank,1.7,
-Two Stage,10000,chartqa_relaxed_overall,0.6008,0.00979663889573671
-Two Stage,10000,docvqa_val_anls,0.625559493523932,0.006163808988970625
-Two Stage,10000,infovqa_val_anls,0.2484394159425024,0.006960467307383163
-Two Stage,10000,mme_total_score,1175.7940176070429,
-Two Stage,10000,mmmu_val_mmmu_acc,0.28444,
-Two Stage,10000,mmstar_average,0.3201372990396749,
-Two Stage,10000,ocrbench_ocrbench_accuracy,0.523,
-Two Stage,10000,seedbench_seed_all,0.5092829349638688,
-Two Stage,10000,textvqa_val_exact_match,0.52334,0.006775531746371587
-Two Stage,11000,ai2d_exact_match,0.4219559585492228,0.008888852746011196
-Two Stage,11000,average,0.4544831873326875,
-Two Stage,11000,average_rank,1.8,
-Two Stage,11000,chartqa_relaxed_overall,0.6128,0.009744149186940382
-Two Stage,11000,docvqa_val_anls,0.6332812103643084,0.006140691371662128
-Two Stage,11000,infovqa_val_anls,0.23863681037743975,0.006726839163261667
-Two Stage,11000,mme_total_score,1205.7752100840335,
-Two Stage,11000,mmmu_val_mmmu_acc,0.27667,
-Two Stage,11000,mmstar_average,0.3207287756303977,
-Two Stage,11000,ocrbench_ocrbench_accuracy,0.542,
-Two Stage,11000,seedbench_seed_all,0.5166759310728183,
-Two Stage,11000,textvqa_val_exact_match,0.5276,0.006779501480792346
-Two Stage,12000,ai2d_exact_match,0.43005181347150256,0.00891065778843896
-Two Stage,12000,average,0.4603231834457321,
-Two Stage,12000,average_rank,1.6,
-Two Stage,12000,chartqa_relaxed_overall,0.612,0.009747841205275417
-Two Stage,12000,docvqa_val_anls,0.6395985301346107,0.006113052714689484
-Two Stage,12000,infovqa_val_anls,0.2439170659215255,0.006865310277271596
-Two Stage,12000,mme_total_score,1157.484293717487,
-Two Stage,12000,mmmu_val_mmmu_acc,0.29556,
-Two Stage,12000,mmstar_average,0.33444157500257155,
-Two Stage,12000,ocrbench_ocrbench_accuracy,0.539,
-Two Stage,12000,seedbench_seed_all,0.5193996664813786,
-Two Stage,12000,textvqa_val_exact_match,0.52894,0.006785904875622425
-Two Stage,13000,ai2d_exact_match,0.4339378238341969,0.00892025987527176
-Two Stage,13000,average,0.46490664749620997,
-Two Stage,13000,average_rank,1.8,
-Two Stage,13000,chartqa_relaxed_overall,0.6224,0.009697675699134625
-Two Stage,13000,docvqa_val_anls,0.6462803017356844,0.0061027748005307945
-Two Stage,13000,infovqa_val_anls,0.24426636134362278,0.006797247018813037
-Two Stage,13000,mme_total_score,1191.0042016806724,
-Two Stage,13000,mmmu_val_mmmu_acc,0.3,
-Two Stage,13000,mmstar_average,0.33993002648901727,
-Two Stage,13000,ocrbench_ocrbench_accuracy,0.545,
-Two Stage,13000,seedbench_seed_all,0.5175653140633686,
-Two Stage,13000,textvqa_val_exact_match,0.5347799999999999,0.0067635803775740536
-Two Stage,14000,ai2d_exact_match,0.44332901554404147,0.008941163900483138
-Two Stage,14000,average,0.47155104399726233,
-Two Stage,14000,average_rank,1.6,
-Two Stage,14000,chartqa_relaxed_overall,0.6268,0.009675026948726469
-Two Stage,14000,docvqa_val_anls,0.6586021078894133,0.006060927182389954
-Two Stage,14000,infovqa_val_anls,0.2553127836308732,0.0069494972189920795
-Two Stage,14000,mme_total_score,1219.156662665066,
-Two Stage,14000,mmmu_val_mmmu_acc,0.30444,
-Two Stage,14000,mmstar_average,0.32252187023399065,
-Two Stage,14000,ocrbench_ocrbench_accuracy,0.564,
-Two Stage,14000,seedbench_seed_all,0.5245136186770428,
-Two Stage,14000,textvqa_val_exact_match,0.54444,0.006760159556655915
-Two Stage,15000,ai2d_exact_match,0.44527202072538863,0.008945084019331405
-Two Stage,15000,average,0.47506404899487137,
-Two Stage,15000,average_rank,1.8,
-Two Stage,15000,chartqa_relaxed_overall,0.628,0.009668701749325345
-Two Stage,15000,docvqa_val_anls,0.6614266719753668,0.006055793707421594
-Two Stage,15000,infovqa_val_anls,0.25669760055121127,0.006992050333066725
-Two Stage,15000,mme_total_score,1198.7210884353742,
-Two Stage,15000,mmmu_val_mmmu_acc,0.31222,
-Two Stage,15000,mmstar_average,0.34599838005318234,
-Two Stage,15000,ocrbench_ocrbench_accuracy,0.553,
-Two Stage,15000,seedbench_seed_all,0.5271817676486937,
-Two Stage,15000,textvqa_val_exact_match,0.5457799999999999,0.006751174267547695
-Two Stage,16000,ai2d_exact_match,0.452720207253886,0.008958830742136086
-Two Stage,16000,average,0.4756900312291722,
-Two Stage,16000,average_rank,1.7,
-Two Stage,16000,chartqa_relaxed_overall,0.6228,0.009695651925812239
-Two Stage,16000,docvqa_val_anls,0.6636227651335681,0.006049765989250173
-Two Stage,16000,infovqa_val_anls,0.2545981800588258,0.0069034382302033005
-Two Stage,16000,mme_total_score,1211.0271108443376,
-Two Stage,16000,mmmu_val_mmmu_acc,0.30778,
-Two Stage,16000,mmstar_average,0.3441840591332238,
-Two Stage,16000,ocrbench_ocrbench_accuracy,0.558,
-Two Stage,16000,seedbench_seed_all,0.5251250694830462,
-Two Stage,16000,textvqa_val_exact_match,0.55238,0.006735691577574321
-Two Stage,17000,ai2d_exact_match,0.45142487046632124,0.008956585653027465
-Two Stage,17000,average,0.478877157951835,
-Two Stage,17000,average_rank,1.7,
-Two Stage,17000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Two Stage,17000,docvqa_val_anls,0.6682822523143818,0.006027291004964481
-Two Stage,17000,infovqa_val_anls,0.2566899031113292,0.006984361605936137
-Two Stage,17000,mme_total_score,1157.7550020008005,
-Two Stage,17000,mmmu_val_mmmu_acc,0.31556,
-Two Stage,17000,mmstar_average,0.3413821094043331,
-Two Stage,17000,ocrbench_ocrbench_accuracy,0.563,
-Two Stage,17000,seedbench_seed_all,0.5275152862701501,
-Two Stage,17000,textvqa_val_exact_match,0.55404,0.006743665997528143
-Two Stage,18000,ai2d_exact_match,0.45077720207253885,0.008955440137395842
-Two Stage,18000,average,0.48011960096968553,
-Two Stage,18000,average_rank,1.7,
-Two Stage,18000,chartqa_relaxed_overall,0.6324,0.00964496273307725
-Two Stage,18000,docvqa_val_anls,0.6669938909662756,0.006030949772272312
-Two Stage,18000,infovqa_val_anls,0.26114082779542375,0.006997258882360672
-Two Stage,18000,mme_total_score,1199.3700480192078,
-Two Stage,18000,mmmu_val_mmmu_acc,0.30222,
-Two Stage,18000,mmstar_average,0.34746272024423847,
-Two Stage,18000,ocrbench_ocrbench_accuracy,0.579,
-Two Stage,18000,seedbench_seed_all,0.5271817676486937,
-Two Stage,18000,textvqa_val_exact_match,0.5539,0.0067478933611137175
-Two Stage,19000,ai2d_exact_match,0.44559585492227977,0.00894572391435784
-Two Stage,19000,average,0.48026929849849115,
-Two Stage,19000,average_rank,1.9,
-Two Stage,19000,chartqa_relaxed_overall,0.6372,0.00961808021316077
-Two Stage,19000,docvqa_val_anls,0.6688318561206944,0.006022351017420005
-Two Stage,19000,infovqa_val_anls,0.2646354907091152,0.007027671735260141
-Two Stage,19000,mme_total_score,1170.1806722689075,
-Two Stage,19000,mmmu_val_mmmu_acc,0.29778,
-Two Stage,19000,mmstar_average,0.35086201891999,
-Two Stage,19000,ocrbench_ocrbench_accuracy,0.574,
-Two Stage,19000,seedbench_seed_all,0.5292384658143413,
-Two Stage,19000,textvqa_val_exact_match,0.55428,0.006746127657232224
-Two Stage,20000,ai2d_exact_match,0.44721502590673573,0.008948865761421001
-Two Stage,20000,average,0.4807284005437735,
-Two Stage,20000,average_rank,1.8,
-Two Stage,20000,chartqa_relaxed_overall,0.632,0.00964715642305132
-Two Stage,20000,docvqa_val_anls,0.6696120046502304,0.0060246464192922275
-Two Stage,20000,infovqa_val_anls,0.2643335615077466,0.007024758501317731
-Two Stage,20000,mme_total_score,1187.4589835934376,
-Two Stage,20000,mmmu_val_mmmu_acc,0.29778,
-Two Stage,20000,mmstar_average,0.34891710287927624,
-Two Stage,20000,ocrbench_ocrbench_accuracy,0.582,
-Two Stage,20000,seedbench_seed_all,0.5282379099499722,
-Two Stage,20000,textvqa_val_exact_match,0.5564600000000001,0.006728915911338792
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f076631fcad76129ed8cab03c72a61965b465e1f3e7fa8dc68b7c7a9275616b
+size 28041

app/src/env.d.ts

@@ -1 +1,13 @@
-/// <reference path="../.astro/types.d.ts" />
+/// <reference path="../.astro/types.d.ts" />
+/// <reference types="astro/client" />
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly PUBLIC_TABLE_OF_CONTENT_AUTO_COLLAPSE?: string | boolean;
+  // Back-compat
+  readonly PUBLIC_TOC_AUTO_COLLAPSE?: string | boolean;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

app/src/pages/index.astro

@@ -4,6 +4,7 @@ import Hero from '../components/Hero.astro';
 import Footer from '../components/Footer.astro';
 import ThemeToggle from '../components/ThemeToggle.astro';
 import Seo from '../components/Seo.astro';
+import TableOfContents from '../components/TableOfContents.astro';
 // Default OG image served from public/
 const ogDefaultUrl = '/thumb.jpg';
 import 'katex/dist/katex.min.css';
@@ -17,11 +18,78 @@ const docTitleHtml = (articleFM?.title ?? 'Untitled article')
   .replace(/\n/g, '<br/>');
 const subtitle = articleFM?.subtitle ?? '';
 const description = articleFM?.description ?? '';
-const authors = articleFM?.authors ?? [];
+// Accept authors as string[] or array of objects { name, url, affiliations? }
+const rawAuthors = (articleFM as any)?.authors ?? [];
+type Affiliation = { id: number; name: string; url?: string };
+type Author = { name: string; url?: string; affiliationIndices?: number[] };
+
+// Normalize affiliations from frontmatter: supports strings or objects { id?, name, url? }
+const rawAffils = (articleFM as any)?.affiliations ?? (articleFM as any)?.affiliation ?? [];
+const normalizedAffiliations: Affiliation[] = (() => {
+  const seen: Map<string, number> = new Map();
+  const list: Affiliation[] = [];
+  const pushUnique = (name: string, url?: string) => {
+    const key = `${String(name).trim()}|${url ? String(url).trim() : ''}`;
+    if (seen.has(key)) return seen.get(key)!;
+    const id = list.length + 1;
+    list.push({ id, name: String(name).trim(), url: url ? String(url) : undefined });
+    seen.set(key, id);
+    return id;
+  };
+  const input = Array.isArray(rawAffils) ? rawAffils : (rawAffils ? [rawAffils] : []);
+  for (const a of input) {
+    if (typeof a === 'string') {
+      pushUnique(a);
+    } else if (a && typeof a === 'object') {
+      const name = a.name ?? a.label ?? a.text ?? a.affiliation ?? '';
+      if (!String(name).trim()) continue;
+      const url = a.url || a.link;
+      // Respect provided numeric id for display stability if present and sequential; otherwise reassign
+      pushUnique(String(name), url ? String(url) : undefined);
+    }
+  }
+  return list;
+})();
+
+// Helper: ensure an affiliation exists and return its id
+const ensureAffiliation = (val: any): number | undefined => {
+  if (val == null) return undefined;
+  if (typeof val === 'number' && Number.isFinite(val) && val > 0) {
+    return Math.floor(val);
+  }
+  const name = typeof val === 'string' ? val : (val?.name ?? val?.label ?? val?.text ?? val?.affiliation);
+  if (!name || !String(name).trim()) return undefined;
+  const existing = normalizedAffiliations.find(a => a.name === String(name).trim());
+  if (existing) return existing.id;
+  const id = normalizedAffiliations.length + 1;
+  normalizedAffiliations.push({ id, name: String(name).trim(), url: val?.url || val?.link });
+  return id;
+};
+
+// Normalize authors and map affiliations -> indices (Distill-like)
+const normalizedAuthors: Author[] = (Array.isArray(rawAuthors) ? rawAuthors : [])
+  .map((a: any) => {
+    if (typeof a === 'string') {
+      return { name: a } as Author;
+    }
+    const name = String(a?.name || '').trim();
+    const url = a?.url || a?.link;
+    let indices: number[] | undefined = undefined;
+    const raw = a?.affiliations ?? a?.affiliation ?? a?.affils;
+    if (raw != null) {
+      const entries = Array.isArray(raw) ? raw : [raw];
+      const ids = entries.map(ensureAffiliation).filter((x): x is number => typeof x === 'number');
+      const unique = Array.from(new Set(ids)).sort((x, y) => x - y);
+      if (unique.length) indices = unique;
+    }
+    return { name, url, affiliationIndices: indices } as Author;
+  })
+  .filter((a: Author) => a.name && a.name.trim().length > 0);
+const authorNames: string[] = normalizedAuthors.map(a => a.name);
 const published = articleFM?.published ?? undefined;
 const tags = articleFM?.tags ?? [];
-// Prefer ogImage from frontmatter if provided
-const fmOg = articleFM?.ogImage as string | undefined;
+// Prefer seoThumbImage from frontmatter if provided
+const fmOg = articleFM?.seoThumbImage as string | undefined;
 const imageAbs: string = fmOg && fmOg.startsWith('http')
   ? fmOg
   : (Astro.site ? new URL((fmOg ?? ogDefaultUrl), Astro.site).toString() : (fmOg ?? ogDefaultUrl));
@@ -42,20 +110,27 @@ const extractYear = (val: string | undefined): number | undefined => {
 };
 
 const year = extractYear(published);
-const citationAuthorsText = authors.join(', ');
+const citationAuthorsText = authorNames.join(', ');
 const citationText = `${citationAuthorsText}${year ? ` (${year})` : ''}. "${titleFlat}".`;
 
-const authorsBib = authors.join(' and ');
-const keyAuthor = (authors[0] || 'article').split(/\s+/).slice(-1)[0].toLowerCase();
+const authorsBib = authorNames.join(' and ');
+const keyAuthor = (authorNames[0] || 'article').split(/\s+/).slice(-1)[0].toLowerCase();
 const keyTitle = titleFlat.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '').slice(0, 24);
 const bibKey = `${keyAuthor}${year ?? ''}_${keyTitle}`;
-const bibtex = `@misc{${bibKey},\n  title={${titleFlat}},\n  author={${authorsBib}},\n  ${year ? `year={${year}}` : ''}\n}`;
+const doi = (ArticleMod as any)?.frontmatter?.doi ? String((ArticleMod as any).frontmatter.doi) : undefined;
+const bibtex = `@misc{${bibKey},\n  title={${titleFlat}},\n  author={${authorsBib}},\n  ${year ? `year={${year}},\n  ` : ''}${doi ? `doi={${doi}}` : ''}\n}`;
+const envCollapse = false;
+const tableOfContentAutoCollapse = Boolean(
+  (articleFM as any)?.tableOfContentAutoCollapse ?? (articleFM as any)?.tableOfContentsAutoCollapse ?? envCollapse
+);
+// Licence note (HTML allowed)
+const licence = (articleFM as any)?.licence ?? (articleFM as any)?.license ?? (articleFM as any)?.licenseNote;
 ---
-<html lang="en" data-theme="light">
+<html lang="en" data-theme="light" data-toc-auto-collapse={tableOfContentAutoCollapse ? '1' : '0'}>
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <Seo title={docTitle} description={description} authors={authors} published={published} tags={tags} image={imageAbs} />
+    <Seo title={docTitle} description={description} authors={authorNames} published={published} tags={tags} image={imageAbs} />
     <script is:inline>
       (() => {
         try {
@@ -66,215 +141,27 @@ const bibtex = `@misc{${bibKey},\n  title={${titleFlat}},\n  author={${authorsBi
         } catch {}
       })();
     </script>
+    <script is:inline src="/scripts/color-palettes.js"></script>
     
     <!-- TO MANAGE PROPERLY -->
     <script src="https://cdn.plot.ly/plotly-3.0.0.min.js" charset="utf-8"></script>
     <script src="https://cdn.jsdelivr.net/npm/d3@7/dist/d3.min.js"></script>
-    <script type="module" src="https://gradio.s3-us-west-2.amazonaws.com/4.4.0/gradio.js"> </script>
+    <script src="https://cdn.jsdelivr.net/npm/medium-zoom@1.1.0/dist/medium-zoom.min.js"></script>
+
   </head>
   <body>
     <ThemeToggle />
-    <Hero title={docTitleHtml} titleRaw={docTitle} description={subtitle} authors={articleFM?.authors} affiliation={articleFM?.affiliation} published={articleFM?.published} />
+    <Hero title={docTitleHtml} titleRaw={docTitle} description={subtitle} authors={normalizedAuthors as any} affiliations={normalizedAffiliations as any} affiliation={articleFM?.affiliation} published={articleFM?.published} doi={doi} />
 
     <section class="content-grid">
-      <aside class="toc">
-        <div class="title">Table of Contents</div>
-        <div id="article-toc-placeholder"></div>
-      </aside>
-      <details class="toc-mobile">
-        <summary>Table of Contents</summary>
-        <div id="article-toc-mobile-placeholder"></div>
-      </details>
+      <TableOfContents tableOfContentAutoCollapse={tableOfContentAutoCollapse} />
       <main>
         <Article />
-        <style is:inline>
-          /* Inline tweak for details blocks used in MDX */
-          details { background: var(--code-bg) !important; border: 1px solid var(--border-color) !important; border-radius: 6px; margin: 1em 0; padding: .5em .75em; }
-        </style>
       </main>
     </section>
 
-    <Footer citationText={citationText} bibtex={bibtex} />
-
-    <!-- Medium-like image zoom (lightbox) -->
-    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/medium-zoom.min.js"></script>
-    <script>
-      // Initialize zoom on img[data-zoomable]; wait for script & content; close on scroll like Medium
-      (() => {
-        /** @type {any} */
-        let zoomInstance = null;
-
-        /** @param {() => void} cb */
-        const ensureMediumZoomReady = (cb) => {
-          // @ts-ignore mediumZoom injected globally by external script
-          if (window.mediumZoom) return cb();
-          // @ts-ignore mediumZoom injected globally by external script
-          const retry = () => (window.mediumZoom ? cb() : setTimeout(retry, 30));
-          retry();
-        };
-
-        /** @returns {HTMLElement[]} */
-        const collectTargets = () => Array.from(document.querySelectorAll('section.content-grid main img[data-zoomable]'));
-
-        const initOrUpdateZoom = () => {
-          const isDark = document.documentElement.getAttribute('data-theme') === 'dark';
-          const background = isDark ? 'rgba(0,0,0,.9)' : 'rgba(0,0,0,.85)';
-          const targets = collectTargets();
-          if (!targets.length) return;
-
-          if (!zoomInstance) {
-            // @ts-ignore medium-zoom injected globally by external script
-            zoomInstance = window.mediumZoom(targets, { background, margin: 24, scrollOffset: 0 });
-
-            let onScrollLike;
-            const attachCloseOnScroll = () => {
-              if (onScrollLike) return;
-              // @ts-ignore medium-zoom instance has close()
-              onScrollLike = () => { zoomInstance && zoomInstance.close(); };
-              window.addEventListener('wheel', onScrollLike, { passive: true });
-              window.addEventListener('touchmove', onScrollLike, { passive: true });
-              window.addEventListener('scroll', onScrollLike, { passive: true });
-            };
-            const detachCloseOnScroll = () => {
-              if (!onScrollLike) return;
-              window.removeEventListener('wheel', onScrollLike);
-              window.removeEventListener('touchmove', onScrollLike);
-              window.removeEventListener('scroll', onScrollLike);
-              onScrollLike = null;
-            };
-            // @ts-ignore medium-zoom instance has on()
-            zoomInstance.on('open', attachCloseOnScroll);
-            // @ts-ignore medium-zoom instance has on()
-            zoomInstance.on('close', detachCloseOnScroll);
-
-            const themeObserver = new MutationObserver(() => {
-              const dark = document.documentElement.getAttribute('data-theme') === 'dark';
-              // @ts-ignore medium-zoom instance has update()
-              zoomInstance && zoomInstance.update({ background: dark ? 'rgba(0,0,0,.9)' : 'rgba(0,0,0,.85)' });
-            });
-            themeObserver.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
-          } else {
-            // @ts-ignore medium-zoom instance has attach()/update()
-            zoomInstance.attach(targets);
-            // @ts-ignore medium-zoom instance has update()
-            zoomInstance.update({ background });
-          }
-        };
-
-        const bootstrap = () => ensureMediumZoomReady(() => {
-          initOrUpdateZoom();
-          setTimeout(initOrUpdateZoom, 0);
-          const main = document.querySelector('section.content-grid main');
-          if (main) {
-            const mo = new MutationObserver(() => initOrUpdateZoom());
-            mo.observe(main, { childList: true, subtree: true });
-          }
-        });
-
-        if (document.readyState === 'complete') bootstrap();
-        else window.addEventListener('load', bootstrap, { once: true });
-      })();
-    </script>
-    
-
-    <script>
-      // Add a small download button to img[data-downloadable]
-      (() => {
-        const SELECTOR = 'section.content-grid main img[data-downloadable]';
-
-        /**
-         * @param {HTMLImageElement} img
-         */
-        const injectDownloadButton = (img) => {
-          if (!img || img.dataset.__dlInjected) return;
-          const parentFigure = img.closest('figure');
-          const parent = img.parentElement;
-          if (!parent) return;
-          img.dataset.__dlInjected = '1';
-
-          // Wrap the image in a positioned inline-block so the button is on the image
-          const wrapper = document.createElement('span');
-          wrapper.className = 'img-dl-wrap';
-          parent.insertBefore(wrapper, img);
-          wrapper.appendChild(img);
-          if (parentFigure && !parentFigure.classList.contains('has-dl-btn')) {
-            parentFigure.classList.add('has-dl-btn');
-          }
-
-          // Determine download href and filename
-          const pickHrefAndName = () => {
-            const current = img.currentSrc || img.src || '';
-            let href = img.getAttribute('data-download-src') || current;
-            // Derive filename from the original source when possible
-            const deriveName = () => {
-              try {
-                const u = new URL(current, location.href);
-                // Prefer original href param if provided by Astro image service
-                const rawHref = u.searchParams.get('href');
-                const candidate = rawHref ? decodeURIComponent(rawHref) : u.pathname;
-                const last = String(candidate).split('/').pop() || '';
-                // Strip query/hash and any appended transform suffixes after extension
-                const base = last.split('?')[0].split('#')[0];
-                const m = base.match(/^(.+?\.(?:png|jpe?g|webp|avif|gif|svg))(?:[._-].*)?$/i);
-                if (m && m[1]) return m[1];
-                // If extension missing, fallback to base as-is
-                return base || 'image';
-              } catch {
-                return 'image';
-              }
-            };
-            const name = img.getAttribute('data-download-name') || deriveName();
-            return { href, name };
-          };
+    <Footer citationText={citationText} bibtex={bibtex} licence={licence} doi={doi} />
 
-          const { href, name } = pickHrefAndName();
-          const a = document.createElement('a');
-          a.className = 'button button--ghost img-dl-btn';
-          a.href = href;
-          if (name) a.download = name;
-          a.setAttribute('aria-label', 'Download image');
-          a.setAttribute('title', name ? `Download ${name}` : 'Download image');
-          a.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M12 16c-.26 0-.52-.11-.71-.29l-5-5a1 1 0 0 1 1.42-1.42L11 12.59V4a1 1 0 1 1 2 0v8.59l3.29-3.3a1 1 0 1 1 1.42 1.42l-5 5c-.19.18-.45.29-.71.29zM5 20a1 1 0 1 1 0-2h14a1 1 0 1 1 0 2H5z"/></svg>';
-
-          // Ensure href/name match currentSrc right before navigation
-          a.addEventListener('click', async (ev) => {
-            try {
-              ev.preventDefault();
-              const picked = pickHrefAndName();
-              const res = await fetch(picked.href, { credentials: 'same-origin' });
-              const blob = await res.blob();
-              const objectUrl = URL.createObjectURL(blob);
-              const tmp = document.createElement('a');
-              tmp.href = objectUrl;
-              tmp.download = picked.name || 'image';
-              document.body.appendChild(tmp);
-              tmp.click();
-              setTimeout(() => { URL.revokeObjectURL(objectUrl); tmp.remove(); }, 1000);
-            } catch {
-              // Fallback to native behavior if fetch fails
-            }
-          });
-
-          // Append inside wrapper so positioning is relative to the image box
-          wrapper.appendChild(a);
-        };
-
-        const scan = () => {
-          document.querySelectorAll(SELECTOR).forEach((el) => injectDownloadButton(el));
-        };
-
-        const bootstrap = () => {
-          scan();
-          const main = document.querySelector('section.content-grid main');
-          if (!main) return;
-          const mo = new MutationObserver(() => scan());
-          mo.observe(main, { childList: true, subtree: true, attributes: true, attributeFilter: ['src'] });
-        };
-
-        if (document.readyState === 'complete') bootstrap();
-        else window.addEventListener('load', bootstrap, { once: true });
-      })();
-    </script>
 
     <script>
       // Open external links in a new tab; keep internal anchors in-page
@@ -320,119 +207,7 @@ const bibtex = `@misc{${bibKey},\n  title={${titleFlat}},\n  author={${authorsBi
       });
     </script>
 
-    <script>
-      // Build TOC from article headings (h2/h3/h4) and render into the sticky aside
-      const buildTOC = () => {
-        const holder = document.getElementById('article-toc-placeholder');
-        const holderMobile = document.getElementById('article-toc-mobile-placeholder');
-        // Always rebuild TOC to avoid stale entries
-        if (holder) holder.innerHTML = '';
-        if (holderMobile) holderMobile.innerHTML = '';
-        const articleRoot = document.querySelector('section.content-grid main');
-        if (!articleRoot) return;
-        const headings = articleRoot.querySelectorAll('h2, h3, h4');
-        if (!headings.length) return;
-
-        // Filter out headings that should not appear in TOC
-        const normalize = (s) => String(s || '')
-          .toLowerCase()
-          .replace(/[^a-z0-9]+/g, ' ')
-          .trim();
-        const isTocLabel = (s) => /^(table\s+of\s+contents?)$|^toc$/i.test(String(s || '').replace(/[^a-zA-Z0-9]+/g, ' ').trim());
-        const shouldSkip = (h) => {
-          const t = h.textContent || '';
-          const id = String(h.id || '');
-          const slug = normalize(t).replace(/\s+/g, '_');
-          if (isTocLabel(t)) return true;
-          if (isTocLabel(id.replace(/[_-]+/g, ' '))) return true;
-          if (isTocLabel(slug.replace(/[_-]+/g, ' '))) return true;
-          return false;
-        };
-        const headingsArr = Array.from(headings).filter(h => !shouldSkip(h));
-        if (!headingsArr.length) return;
-
-        // Ensure unique ids for headings (deduplicate duplicates)
-        const usedIds = new Set<string>();
-        const slugify = (s: string) => String(s || '')
-          .toLowerCase()
-          .trim()
-          .replace(/\s+/g, '_')
-          .replace(/[^a-z0-9_\-]/g, '');
-        headingsArr.forEach((h) => {
-          let id = (h.id || '').trim();
-          if (!id) {
-            const base = slugify(h.textContent || '');
-            id = base || 'section';
-          }
-          let candidate = id;
-          let n = 2;
-          while (usedIds.has(candidate)) {
-            candidate = `${id}-${n++}`;
-          }
-          if (h.id !== candidate) h.id = candidate;
-          usedIds.add(candidate);
-        });
-
-        const nav = document.createElement('nav');
-        let ulStack = [document.createElement('ul')];
-        nav.appendChild(ulStack[0]);
-
-        const levelOf = (tag) => tag === 'H2' ? 2 : tag === 'H3' ? 3 : 4;
-        let prev = 2;
-        headingsArr.forEach((h) => {
-          const lvl = levelOf(h.tagName);
-          // adjust depth
-          while (lvl > prev) { const ul = document.createElement('ul'); ulStack[ulStack.length-1].lastElementChild?.appendChild(ul); ulStack.push(ul); prev++; }
-          while (lvl < prev) { ulStack.pop(); prev--; }
-          const li = document.createElement('li');
-          const a = document.createElement('a');
-          a.href = '#' + h.id; a.textContent = h.textContent; a.target = '_self';
-          li.appendChild(a);
-          ulStack[ulStack.length-1].appendChild(li);
-        });
-
-        if (holder) holder.appendChild(nav);
-        if (holderMobile) holderMobile.appendChild(nav.cloneNode(true));
-
-        // active link on scroll
-        const links = [
-          ...(holder ? holder.querySelectorAll('a') : []),
-          ...(holderMobile ? holderMobile.querySelectorAll('a') : [])
-        ];
-        const onScroll = () => {
-          for (let i = headingsArr.length - 1; i >= 0; i--) {
-            const top = headingsArr[i].getBoundingClientRect().top;
-            if (top - 60 <= 0) {
-              links.forEach(l => l.classList.remove('active'));
-              const id = '#' + headingsArr[i].id;
-              const actives = Array.from(links).filter(l => l.getAttribute('href') === id);
-              actives.forEach(a => a.classList.add('active'));
-              break;
-            }
-          }
-        };
-        window.addEventListener('scroll', onScroll);
-        onScroll();
-
-        // Close mobile accordion when a link inside it is clicked
-        if (holderMobile) {
-          const details = holderMobile.closest('details');
-          holderMobile.addEventListener('click', (ev) => {
-            const target = ev.target as Element | null;
-            const anchor = target && 'closest' in target ? (target as Element).closest('a') : null;
-            if (anchor instanceof HTMLAnchorElement && details && (details as HTMLDetailsElement).open) {
-              (details as HTMLDetailsElement).open = false;
-            }
-          });
-        }
-      };
-
-      if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', buildTOC, { once: true });
-      } else { buildTOC(); }
-    </script>
-
-    <!-- Removed JS fallback for language chips; labels handled by CSS/Shiki -->
+    
   </body>
 </html>
 

app/src/styles/_base.css

@@ -1,19 +1,6 @@
-/* ============================================================================ */
-/* Base / Reset */
-/* ============================================================================ */
-html { box-sizing: border-box; }
-*, *::before, *::after { box-sizing: inherit; }
-body { margin: 0; font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, Helvetica Neue, Arial, Apple Color Emoji, Segoe UI Emoji; color: var(--text-color); }
-audio { display: block; width: 100%; }
-/* Avoid constraining <main> inside grid; scope container sizing elsewhere if needed */
-/* main { max-width: 980px; margin: 24px auto; padding: 16px; } */
+@import "https://fonts.googleapis.com/css2?family=Source+Sans+Pro:ital,wght@0,200..900;1,200..900&display=swap";
 
-/* ============================================================================ */
-/* Typography (inspired by Distill) */
-/* ============================================================================ */
-html { font-size: 14px; line-height: 1.6; }
-@media (min-width: 768px) { html { font-size: 16px; } }
-@media (min-width: 1024px) { html { font-size: 17px; } }
+html { font-size: 16px; line-height: 1.6; }
 
 .content-grid main { color: var(--text-color); }
 .content-grid main p { margin: 0 0 var(--spacing-3); }
@@ -48,10 +35,14 @@ html { font-size: 14px; line-height: 1.6; }
 /* Do not underline heading links inside the article (not the TOC) */
 .content-grid main h2 a,
 .content-grid main h3 a,
-.content-grid main h4 a { color: inherit; border-bottom: none; text-decoration: none; }
+.content-grid main h4 a,
+.content-grid main h5 a,
+.content-grid main h6 a { color: inherit; border-bottom: none; text-decoration: none; }
 .content-grid main h2 a:hover,
 .content-grid main h3 a:hover,
-.content-grid main h4 a:hover { color: inherit; border-bottom: none; text-decoration: none; }
+.content-grid main h4 a:hover,
+.content-grid main h5 a:hover,
+.content-grid main h6 a:hover { color: inherit; border-bottom: none; text-decoration: none; }
 
 .content-grid main ul,
 .content-grid main ol { padding-left: 24px; margin: 0 0 var(--spacing-3); }
@@ -66,211 +57,12 @@ html { font-size: 14px; line-height: 1.6; }
   margin: var(--spacing-4) 0;
 }
 
-/* Rely on Shiki's own token spans; no class remap */
-/* Placeholder block (discreet centered text) */
-.placeholder-block {
-  display: grid;
-  place-items: center;
-  min-height: 120px;
-  color: var(--muted-color);
-  font-size: 12px;
-  border: 1px dashed var(--border-color);
-  border-radius: 8px;
-  background: var(--surface-bg);
-}
-
-/* Demo blocks for width helpers */
-.demo-wide,
-.demo-full-width {
-  display: grid;
-  place-items: center;
-  min-height: 150px;
-  color: var(--muted-color);
-  font-size: 12px;
-  border: 1px dashed var(--border-color);
-  border-radius: 8px;
-  background: var(--surface-bg);
-}
-
-
-.content-grid main table { border-collapse: collapse; width: 100%; margin: 0 0 var(--spacing-4); }
-.content-grid main th, .content-grid main td { border-bottom: 1px solid var(--border-color); padding: 6px 8px; text-align: left; font-size: 15px; }
-.content-grid main thead th { border-bottom: 1px solid var(--border-color); }
-
 .content-grid main hr { border: none; border-bottom: 1px solid var(--border-color); margin: var(--spacing-5) 0; }
 
-/*
-.code-block {
-  background: rgba(120, 120, 120, 0.5);
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  padding: var(--spacing-3);
-  font-size: 14px;
-  overflow: auto;
-}
-*/
-
-/* ============================================================================ */
-/* Media / Figures */
-/* ============================================================================ */
-img,
-picture {
-  max-width: 100%;
-  height: auto;
-  display: block;
-  position: relative;
-  z-index: var(--z-elevated);
-}
-
-/* Inline feature tags */
-.tag-list { display: flex; flex-wrap: wrap; gap: 8px; margin: 8px 0 16px; }
-.tag {
-  display: inline-flex;
-  align-items: center;
-  gap: 6px;
-  padding: 4px 8px;
-  font-size: 12px;
-  line-height: 1;
-  border-radius: 999px;
-  background: var(--surface-bg);
-  border: 1px solid var(--border-color);
-  color: var(--text-color);
-}
-[data-theme="dark"] .tag { background: #1a1f27; border-color: rgba(255,255,255,.15); }
-
-
-
-/* ============================================================================ */
-/* Figures, captions & image credits */
-/* ============================================================================ */
-figure { margin: 12px 0; }
-figcaption { text-align: left; font-size: 0.9rem; color: var(--muted-color); margin-top: 6px; }
-.image-credit { display: block; margin-top: 4px; font-size: 12px; color: var(--muted-color); }
-.image-credit a { color: inherit; text-decoration: underline; text-underline-offset: 2px; }
-
-/* Zoomable overlay container (if used by any lightbox implementation) */
-[data-zoom-overlay],
-.zoom-overlay {
-  position: fixed;
-  inset: 0;
-  z-index: var(--z-overlay);
-}
-
-/* Download link inside figures */
-figure .download-link { position: relative; z-index: var(--z-elevated); }
-
-/* ============================================================================ */
-/* Buttons (minimal, clean) */
-/* ============================================================================ */
-button, .button {
-  appearance: none;
-  background: linear-gradient(15deg, var(--primary-color) 0%, var(--primary-color-hover) 35%);
-  color: white!important;
-  border: 1px solid transparent;
-  border-radius: 6px;
-  padding: 8px 12px;
-  font-size: 14px;
-  line-height: 1;
-  cursor: pointer;
-  display: inline-block;
-  transition: background-color .15s ease, border-color .15s ease, box-shadow .15s ease, transform .02s ease;
-}
-/* Icon-only buttons: equal X/Y padding */
-button:has(> svg:only-child),
-.button:has(> svg:only-child) {
-  padding: 8px !important;
-}
-button:hover, .button:hover {
-  filter: brightness(96%);
-}
-button:active, .button:active {
-  transform: translateY(1px);
-}
-button:focus-visible, .button:focus-visible {
-  outline: none;
-}
-button:disabled, .button:disabled {
-  opacity: .6;
-  cursor: not-allowed;
-}
-
-/* Ghost/Muted button: subtle outline, primary color text/border */
-.button--ghost {
-  background: transparent !important;
-  color: var(--primary-color) !important;
-  border-color: var(--primary-color) !important;
-}
-.button--ghost:hover {
-  color: var(--primary-color-hover) !important;
-  border-color: var(--primary-color-hover) !important;
-  filter: none;
-}
-
-.button-group .button {
-  margin: 5px;
-}
-
-/* ============================================================================ */
-/* Print styles */
-/* ========================================================================= */
-@media print {
-  html, body { background: #fff; }
-  /* Margins handled by Playwright; avoid extra global margins */
-  body { margin: 0; }
-
-  /* Keep the banner (hero), hide non-essential UI elements */
-  #theme-toggle { display: none !important; }
-
-  /* Links: remove underline */
-  .content-grid main a { text-decoration: none; border-bottom: 1px solid rgba(0,0,0,.2); }
-
-  /* Avoid breaks inside complex blocks */
-  .content-grid main pre,
-  .content-grid main blockquote,
-  .content-grid main table,
-  .content-grid main figure { break-inside: avoid; page-break-inside: avoid; }
-
-  /* Soft page breaks around main headings */
-  .content-grid main h2 { page-break-before: auto; page-break-after: avoid; break-after: avoid-page; }
-
-  /* Small icon labels not needed when printing */
-  .code-lang-chip { display: none !important; }
-
-  /* Adjust more contrasty colors for print */
-  :root {
-    --border-color: rgba(0,0,0,.2);
-    --link-underline: rgba(0,0,0,.3);
-    --link-underline-hover: rgba(0,0,0,.4);
-  }
-
-  /* Force single column to reduce widows/orphans and awkward breaks */
-  .content-grid { grid-template-columns: 1fr !important; }
-  .toc, .right-aside, .toc-mobile { display: none !important; }
-  main > nav:first-of-type { display: none !important; }
-
-  /* Avoid page breaks inside complex visual blocks */
-  .hero,
-  .hero-banner,
-  .d3-galaxy,
-  .d3-galaxy svg,
-  .html-embed__card,
-  .html-embed__card,
-  .js-plotly-plot,
-  figure,
-  pre,
-  table,
-  blockquote,
-  .wide,
-  .full-width {
-    break-inside: avoid;
-    page-break-inside: avoid;
-  }
-  /* Prefer keeping header+lead together */
-  .hero { page-break-after: avoid; }
-}
-
 .muted {
   color: var(--muted-color);
 }
 
-
+[data-footnote-ref] {
+  margin-left: 4px;
+}

app/src/styles/_layout.css

@@ -1,96 +1,77 @@
 /* ============================================================================ */
-/* Layout – 3-column grid (TOC / Article / Aside) */
+/* Layout – 3-column grid (Table of Contents / Article / Aside) */
 /* ============================================================================ */
-:root {
-  --content-padding-x: 16px;
-}
 
-.content-grid { max-width: 1280px; margin: 0 auto; padding: 0 var(--content-padding-x); margin-top: 40px; display: grid; grid-template-columns: 220px minmax(0, 680px) 260px; gap: 32px; align-items: start; }
-.content-grid > main { max-width: 100%; margin: 0; padding: 0; }
-
-/* TOC (left column) */
-.toc { position: sticky; top: 24px; }
-.toc nav { border-left: 1px solid var(--border-color); padding-left: 16px; font-size: 13px; }
-.toc .title { font-weight: 600; font-size: 14px; margin-bottom: 8px; }
-
-/* Hide in-article TOC (duplicated by sticky aside) */
-main > nav:first-of-type { display: none; }
-
-/* TOC look & feel */
-.toc nav ul { margin: 0 0 6px; padding-left: 1em; }
-.toc nav li { list-style: none; margin: .25em 0; }
-.toc nav a { color: var(--text-color); text-decoration: none; border-bottom: none; }
-.toc nav > ul > li > a { font-weight: 700; }
-.toc nav a:hover { text-decoration: underline solid var(--muted-color); }
-.toc nav a.active { text-decoration: underline; }
-
-/* Mobile TOC accordion */
-.toc-mobile { display: none; margin: 8px 0 16px; }
-.toc-mobile > summary { cursor: pointer; list-style: none; padding: 8px 12px; border: 1px solid var(--border-color); border-radius: 8px; color: var(--text-color); font-weight: 600; }
-.toc-mobile[open] > summary { border-bottom-left-radius: 0; border-bottom-right-radius: 0; }
-.toc-mobile nav { border-left: none; padding: 10px 12px; font-size: 14px; border: 1px solid var(--border-color); border-top: none; border-bottom-left-radius: 8px; border-bottom-right-radius: 8px; }
-.toc-mobile nav ul { margin: 0 0 6px; padding-left: 1em; }
-.toc-mobile nav li { list-style: none; margin: .25em 0; }
-.toc-mobile nav a { color: var(--text-color); text-decoration: none; border-bottom: none; }
-.toc-mobile nav > ul > li > a { font-weight: 700; }
-.toc-mobile nav a:hover { text-decoration: underline solid var(--muted-color); }
-.toc-mobile nav a.active { text-decoration: underline; }
-
-/* Right aside (notes) */
-.right-aside { position: sticky; top: 24px; }
-.right-aside .aside-card { background: var(--surface-bg); border: 1px solid var(--border-color); border-radius: 8px; padding: 10px; margin-bottom: 10px; font-size: 0.9rem; color: var(--text-color); }
-
-/* Responsive – collapse to single column */
-@media (max-width: 1100px) {
-  .content-grid { grid-template-columns: 1fr; }
-  .toc { position: static; display: none; }
-  .toc-mobile { display: block; }
-  .right-aside { display: none; }
-  main > nav:first-of-type { display: block; }
+.content-grid {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 0 var(--content-padding-x);
+  margin-top: 40px;
+  display: grid;
+  grid-template-columns: 220px minmax(0, 680px) 260px;
+  gap: 32px;
+  align-items: start;
 }
 
+.content-grid > main {
+  max-width: 100%;
+  margin: 0;
+  padding: 0;
+}
 
+@media (--bp-content-collapse) {
+  .content-grid {
+    overflow: hidden;
+    display: block;
+    margin-top: var(--spacing-2);
+  }
 
-.margin-aside { position: relative; margin: 12px 0; }
+  .content-grid {
+    grid-template-columns: 1fr;
+  }
 
-.margin-aside__aside {
-  position: absolute;
-  top: 0;
-  right: -260px; /* push into the right grid column (width 260 + gap 32) */
-  width: 260px;
-  border-radius: 8px;
-  padding: 0 30px;
-  font-size: 0.9rem;
-  color: var(--muted-color);
-}
-@media (max-width: 1100px) {
-  .margin-aside__aside {
+  .table-of-contents {
     position: static;
-    width: auto;
-    margin-top: 8px;
+    display: none;
+  }
+
+  .table-of-contents-mobile {
+    display: block;
+  }
+
+  .footer-inner {
+    grid-template-columns: 1fr;
+    gap: 16px;
+  }
+
+  .footer-inner > h3 {
+    grid-column: auto;
+    margin-top: 16px;
+  }
+
+  .footer-inner {
+    display: block;
+    padding: 40px 16px;
   }
 }
 
 
+
 /* ============================================================================ */
 /* Width helpers – slightly wider than main column, and full-width to viewport */
 /* ---------------------------------------------------------------------------- */
-/* Usage in MDX: */
-/* <div className="wide"> ... </div> */
-/* <div className="full-width"> ... </div> */
-/* These center the content relative to the viewport while keeping it responsive. */
-/* */
-/* Notes: */
-/* - These helpers work inside the main article column; they break out visually */
-/*   to be wider or fully span the viewport. On small screens, they fall back to 100%. */
-/* - Adjust the target width in .wide if desired. */
+
 .wide,
-.full-width { box-sizing: border-box; position: relative; z-index: var(--z-elevated); }
+.full-width {
+  box-sizing: border-box;
+  position: relative;
+  z-index: var(--z-elevated);
+}
 
 .wide {
-  /* Target up to ~1400px while staying within viewport minus page gutters */
-  width: min(1400px, 100vw - 32px);
-  margin-left: 50%;
+  /* Target up to ~1100px while staying within viewport minus page gutters */
+  width: min(1100px, 100vw - 32px);
+  margin-left: calc(50% + var(--content-padding-x) * 2);
   transform: translateX(-50%);
 }
 
@@ -101,7 +82,7 @@ main > nav:first-of-type { display: none; }
   margin-right: calc(50% - 50vw);
 }
 
-@media (max-width: 1100px) {
+@media (--bp-content-collapse) {
   .wide,
   .full-width {
     width: 100%;
@@ -111,5 +92,40 @@ main > nav:first-of-type { display: none; }
   }
 }
 
+/* ------------------------------------------------------------------------- */
+/* Hero meta bar responsiveness                                               */
+/* Two columns at collapse breakpoint, then one column below small screens    */
+/* ------------------------------------------------------------------------- */
+@media (--bp-sm) {
+  header.meta .meta-container {
+    display: flex;
+    flex-wrap: wrap;
+    row-gap: 12px;
+    column-gap: 8px;
+    max-width: 100%;
+    padding: 0 var(--spacing-4);
+  }
+  header.meta .meta-container .meta-container-cell {
+    flex: 1 1 calc(50% - 8px);
+    min-width: 0;
+  }
+}
+
+@media (--bp-xxs) {
+  header.meta .meta-container .meta-container-cell {
+    flex-basis: 100%;
+    text-align: center;
+  }
+  /* Center ordered list numbers within meta (e.g., affiliations) */
+  header.meta .affiliations {
+    list-style-position: inside;
+    padding-left: 0;
+    margin-left: 0;
+  }
+  header.meta .affiliations li {
+    text-align: center;
+  }
+}
+
 
 

app/src/styles/_print.css

@@ -0,0 +1,68 @@
+
+/* ============================================================================ */
+/* Print styles */
+/* ========================================================================= */
+@media print {
+    html, body { background: #fff; }
+    /* Margins handled by Playwright; avoid extra global margins */
+    body { margin: 0; }
+  
+    /* Keep the banner (hero), hide non-essential UI elements */
+    #theme-toggle { display: none !important; }
+  
+    /* Links: remove underline */
+    .content-grid main a { text-decoration: none; border-bottom: 1px solid rgba(0,0,0,.2); }
+  
+    /* Avoid breaks inside complex blocks */
+    .content-grid main pre,
+    .content-grid main blockquote,
+    .content-grid main table,
+    .content-grid main figure { break-inside: avoid; page-break-inside: avoid; }
+  
+    /* Soft page breaks around main headings */
+    .content-grid main h2 { page-break-before: auto; page-break-after: avoid; break-after: avoid-page; }
+  
+    /* Small icon labels not needed when printing */
+    .code-lang-chip { display: none !important; }
+  
+    /* Adjust more contrasty colors for print */
+    :root {
+      --border-color: rgba(0,0,0,.2);
+      --link-underline: rgba(0,0,0,.3);
+      --link-underline-hover: rgba(0,0,0,.4);
+    }
+  
+    /* Force single column to reduce widows/orphans and awkward breaks */
+    .content-grid { grid-template-columns: 1fr !important; }
+    .table-of-contents, .right-aside, .table-of-contents-mobile { display: none !important; }
+    main > nav:first-of-type { display: none !important; }
+  
+    /* Avoid page breaks inside complex visual blocks */
+    .hero,
+    .hero-banner,
+    .d3-galaxy,
+    .d3-galaxy svg,
+    .html-embed__card,
+    .html-embed__card,
+    .js-plotly-plot,
+    figure,
+    pre,
+    table,
+    blockquote,
+    .wide,
+    .full-width {
+      break-inside: avoid;
+      page-break-inside: avoid;
+    }
+    /* Prefer keeping header+lead together */
+    .hero { page-break-after: avoid; }
+  }
+
+    
+  @media print {
+    .meta-container-cell--pdf {
+      display: none !important;
+    }
+  }
+  
+  

app/src/styles/_reset.css

@@ -0,0 +1,13 @@
+html { box-sizing: border-box; }
+*, *::before, *::after { box-sizing: inherit; }
+body { margin: 0; font-family: var(--default-font-family); color: var(--text-color); }
+audio { display: block; width: 100%; }
+
+img,
+picture {
+  max-width: 100%;
+  height: auto;
+  display: block;
+  position: relative;
+  z-index: var(--z-elevated);
+}

app/src/styles/_variables.css

@@ -1,28 +1,34 @@
 /* ============================================================================ */
-/* Theme Variables (inspired by Distill) */
+/* Design Tokens */
 /* ============================================================================ */
 :root {
-  /* Neutral palette */
+  /* Neutrals */
   --neutral-600: rgb(107, 114, 128);
   --neutral-400: rgb(185, 185, 185);
   --neutral-300: rgb(228, 228, 228);
   --neutral-200: rgb(245, 245, 245);
 
-  /* Primary brand color */
-  --primary-color: rgb(232, 137, 171);
-  --primary-color-hover: rgb(212, 126, 156);
+  --default-font-family: Source Sans Pro,ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";
+
+  /* Brand (OKLCH base + derived states) */
+  --primary-base: oklch(0.75 0.12 340);
+  --primary-color: var(--primary-base);
+  --primary-color-hover: oklch(from var(--primary-color) calc(l - 0.05) c h);
+  --primary-color-active: oklch(from var(--primary-color) calc(l - 0.10) c h);
   --on-primary: #ffffff;
 
+  /* Text & Surfaces */
   --text-color: rgba(0,0,0,.85);
   --muted-color: rgba(0,0,0,.6);
   --border-color: rgba(0,0,0,.1);
-
-  /* Light surfaces & links */
   --surface-bg: #fafafa;
   --code-bg: #f6f8fa;
-  --link-underline: var(--primary-color); /* based on --primary-color */
+
+  /* Links */
+  --link-underline: var(--primary-color);
   --link-underline-hover: var(--primary-color-hover);
 
+  /* Spacing scale */
   --spacing-1: 8px;
   --spacing-2: 12px;
   --spacing-3: 16px;
@@ -34,29 +40,64 @@
   --spacing-9: 64px;
   --spacing-10: 72px;
 
-  /* Z-index scale */
-  --z-base: 0;           /* background/base */
-  --z-content: 1;        /* regular content */
-  --z-elevated: 10;      /* wide/full-width blocks, images */
-  --z-overlay: 1000;     /* overlays/lightboxes */
-  --z-modal: 1100;       /* modals/dialogs */
-  --z-tooltip: 1200;     /* tooltips/popovers */
+  /* Custom Media aliases compiled by PostCSS */
+  @custom-media --bp-xxs (max-width: 320px);
+  @custom-media --bp-xs (max-width: 480px);
+  @custom-media --bp-sm (max-width: 640px);
+  @custom-media --bp-md (max-width: 768px);
+  @custom-media --bp-lg (max-width: 1024px);
+  @custom-media --bp-xl (max-width: 1280px);
+  @custom-media --bp-content-collapse (max-width: 1100px);
+
+  /* Layout */
+  --content-padding-x: 16px; /* default page gutter */
+  --block-spacing-y: var(--spacing-4); /* default vertical spacing between block components */
+
+  /* Config */
+  --palette-count: 6;
+
+  /* Button tokens */
+  --button-radius: 6px;
+  --button-padding-x: 12px;
+  --button-padding-y: 8px;
+  --button-font-size: 14px;
+  --button-icon-padding: 8px;
+  /* Big button */
+  --button-big-padding-x: 16px;
+  --button-big-padding-y: 12px;
+  --button-big-font-size: 16px;
+  --button-big-icon-padding: 12px;
+
+  /* Table tokens */
+  --table-border-radius: 8px;
+  --table-header-bg: oklch(from var(--surface-bg) calc(l - 0.02) c h);
+  --table-row-odd-bg: oklch(from var(--surface-bg) calc(l - 0.01) c h);
+
+  /* Z-index */
+  --z-base: 0;
+  --z-content: 1;
+  --z-elevated: 10;
+  --z-overlay: 1000;
+  --z-modal: 1100;
+  --z-tooltip: 1200;
 }
-/* Theme tokens for dark mode */
+
+/* ============================================================================ */
+/* Dark Theme Overrides */
+/* ============================================================================ */
 [data-theme="dark"] {
   --text-color: rgba(255,255,255,.9);
   --muted-color: rgba(255,255,255,.7);
   --border-color: rgba(255,255,255,.15);
   --surface-bg: #12151b;
   --code-bg: #12151b;
-  /* Primary in dark mode */
-  --primary-color: rgb(232, 137, 171);
-  --primary-color-hover: rgb(212, 126, 156);
+
+  /* Primary (lower L in dark) */
+  --primary-color: oklch(from var(--primary-base) calc(l - 0.08) c h);
+  --primary-color-hover: oklch(from var(--primary-color) calc(l - 0.05) c h);
+  --primary-color-active: oklch(from var(--primary-color) calc(l - 0.10) c h);
   --on-primary: #0f1115;
 
   color-scheme: dark;
   background: #0f1115;
-}
-
-
-
+}

app/src/styles/components/_button.css

@@ -0,0 +1,58 @@
+button, .button {
+    appearance: none;
+    background: linear-gradient(15deg, var(--primary-color) 0%, var(--primary-color-hover) 35%);
+    color: white!important;
+    border: 1px solid transparent;
+    border-radius: var(--button-radius);
+    padding: var(--button-padding-y) var(--button-padding-x);
+    font-size: var(--button-font-size);
+    line-height: 1;
+    cursor: pointer;
+    display: inline-block;
+    text-decoration: none;
+    transition: background-color .15s ease, border-color .15s ease, box-shadow .15s ease, transform .02s ease;
+  }
+  /* Icon-only buttons: equal X/Y padding */
+  button:has(> svg:only-child),
+  .button:has(> svg:only-child) {
+    padding: var(--button-icon-padding) !important;
+  }
+  button:hover, .button:hover {
+    filter: brightness(96%);
+  }
+  button:active, .button:active {
+    transform: translateY(1px);
+  }
+  button:focus-visible, .button:focus-visible {
+    outline: none;
+  }
+  button:disabled, .button:disabled {
+    opacity: .6;
+    cursor: not-allowed;
+  }
+  
+  /* Ghost/Muted button: subtle outline, primary color text/border */
+  .button--ghost {
+    background: transparent !important;
+    color: var(--primary-color) !important;
+    border-color: var(--primary-color) !important;
+  }
+  .button--ghost:hover {
+    color: var(--primary-color-hover) !important;
+    border-color: var(--primary-color-hover) !important;
+    filter: none;
+  }
+  
+  /* Big button: larger padding and font size */
+  .button--big {
+    padding: var(--button-big-padding-y) var(--button-big-padding-x) !important;
+    font-size: var(--button-big-font-size);
+  }
+  .button--big:has(> svg:only-child) {
+    padding: var(--button-big-icon-padding) !important;
+  }
+  
+  .button-group .button {
+    margin: 5px;
+  }
+  

app/src/styles/components/_code.css

@@ -1,8 +1,10 @@
+/* ============================================================================ */
+/* Inline code */
+/* ============================================================================ */
 code {
   font-size: 14px;
   font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
   background-color: var(--code-bg);
-  padding: 0.2em 0.4em;
   border-radius: 0.3em;
   border: 1px solid var(--border-color);
   color: var(--text-color);
@@ -10,81 +12,141 @@ code {
   line-height: 1.5;
 }
 
-/* Sync Shiki variables with current theme */
-/* Standard wrapper look for code blocks */
-.astro-code { border: 1px solid var(--border-color); border-radius: 6px; padding: 0; font-size: 14px; --code-gutter-width: 2.5em; }
-.astro-code { position: relative; }
+/* ============================================================================ */
+/* Shiki code blocks */
+/* ============================================================================ */
+.astro-code {
+  position: relative;
+  border: 1px solid var(--border-color);
+  border-radius: 6px;
+  padding: 0;
+  font-size: 14px;
+  --code-gutter-width: 2.5em;
+}
+
+/* Shared sizing & horizontal scroll for code containers */
+.astro-code,
+section.content-grid pre {
+  overflow-x: auto;
+  width: 100%;
+  max-width: 100%;
+  box-sizing: border-box;
+  -webkit-overflow-scrolling: touch;
+  padding: 0;
+  margin-bottom: var(--block-spacing-y) !important;
+}
 
-/* Prevent code blocks from breaking layout on small screens */
-.astro-code { overflow-x: auto; width: 100%; max-width: 100%; box-sizing: border-box; -webkit-overflow-scrolling: touch; }
-section.content-grid pre { overflow-x: auto; width: 100%; max-width: 100%; box-sizing: border-box; -webkit-overflow-scrolling: touch; padding: 0; }
-section.content-grid pre code { display: inline-block; min-width: 100%; }
+section.content-grid pre { margin: 0; }
+
+section.content-grid pre code {
+  display: inline-block;
+  min-width: 100%;
+}
 
-/* Wrap long lines on mobile to avoid overflow (URLs, etc.) */
 /* Wrap long lines only on small screens to prevent layout overflow */
-@media (max-width: 1100px) {
+@media (--bp-content-collapse) {
   .astro-code,
-  section.content-grid pre { white-space: pre-wrap; overflow-wrap: anywhere; word-break: break-word; }
-  section.content-grid pre code { white-space: pre-wrap; display: block; min-width: 0; }
+  section.content-grid pre {
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+    word-break: break-word;
+  }
+
+  section.content-grid pre code {
+    white-space: pre-wrap;
+    display: block;
+    min-width: 0;
+  }
 }
 
-html[data-theme='light'] .astro-code { background-color: var(--code-bg); }
-
-html[data-theme='dark'] .astro-code { background-color: var(--shiki-dark-bg); }
+/* Themes */
+[data-theme='light'] .astro-code { background-color: var(--code-bg); }
 
 /* Apply token color from per-span vars exposed by Shiki dual themes */
-html[data-theme='light'] .astro-code span { color: var(--shiki-light) !important; }
-html[data-theme='dark'] .astro-code span { color: var(--shiki-dark) !important; }
+[data-theme='light'] .astro-code span { color: var(--shiki-light) !important; }
+[data-theme='dark'] .astro-code span { color: var(--shiki-dark) !important; }
 
-/* Token color remapping using Shiki CSS variables on the wrapper */
 /* Optional: boost contrast for light theme */
-html[data-theme='light'] .astro-code {
+[data-theme='light'] .astro-code {
   --shiki-foreground: #24292f;
   --shiki-background: #ffffff;
 }
 
 /* Line numbers for Shiki-rendered code blocks */
-.astro-code code { counter-reset: astro-code-line; display: block; background: none; border: none;  }
-.astro-code .line { display: inline-block; position: relative; padding-left: calc(var(--code-gutter-width) + var(--spacing-1)); min-height: 1.25em; }
-.astro-code .line::before { counter-increment: astro-code-line; content: counter(astro-code-line); position: absolute; left: 0; top: 0; bottom: 0; width: calc(var(--code-gutter-width)); text-align: right; color: var(--muted-color); opacity: .30; user-select: none; padding-right: var(--spacing-2); border-right: 1px solid var(--border-color); }
+.astro-code code {
+  counter-reset: astro-code-line;
+  display: block;
+  background: none;
+  border: none;
+}
+
+.astro-code .line {
+  display: inline-block;
+  position: relative;
+  padding-left: calc(var(--code-gutter-width) + var(--spacing-1));
+  min-height: 1.25em;
+}
+
+.astro-code .line::before {
+  counter-increment: astro-code-line;
+  content: counter(astro-code-line);
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: calc(var(--code-gutter-width));
+  text-align: right;
+  color: var(--muted-color);
+  opacity: .3;
+  user-select: none;
+  padding-right: var(--spacing-2);
+  border-right: 1px solid var(--border-color);
+}
+
 .astro-code .line:empty::after { content: "\00a0"; }
+
 /* Hide trailing empty line added by parsers */
 .astro-code code > .line:last-child:empty { display: none; }
 
-/* (Removed JS fallback chip: label handled via CSS in _base.css) */
-
-/* Rehype-injected wrapper for non-Shiki pre blocks */
+/* ============================================================================ */
+/* Non-Shiki pre wrapper (rehype) */
+/* ============================================================================ */
 .code-card { position: relative; }
+
 .code-card .code-copy {
-  position: absolute; top: 6px; right: 6px; z-index: 3; padding: 6px 12px; border: none;
+  position: absolute;
+  top: var(--spacing-2);
+  right: var(--spacing-2);
+  z-index: 3;
+  display: none;
 }
-.code-card .code-copy svg { width: 16px; height: 16px; display: block; fill: currentColor; }
-.code-card pre { margin: 0; margin-bottom: var(--spacing-1);}
 
-/* Discreet filetype/language label shown under the Copy button */
-.code-card::after {
-  content: attr(data-language);
-  position: absolute;
-  top: 8px;
-  right: 56px; /* leave room for copy button */
-  font-size: 10px;
-  line-height: 1;
-  text-transform: uppercase;
-  color: var(--muted-color);
-  pointer-events: none;
-  z-index: 2;
+.code-card:hover .code-copy {
+  display: block;
 }
 
-/* When no copy button (single-line), keep the label in the top-right corner */
-.code-card.no-copy::after { top: 8px; right: 8px; }
+.code-card .code-copy svg {
+  width: 16px;
+  height: 16px;
+  display: block;
+  fill: currentColor;
+}
 
+.code-card pre { margin: 0 0 var(--spacing-1); }
 
+/* When no copy button (single-line), keep the label in the top-right corner */
+.code-card.no-copy::after { top: 8px; right: 8px; }
 
-/* Overrides inside Accordion: remove padding and border on code containers */
+/* ============================================================================ */
+/* Contextual overrides */
+/* ============================================================================ */
+/* Inside Accordions: remove padding and border on code containers */
 .accordion .astro-code { padding: 0; border: none; }
 
-/* Language/extension vignette for Shiki blocks (bottom-right, discreet) */
-.astro-code::after {
+/* ============================================================================ */
+/* Language/extension vignette (bottom-right, discreet) */
+/* ============================================================================ */
+/* .astro-code::after {
   content: attr(data-language);
   position: absolute;
   right: 0;
@@ -96,11 +158,11 @@ html[data-theme='light'] .astro-code {
   background: var(--surface-bg);
   border-top: 1px solid var(--border-color);
   border-left: 1px solid var(--border-color);
-  opacity: 0.5;
-  border-radius: 8px 0 0 0; /* round only top-left */
+  opacity: 1;
+  border-radius: 8px 0 0 0; 
   padding: 4px 6px;
   pointer-events: none;
-}
+} */
 
 /* Fallback if Shiki uses data-lang instead of data-language */
 .astro-code[data-lang]::after { content: attr(data-lang); }

app/src/styles/components/_footer.css

@@ -1,56 +0,0 @@
-.distill-footer { contain: layout style; font-size: 0.8em; line-height: 1.7em; margin-top: 60px; margin-bottom: 0; border-top: 1px solid rgba(0, 0, 0, 0.1); color: rgba(0, 0, 0, 0.5); }
-.footer-inner { max-width: 1280px; margin: 0 auto; padding: 60px 16px 48px; display: grid; grid-template-columns: 220px minmax(0, 680px) 260px; gap: 32px; align-items: start; }
-
-/* Use the parent grid (3 columns like .content-grid) */
-.citation-block,
-.references-block { display: contents; }
-.citation-block > h3,
-.references-block > h3 { grid-column: 1; font-size: 15px; margin: 0; text-align: right; padding-right: 30px; }
-.citation-block > :not(h3),
-.references-block > :not(h3) { grid-column: 2; }
-@media (max-width: 1100px) {
-  .footer-inner { grid-template-columns: 1fr; gap: 16px; }
-  .footer-inner > h3 { grid-column: auto; margin-top: 16px; }
-}
-.citation-block h3 { margin: 0 0 8px; }
-.citation-block h4 { margin: 16px 0 8px; font-size: 14px; text-transform: uppercase; color: var(--muted-color); }
-
-.citation-block p, .references {
-  margin-top:0;
-}
-
-/* Distill-like appendix citation styling */
-.citation {
-  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
-  font-size: 11px;
-  line-height: 15px;
-  border-left: 1px solid rgba(0, 0, 0, 0.1);
-  padding-left: 18px;
-  border: 1px solid rgba(0,0,0,0.1);
-  background: rgba(0, 0, 0, 0.02);
-  padding: 10px 18px;
-  border-radius: 3px;
-  color: rgba(150, 150, 150, 1);
-  overflow: hidden;
-  margin-top: -12px;
-  white-space: pre-wrap;
-  word-wrap: break-word;
-}
-
-.citation a { color: rgba(0, 0, 0, 0.6); text-decoration: underline; }
-
-.citation.short { margin-top: -4px; }
-
-.references-block h3 { margin: 0; }
-
-/* Distill-like list styling for references/footnotes */
-.references-block ol { padding: 0 0 0 15px; }
-@media (min-width: 768px) { .references-block ol { padding: 0 0 0 30px; margin-left: -30px; } }
-.references-block li { margin-bottom: 1em; }
-.references-block a { color: rgba(0, 0, 0, 0.6); }
-
-@media (max-width: 1100px) {
-  .footer-inner { display: block; padding: 40px 16px; }
-}
-
-

app/src/styles/components/_poltly.css

@@ -1,44 +0,0 @@
-/* ============================================================================ */
-/* Plotly – fragments & controls */
-/* ============================================================================ */
-.html-embed__card svg text { fill: var(--text-color) !important; }
-.html-embed__card label { color: var(--text-color) !important; }
-.plotly-graph-div { width: 100% !important; min-height: 320px; }
-@media (max-width: 768px) { .plotly-graph-div { min-height: 260px; } }
-[id^="plot-"] { display: flex; flex-direction: column; align-items: center; gap: 15px; }
-.plotly_caption { font-style: italic; margin-top: 10px; }
-.plotly_controls { display: flex; flex-wrap: wrap; justify-content: center; gap: 30px; }
-.plotly_input_container { display: flex; align-items: center; flex-direction: column; gap: 10px; }
-.plotly_input_container > select { padding: 2px 4px; line-height: 1.5em; text-align: center; border-radius: 4px; font-size: 12px; background-color: var(--neutral-200); outline: none; border: 1px solid var(--neutral-300); }
-.plotly_slider { display: flex; align-items: center; gap: 10px; }
-.plotly_slider > input[type="range"] { -webkit-appearance: none; appearance: none; height: 2px; background: var(--neutral-400); border-radius: 5px; outline: none; }
-.plotly_slider > input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; width: 18px; height: 18px; border-radius: 50%; background: var(--primary-color); cursor: pointer; }
-.plotly_slider > input[type="range"]::-moz-range-thumb { width: 18px; height: 18px; border-radius: 50%; background: var(--primary-color); cursor: pointer; }
-.plotly_slider > span { font-size: 14px; line-height: 1.6em; min-width: 16px; }
-
-/* ---------------------------------------------------------------------------- */
-/* Dark mode overrides for Plotly readability */
-/* ---------------------------------------------------------------------------- */
-[data-theme="dark"] .html-embed__card .xaxislayer-above text,
-[data-theme="dark"] .html-embed__card .yaxislayer-above text,
-[data-theme="dark"] .html-embed__card .infolayer text,
-[data-theme="dark"] .html-embed__card .legend text,
-[data-theme="dark"] .html-embed__card .annotation text,
-[data-theme="dark"] .html-embed__card .colorbar text,
-[data-theme="dark"] .html-embed__card .hoverlayer text { fill: #fff !important; }
-
-[data-theme="dark"] .html-embed__card .xaxislayer-above path,
-[data-theme="dark"] .html-embed__card .yaxislayer-above path,
-[data-theme="dark"] .html-embed__card .xlines-above,
-[data-theme="dark"] .html-embed__card .ylines-above { stroke: rgba(255,255,255,.35) !important; }
-
-[data-theme="dark"] .html-embed__card .gridlayer path { stroke: rgba(255,255,255,.15) !important; }
-
-/* Legend and hover backgrounds */
-[data-theme="dark"] .html-embed__card .legend rect.bg { fill: rgba(0,0,0,.25) !important; stroke: rgba(255,255,255,.2) !important; }
-[data-theme="dark"] .html-embed__card .hoverlayer .bg { fill: rgba(0,0,0,.8) !important; stroke: rgba(255,255,255,.2) !important; }
-
-/* Colorbar background (keep gradient intact) */
-[data-theme="dark"] .html-embed__card .colorbar .cbbg { fill: rgba(0,0,0,.25) !important; stroke: rgba(255,255,255,.2) !important; }
-
-

app/src/styles/components/_table.css

@@ -0,0 +1,95 @@
+.content-grid main table {
+    border-collapse: collapse;
+    table-layout: auto;
+    margin: 0;
+  }
+  .content-grid main th, .content-grid main td {
+    border-bottom: 1px solid var(--border-color);
+    padding: 6px 8px;
+    text-align: left;
+    font-size: 15px;
+    white-space: nowrap; /* prevent squashing; allow horizontal scroll instead */
+  }
+  .content-grid main thead th { border-bottom: 1px solid var(--border-color); }
+  .content-grid main thead th {
+    border-bottom: 1px solid var(--border-color);
+  }
+  .content-grid main thead th {
+    background: var(--table-header-bg);
+    padding-top: 10px;
+    padding-bottom: 10px;
+    font-weight: 600;
+  }
+  
+  .content-grid main hr {
+    border: none;
+    border-bottom: 1px solid var(--border-color);
+    margin: var(--spacing-5) 0;
+  }
+  
+  /* Scroll wrapper: keeps table 100% width but enables horizontal scroll when needed */
+  .content-grid main .table-scroll {
+    width: 100%;
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+    border: 1px solid var(--border-color);
+    border-radius: var(--table-border-radius);
+    background: var(--surface-bg);
+    margin: 0 0 var(--block-spacing-y);
+  }
+  .content-grid main .table-scroll > table {
+    width: fit-content;
+    min-width: 100%;
+    max-width: none;
+  }
+  /* Vertical dividers between columns (no outer right border) */
+  .content-grid main .table-scroll > table th,
+  .content-grid main .table-scroll > table td {
+    border-right: 1px solid var(--border-color);
+  }
+  .content-grid main .table-scroll > table th:last-child,
+  .content-grid main .table-scroll > table td:last-child {
+    border-right: none;
+  }
+  .content-grid main .table-scroll > table thead th:first-child {
+    border-top-left-radius: var(--table-border-radius);
+  }
+  .content-grid main .table-scroll > table thead th:last-child {
+    border-top-right-radius: var(--table-border-radius);
+  }
+  .content-grid main .table-scroll > table tbody tr:last-child td:first-child {
+    border-bottom-left-radius: var(--table-border-radius);
+  }
+  .content-grid main .table-scroll > table tbody tr:last-child td:last-child {
+    border-bottom-right-radius: var(--table-border-radius);
+  }
+  /* Zebra striping for odd rows */
+  .content-grid main .table-scroll > table tbody tr:nth-child(odd) td {
+    background: var(--table-row-odd-bg);
+  }
+  /* Remove bottom border on last row */
+  .content-grid main .table-scroll > table tbody tr:last-child td {
+    border-bottom: none;
+  }
+  
+  /* Accordion context: remove outer borders/radius and fit content flush */
+  .accordion .accordion__content .table-scroll {
+    border: none;
+    border-radius: 0;
+    margin: 0;
+  }
+  .accordion .accordion__content .table-scroll > table thead th:first-child,
+  .accordion .accordion__content .table-scroll > table thead th:last-child,
+  .accordion .accordion__content .table-scroll > table tbody tr:last-child td:first-child,
+  .accordion .accordion__content .table-scroll > table tbody tr:last-child td:last-child {
+    border-radius: 0;
+  }
+  
+  /* Fallback for browsers without fit-content support */
+  @supports not (width: fit-content) {
+    .content-grid main .table-scroll > table {
+      width: max-content;
+      min-width: 100%;
+    }
+  }
+  

app/src/styles/components/_tag.css

@@ -0,0 +1,14 @@
+.tag-list { display: flex; flex-wrap: wrap; gap: 8px; margin: 8px 0 16px; }
+
+.tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 10px 16px;
+  font-size: 12px;
+  line-height: 1;
+  border-radius: 100px;
+  background: var(--surface-bg);
+  border: 1px solid var(--border-color);
+  color: var(--text-color);
+}

app/src/styles/global.css

@@ -1,56 +1,27 @@
 @import './_variables.css';
+@import './_reset.css';
 @import './_base.css';
 @import './_layout.css';
-@import './components/_footer.css';
+@import './_print.css';
 @import './components/_code.css';
-@import './components/_poltly.css';
+@import './components/_button.css';
+@import './components/_table.css';
+@import './components/_tag.css';
 
-/* Dark-mode form tweak */
-[data-theme="dark"] .plotly_input_container > select { background-color: #1a1f27; border-color: var(--border-color); color: var(--text-color); }
-
-[data-theme="dark"] .html-embed__card:not(.is-frameless) { background: #12151b; border-color: rgba(255,255,255,.15); }
-[data-theme="dark"] .right-aside .aside-card { background: #12151b; border-color: rgba(255,255,255,.15); }
-[data-theme="dark"] .content-grid main pre { background: #12151b; border-color: rgba(255,255,255,.15); }
-[data-theme="dark"] .toc nav { border-left-color: rgba(255,255,255,.15); }
-[data-theme="dark"] .distill-footer { border-top-color: rgba(255,255,255,.15); color: rgba(200,200,200,.8); }
-[data-theme="dark"] .citation { background: rgba(255,255,255,0.04); border-color: rgba(255,255,255,.15); color: rgba(200,200,200,1); }
-[data-theme="dark"] .citation a { color: rgba(255,255,255,0.75); }
-
-/* Opt-in zoomable images */
-img[data-zoomable] { cursor: zoom-in; }
-.medium-zoom--opened img[data-zoomable] { cursor: zoom-out; }
-
-/* Download button for img[data-downloadable] */
-figure.has-dl-btn { position: relative; }
-.dl-host { position: relative; }
-.img-dl-wrap { position: relative; display: inline-block; }
-.img-dl-btn {
-  position: absolute;
-  right: 8px;
-  bottom: 8px;
-  align-items: center;
-  justify-content: center;
-  width: 30px;
-  height: 30px;
-  border-radius: 6px;
-  color: white;
-  text-decoration: none;
-  border: 1px solid rgba(255,255,255,0.25);
-  z-index: var(--z-elevated);
-  display: none;
+.demo-wide,
+.demo-full-width {
+  display: grid;
+  place-items: center;
+  min-height: 150px;
+  color: var(--muted-color);
+  font-size: 12px;
+  border: 1px dashed var(--border-color);
+  border-radius: 8px;
+  background: var(--surface-bg);
+  margin-bottom: var(--block-spacing-y);
 }
-.img-dl-btn svg { width: 18px; height: 18px; fill: currentColor; }
-.img-dl-wrap:hover .img-dl-btn { display: inline-flex; }
-[data-theme="dark"] .img-dl-btn { background: rgba(255,255,255,0.15); color: white; border-color: rgba(255,255,255,0.25); }
-[data-theme="dark"] .img-dl-btn:hover { background: rgba(255,255,255,0.25); }
-
-/* ============================================================================ */
-/* Theme Toggle button (moved from component) */
-/* ============================================================================ */
-#theme-toggle { display: inline-flex; align-items: center; gap: 8px; border: none; background: transparent; padding: 6px 10px; border-radius: 8px; cursor: pointer; margin: 12px 16px; color: var(--text-color) !important; }
-#theme-toggle .icon.dark { display: none; }
-[data-theme="dark"] #theme-toggle .icon.light { display: none; }
-[data-theme="dark"] #theme-toggle .icon.dark { display: inline; }
-#theme-toggle .icon { filter: none !important; }
-
 
+.mermaid {
+    background: none!important;
+    margin-bottom: var(--block-spacing-y) !important;
+}