A quick update from the desk: a Raspberry Pi 5 with one BrainChip AKD1500 card could learn objects in about a second. Day 4 ended with an annoyance. Whenever two things touched, two objects turned into a mess of outlines. Today was about that, and the answer was as much about dividing the work as it was about algorithms.
The Pi computes where; the chip answers what
That division became the principle behind the system. Geometry is cheap on a CPU. The Pi compares the live camera image with a previously captured empty scene and finds pixel-precise object boundaries in milliseconds. Recognition is more expensive. So the AKD1500 receives one question per region: what is this? It does not have to locate everything, count it all or scan the entire image again. One question, one answer and, in our historical desk measurement, a few millijoules.
Why this chip?
The chip learns on the device itself. Its last layer learns directly on the card, in about a second for the small experiment: no cloud and no lengthy external training run. We had considered a large detector network because it would have made overlap easier, but the design we examined needed roughly 70 neural processors while our card had 32. Adding a new class to that kind of detector would also have meant a new training run, unlike our on-chip prototype learning. At the time I wrote “hours instead of a second” and invited correction; that was an architectural estimate, not a general law about detectors. Solving overlap by giving up instant learning would have changed the project.
The outputs matched bit for bit when we ran the same calculation on the Pi’s CPU for comparison. The card did not gain speed by changing the answer, which made debugging possible: I could recompute and compare. In the historical setup it was 2.4 times faster. Our Pi-side energy comparison gave 22 millijoules per recognition on Akida and 236 on the CPU, a factor of 10.7. This is a dated desk test, not a current whole-cell energy measurement.
Processing one image or twenty-five in sequence took the same time per image in that test. It looked like there was no hidden per-batch administration penalty, an encouraging observation with three more cards due to arrive. It did not prove the scaling of the future machine by itself.
Seeing what overlaps
The search escalated in four stages, each used only if the earlier stage could not resolve the scene. Separate objects meant two regions and two questions. For touching objects, the Pi looked for a narrow waist and split there, but each resulting piece had to identify itself; otherwise a delicate carabiner could be cut apart by the algorithm. For overlapping objects, a grid over the disputed area let local cells vote for ownership. If none of that worked, the fourth stage returned an honest question mark. “I do not know” beat an invented label.
The important change came from an embarrassingly simple question. The voting grid had been deciding two things at once: which object owned a pixel, and where the object’s outline ran. That locked the drawn boxes to cell boundaries. Finer cells meant sharper boxes and more chip calls. But the Pi had already measured the region at pixel resolution. Why ask the grid to supply geometry again? The refinement I had spent the morning on became unnecessary by evening.
After that, the grid only decided ownership. Each object pixel took the class that was stronger in its local neighbourhood; the outline was the boundary of those pixels. In that bench comparison, overlap with the desired region went from 0.56 to 0.95 without any extra chip measurements. The information had already been available; we simply had not used it.
If the software knows the object pixels, it can stop drawing generic rectangles. ENGRAM began drawing contours. Around a round object, 46 percent of the rectangle could be background. Under overlap, a contour showed which pixels belonged to which object instead of placing one box across another. Again, no additional card call. In one example two SD cards and a carabiner touched, creating one connected region; the middle card had previously been recognised and then silently discarded by the later filtering rule.
A factor of seventeen, and a loop I like
For three separate objects, the expensive old method used 51 chip measurements. The new path used three. The fine grid had run even when each object sat alone: the chip had effectively checked 48 extra times whether a second object was hidden beneath an SD card. That made the historical scene seventeen times cheaper in chip calls.
This architecture has a property I like: better accuracy need not cost more energy. Uncertainty triggered the expensive grid. Our objects scored around 52–56 percent, so the grid often ran. If a better model named the same objects at 85 percent, it would avoid that fallback and save work automatically. Better recognition could make this specific pipeline cheaper, not more expensive.
Obstacles of the day
A comment contradicted the code. The comment promised the full recognition threshold, while two lines below the code checked against three quarters of it. The result was a ghost “carabiner 28 percent” outline on an SD card. The comment was right; the code was wrong.
A neat rule was too coarse. Keeping only the largest connected region stopped a mess of frames but reliably discarded the second SD card whenever both cards were connected by a carabiner.
Physics resisted a tidy shadow rule. I wanted automatic cast-shadow detection, but “same colour, less brightness” cannot decide pixel by pixel whether a medium-grey object on grey paper is a shadow. Edge sharpness would be a better cue, but that depends on the lamp and the background of my particular desk. I left the automatic claim aside and added a switch instead.
Success has to be measured. My impression said it worked wonderfully. The test bench disagreed seven times.
As always, correct me if I get something wrong. Day 5 left us with a clear principle: the Pi knows where; Akida knows what. And the better Akida becomes at naming things, the less often we need to ask it.
The Pi-versus-chip division still informs VORSA INSPECT. The 51-to-3-call result and energy figures above belong to the August 2026 desk experiment; detector quality on real M3 images and energy per finished object are still open.