Just One Look

Say “AI” these days and everybody pictures the chatty large models: tens of billions of parameters, and a whole roomful of GPUs to keep them in the style to which they’ve become accustomed.

But there’s a kind of AI that doesn’t like to talk. It just likes to stare. And it’s surprisingly small. The smallest one has a weights file of 5.5MB, not much bigger than a photo on your phone, and it runs on a Raspberry Pi, a phone, a drone.

It’s called YOLO, and it’s the most famous name in open source vision models.

Cartoon illustration: a wooden bird feeder hangs over a balcony. On the left stands a sparrow in an orange box labeled “sparrow 0.92”; on the right, a magpie in a blue box labeled “magpie 0.88”. A small green circuit board with a camera is clamped to the railing, tagged “5.5MB”. Behind the railing a grey cat hangs on and peeks up, in a red box labeled “cat 0.97”. On the right, lzbob in a black baseball cap sits behind a table with an enamel mug, facing a small screen that reads “Today’s visitors: Sparrow ×23, Magpie ×4, Cat ×1”. — Roll call for the sparrows and magpies, one by one. Nobody gets away. That guy hanging off the railing, bottom left? It spotted him too.

So what is it

YOLO stands for You Only Look Once, and the name is its whole party trick. An image goes in, makes one pass through the network, and everything comes out in one go: where each thing is, what it is, and how sure it is. No circling candidate boxes first, no going back for a second look.

The version most people use today is Ultralytics’. The code lives at ultralytics/ultralytics, with over 62,000 stars (62,815 when I looked) and nearly 12,000 forks. The current head of the family is YOLO26; the next generation, YOLO27, has been announced but isn’t out yet. The old-timer, YOLOv5, lives in its own repo and has 58,000 stars of its own.

The smallest, YOLO26n, has 2.4 million parameters and a 5.5MB weights file. It recognizes all 80 classes of things in the COCO dataset, with an mAP of 40.9. By big-model standards, that many parameters wouldn’t even get stuck in your teeth. In vision, it’s enough to do plenty of honest work.

How much the little guy can do

One family of models, a lot of jobs:

Detection: boxes up what something is and where, with a confidence score.
Segmentation: not just a box, it cuts out the outline too.
Pose: finds the joints on a human body.
Rotated boxes: a car parked at an angle in an aerial photo, a part lying crooked, and the box tilts right along with it.
Classification and depth estimation are in the newer versions too.

Each job has its own set of weights: yolo26n.pt does detection, yolo26n-pose.pt does pose. One look at the file name and you know.

It does video too. It runs detection on every single frame, then a tracker strings the same object together across frames and gives it a fixed ID number. Six trackers come built in, the famous ByteTrack among them.

Once you have tracks, you can start doing the math: how many crossed a line, how long something hung around in an area, how fast it was going. Ultralytics also ships a pile of ready-made “solutions”: line-crossing counts, parking space management, queue management, speed estimation, workout monitoring. Grab one and go.

It won’t answer you out loud. It’ll just work the answer out for you.

So how fast is it, really

Time for some honesty. Ultralytics benchmarked YOLO26n on a Raspberry Pi 5, 640-pixel images, CPU only:

Run straight in PyTorch: nearly 300 milliseconds per image.
Exported to NCNN: 67 milliseconds per image, around fifteen frames a second.

Fifteen frames a second is plenty for keeping an eye on a bird feeder or a parking lot. If you want to follow a ball flying across a field, you’ll need to shrink the images or switch to a board with an accelerator chip. Phone and computer CPUs are faster than a Pi’s, so the frame rate climbs from there.

Deployment is painless too. One line exports it to other formats: ONNX, NCNN, OpenVINO, TensorRT, CoreML. Pretty much every chipmaker has a match on that list.

Teach it to recognize your stuff

COCO’s 80 classes are the everyday stuff: people, cars, cats, dogs, cups. If you want it to recognize your delivery boxes or the parts in your factory, you have to teach it yourself.

The way to do that is fine-tuning: shoot a batch of photos, draw boxes around the things you want it to recognize, and keep training from the official pretrained weights. For a simple scene, a few hundred images and one night of training gets you a usable first model. If you want it solid, the official advice is 1,500 images and 10,000 labels per class, and up.

Train it, export it, and stuff it right back into the Raspberry Pi.

Now the fun starts:

Hang a bird feeder on the balcony, and it keeps the books on how many sparrows and magpies drop by each day.
One camera covers a whole parking lot, and you can tell at a glance which spots are free.
While you work out, it watches your form. Did that squat go deep enough? It’s pickier about it than your trainer.
In game footage, cut 5 seconds either side of the frame where the goal goes in, and the highlight reel makes itself.
A cat flap that opens only for your own cat. The neighbor’s cat and the weasel from down the hutong stay out, no exceptions.
On the factory floor, it inspects solder joints on circuit boards and picks out the bad ones. Sharper eyes than the line’s most seasoned veteran, and it never gets tired.

The most valuable part: the license

Everything so far is good news. This part deserves a second look.

Ultralytics YOLO, from v5 and v8 through 11 and 26, is all under the AGPL-3.0 license. This license has a temper: if your thing uses it, your whole project has to be open source under the same license. And serving it to people over a network counts too.

According to Ultralytics, it reaches even further: closed-source commercial products, embedded hardware, internal company tools, even models you trained with it yourself, once they’re used commercially, are all covered. If you don’t want to open source, you buy their enterprise license.

The classic trap: the product is already live by the time somebody thinks to read the license.

If you want to go closed-source and commercial, you’ve got roughly three roads:

Buy an Ultralytics enterprise license. The least hassle. You’re paying for peace of mind.
Switch to a YOLO variant with a looser license. YOLOX, for one, is Apache-2.0, so closed-source commercial use comes with far fewer strings. The price: accuracy is a notch lower, and the code has barely moved in over a year, so plenty of things you’ll have to tune yourself.
Open source the whole project. If you were planning to anyway, you’re in the clear.

I’m not a lawyer. This section is just a heads-up. If you’re really going commercial, check with someone who knows this stuff first.

One last thing

The big chat models handle the smooth talking. Little guys like YOLO handle the sharp eyes and quick reflexes. One 5.5MB file, tucked into a Raspberry Pi, can keep watch on your balcony, your parking spots and your production line for you.

YOLO needs one look to see what’s what. The license needs a few more. You only look once? Not at the license, you don’t.