Benchmark · photography and local models

How you word the question matters more than model size

A benchmark on real photographs, and how much of the error was my own fault

Simone · August 2026 · entirely local · Italiano

Why

Benchmarks for models that "see" run on academic datasets, UI screenshots, stock imagery. Almost nobody puts them in front of real photography: backlight, chiaroscuro, motion blur, darkness, ambiguous composition. And the people who could judge the result, photographers, are not in the local-model community.

I have an archive I own the rights to, and twelve years spent photographing. I put the two together.

The starting point was a practical question: if I want a model running on my own laptop to label my archive, which one do I pick? The answer I found is not the one I was looking for, and it is more useful.


The dataset

133 photographs, 51 different shoots, 1330 human judgements. They all come from my own archive.

Chosen for difficulty, not for beauty: night scenes with artificial light (40), backlight and silhouettes (29), high-contrast black and white (18), crowds (17), portraits (15), dim interiors (5), plus a sample of ordinary photographs (9) that exists to show what the models get right.

Ten yes/no questions per photograph, never free description. A four-billion parameter model is bad at "describe this photo" and decent at "which of these ten tags apply": it produces fluent prose that is useless to measure. Each tag is asked separately, one question at a time. Ticking a single list gives unstable answers; one question at a time does not.

What was excluded, and why I say so. Three model-generated or test images, which got in through a flaw in my automatic selection: a benchmark measuring models on real photography cannot contain synthetic images. Fourteen duplicates of the same frame, which got in because the filter only compared new photos against each other. Fifty-four extra frames from shoots already represented at least three times: they added repetition, not evidence. Everything is marked in the file with its reason, not deleted.

How reliable the annotator is. The fourteen duplicates were annotated twice without my noticing. Comparing the two passes: 104 identical judgements out of 106, 98%. That is a measure of annotator stability that almost no dataset reports, and here it arrived by accident. "Uncertain" was an allowed answer and was used: 1.7% of judgements.

The machine. Sections 1-4 were measured on a MacBook Air M4 with 16 GB of unified memory; sections 5-8 on a MacBook Pro M5 Pro with 24 GB, where an 8B at Q8 precision finally fits. Accuracies do not depend on the machine. Timings do, and every timing comparison in this article is between measurements taken on the same one. Entirely local: no cloud, no paid API, nothing rented.


The results

1. Question wording beats model size

The sorgente tag asked: «Si vede dentro l'inquadratura una sorgente di luce: sole, lampada, finestra o porta illuminata?» (is a light source visible inside the frame: sun, lamp, window or lit doorway?)

The 4-billion model answered "yes" just 18 times out of 126, and missed 55 photographs where the light was in the middle of the frame. It looked like blindness. The raw answers gave the reason: «No, the photo was taken at night and there is no sun». It was answering the first example in the list rather than the question.

I rewrote the question keeping the meaning identical: «Nella fotografia si vede una luce accesa?» (is a lit light visible in the photograph?). Same 126 photos, same ground truth, same model.

wordingqwen3-vl:4bqwen3-vl:8b
with the list of examples47%70%
without the list82%91%
Same 126 photographs, same ground truth, same model. Only the wording changes.

Thirty-five points on the small model, twenty on the large one, without touching a single weight. And more to the point: the 4 GB model with the right question (82%) beats the 6 GB model with the wrong one (70%).

Any comparison between models that holds the prompt fixed, which is almost all of them, is also measuring, and perhaps mostly measuring, its own wording.

The explanation I gave here, "it answers the first example", turned out to be incomplete. Sections 7 and 8 correct it: it is not the list, it is a first example the image contradicts, and how small the model is matters a great deal.

2. Negation breaks the large model

A third wording, the same thing with reversed polarity: «Nella fotografia manca qualsiasi luce accesa visibile?» (is any visible lit light absent from the photograph?)

The 8-billion model answers "yes" once out of 126. It always says "no, the light is not missing", regardless of the image: it gets all 64 photographs where the light genuinely was absent wrong. It does not see badly. It does not process the negation, and answers as if the question were the affirmative one.

The 4-billion model, on the same cases, answers "yes" 16 times: not many, but not a blockage either.

The model that looked more robust is the one that falls apart on a change of word a human reader would not even notice.

3. Same average, opposite defects

Across all ten questions the two models are indistinguishable: 90% ±2 both. Six gigabytes against four, and 45% more time, buy nothing on the average.

But the average hides everything:

qwen3-vl:4bqwen3-vl:8b
sorgente, a lit light is visible48%71%
volto, facial features are distinguishable96%81%
The two questions where the models diverge most. On the other eight they are within a point or two of each other.

It has to be counted per scene, not per frame, or one bad evening disguises itself as a trend: of the small model's 65 errors on sorgente, 34 come from three night shoots and 14 from a single one. Counted properly the picture holds anyway: the small model gets sorgente wrong in 23 shoots out of 51, the large one gets volto wrong in 12.

If your work is night scenes with lights in frame, you want the large model. If you need faces, you want the small one. A single-score leaderboard would say they are equivalent, and would have you choose at random.

4. Half my questions measured nothing

This one is against me and has to be said.

For each tag I compared the model against a parrot that always answers the most frequent answer:

tagparrot4b8b
molte, more than five people53%97%98%
notte, night60%96%93%
sorgente, lit light visible51%48%71%
volto, a readable face75%96%81%
mono, monochrome78%99%100%
esterno, outdoors79%93%91%
ombra, black background75%79%77%
mare, the sea is visible88%99%100%
persone, at least one person83%97%98%
silhouette, backlit subject97%96%91%
The parrot always answers the most frequent answer without looking at the image. A model that does not beat it is measuring nothing.

silhouette has four "yes" out of 132 photographs: the parrot beats both models. That 96%, which looked like an excellent result, says nothing at all. ombra sits four points above the parrot, which is noise.

A tag measures something only if the two answers are balanced. It is no accident that the only genuinely informative tag is sorgente, at 49% "yes", and that it is the one everything else came out of. Accuracy percentages without the parrot beside them are decoration.

5. Q4 against Q8: before the numbers, the model stops answering

This test was planned from the start and I had never run it, because on the laptop I had then an 8B at Q8 precision did not fit in memory. Now it does, and the question is simple: does the less compressed version make fewer mistakes?

The first run said no. In fact it said Q8 was clearly worse. That was false, and the way it was false matters more than the answer.

At Q8 the 8b was not answering. A third of the time it returned nothing: one token generated, then stop. The score was being computed only over the times an answer arrived, that is over a subset chosen by the failure itself. The cause was not the model but one line of my code: the <think></think> prefill, which exists to stop thinking models from spending all their tokens reasoning. On Q4 it works. On Q8 it makes the model emit the end token immediately.

Written across several lines, the 8b answers every time again. But then it is the 4b at Q8 that stops obeying the format and starts describing the photograph in English: "The image shows a group of people performing on an outdoor stage". It was not even visible, because my reader has a fallback that looks for a "yes" or a "no" inside the text, and it was finding them inside the prose. A description was being counted as an answer.

Here is how many answers are genuinely in the format asked for, a single word, depending on a whitespace difference in one line of prompt:

<think></think>across several linesno prefill
4b Q4100%100%76%
4b Q814%17%100%
8b Q495%100%78%
8b Q869%100%100%
Share of answers that are genuinely a single word. Not accuracy: whether an answer arrived at all.

There is no single line that works for all four. With the prefill the Q4 models answer and the 4b at Q8 writes prose; without it, the 4b at Q8 answers and both Q4 models go silent. This is not an obstacle to work around. It is the result.

Measured again with each model in the configuration where it obeys, all four at 100% format compliance and 1300 judgements each:

Q4Q8
4b90.1%86.5%Q4 better, intervals do not overlap
8b88.5%89.2%not distinguishable from noise
Each model in the configuration where it obeys the format, 1300 judgements each. Wilson 95% intervals.

So: Q8 is not worth it. On the small model it gets worse, on the large one nothing measurable changes, and it costs twice the memory. On 24 GB shared with the operating system that is a practical answer: keep Q4 and spend the memory on something else.

Once again the average hides, and this time in the same direction on both sizes:

question4b8b
silhouette−38%−22%
sorgente+6%+16%
ombra+7%+8%

Q8 recovers where Q4 was weakest, the light source and the shadow, and collapses on silhouette. That it is consistent across two different sizes says it is not noise. That silhouette has four "yes" out of 132 says not to lean on it too hard anyway: the paragraph above applies.

One note worth more than the table. Simply moving from <think></think> to the multi-line prefill shifts the 8b at Q4 from 90.3% to 88.5%. Almost two points from a whitespace difference, on the same model and the same photographs. If you want a reason to distrust single-score leaderboards, this is it.

6. On a completely different family, it happens again

Two related models so far. Does the same thing hold elsewhere?

SigLIP 2 is not a model that answers. It is a contrastive dual encoder: it puts photographs and phrases in the same space and compares them. It generates nothing, has no prompt, cannot misread an instruction. If the wording effect were a quirk of models that write, it should not be here.

Same hand-annotated photographs, 128 of the 133 that are also in the archive, same ten tags. Three wordings per tag, written down before looking at any results and all three reported: the benchmark question word for word, a short phrase in Italian, the same phrase in English. The metric is average precision, which has no threshold to tune, compared against the base rate, which is the AP of a random ordering.

tagbasebenchmark questionshort phrasein English
mare12%70%95%99%
silhouette3%75%86%92%
mono20%93%81%95%
molte48%64%91%94%
sorgente50%47%69%82%
notte41%43%79%64%
persone83%84%94%97%
esterno78%77%86%90%
ombra25%31%43%29%
volto76%70%67%71%
Average precision against the base rate, which is the AP of a random ordering. The three wordings were written down before any result was seen.

Average gain over the base rate: +22 points with the benchmark question, +35 with the short phrase, +37 in English.

The rows in bold are the ones where the benchmark question sits below chance: sorgente 47% against a 50% base, esterno 77% against 78%, notte 43% against 41%. Writing the same thing in three words takes them to 69%, 86%, 79%. On sorgente, in English, 82%: thirty-five points from wording alone, again, and on exactly the tag everything else came out of.

So no, it was not a quirk of models that write. It happens to a model that does not write either.

Two things have to be said against this result. First, volto stays below the base rate with all three wordings. SigLIP does not see that tag, and there the 4b scores 96%. It is not a better model, it is blind to different things. Second, three wordings are few, and the fact that English wins almost everywhere reinforces a doubt the article already declares: that part of what I am measuring is linguistic competence rather than visual. Section 8 goes and measures it.

7. The defect, built on purpose

Up to here, one badly written question found by accident and rewritten. But finding a correlation on a single case proves nothing: you have to manufacture the defect and see whether it appears.

In section 1 the explanation was "it answers the first example in the list". Wrong, or at least incomplete. The second run narrowed it: with a list of examples that are true for the photograph nothing happens, notte goes from 96% to 97%. The damage only arrives with a first example the image contradicts.

The first run used only two questions, but four models, to separate "a defect of small models" from "a defect of qwen":

modelquestionhealthytrue examplesfalse examplep
qwen3-vl 4bnotte96%97%81%0.0002
qwen3-vl 4bvolto96%—58%2e-11
qwen3-vl 8bnotte93%92%95%0.2
qwen3-vl 8bvolto81%—71%0.02
gemma-3 4bnotte84%59%74%0.001
gemma-3 4bvolto91%—80%0.01
gemma-3 27bnotte77%80%81%0.2
gemma-3 27bvolto92%—85%0.1
p is McNemar's paired test against the healthy question: the same photographs under two wordings are not independent samples, and an ordinary test would report inflated significance.

*First run, Italian only. gemma-3 4b is the control that matters: different family, same size as the fragile model. It loses 25 points on night, where qwen loses nothing, and with true examples it collapses where qwen holds. The defect does not belong to one family: it belongs to the size.*

Then I widened it. Five healthy benchmark questions, and for each one the same question with a list whose first example is almost always false for these photographs. Not picked by intuition, measured first against the archive's own descriptions:

tagfirst examplehow often it is true
nottestars, moon2 out of 174
moltea full stadium0 out of 224
marea lighthouse1 out of 116
monosepia0 out of 123
How often the first example in each poisoned list is actually true of these photographs, measured against the archive's own descriptions.

The fifth is volto, and it is not in the table because its first example, "eyeglasses", is a detail inside a face, and the archive's descriptions do not write down the details of faces: the section above measures exactly that. There I estimated the frequency by looking at the photographs.

Then everything crossed with three languages and three models from two families. 9044 queries, zero unreadable answers.

The damage, in points, against the same question without the list:

questionmodellanguagehealthypoisoneddamagep
volto4bItalian96%60%-365e-11
volto4bSpanish94%67%-272e-08
volto4bEnglish88%65%-242e-07
volto8bItalian81%69%-120.009
volto8bSpanish88%85%-40.3
volto8bEnglish72%60%-120.0007
volto27BItalian92%85%-60.12
volto27BEnglish95%82%-130.0005
notte4bItalian96%81%-150.0002
notte4bSpanish91%90%-11
notte4bEnglish92%92%-11
notte8bItalian92%89%-40.38
notte8bSpanish90%90%+0—
notte8bEnglish95%97%+20.37
notte27BItalian77%81%+40.23
notte27BEnglish83%80%-30.29
mare4bItalian99%89%-100.0009
mare4bEnglish100%99%-11
mare8bItalian100%99%-11
mare8bEnglish100%100%+0—
molte4bItalian97%88%-90.003
molte4bEnglish96%96%+00.62
molte8bItalian98%90%-80.009
molte8bEnglish95%92%-40.23
mono4bItalian99%98%-11
mono4bEnglish99%98%-11
mono8bItalian100%98%-20.25
mono8bEnglish100%100%+0—
Damage is the poisoned question minus the healthy one, on the same photographs. p is McNemar's paired test: the same photos under two wordings are not independent samples, and an ordinary test would report inflated significance. Rows in evidence lose 9 points or more.

The control holds: the list with true examples does no damage anywhere, ten cells between −4 and +6, all noise. It is not the list. It is the false example.

And the defect is not a property of vision-language models in general. It is a disease of the small ones. On the 4-billion model it bites in four tags out of five; on the 8-billion, in two; on gemma at 27 billion it is noise. On notte the scale is orderly: −15, −4, +4.

mono never moves, and it is clear why: it starts at 99% on a global property of the image, black and white against colour, where there is nothing to look for inside the frame and no margin to lose.

8. And language? Yes, but less than it looked

The broken sorgente question, translated literally into English, list of examples included and without improving it, goes from 46% to 87% on the 4b and from 54% to 86% on the 8b. It looked enormous, and for a day I believed I had "the defect depends on the language" in my hands.

The data in section 7 cuts it down to size, and rightly so.

On the small model language matters. On the same four tags, in the order volto, notte, mare, molte: in Italian −36, −15, −10, −9; in English −24, −1, −1, 0. Spanish, which is far more abundant than Italian in training corpora, sits in between on volto: −27 between −36 and −24.

On the other two models it does not matter. On the 8b the damage is identical in both languages; on gemma English is actually worse than Italian, −13 against −6.

So this is not "models understand Italian worse", which would be old and well known. It is something narrower and more useful:

A badly written question holds up in English and gives way in Italian, but only if the model is small. On a large model it gives way equally in both, or not at all.

The practical consequence, which is why this section exists: if you use a four-billion model in your own language, you have to check your questions one by one, and the average will not tell you, because nine questions out of ten are perfectly fine. With a 27B the problem does not arise.


And the other nine questions?

Once you have found one badly written question, the next step is obvious: how do I know the others are fine? I identified three as suspicious by their shape, one with a list, one with two conditions in a single sentence, one with a definition inside it, and rewrote them, measuring both versions on the same photos.

questioncurrentrewrittenoutcome
sorgente47%82%broken: +35
mono99%100%saturated
esterno93%90%fine
silhouettethe parrot scores 97%—measures nothing

One question in ten was badly written, and it is the one the main result came out of. The esterno rewrite is three points worse, which on 133 photos sits inside the confidence interval: no sensitivity.


Prose says what it is, never how it looks

My personal archive, 971 photographs, has been indexed for months in another way: a free description written by qwen3-vl:8b for each shot, and search runs over the meaning of that text. That is, with exactly the method this benchmark was built to question.

I had never measured it. Then I realised I could, without running anything: the benchmark photos are also in the archive, and they can be found again by perceptual hash even though here they are renamed and resized. Of the 204 photographs I annotated, the benchmark's 133 plus the 71 discarded, 194 match exactly. On one side the hand-annotated truth, on the other a description written months earlier, and no model to re-run in between.

Across the benchmark's 128 that match again:

the description names it when presentout of how many have it
persone99%106
mare100%15
molte25%61
volto14%95
sorgente5%61
ombra3%30

And where the description explicitly states both directions, esterno and mono, it is right 95 and 97 percent of the time when it commits.

It is not a mediocre archive. It is precise on one half and blind on the other, and the split is not random: prose always says what the photograph is of, people, sea, outdoors, black and white, and almost never how it is made: where the light is, whether the background closes, whether faces read, how many there are. Of the 61 photographs with a light source in frame, the description names it in three.

Those are the two categories that separate an archive from a photographic archive. And the reason I had not noticed in months of use is that the things that work are the things you try: you search "beach" and you find it, you search "black and white" and you find it. It does not occur to you to search "lamp".

The flaw in free description is not that it is imprecise. It is that it decides what to talk about. A closed vocabulary is poorer and works for that reason: you ask the ten questions yourself, one at a time, and it cannot fail to answer any of them.

How I arrived at these numbers matters as much as the numbers. I search for words inside the text, "lamp", "backlight", "face", and the first version counted a description saying "no person visible" as people being present: it looked for the word and never checked what stood in front of it. With negation handled, among the descriptions that commit on persone the correct ones go from 92% to 97%, and the ones that commit at all from 114 to 122 out of 128.

That is: I had just finished writing that negation sends the 8-billion model off a cliff, and an hour later I built a measuring instrument that ignores negation. Not through carelessness about something I did not know. On precisely the thing I had just finished documenting.

I am not telling this for self-criticism. I am telling it because it moves the conclusion. The first time, negation broke a small model: that is a limit of that model. The second time it broke a regular expression I wrote myself, which has no parameters at all. So it was not a limit of that model. It is that a measurement made by searching for words cannot tell a thing from its negation, and no model size fixes that. If I had measured only with the new instrument I would have believed the result, exactly as someone measuring only with the model believes theirs.

Knowing a trap exists does not protect you from falling into it again the moment you change tools, because you do not recognise it: it looks like a different problem.


And then I applied it

A benchmark that ends in a table is an exercise. So I took the ten questions, sorgente in its rewritten version, and asked them of the whole archive: 966 photographs, 9660 answers, a little under an hour on a laptop. It is 966 and not 971 because for five of them the archive keeps the record but the file is no longer on disk.

Each question to the model the benchmark had elected: sorgente to the 8b, which scores 91% against 82% there, everything else to the 4b, which scores 96% against 81% on volto. That is not a preference, it is the result applied rather than recounted.

What appeared:

searching forwith textwith the question
a light source in frame432896.7×
a black background10282.8×
a backlit subject4142same
Photographs found in the archive of 966, searching the free-text descriptions against asking the ten questions.

Two hundred and eighty-nine photographs with a lit light inside the frame, and searching for them in words I was finding forty-three. The other 246 had been there for months, on my own disk, inside an archive I believed I could query.

The last row explains all three. silhouette gains nothing because "backlight" and "silhouette" are caption words: a model that describes uses them spontaneously. "There is a lamp on" is not a caption word, and indeed it never wrote it. Prose is not blind at random: it is blind where it would not occur to it to speak.

And the archive, counted, is also a portrait of the person who made it: 75% of my photographs have a readable face, 60% are outdoors, 3% have a black background. I did not know that, and there was no way to know it.

One thing has to be said and kept in view: that 289 is not a fact, it is a measurement at 91%. A couple of dozen will be wrong. In the search panel every filter carries its own measured accuracy, because a filter whose error you do not know makes you believe you know something you do not, which is precisely the flaw in the descriptions I started from.


How the numbers are computed

Four tools, all standard. I write them out because an article that keeps saying "look at how you measure" and then hides its own definitions would be inconsistent.

Accuracy. Agreeing answers divided by answers given, over the judgements where the ground truth is not "uncertain". Unreadable answers are not counted as errors: counting them would confuse gets it wrong with does not answer, which is exactly the trap in section 5.

The parrot. The share of the most frequent answer:

parrot = max(number of yes, number of no) / total

It is the score you get without looking at the image. A model that does not beat it is measuring nothing.

Wilson 95% interval. With p accuracy, n judgements, z = 1.96:

centre = (p + z²/2n) / (1 + z²/n)
half   = z · √( p(1−p)/n + z²/4n² ) / (1 + z²/n)

Not the normal approximation p ± z√(p(1−p)/n): with accuracies near 100% that produces bounds above 1, which do not exist.

Cohen's kappa. How far agreement exceeds what chance would give, with po the observed agreement and pa, pb the share of "yes" from the two raters:

pe    = pa·pb + (1−pa)(1−pb)
kappa = (po − pe) / (1 − pe)

It is needed where accuracy lies: on silhouette, four yes out of 132, always answering "no" scores 97% and has kappa zero.

Average precision. Used in section 6 because it has no threshold to tune: you walk down the ranking and at every relevant item add the precision up to that point, then divide by the number of relevant items. The AP of a random ordering is the base rate, which is why the two columns sit side by side in the table.

The implementations are in quantizzazione.py and prova-siglip.py.


What cannot be concluded


Materials

verita.json: the annotations, with the reason for every exclusion vocabolario.json: the ten questions, with the reason each is worded as it is banco.py: the full run, 11 minutes with the 4b, 29 with the 8b, on a laptop annota.html: the tool for annotating from a phone prova-sorgente.py: the experiment on wordings prova-veleno-lingua.py: the defect built on purpose, crossed with three languages and three models. The first example in each list is chosen by measuring it against the archive, not by guesswork, and the reason is written in the file prova-veleno-lingua.sqlite3, prova-lingua.sqlite3: the 9044 answers prova-siglip.py: the same human truth against a contrastive model. The three wordings per tag are written in the file, ahead of the results, and all three are reported prova-prefill.py: the Q4/Q8 comparison. It writes to a database of its own: banco.py uses insert or replace, and re-running it would have overwritten the answers everything else is built on quantizzazione.py: the arithmetic, with the Wilson interval. It prints the uncomfortable conclusion by itself when the intervals overlap prova-prefill-nuovo.sqlite3, prova-prefill-senza.sqlite3: the four models' answers under the two prefills indicizza-archivio.py: applies the ten questions to a whole archive. It imports the protocol from banco.py instead of copying it: rewriting it, even identically in intent, would invalidate the measured accuracies misura-archivio.py: the comparison between the free descriptions and the annotated truth, matching photos by perceptual hash. It runs no model

The last two read a personal archive that is not part of the package: they count as method, not as a measurement you can re-run.

The photographs are not included. They are mine, there are people in them, and they do not go into the package. The consequence has to be stated: the measurement is not reproducible to the letter. Anyone who wants to redo it has to use their own archive. The method is written so that this is possible.

The photograph and shoot identifiers are deliberately neutral.

Entirely local, on a laptop.


What I take away

I started out wanting to know which model to choose. I did not find out, and the reason is that the question was badly posed.

Every time a number seemed to say something about the model, underneath it there was something saying something about me. A list of examples inside a question, worth 35 points. A negation that sends an eight-billion model off a cliff. Tags so unbalanced that a parrot beats them. A whitespace character in one line of prompt deciding whether a model answers or starts describing the photograph in English. And the first comparison between two precisions, which said "this one is worse" when the truth was "this one was not answering".

And when I stopped finding defects by accident and started building them on purpose, the defect appeared on command: four healthy questions out of five break if you put in an example the photograph contradicts, but only on the small model, and worse if the question is not in English.

The last test removes the last excuse as well. It happens to SigLIP too, which does not even read a prompt: my vocabulary's question, on sorgente, does worse than a random ordering, and three words in English score 82%.

So the thing to take away is not that prompts should be written well.

A score does not measure the model. It measures the model and your scaffolding together. The scaffolding half is larger than anyone expects, and when it breaks it does not say so: the number sits there, plausible, telling you a story about the model that is not true.

Three things, before trusting any leaderboard, including mine. Put the parrot that always answers the most frequent answer next to your numbers. Count how many answers are genuinely in the format you asked for, not how many your code manages to interpret. And rewrite every question at least once: if the number moves by thirty points, you were not measuring the model.

The value of a benchmark is not the ranking it produces. It is that it forces you to find out how much of your measurement is you.

verita.json · vocabolario.json · banco.py · prova-prefill.py · quantizzazione.py · prova-siglip.py · prova-veleno-lingua.py · annota.html
The photographs are not included. Measured on a MacBook Air M4 (16 GB) and a MacBook Pro M5 Pro (24 GB). Entirely local.
Data, code and model answers: github.com/VellBlue/vlm-photo-bench