Edge vision test · Sep 2026

Can a factory camera learn a new part in milliseconds?

A three day test, built on a phone, a steel tray and a cloud GPU. It started as a take-home brief in a final round interview for an operations role. The company is not named and none of this is their data. Every frame was filmed at home.

One camera of ten. A fast classifier reads every frame. When it is unsure, the frame goes to a small vision language model, the checker.

The idea

Freeze the big model. Relearn only 769 numbers.

Factory camera systems often run fine-tuned detectors. They are accurate but static: every new part, light or layout means new images, new labels and a full retrain on a GPU. Here a frozen image encoder turns each frame into 768 numbers, and a tiny layer on top (768 weights and one offset) decides if a part is on the tray. Only that layer ever learns.

7 ms
A new part needed 5 labels either way. Then a 7 ms refit on a CPU, against a 26 second GPU retrain.
76 ms vs 498 ms
Same model, same frames. Picking Yes or No took 76 ms. Writing a 60 token answer took 498 ms. Deciding fits on an edge box. Writing does not.
22 to 38%
Estimated share of one edge GPU for 10 cameras at 0.5 frames per second, checker included. Estimated from published specs, not measured on the box.

The design

Cheap model on every frame. The checker only when unsure.

Solid lines run on every frame. Dashed lines run once a day: labels collect, the tiny layer refits overnight, and a ship gate decides whether the new version goes live before the morning shift.

Flowchart. Camera frames are cropped into fixed zones. A fast classifier reads every frame; unsure frames go to a checker, a small vision language model. Confident checker answers become labels, the rest go to a human review queue. Nightly, a balance and coverage check refits the tiny layer, and a ship gate compares it with yesterday on a people-labelled golden set before deploying. Existing YOLO detectors run alongside, feeding the same event logic and dashboard.

The design as I pitched it, so the numbers in it are targets. The test then measured the refit in milliseconds, not seconds.

The checks

The ship gate rejected my own model.

A new version goes live only if no cell of a fixed, people-labelled test set gets worse. My fast classifier, which had never seen the new part, averaged 90.7%. It was a coin flip on one cell, so it did not ship.

Accuracy, %, on "is there a part on the tray?"
Cell	YOLO stand-in	Fast classifier
Day, old part	100	100
Day, new part	98	98
Day, empty	100	100
Lamp, old part	100	100
Lamp, new part	100	47
Lamp, empty	100	100
Mean	99.6	90.7

The YOLO stand-in was as accurate or better everywhere in the test. The win is the cost of adapting, not accuracy.

The teacher loop

Confident is not the same as covered.

At the new station I let the checker label the training frames and kept only its confident answers.

39 of 39
Confident labels that were correct. The checker was sure on 39 of 92 frames, and right every time.
65%
What the classifier trained on them scored. Exactly what “always say part” scores. Every one of the 9 “part” labels was the whisk, so it never learnt the padlock.
5 labels
Five frames confirmed by a person took the same classifier to 100%. A model that teaches itself needs a coverage check, not only a confidence cutoff.

Limits

What I do not claim.

Nothing ran on an edge box. Everything ran on a cloud T4 and my laptop. Every edge number is an estimate.

One camera, one scene, one day. The accuracy numbers will not transfer to a real machine cell. The method, the checks and the speed ratios should.

I threw away my first two runs. The first seconds of each clip showed an empty tray under a “part” label. The fix was one rule, decided from the footage, not the results: drop the first 10 seconds of every clip.

How it was built. The question, the design, the test, the filming and every claim are mine. I directed Claude Code to write the notebook code from my spec, then checked, corrected and reran it four times.