I’ve always been fascinated by how machines see. Over the years, I’ve watched object detection grow from a slow, academic concept into something you can run on a laptop in real-time. This shift is why I’m writing this. I want to show you how accessible this powerful technology has become. You can now build a system that identifies people, cars, or any object you choose, live from a video feed, with surprisingly little code. Let me show you how.
This guide focuses on YOLOv8, a modern tool that balances speed and accuracy. Why this one? It’s incredibly user-friendly, well-documented, and powerful. You’ll use it with OpenCV, a classic library for handling video and images. The combination is potent. You’ll be surprised at what you can create in an afternoon. Have you ever wondered how a security camera knows to send an alert when it sees a person? You’re about to learn the core idea behind it.
First, let’s prepare our workspace. Open your terminal. I always recommend using a virtual environment to keep project dependencies tidy. Create one with python -m venv yolo_env and activate it. On Mac or Linux, use source yolo_env/bin/activate. On Windows, use yolo_env\Scripts\activate.
Now, install the essentials. You only need two main packages to start.
pip install ultralytics opencv-pythonThe ultralytics package gives us YOLOv8. OpenCV will handle reading video, displaying windows, and drawing boxes on our detections.
With the setup done, let’s test the water. How quickly can we get a result? The code below loads a pre-trained model and runs it on an image. YOLOv8 comes with models trained on the COCO dataset, which can recognize 80 everyday objects like people, cars, and dogs.
from ultralytics import YOLO
import cv2
# Load the nano model - it's the smallest and fastest.
model = YOLO('yolov8n.pt')
# Run inference on an image file.
results = model('path/to/your/image.jpg')
# The results object contains everything.
for result in results:
# Draw the bounding boxes and labels on the image.
annotated_frame = result.plot()
# Display it.
cv2.imshow("Detection Output", annotated_frame)
cv2.waitKey(0)
cv2.destroyAllWindows()Run that. You should see your image with colored boxes around detected objects. That’s the foundation. The model did the heavy lifting. Notice how we didn’t have to define the architecture or handle complex data loading? The library abstracts that away, letting us focus on the application.
Now, for the main event: real-time video. This is where the magic feels tangible. The logic is a loop: grab a frame from the camera, run detection, draw results, and display it. We’ll use your computer’s webcam.
import cv2
from ultralytics import YOLO
# Load the model.
model = YOLO('yolov8n.pt')
# Open the webcam (0 is usually the default camera).
cap = cv2.VideoCapture(0)
while cap.isOpened():
# Read a frame.
success, frame = cap.read()
if not success:
break # Exit if the frame isn't read correctly.
# Run YOLOv8 inference on the frame.
results = model(frame, verbose=False) # `verbose=False` cleans up the output.
# Visualize the results on the frame.
annotated_frame = results[0].plot()
# Display the annotated frame.
cv2.imshow("YOLOv8 Live Detection", annotated_frame)
# Break the loop if 'q' is pressed.
if cv2.waitKey(1) & 0xFF == ord("q"):
break
# Release resources.
cap.release()
cv2.destroyAllWindows()Run this script. You should see a video window with real-time detections. This simple loop is the core of countless applications. What could you build if the program counted the number of people in the frame, or tracked a specific object?
You might want to detect something not in the COCO dataset—a specific product, a type of machinery, or a particular animal. This is where custom training comes in. YOLOv8 makes this process more straightforward than ever. You need to prepare your images, label them, and structure the data in a specific format. I use a tool called Roboflow for labeling; it’s free for small projects and exports data in the right format for YOLO.
Once you have a dataset, training involves just a few lines.
from ultralytics import YOLO
# Load a small model to fine-tune.
model = YOLO('yolov8n.pt')
# Train the model.
results = model.train(
data='path/to/your/data.yaml', # This file defines your dataset paths and class names.
epochs=50, # Number of training cycles.
imgsz=640, # Image size.
batch=8, # Number of images processed together.
name='my_custom_model' # Name for the training run.
)After training, you use your new model file (best.pt) just like the pre-trained one. The ability to teach a model to see what you need is the most powerful part of this whole process.
As you experiment, you’ll think about performance. Can it run on a Raspberry Pi? For lighter hardware, you can export the model to formats like ONNX or TensorFlow Lite. The Ultralytics library provides a simple model.export() method for this. You can also adjust the inference size; a smaller imgsz (like 320) makes detection much faster but slightly less accurate.
I often get asked about common problems. If your webcam doesn’t open, try index 1 in cv2.VideoCapture(1). If you see a CUDA out-of-memory error, reduce the imgsz or batch size during training. If detections are slow, switch to the nano (n) or small (s) model variants.
Building this system shows the immediate power of modern computer vision. From a few lines of code, you create a program that interacts with the visual world. I wrote this to strip away the mystery and show you the practical steps. The tools are here, they are free, and they are waiting for you to build something amazing.
What will you build with it? A wildlife monitor? A tool to help in a workshop? The first step is to run the code and see it work for yourself. If you found this guide helpful, please share it with someone else who might be starting their journey. I’d love to hear what you create—leave a comment below with your project ideas or questions. Let’s keep the conversation going.
