Computer Vision Foundations·Read the Metrics·Lesson 10/10

Lessonbeginner

From Lab to Production

The smallest end-to-end loop: install, predict, measure, decide.

Concepts are nice. A model running on your machine is better. In this final lesson, we install Ultralytics via the quickstart, run inference on a real image with YOLO26, look at the output, and connect it back to the framing exercise from lesson 1. By the end you'll know whether your project is ready to move into the Train your first YOLO model course — and whether your next step is fine-tuning, model deployment, or shipping to the edge.

Outcome

Install Ultralytics, run a pretrained Ultralytics YOLO model on a real image, and interpret the output in terms of your task spec.

Fast Track

If you already know your way around, here's the short version.

Install: pip install ultralytics.
Predict: yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'.
Inspect: open the saved image with detections, look at the boxes.
Compare with your task spec from lesson 1.

Hands-on

Install

The Ultralytics quickstart starts with the package on PyPI. One command:

pip install ultralytics

That installs the ultralytics Python library and the yolo command-line tool. Both wrap the same models — pick whichever fits your shell habits.

Python version

Ultralytics supports Python 3.9+. If your environment is older, create a fresh virtual environment with a recent Python before installing.

A first prediction

The smallest possible CLI test runs through Predict mode:

yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'

That command:

Downloads yolo26n.pt (the smallest Ultralytics YOLO26 detection model — about 6 MB).
Runs it on a bus image.
Saves the annotated result to runs/detect/predict/.

Open the saved image. You should see a bus, some people, and labeled boxes.

The same thing in Python

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model("https://ultralytics.com/images/bus.jpg")

for box in results[0].boxes:
    cls = model.names[int(box.cls)]
    conf = float(box.conf)
    x1, y1, x2, y2 = box.xyxy[0].tolist()
    print(f"{cls} ({conf:.2f}): ({x1:.0f},{y1:.0f}) → ({x2:.0f},{y2:.0f})")

You'll see a list of detections. Each one has the three pieces from lesson 3: class, box, confidence.

Connect it back to your task spec

Take the task spec from lesson 1 (input / output / decision). Now answer:

Question	For your project
Does Ultralytics YOLO26's pretrained class list contain your classes?	If yes — you may not need custom training to start. If no — follow the fine-tuning guide.
Are the detections at confidence > 0.5 in the right places?	If yes — your task is well-matched. If not — likely a domain gap (lesson 6), data drift, or class mismatch.
What threshold gives you the precision/recall tradeoff your decision needs?	Sweep, pick deliberately.

If you've made it this far you have:

A task spec you can defend.
A dataset plan that covers reality.
A grasp of metrics that won't lie to you.
Ultralytics installed and a model running.

That's everything you need to start the next course — and to start thinking about MLOps and model monitoring once your first model is in production.

Where the next course goes

The Train your first YOLO model course picks up exactly here:

You'll prepare a custom dataset in Ultralytics YOLO format.
Write a dataset YAML file.
Run model.train(...) and watch metrics tick up live.
Validate, diagnose, and re-train.
Export the trained model — optionally with model quantization — for deployment.

Each step uses everything we covered in this course.

Try It

Run the prediction command in this lesson on three of your own images. For each, write whether Ultralytics YOLO26's pretrained classes match your task. That tells you whether your next step is fine-tuning or working with the pretrained model.

Commit

git add -A && git commit -m "docs(academy): completed Computer Vision Foundations"

Done When

You've finished the lesson when all of these are true.

Ultralytics is installed in your environment.
You've run inference on at least one real image and seen detections.
You can connect each detection back to a piece of your task spec from lesson 1.

Show solution

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.predict(
    source="https://ultralytics.com/images/bus.jpg",
    conf=0.25,
    save=True,
)

print(f"Found {len(results[0].boxes)} detections")
for box in results[0].boxes:
    print(f"  {model.names[int(box.cls)]} @ {float(box.conf):.2f}")

What's next

Course complete — and you've earned the right to take the final quiz. After that, Train your first YOLO model is waiting.

Get Started