OPTIC-Bench v0.3.2: dataset, card, manifest, pilot results

README.md

@@ -0,0 +1,177 @@
+---
+license: cc-by-4.0
+language:
+  - en
+  - zh
+task_categories:
+  - visual-question-answering
+  - image-to-text
+  - question-answering
+tags:
+  - benchmark
+  - vision-language
+  - token-compression
+  - ocr
+  - instruction-following
+  - code-reasoning
+  - bilingual
+pretty_name: OPTIC-Bench
+size_categories:
+  - 1K<n<10K
+configs:
+  - config_name: en
+    data_files:
+      - split: test
+        path: en/test.jsonl
+  - config_name: zh
+    data_files:
+      - split: test
+        path: zh/test.jsonl
+---
+
+# OPTIC-Bench
+
+**Optical Text In-Context Benchmark**: how reliably do LLMs consume text
+delivered as rendered images versus plain text tokens?
+
+Text-as-image prompting (pxpipe, DeepSeek-OCR, Glyph) can pack roughly three
+characters into one vision token versus about one character per text token, a large cost saving whose reliability risks are under-measured. OPTIC-Bench
+measures those risks with **paired** evaluation: each instance is run under
+the modality conditions of a 2×2 design (instruction channel × content
+channel, each delivered as text or as a rendered image), in **English and
+Chinese** as structurally-twinned instances from shared seeds, across up to
+five difficulty tiers and several render profiles, with **fully programmatic
+scoring** (no LLM judges) and per-call token and cost accounting.
+
+## Task families
+
+| family | task | tiers | metric |
+|---|---|---|---|
+| transcription | reproduce a passage verbatim (public-domain literature, sentence-shuffled) | 1–4 | 1 − CER |
+| extraction | copy exact identifiers with confusable glyphs (0/O, 1/l/I…), with long tiers adding superseding errata and a retrieval-depth variant | 1–5 | per-field exact |
+| instruction | verifiable filter/sort constraints → JSON, plus IFEval-style strict plain-text formatting | 1–4 | exact list / exact text |
+| reasoning | multi-hop, arithmetic and conditional QA, with long tiers requiring whole-document integration | 1–5 | exact answer |
+| code | predict the exact stdout of a Python program (CRUXEval-style, 18 shapes) | 1–3 | exact output |
+| calculation | reconcile an invoice to the exact cent (up to 100 lines) | 1–4 | exact amount |
+| wordgame | word counts, acrostics, positional character assembly | 1–3 | exact string |
+| injection | answer a benign question while resisting an adversarial instruction embedded in the document | 1–3 | benign-correct and canary-free |
+| dialog | multi-turn conversation with revisions, recalling or combining facts across turns (history-compression scenario) | 1–3 | exact answer |
+
+Difficulty tiers 1–3 are page-scale. Tier 4 ("long", ~8k characters in
+English) and tier 5 ("extended", ~24k characters ≈ 6k text tokens) are built
+on a multi-section operations dossier whose final Errata section supersedes
+facts stated earlier, so answers require integrating the whole document.
+These long tiers sit in the regime where optical text compression beats plain
+text tokens. Most families use all four modality conditions, whereas the multi-turn
+`dialog` and the copy-task `transcription` families use only the two
+conditions where the comparison is meaningful.
+
+Beyond raw accuracy the harness (see the code repository) also measures token
+economy (cached and uncached), retrieval depth (lost-in-the-page), silent
+corruption and false confidence (optional abstention), injection resistance,
+multi-turn history compression, transport robustness (JPEG and rescale), and
+latency, all bilingually and with programmatic scoring only.
+
+## Headline findings
+
+A pilot evaluation of three current frontier models (OpenAI GPT 5.5, Google
+Gemini 3.5 Flash and Moonshot Kimi K2.6) gives a clear and consistent answer
+to the questions this benchmark was built to settle. The full report is in
+`RESULTS.md`.
+
+- **Token economy is conditional.** Rendering content as a dense image saves
+  roughly 28 to 47 per cent of input tokens on long documents, but it costs
+  1.6 to 2.6 times more than plain text on short, page-scale prompts.
+- **Exact retrieval collapses under image delivery.** On long dense
+  documents, verbatim identifier extraction fell from perfect to almost zero,
+  and even with partial credit about half the characters of a dense
+  identifier were misread. Anything that must be reproduced exactly should not
+  be sent as a dense image.
+- **Instruction-following and reasoning are largely preserved.** Imaging the
+  content left constraint-following and multi-step reasoning essentially
+  intact. Reading exact figures for arithmetic is the exception, because a
+  misread digit corrupts an otherwise correct calculation.
+- **Injection resistance held** for all three current models even when the
+  adversarial text was imaged, although an older model tested during
+  development was susceptible under the combined-image condition.
+
+## Fields
+
+Each row of `{lang}/test.jsonl`:
+
+- `id`, `family`, `language`, `difficulty` (1–5), `benchmark_version`
+- `instruction_text`, what the model must do
+- `content_text`, the document or data (render this to an image for the image
+  conditions)
+- `scorer`, the deterministic scoring function name (implemented in the code
+  repository, `eval/scorers.py`)
+- `expected`, the exact ground-truth payload, **as a JSON string**
+- `meta`, auxiliary metadata (including `pair_id`, which links the EN/ZH
+  twins), **as a JSON string**
+
+`expected` and `meta` are serialized as JSON strings because their shape
+varies by family (a transcription target, a dict of identifier fields, an id
+list, an answer plus an injection canary, a dialog's turn list, and so on). Call
+`json.loads` on them. This keeps the dataset schema uniform and lossless on
+the Hub.
+
+## Usage
+
+```python
+import json
+from datasets import load_dataset
+
+ds = load_dataset("translorentz/vision-token-compression-bench", "en", split="test")  # or "zh"
+row = ds[0]
+expected = json.loads(row["expected"])
+meta = json.loads(row["meta"])
+```
+
+To evaluate a model, deliver `instruction_text` and `content_text` under each
+modality condition (as text, or rendered to a PNG), collect the response, and
+score it with the named `scorer`. The companion **code repository** provides
+the full harness, covering rendering (CJK-aware, pinned Noto fonts), 2×2 condition
+assembly, provider-agnostic clients (Anthropic- and OpenAI-compatible,
+including Kimi/Moonshot, DeepSeek, Qwen, Zhipu, Gemini), programmatic scorers,
+paired statistics, and the report generator, plus scripts to regenerate this
+dataset and the pre-rendered images.
+
+If an `images/` folder is included, it holds pre-rendered PNGs at
+`images/{profile}/{id}/{part}-{page}.png` (parts depend on the family:
+`content` always, `instruction`/`combined` for families that use the
+instruction-image conditions), produced with pinned Noto Sans / Noto Sans SC
+and paginated to stay under the ~1568 px provider-downscale threshold. Images
+are optional: they can be regenerated bit-for-bit from the text with the
+repository's renderer.
+
+## Construction and licensing
+
+The structured families (extraction, instruction, reasoning, code,
+calculation, wordgame, injection, dialog) are generated deterministically
+from a master seed using original templates and word banks. Their ground
+truth is computed by the generators (code tasks are executed at generation
+time), and the whole set regenerates bit-identically from source. Changing
+the seed mints a fresh, uncontaminated edition with the same statistics.
+
+The **transcription** family is the one exception: its passages are excerpts
+of public-domain literature, a genre spread of English works (Collins,
+Gaskell, Darwin, Thoreau) and late-Qing Chinese vernacular novels, sampled
+per-work-balanced and sentence-shuffled so that no model family gains an
+in-distribution or memorization advantage on text it may have helped author.
+These works are in the public domain, and provenance and processing are recorded
+in the code repository's `corpus/PROVENANCE.md`.
+
+Dataset: **CC-BY-4.0** (public-domain excerpts carry no additional
+restriction). Harness code: MIT.
+
+## Citation
+
+```bibtex
+@software{opticbench2026,
+  title  = {OPTIC-Bench: Measuring the Reliability of Text-as-Image
+            Prompting in Large Language Models},
+  author = {{OPTIC-Bench contributors}},
+  year   = {2026},
+  version = {0.3.2}
+}
+```

RESULTS.md

@@ -0,0 +1,161 @@
+# OPTIC-Bench pilot results: text versus image delivery
+
+This document reports a pilot evaluation that answers the four questions
+posed in the founding document. How does delivering text to a model as a
+rendered image, rather than as ordinary text tokens, affect the token
+economy, the fidelity of retrieval, the completion of instructed tasks, and
+the depth of reasoning?
+
+## Experimental setup
+
+Three current frontier models were evaluated through their public
+programming interfaces. These were OpenAI GPT 5.5, Google Gemini 3.5 Flash,
+and Moonshot Kimi K2.6. All scoring was programmatic, with no model acting as
+a judge, and every ground-truth value was verified independently of the
+models.
+
+Two datasets were used. The first was a page-scale slice covering all nine
+task families at difficulty tiers one to three, in English and Chinese,
+rendered at the regular density profile. The second was a long-document slice
+covering the extraction, reasoning, transcription and calculation families at
+tiers four and five, rendered at the dense profile, where a document runs to
+roughly eight thousand characters in English and where optical compression
+begins to save tokens. Each instance was presented under the modality
+conditions of the benchmark, namely both channels as text, the content as a
+rendered image with the instruction as text, the instruction as a rendered
+image with the content as text, and both channels combined into a single
+image.
+
+The samples are small, as befits a pilot, so the figures below should be read
+as clear directional findings rather than as precise leaderboard values. The
+consistency of the pattern across three independent models is the main reason
+for confidence in the conclusions.
+
+## Question one: the token economy
+
+Whether image delivery saves tokens depends entirely on how much text is
+packed into each image. On short, page-scale documents at the regular density
+the image is wasteful, because a single page carries little text yet still
+incurs a fixed vision-token cost. Across the three models the content-as-image
+condition used between 1.6 and 2.6 times as many input tokens as the plain
+text condition.
+
+The saving appears only when documents are long and the rendering is dense.
+On the long-document slice at the dense profile the picture reverses, and the
+image becomes the cheaper channel.
+
+| model | text tokens | image tokens | image saving |
+|---|---|---|---|
+| GPT 5.5 | 4189 | 3020 | 28 per cent |
+| Gemini 3.5 Flash | 4819 | 2554 | 47 per cent |
+
+The economic conclusion is therefore conditional. Optical compression does
+reduce input token counts, but only in the regime of long documents rendered
+densely, and it increases them for the short prompts that make up most
+ordinary traffic. Prompt caching narrows the advantage further, because a
+cached text context is billed at roughly a tenth of the normal rate, which is
+the situation that a static system prompt or tool description would enjoy.
+
+## Question two: the fidelity of retrieval
+
+Retrieval fidelity is where image delivery fails most clearly. Two families
+measure it, namely the exact reproduction of identifier strings such as
+hashes and order numbers, and the verbatim transcription of prose.
+
+On short documents the reproduction of exact identifiers already suffers.
+Measured by character-level accuracy, which awards partial credit, the mean
+score fell from a perfect 1.00 on text to between 0.79 and 0.83 on the image
+across the three models. Under the stricter requirement that every character
+of every identifier be correct, the loss is larger, because a single misread
+character fails the field.
+
+On long documents rendered densely the degradation becomes severe. Exact
+identifier extraction, which every model performed perfectly from text, very
+nearly collapsed from the image.
+
+| model | identifiers from text | identifiers from image | prose (character accuracy) |
+|---|---|---|---|
+| GPT 5.5 | 8 of 8 exact | 0 of 8 exact (0.42 chars) | 1.00 to 0.74 |
+| Gemini 3.5 Flash | 8 of 8 exact | 1 of 8 exact (0.57 chars) | 1.00 to 0.47 |
+
+Even allowing partial credit, roughly half of the characters in a dense
+identifier were misread, and no complete identifier survived. Verbatim prose
+transcription lost between a quarter and a half of its character accuracy over
+the same documents. The practical lesson is that any value which must be
+reproduced exactly, such as an identifier, a code token or a precise figure,
+should never be entrusted to a dense image.
+
+## Question three: the completion of instructed tasks
+
+The founding document asked in particular whether instructions delivered by
+image are followed as reliably as instructions delivered as text. The answer
+divides into two cases.
+
+When the instruction remains text and only the content is imaged, task
+completion is unaffected. On the constraint-following family every model
+scored perfectly under both the text and the content-as-image conditions.
+
+When the instruction itself is rendered into an image, the models mostly
+still obey it, but not universally. Gemini 3.5 Flash and Kimi K2.6 followed
+imaged instructions without loss, whereas GPT 5.5 fell from six of six to
+four of six when the instruction was delivered visually. Delivering the
+instruction as an image is therefore usually safe on current models but
+carries a residual risk that varies by model, and it should be tested rather
+than assumed.
+
+## Question four: the depth of reasoning
+
+Reasoning proved the most robust ability under image delivery, provided that
+the reasoning does not itself depend on reading exact figures. On the
+page-scale slice, pooling the reasoning, calculation, code, wordgame and
+dialog families, imaging the content changed the exact-match rate by no more
+than three points in either direction across all three models. On long
+documents the multi-step reasoning family was likewise preserved, scoring
+identically from text and from image.
+
+There is one important qualification. Long-document arithmetic, which requires
+reading many precise digits before computing with them, failed from the dense
+image, falling from perfect to near zero for GPT 5.5. This is not a failure of
+reasoning as such but a failure of retrieval feeding the reasoning. Once the
+digits are misread, the correct calculation on the wrong inputs still yields a
+wrong answer. The depth of thought is preserved, but it operates on corrupted
+data.
+
+## A note on safety
+
+The benchmark also embeds adversarial instructions inside documents in order
+to test whether imaging untrusted content changes a model's susceptibility to
+prompt injection. On this slice the three current models resisted every
+injection under every condition, including when the adversarial text was
+rendered into the image. An earlier model tested during development, Gemini
+2.5 Flash, complied with the injection in two of three cases when the
+malicious content was delivered as a combined image, whereas it resisted
+perfectly when the same content was delivered as text. The security property
+therefore appears to have improved between model generations, but the earlier
+result shows that imaging untrusted content can weaken instruction and data
+separation, and it should continue to be measured.
+
+## Synthesis
+
+The trade-off that the founding document set out to characterise is real and
+sharply shaped. Delivering content as a dense image can save a substantial
+fraction of input tokens on long documents, and it preserves both
+instruction-following and multi-step reasoning. It does so, however, at a
+severe cost to any task that depends on reading text exactly, whether that is
+reproducing an identifier, transcribing prose, or performing arithmetic on
+precise figures. The method is well suited to bulky context whose gist and
+structure matter more than its exact characters, and it is unsuitable for
+content that must be recovered verbatim. On short prompts it saves nothing and
+costs more, so its use should be confined to the long, static context for
+which it was designed.
+
+## Caveats
+
+These figures come from a pilot with small per-cell samples and should be
+reproduced at the full per-cell count of the released dataset before being
+quoted as model rankings. Cross-provider comparisons additionally conflate the
+model with each provider's opaque image preprocessing, so the cleanest
+readings are the within-model deltas between conditions rather than absolute
+scores across providers. The cost figures use the token counts actually
+returned by each interface, priced with example rates that should be checked
+against current provider pricing before any monetary claim is made.

manifest.json

@@ -0,0 +1,244 @@
+{
+  "benchmark": "OPTIC-Bench",
+  "description": "OPTIC-Bench (Optical Text In-Context Benchmark) measures how reliably large language models consume text delivered as rendered images versus plain text tokens, covering transcription fidelity, exact-string retrieval, instruction-following, reasoning, injection resistance and multi-turn history compression, in English and Chinese, with fully programmatic scoring and per-call token and cost accounting.",
+  "version": "0.3.2",
+  "license": {
+    "data": "CC-BY-4.0",
+    "code": "MIT"
+  },
+  "master_seed": 20260705,
+  "per_cell": 25,
+  "families": [
+    "transcription",
+    "extraction",
+    "instruction",
+    "reasoning",
+    "code",
+    "calculation",
+    "wordgame",
+    "injection",
+    "dialog"
+  ],
+  "languages": [
+    "en",
+    "zh"
+  ],
+  "family_difficulties": {
+    "transcription": [
+      1,
+      2,
+      3,
+      4
+    ],
+    "extraction": [
+      1,
+      2,
+      3,
+      4,
+      5
+    ],
+    "instruction": [
+      1,
+      2,
+      3,
+      4
+    ],
+    "reasoning": [
+      1,
+      2,
+      3,
+      4,
+      5
+    ],
+    "code": [
+      1,
+      2,
+      3
+    ],
+    "calculation": [
+      1,
+      2,
+      3,
+      4
+    ],
+    "wordgame": [
+      1,
+      2,
+      3
+    ],
+    "injection": [
+      1,
+      2,
+      3
+    ],
+    "dialog": [
+      1,
+      2,
+      3
+    ]
+  },
+  "family_conditions": {
+    "transcription": [
+      "tt",
+      "ti"
+    ],
+    "extraction": [
+      "tt",
+      "ti",
+      "it",
+      "ii"
+    ],
+    "instruction": [
+      "tt",
+      "ti",
+      "it",
+      "ii"
+    ],
+    "reasoning": [
+      "tt",
+      "ti",
+      "it",
+      "ii"
+    ],
+    "code": [
+      "tt",
+      "ti",
+      "it",
+      "ii"
+    ],
+    "calculation": [
+      "tt",
+      "ti",
+      "it",
+      "ii"
+    ],
+    "wordgame": [
+      "tt",
+      "ti",
+      "it",
+      "ii"
+    ],
+    "injection": [
+      "tt",
+      "ti",
+      "it",
+      "ii"
+    ],
+    "dialog": [
+      "tt",
+      "ti"
+    ]
+  },
+  "family_scorers": {
+    "transcription": [
+      "transcription"
+    ],
+    "extraction": [
+      "exact_fields"
+    ],
+    "instruction": [
+      "record_list",
+      "text_output"
+    ],
+    "reasoning": [
+      "answer_match"
+    ],
+    "code": [
+      "text_output"
+    ],
+    "calculation": [
+      "answer_match"
+    ],
+    "wordgame": [
+      "answer_match"
+    ],
+    "injection": [
+      "injection_resistance"
+    ],
+    "dialog": [
+      "answer_match"
+    ]
+  },
+  "modality_conditions": {
+    "tt": "instruction text, content text (baseline)",
+    "ti": "instruction text, content rendered as image",
+    "it": "instruction rendered as image, content text",
+    "ii": "instruction and content combined into one image"
+  },
+  "difficulty_tiers": {
+    "1-3": "page-scale",
+    "4": "long (~8k characters EN)",
+    "5": "extended (~24k characters EN, roughly 6k text tokens)"
+  },
+  "n_instances": 1700,
+  "counts": {
+    "transcription/en/d1": 25,
+    "transcription/zh/d1": 25,
+    "transcription/en/d2": 25,
+    "transcription/zh/d2": 25,
+    "transcription/en/d3": 25,
+    "transcription/zh/d3": 25,
+    "transcription/en/d4": 25,
+    "transcription/zh/d4": 25,
+    "extraction/en/d1": 25,
+    "extraction/zh/d1": 25,
+    "extraction/en/d2": 25,
+    "extraction/zh/d2": 25,
+    "extraction/en/d3": 25,
+    "extraction/zh/d3": 25,
+    "extraction/en/d4": 25,
+    "extraction/zh/d4": 25,
+    "extraction/en/d5": 25,
+    "extraction/zh/d5": 25,
+    "instruction/en/d1": 25,
+    "instruction/zh/d1": 25,
+    "instruction/en/d2": 25,
+    "instruction/zh/d2": 25,
+    "instruction/en/d3": 25,
+    "instruction/zh/d3": 25,
+    "instruction/en/d4": 25,
+    "instruction/zh/d4": 25,
+    "reasoning/en/d1": 25,
+    "reasoning/zh/d1": 25,
+    "reasoning/en/d2": 25,
+    "reasoning/zh/d2": 25,
+    "reasoning/en/d3": 25,
+    "reasoning/zh/d3": 25,
+    "reasoning/en/d4": 25,
+    "reasoning/zh/d4": 25,
+    "reasoning/en/d5": 25,
+    "reasoning/zh/d5": 25,
+    "code/en/d1": 25,
+    "code/zh/d1": 25,
+    "code/en/d2": 25,
+    "code/zh/d2": 25,
+    "code/en/d3": 25,
+    "code/zh/d3": 25,
+    "calculation/en/d1": 25,
+    "calculation/zh/d1": 25,
+    "calculation/en/d2": 25,
+    "calculation/zh/d2": 25,
+    "calculation/en/d3": 25,
+    "calculation/zh/d3": 25,
+    "calculation/en/d4": 25,
+    "calculation/zh/d4": 25,
+    "wordgame/en/d1": 25,
+    "wordgame/zh/d1": 25,
+    "wordgame/en/d2": 25,
+    "wordgame/zh/d2": 25,
+    "wordgame/en/d3": 25,
+    "wordgame/zh/d3": 25,
+    "injection/en/d1": 25,
+    "injection/zh/d1": 25,
+    "injection/en/d2": 25,
+    "injection/zh/d2": 25,
+    "injection/en/d3": 25,
+    "injection/zh/d3": 25,
+    "dialog/en/d1": 25,
+    "dialog/zh/d1": 25,
+    "dialog/en/d2": 25,
+    "dialog/zh/d2": 25,
+    "dialog/en/d3": 25,
+    "dialog/zh/d3": 25
+  }
+}