How AI Sees an Image: Hinton's Bird Test on 4 Vision Models

I shrank a photo of a gull until its wingspan was 19 pixels inside a 1024-pixel frame of blue sky, then asked four vision models whether the most prominent thing in the image was a bird. All four said yes. At about 9 pixels, all four said no. Two of them still mentioned "a small dot" or "a tiny, indistinct speck", but wouldn't call it a bird. That part went the way I hoped. Then I sent the same question with no image attached at all, and both Qwen 3.5 models said yes anyway. The 0.8B one added "a large bird is visible in the foreground."

The question comes from a StarTalk Plus clip where Geoffrey Hinton explains, step by step, how a neural net gets from a grid of numbers to "bird". I ran his example on a CPU-only VM built in my home lab: his single edge neuron wired by hand in numpy, a search for edge detectors in the first layer of three local Ollama vision models, and his bird question on 15 images plus two controls.

What Hinton explains in the clip

The video is What Actually Happens When AI Sees an Image? from StarTalk Plus, published October 14, 2026. It's a cut from the longer episode Is AI Hiding Its Full Power? With Geoffrey Hinton.

He starts from what the computer actually gets. An image is pixels, and to the computer "that's just a big array of numbers" (0:57). The task is to decide "whether the prominent thing in the image is a bird" (1:04), and he points out that people tried to write that program by hand "for many, many years, like half a century" without really succeeding (1:11). Birds show up as an ostrich up close, a seagull far away, a crow, or a bird in the middle of a forest (1:23 to 1:38).

Wiring every pixel straight to outputs like "bird and cat and dog and politician" won't work (4:46), because the brightness of one pixel "doesn't tell you anything" (5:00 to 5:15). So he builds one neuron by hand. It has a column of three pixels with positive weights next to a column of three with negative weights. If both columns are equally bright, it gets "zero net input and it'll just stay quiet." If the left column is brighter, it says "I found the thing I like," and "the thing it likes is an edge, which is brighter on the left than on the right" (5:29 to 7:09).

From there it stacks up. You need these at "thousands of different positions and dozens of different orientations and several different scales" (7:40), "a gazillion little edge detectors." Scale matters because "a cloud, for example, has a big soft fuzzy edge" (8:05). The next layer looks for edges that meet in a point, a possible beak, though "It could be an arrowhead" (9:13 to 10:12). A circle could be a bird's eye or "a knob on a computer" (10:23 to 10:40). Then a bird's head, then a final layer for cat, dog, bird. His closing point is that "it would be a nightmare to design this by hand" (12:30), and a real network has "at least a billion connections" (12:44).

There's one moment I wanted to test directly. The host describes a curved V drawn on a cloud and says everyone who sees it will say it's a bird. Hinton's answer:

"me it's a curved V." Geoffrey Hinton, StarTalk Plus, 2:47 to 3:09

The lab setup

Everything local ran on my usual Ubuntu VM: 8 vCPUs of a Xeon E5-2670 (AVX only, no AVX2), 16 GB of RAM, no GPU, Ollama 0.40.10. I covered the base install in Install Ollama on Ubuntu.

Every request used the same prompt: "Is the most prominent thing in this image a bird? Answer on two lines. Line 1: yes or no. Line 2: what the image shows, in under 12 words." Options were temperature: 0, seed: 1, num_predict: 48, and think: false. For the local runs I also set draft_num_predict: 0, the drafter gotcha from my Nemotron Bolt test. I stopped my other Docker containers during the timed run so they wouldn't skew the numbers.

I picked the test images to follow Hinton's examples: an ostrich portrait, a crow's head at three sizes, a small crested bird on the ground, a gull pasted onto an empty sky at five sizes, and four non-birds (a cat, plain clouds, a flint arrowhead, a unicorn illustration). The 15th image is my curved V drawn over the clouds photo. All photos are from Wikimedia Commons, credited at the end.

Hinton's edge neuron, wired by hand

His neuron is small enough to type in. Six weights: +1 on three pixels in one column, −1 on the three pixels in the column to its right. I fed it his three cases first, using pixel values from 0 to 255:

Then I slid it across real photos. On the 1024-pixel crow there are 646,536 positions where it fits. One neuron, looking only for brighter-on-the-left, was excited at 0.44% of them. Adding three more directions (right brighter, top brighter, bottom brighter) raised that to 1.6%. Counting the single neuron, the four directions, and the same four again on a copy shrunk 8x, that came to 3,268,960 neuron evaluations in 0.111 seconds on the VM. One layer of edge detectors costs almost nothing.

The curved V image shows his cloud point. At fine scale only 0.58% of positions excited one of the four directions. At 8x coarser scale it jumped to 3.8%, because the soft cloud edges only look like edges when you zoom out. The crow barely moved, 1.74% coarse against 1.6% fine. The gull at full size barely registered anywhere: 0.23% fine, 0.63% coarse, because most of that image is smooth sky.

Edge detectors inside real models

Hinton's argument is that nobody should design those detectors by hand, because the network learns them. I wanted to see them. Each Ollama vision model ships its vision encoder as a separate GGUF blob (the second FROM line in ollama show --modelfile). Inside each is a tensor called v.patch_embd.weight: a stack of 16x16 RGB filters that every image patch is multiplied by before anything else happens. In a modern vision transformer, this is the nearest match to Hinton's first layer.

I read those filters with the gguf Python package and scored each one against eight step-edge templates, at angles 22.5 degrees apart, using the absolute cosine similarity so either polarity counts. As a control I scored the same filters with their 256 pixel positions shuffled, which keeps the weight values but destroys any spatial pattern.

Gemma's first layer is full of edge detectors: 148 of 768 filters look like a step edge, against zero once shuffled. The Qwen 2B has fewer but still far above the control. The Qwen 0.8B has 13, and its median score is no better than shuffled, so most of its filters are something else. One caveat: Qwen splits its patch embedding into two tensors (one per video frame), and I only scored the first.

The top-scoring filters are soft light-to-dark ramps at different angles, which is Hinton's edge neuron with blurrier weights. The unsorted ones are worth a look too: stripes at several spacings, small blobs, and patches that set one color against another. He sets color aside in the clip (8:55), and the models obviously didn't.

The bird question

On the clear cases all four models were perfect: 14 of 14 (10 birds, including the gull at 19 pixels, and 4 non-birds). The arrowhead is Hinton's own example of a point that could pass for a beak, and all four said no bird. gemma4:31b called it "a stone arrowhead", the small Qwen called it "a piece of pottery or a similar object", and all four noticed the unicorn was a unicorn.

The interesting rows are the ones where the answer isn't obvious:

The curved V split the models down the middle, and two of them disagreed with themselves. The Qwen 0.8B said yes and then described a black line. The local Gemma said no and then described a bird silhouette. Only gemma4:31b gave Hinton's answer with a description to match: a dark curved object. I read that as the yes/no line and the description line being produced somewhat independently, which is worth knowing if you ever parse only the first line of a model's answer.

The no-image row worries me more. Both Qwen models said yes to a bird that wasn't there, and if your pipeline drops an attachment, they won't tell you. Both Gemma models refused to guess. I reran the no-image request in a separate batch later and got the same answers word for word, which is expected at temperature 0 with a fixed seed.

What an image costs on a CPU

Before the model reads a single word of the prompt, the vision encoder turns the image into tokens. The two families do that differently, and on a CPU it's where nearly all the time goes.

Qwen's token count follows resolution: halve the width and you get about a quarter of the tokens. The 1024 x 1230 cat cost 1,218 image tokens on Qwen, against 548 on local Gemma. Local Gemma drops to a floor of 79 for small images, and the cloud gemma4:31b reported 275 for all three crops.

The answer itself is about a dozen tokens. Almost all of the wall time is prompt evaluation, meaning the image. The cat took 34.9 seconds of prompt evaluation on the 0.8B, 86.8 on the 2B and 62.0 on Gemma. Gemma processes fewer tokens per second than the 2B Qwen but needs far fewer tokens, so its median time per image came in well under the 2B's. It also used the most memory by far: 8 GB peak RSS, against the 6.3 GB that ollama ps reported, and its cold load took 23 seconds.

One gotcha cost me a confusing row. In the 0.8B's main run, the crow and the curved V came back with prompt evaluation of 0.108 seconds. I had sent those exact images in a probe a few minutes earlier, the model was still loaded, and Ollama reused the cached prompt. For those two I used the probe timings (16.97 and 15.18 seconds). If an image result looks impossibly fast, check whether you sent it recently.

What I'd test next

Hinton's chain of pixels, edges, parts and bird held up better than I expected on my hardware. I could wire his first neuron in a few lines, and the trained models had grown their own versions of it. The part he says is a nightmare to design by hand is exactly the part I can't see from the first layer.

Next I want to go one layer up and look for his beak detector: run the crow and the arrowhead through Gemma's encoder, dump the activations after the first few blocks, and see whether any unit responds to both, which is the confusion he predicts. I'd also like to fill in the gull curve between 9 and 19 pixels, and rerun the no-image test across more models, since I'd want that answer before putting a small vision model in a real pipeline. For more on how small models behave on this CPU, see my tiny Ollama models shootout and my earlier post on Hinton and chain of thought.

Sources and credits

• StarTalk Plus, What Actually Happens When AI Sees an Image?, October 14, 2026: pixels as numbers (0:57), the bird task (1:04 to 1:38), the curved V (2:47 to 3:09), one pixel tells you nothing (5:00 to 5:15), the edge neuron (5:29 to 7:09), positions, orientations and scales (7:40), the soft cloud edge (8:05), beak or arrowhead (9:13 to 10:12), eye or knob (10:23 to 10:40), designing it by hand (12:30), a billion connections (12:44).
• Full episode: Is AI Hiding Its Full Power? With Geoffrey Hinton.
• Images from Wikimedia Commons: female ostrich portrait by Joselodos (CC0); ring-billed gull in flight by Rhododendrites (CC BY-SA 4.0), cut out and placed on a generated sky; carrion crow head by Alexis Lours (CC BY 4.0); hoary-throated barwing by Shiv's fotografia (CC BY-SA 4.0); white cumulus clouds by Lance Vanlewen (CC BY-SA 4.0), also the background of the curved V image; vintage unicorn illustration by Rawpixel Ltd (CC BY 2.0); tabby cat by AdinaVoicu (CC0); flint arrowhead, The Met (CC0). All were resized; the gull and curved V images are my modifications.
• Raw data on my lab VM: per-request JSON for every local and cloud call, vision.csv, controls.csv, the edge neuron and filter logs, and memory samples.