Image recognition, text reading and GUI grounding by cited exemplars over fixed descriptors; no learned weights.

Oracle7-Vision 2.0 (internal)

Status: public release. Prometheus7 Research Institute, 2026-09-25. Source SHA-256 (sorted vision/*.py + eval/*.py on box four, /opt/oracle7-vision): b796b4eeff80115425d97fa0157e0dcc09187c698ca87e950d10a19891199a02 (the final code, including vision/screen.py; the C-locale sorted concatenation of vision/*.py and eval/*.py). Each result file also carries the SHA of the code that produced it. The exemplar results were produced by 9f571b4b… (before the glyph and chart modules were added; the exemplar path itself is unchanged).

What it is

Vision has no trained weights. An image is described by fixed descriptors:

• HOG at two cell sizes,
• LBP texture histograms,
• an HSV colour histogram,
• a small thumbnail.

Each descriptor group goes through a seeded random projection and is bound to a role vector by circular convolution (HRR, D = 2048). The groups are then bundled into one vector. Recognition is a k-nearest-neighbour vote over a store of labelled exemplars.

Each answer cites the store indices that voted for it. When the vote margin falls below a threshold chosen on the dev split, Vision abstains.

Text is read by synthesis:

• Glyphs are rendered in many open-licence fonts.
• Their geometry is measured against the baseline and cap height.
• A line is segmented by recognition (dynamic programming over merge/split atoms).
• Tokens are repaired with digit/letter maps.

Chart questions are answered by fixed rules over the words Vision has read and positioned: axis ticks, legend, bar/label alignment.

Protocol (fixed before any held-out data was read)

Task	Development	Held-out, scored once
Classification (MNIST, Fashion-MNIST, CIFAR-10, CIFAR-100; Hugging Face parquet, official splits)	last 10% of official train; store = first 90%	official test; store = full train
Text reading (rendered lines)	store font families, seeds 0–199	font families the store has never seen (fixed hash split), fresh seeds 20000–20399
ChartQA (HuggingFaceM4/ChartQA)	val split	official test split (2,500: 1,250 human + 1,250 augmented)

Every accuracy is reported with a Wilson 95% CI.

Classification is checked by an instrument mutant: the store labels are shuffled, and accuracy must fall to chance.

Results (held-out)

Classification: full coverage, accuracy [95% CI]

Dataset	Vision	Raw-pixel kNN	Nearest class mean	Mutant (chance)
MNIST	98.58% [98.33, 98.79]	97.56%	91.12%	10.18% (10%)
Fashion-MNIST	90.46% [89.87, 91.02]	87.00%	74.76%	9.84% (10%)
CIFAR-10	62.99% [62.04, 63.93]	46.22%	43.85%	10.26% (10%)
CIFAR-100	35.38% [34.45, 36.32]	22.37%	23.44%	0.99% (1%)

Selective accuracy uses the thresholds that gave 70% coverage on dev:

Dataset	Held-out coverage	Accuracy on answered
Fashion-MNIST	69.3%	98.77%
CIFAR-10	68.1%	76.39%
CIFAR-100	70.6%	45.58%

MNIST's vote margin saturates: at both dev thresholds, 90.7% of test images are answered at 99.85% accuracy.

Queries take about 2–2.6 ms on one CPU. The store is 410–490 MB.

Text reading in unseen fonts: character error rate (lower is better)

Reader	CER	Exact line
v0, first held-out run (seeds 10000–10399, since retired)	0.3025	4.3%
Shape only (geometry weight 0)	0.2615	6.25%
v1	0.1955	20.0%
v1 on development fonts	0.1237	34.5%

The held-out fonts are Caladea, Carlito, Latin Modern Roman Demi, Mulish, Oswald, Raleway and Roboto.

ChartQA test (relaxed accuracy, the standard metric)

Split	Accuracy	Coverage	Accuracy on answered
All 2,500	3.64%	33.8%	10.8%
Human questions	1.68%
Augmented questions	5.60%

By rule (n answered): lookup 27.0% (226), argmax label 13.5% (52), min 7.6% (53), max 5.6% (215), max−min 5.3% (38), average 3.1% (131), count 1.0% (101). There were 1,652 abstentions.

ScreenSpot: GUI grounding (instruction + screenshot → click; correct = inside the target box)

• Data: bevaya/ScreenSpot, the renamed rootsautomation/ScreenSpot, 1,272 items.
• Split, fixed before any scoring: dev = index % 5 == 0 (255 items); held-out = the other 1,017, scored once.
• Threshold: the dev sweep chose 0.0. Abstaining counts as wrong, and answering beat abstaining at every threshold.
• Code SHA: b796b4eeff80115425d97fa0157e0dcc09187c698ca87e950d10a19891199a02.

	Held-out click accuracy	Coverage
Vision, all 1,017	21.34% [18.93, 23.96]	53.4% (39.96% right on answered)
Text targets (569)	36.0%	64.9%
Icon targets (448)	2.7%	38.8%
Mobile / desktop / web	29.9% / 18.4% / 13.8%
Baseline: click the screen centre	2.46%
Baseline: click a random read token	2.95%
Dev (255)	21.2%	48.6%

Published click accuracy on the same benchmark: GPT-4V 16.2%, CogAgent 47.4%, SeeClick 53.4%.

Method (vision/screen.py):

1. Each pixel is compared with its local background, so text of either polarity becomes dark on white.
2. Components that cannot be glyphs (taller than 48 px or wider than 120 px) are erased.
3. The glyph reader reads the tokens.
4. The instruction's content words are matched to token spans by edit similarity, and the click is the centre of the best span.

The first dev run was killed for memory at 100 items. The fixes changed only resource use:

• a pixel bound on reader upscaling (off by default, so the OCR and ChartQA paths are unchanged),
• streaming parquet batches,
• a chunked glyph classifier that computes each row identically.

Failures, stated plainly

• ChartQA is weak. Published multimodal LLMs score 60–90% on ChartQA; Vision scores 3.6%. The rule set covers only a third of the questions. On the questions it does answer it is right about one time in ten, because reading real chart images is far below the rendered-line OCR number. Human-written questions need reasoning the rule set does not have. This result is the honest floor of the method, not a competitive score.
• CIFAR is far from learned models. Fixed descriptors plus kNN reach 63% on CIFAR-10 and 35% on CIFAR-100. Trained CNNs exceed 95%. The gains over raw pixels (+16.8 and +13.0 points) are real; the absolute level is not competitive.
• Text reading is on rendered lines, not photographs or scans. A CER of 0.20 in unseen fonts is a measurement on clean synthetic text at 11–26 px. Typical errors are merged words ("JulyConodo"), extra spaces inside numbers ("1 1 1.49") and o/a confusions.
• ScreenSpot icons: 2.7%. An icon target has no text to read, and the method has no icon vocabulary. Among text targets, wrong clicks are mostly a second occurrence of the same word (a heading instead of a menu item), or a partial match ("To help" for "need some help").
• Not evaluated: DocVQA, VQAv2, TextVQA. The method has no component for open-ended visual questions. These are the next scope, and they are not claimed.

What the evidence supports

On standard benchmarks, a deterministic descriptor + HRR + exemplar-kNN recogniser with no learned weights:

• beats raw-pixel and class-mean baselines on all four classification sets;
• abstains usefully (accuracy rises sharply as coverage falls);
• cites the training exemplars behind each answer;
• is verified by a shuffled-label mutant that falls to chance.

Its text reader transfers to font families it has never seen, with an error rate that fell from 0.30 to 0.20 between v0 and v1, measured on fresh seeds.

The same reader grounds GUI instructions on real screenshots at 21.3%: more than seven times the centre and random-token baselines and above published GPT-4V, with the gap to trained grounding models (SeeClick 53.4%) almost entirely on icons.

Reproduce (box four)

cd /opt/oracle7-vision
venv/bin/python eval/eval_exemplar.py <mnist|fashion|cifar10|cifar100>
venv/bin/python eval/eval_glyph_ocr.py
venv/bin/python eval/eval_chartqa.py test
venv/bin/python eval/eval_screenspot.py dev 0      # chooses the threshold
venv/bin/python eval/eval_screenspot.py heldout 0.0

Result files are in results/, with a copy beside this card.