YOLOv8: Real-Time Detection & Edge Deployment

Learning Goal: Build and deploy real-time object detection and tracking systems on edge devices using the YOLOv8 framework.

• Prerequisites: Basic computer literacy, familiarity with command-line interfaces, and an eagerness to learn Python and Deep Learning workflows. No prior AI experience is required.
• Estimated Total Study Time: 38 Hours (including video runtime, hands-on coding, dataset curation, model training, and physical edge device setup).

Module 1: Python & Computer Vision Foundations

This module introduces the programming and image manipulation foundations required for computer vision. You will master basic Python syntax, data types, and file execution, and then transition to OpenCV—the industry-standard library for reading, displaying, and preprocessing visual data.

Recommended Videos

Python Crash Course [Beginner Tutorial]

@MatthewMYoung01:17:031,008

Python Crash Course [Beginner Tutorial]

This tutorial covers the essential foundations of Python programming, including variables for storing data, data types (strings, integers, floats, booleans, lists, tuples, sets, and dictionaries), basic mathematical operations, indexing and slicing, string formatting methods, comparison operators, conditional statements (if/elif/else), for and while loops, functions with parameters, scope and variable visibility, error handling with try/except, built-in modules, and classes with objects for obje

@MatthewMYoung · 01:17:03

• Why this video: A comprehensive, beginner-friendly crash course that quickly covers core Python structures. Before diving into machine learning architectures, you need to understand variables, lists, loops, and functions. This tutorial gets you ready to write custom computer vision inference loops.

• Knowledge Checkpoint:

  • Write a Python script that declares variables of different data types (strings, integers, floats, and booleans).
  • Use a for loop to iterate through a list of image filenames and print them conditionally using if-else statements.
  • Define and call functions that accept parameters and return computed values.

LEARN OPENCV in 3 HOURS with Python | Including 3xProjects | Computer Vision

@murtazasworkshop03:09:073,573,333

LEARN OPENCV in 3 HOURS with Python | Including 3xProjects | Computer Vision

This comprehensive tutorial covers OpenCV Python programming for computer vision, including image fundamentals (pixels, color spaces, image formats), installation and setup, basic operations (reading images/videos/webcams, resizing, cropping, drawing shapes and text), advanced techniques (perspective transformation, color detection using HSV space with trackbars, contour detection and shape classification, face detection using cascade classifiers), and practical projects including virtual paint,

@murtazasworkshop · 03:09:07

• Why this video: To work with YOLOv8, you must be comfortable reading, resizing, and feeding video frames to your model. This masterclass teaches you how images are represented as NumPy arrays, how color spaces function (such as BGR in OpenCV), and how to perform spatial operations like cropping and scaling.

• Knowledge Checkpoint:

  • Read an image from your local drive using cv2.imread() and display it in a window using cv2.imshow().
  • Convert a standard color image to grayscale and explain how the pixel matrix changes from 3 channels to 1.
  • Resize and crop an image to specific pixel dimensions while preserving its original aspect ratio.

OpenCV TUTORIAL with Python Series #1 - Basic Grayscale - 1

@CodingEntrepreneurs00:10:2489,235

OpenCV TUTORIAL with Python Series #1 - Basic Grayscale - 1

This tutorial demonstrates how to use OpenCV with Python to capture webcam video, display frames, and convert color images to grayscale using cv2.cvtColor() with the cv2.COLOR_BGR2GRAY flag, showing the fundamental steps of OpenCV setup including importing cv2, initializing a VideoCapture object, reading frames in a while loop, and displaying them with cv2.imshow().

@CodingEntrepreneurs · 00:10:24

• Why this video: This tutorial demonstrates how to connect to a live camera stream or web camera feed. Because edge deployment is designed for live feeds, understanding how to construct a robust frame-by-frame processing loop with appropriate exit keys (such as pressing 'q') is a critical milestone.

• Knowledge Checkpoint:

  • Initialize a camera capture object in Python using cv2.VideoCapture(0).
  • Write a continuous while loop that captures and displays frames from a live webcam feed in real-time.
  • Implement a keyboard interrupt system to cleanly release system camera resources and close active windows.

Module 2: Neural Networks & Convolutional Networks (CNNs)

This module shifts the focus from traditional, manual rule-based computer vision to modern deep learning. You will explore how neural networks learn directly from data, why convolutional architectures are so effective at handling spatial data (such as pixels), and how image classification differs fundamentally from object detection.

Recommended Videos

Neural Networks Explained: Architecture, Weights, and Biases

@3blue1brown00:18:4121,942,024

Neural Networks Explained: Architecture, Weights, and Biases

A neural network is a computational system composed of interconnected neurons organized into layers, where each neuron receives weighted inputs from the previous layer, sums them with a bias, applies an activation function (such as sigmoid or ReLU) to produce an output between 0 and 1, and this layered structure enables the network to learn hierarchical representations—from detecting simple features like edges in early layers to recognizing complex patterns or objects in later layers—through the

@3blue1brown · 00:18:41

• Why this video: Grant Sanderson’s visual explanations of neural networks are unmatched. This video demystifies neurons, layers, weights, and biases, helping you understand how a network takes raw pixel inputs, performs matrix multiplications, and produces structured output predictions.

• Knowledge Checkpoint:

  • Explain the roles of input, hidden, and output layers in a basic neural network.
  • Describe how weights and biases scale and shift incoming signal values to help a network map patterns.
  • Define the purpose of an activation function (like ReLU or Sigmoid) in introducing non-linearity.

MIT 6.S191: Convolutional Neural Networks for Computer Vision (2025)

@AAmini01:01:03176,688

MIT 6.S191: Convolutional Neural Networks for Computer Vision (2025)

Convolutional Neural Networks (CNNs) are specialized deep learning architectures designed to process grid-like data such as images by leveraging spatial hierarchies; they use convolution operations that apply learnable filters to detect local patterns in image patches, followed by nonlinear activation functions and pooling operations to progressively extract increasingly abstract features from raw pixel data, enabling powerful applications in image classification, object detection, semantic segm

@AAmini · 01:01:03

• Why this video: Traditional neural networks struggle to process high-resolution images because they lose critical spatial relationships. This MIT lecture details how Convolutional Neural Networks (CNNs) use sliding kernels, filters, and pooling operations to detect local features, building up to complex spatial representations.

• Knowledge Checkpoint:

  • Explain how a convolution operation works and why sliding filters preserve spatial relationships.
  • Explain the difference between convolutional layers (feature extraction) and pooling layers (downsampling).
  • Describe how a CNN's feature maps evolve from simple lines and edges to complex shapes as you go deeper into the network.

Deep Learning - Image Classification Tutorial step by step (for Beginners) (python / TensorFlow)

@deeplearning_by_phdscholar692500:01:46169,972

Deep Learning - Image Classification Tutorial step by step (for Beginners) (python / TensorFlow)

Image classification identifies what objects are present in an image but does not determine their location. Object detection extends classification by also localizing objects within the image through bounding boxes, identifying both what and where objects are located. For example, while classification might identify a cat and dog in an image, object detection would separately locate each animal with specific coordinates.

@deeplearning_by_phdscholar6925 · 00:01:46

• Why this video: This video helps you understand the operational distinction between image classification and object detection. While classification simply labels an entire image, object detection identifies both what objects are present and where they are located.

• Knowledge Checkpoint:

  • Contrast image classification with object detection in terms of network output (labels vs. bounding box coordinates).
  • Define localized object detection and explain how bounding boxes are typically represented as coordinate vectors (e.g., center x, center y, width, height).

Module 3: YOLOv8 Object Detection Core

This module focuses on the core YOLO (You Only Look Once) architecture. You will learn the mechanics behind its real-time performance, run basic inference workloads on images and videos, and progress to curating custom datasets to train your own YOLOv8 detectors.

Recommended Videos

How YOLO Object Detection Works

@deepbean00:17:04134,352

How YOLO Object Detection Works

YOLO (You Only Look Once) is a real-time object detection framework that processes an image in a single pass using a single convolutional neural network, dividing the input image into a grid where each cell predicts multiple bounding boxes with associated confidence scores and class probabilities, then combining this information through a loss function that includes class loss, localization loss, and confidence loss to achieve fast and efficient object detection while maintaining reasonable accu

@deepbean · 00:17:04

• Why this video: This video breaks down how YOLO achieves high-speed processing by framing object detection as a single regression problem. Instead of looking at an image multiple times (like region-proposal networks), YOLO processes the entire frame in a single forward pass, dividing it into grid cells to predict bounding boxes and class probabilities simultaneously.

• Knowledge Checkpoint:

  • Explain how grid cell division works in a single forward pass under the YOLO framework.
  • Describe the role of confidence thresholds and Intersection over Union (IoU) in filtering out weak predictions.
  • Explain Non-Maximum Suppression (NMS) and how it eliminates duplicate overlapping bounding boxes.

YOLOv8: How to Train for Object Detection on a Custom Dataset

@Roboflow00:03:09491,147

YOLOv8: How to Train for Object Detection on a Custom Dataset

YOLO V8 is the latest iteration of the influential You Only Look Once algorithm, developed by Ultralytics. The model demonstrates faster fine-tuning compared to predecessors like YOLO V5 and V7 when tested on the Roboflow 100 dataset. This video tutorial covers training YOLO V8 for object detection on custom datasets, with future videos covering instance segmentation and classification. The training process includes preparing data, training, validating, predicting, and deploying the model.

@Roboflow · 00:03:09

• Why this video: This quick tutorial walks you through setting up and running custom dataset training workflows using YOLOv8 and Roboflow. You will learn how to structure your directories, configure the configuration .yaml file, and train the model using either Google Colab GPUs or your local machine.

• Knowledge Checkpoint:

  • Set up a workspace inside Roboflow, label a small set of images with bounding boxes, and export them in the YOLOv8 PyTorch format.
  • Set up the directory path structure within the dataset configuration data.yaml file.
  • Use the command-line interface (CLI) to launch a training run (yolo task=detect mode=train...).

YOLOv8 | How to Train for Object Detection on a Custom Dataset | Computer Vision

@dswithbappy00:42:30169,350

YOLOv8 | How to Train for Object Detection on a Custom Dataset | Computer Vision

YOLOv8 is a unified computer vision framework that supports three tasks—object detection, image segmentation, and classification—in a single model, offering faster training and more lightweight architecture than previous versions. To train YOLOv8 on custom datasets, users must prepare data in the YOLO format with specific folder structures (train/validation/test containing images and corresponding label files) and a data.yaml configuration file specifying dataset paths and class names. The model

@dswithbappy · 00:42:30

• Why this video: A deeper, step-by-step programming tutorial that covers custom training from scratch. This video helps you understand the training output metrics (such as Precision, Recall, and mAP50-95), and shows you how to navigate folder paths to locate your trained weights file (best.pt).

• Knowledge Checkpoint:

  • Locate your training run folder and identify key training artifacts like confusion_matrix.png and results.csv.
  • Define Mean Average Precision (mAP) and explain how mAP50 differs from mAP50-95.
  • Run test-set inference using your newly generated best.pt file to verify its real-world performance.

Module 4: Real-Time Object Tracking

Object detection evaluates frames in isolation, which can cause object IDs to change between frames. This module introduces multi-object tracking (MOT) systems that keep track of individual object identities across video frames.

Theoretical Gap Note: While the implementation videos below are highly practical, they do not go deep into the underlying math of modern tracking algorithms. To build a strong conceptual foundation, pay close attention to how Kalman Filters and the Hungarian Algorithm operate:

1. Kalman Filters: A two-step recursive mathematical process (predict and update) used to estimate the state of a moving object (its position and velocity) amidst noisy measurements. It predicts where the bounding box will be in the next frame based on past motion.
2. Hungarian Algorithm: A combinatorial optimization algorithm that solves the assignment problem in polynomial time. It determines the best match between the newly detected bounding boxes and the existing tracks predicted by the Kalman filter.

Recommended self-study search queries: "Kalman filter derivation intuitive explanation", "Hungarian algorithm linear assignment step-by-step example".

Recommended Videos

ByteTrack Tracking Tutorial: Perform Tracking with YOLO

@Labellerr00:14:001,448

ByteTrack Tracking Tutorial: Perform Tracking with YOLO

ByteTrack is a two-step multi-object tracking algorithm that improves upon traditional trackers by utilizing both high-confidence and low-confidence detection boxes, combined with Kalman filter predictions, to maintain object identities during occlusions and crowded scenes; this approach enables robust real-time tracking of multiple objects like people, vehicles, and animals while minimizing ID switching errors.

@Labellerr · 00:14:00

• Why this video: ByteTrack is a highly efficient tracking algorithm. This video explains how it retains low-score detection boxes (which traditional trackers discard) to recover objects that are partially blocked from view (occluded) or momentarily out of focus, maintaining consistent tracking IDs.

• Knowledge Checkpoint:

  • Explain how ByteTrack leverages low-confidence detection boxes to handle object occlusion.
  • Contrast standard tracking-by-detection systems with ByteTrack’s double-association logic.
  • Run ByteTrack alongside a YOLO model on a custom video to observe how tracking handles temporary visual obstructions.

Track & Count Objects using YOLOv8 ByteTrack & Supervision

@Roboflow00:03:29184,769

Track & Count Objects using YOLOv8 ByteTrack & Supervision

This section demonstrates running YOLOv8 object detection on video frames. The process involves: (1) Using the CLI for quick initial testing; (2) Migrating to Python scripting for custom workflows; (3) Loading video frames one at a time using Supervision's generator to prevent memory issues; (4) Converting YOLOv8 results to Supervision's Detections format; (5) Applying bounding box annotations with customizable labels including class names and confidence scores. This establishes the fundamental

@Roboflow · 00:03:29

• Why this video: This video demonstrates how to implement a complete object tracking pipeline in Python. It teaches you how to connect YOLOv8 detections to ByteTrack using the Roboflow Supervision library, allowing you to easily track, trace, and count objects across a spatial region.

• Knowledge Checkpoint:

  • Write a Python script that integrates ultralytics YOLOv8 with the supervision library.
  • Initialize a tracking tracker object and run video inference while displaying unique, persistent IDs above each bounding box.
  • Implement a counting threshold line and write code that increments a counter whenever a tracked object crosses it.

Real-Time Object Tracking using YOLOv8 and DeepSORT \| Vehicles Counting (Vehicles Entering& Leaving)

@muhammadmoinfaisal00:29:0964,067

Real-Time Object Tracking using YOLOv8 and DeepSORT \| Vehicles Counting (Vehicles Entering& Leaving)

This video demonstrates how to implement real-time object tracking using YOLOv8 for object detection combined with DeepSORT for multi-object tracking, including vehicle counting by detecting when tracking trails intersect predefined lines to count vehicles entering and leaving a highway road.

@muhammadmoinfaisal · 00:29:09

• Why this video: This tutorial walks you through using DeepSORT, a tracking method that adds an extra layer of robustness by combining motion prediction (via Kalman Filters) with deep-learning feature embeddings. This helps the system remember what objects look like, allowing it to correctly re-identify them even after long periods of occlusion.

• Knowledge Checkpoint:

  • Explain how DeepSORT uses deep feature embeddings (appearance models) to re-associate objects after an extended tracking loss.
  • Contrast DeepSORT’s reliance on appearance metrics with ByteTrack's simpler geometric intersection (IoU) association.
  • Set up a custom python script using YOLOv8 and DeepSORT to track vehicles or people across complex scenes with high occlusion.

Module 5: Edge AI Deployment & Model Optimization

Deploying deep learning models to low-power edge systems like the Raspberry Pi or NVIDIA Jetson requires model optimization. In this module, you will learn about model quantization, explore how to export models to ONNX and TensorRT formats, and learn how to run hardware-accelerated inference.

Optimization & Benchmarking Note: Because edge devices have limited computational resources, you cannot simply run raw PyTorch .pt models in production. You must compile your models to maximize throughput. Pay close attention to these key optimization concepts:

1. Quantization: The process of converting model weights and activations from high-precision representations (like FP32, 32-bit floating-point) to lower-precision representations (like FP16 or INT8, 8-bit integer). This drastically reduces memory usage and speeds up inference with minimal loss in accuracy.
2. ONNX Export: Exporting your model to the Open Neural Network Exchange (ONNX) format, which standardizes your neural network's computation graph so it can run efficiently on different hardware runtimes.
3. TensorRT Compilation: Compiling your ONNX model into a highly optimized engine tailored specifically for your NVIDIA GPU. This step optimizes GPU register memory allocation and merges redundant network layers.
4. Benchmarking: You should always profile your model's performance before and after optimization. Be sure to measure and log:
   • Inference Latency (ms): The time required to process a single frame.
   • Throughput (FPS): Frames processed per second.
   • Memory footprint (MB): VRAM/RAM allocation.

Recommended Videos

Optimize Your AI - Quantization Explained

@technovangelist00:12:09403,293

Optimize Your AI - Quantization Explained

Quantization is a technique that reduces the precision of AI model weights (from 32-bit floating point to lower bit representations like Q2, Q4, or Q8) to significantly decrease memory requirements, enabling large AI models (such as 70B parameter models) to run on standard consumer hardware; Q2 offers the most memory savings but may sacrifice some accuracy, while Q4 provides a balanced trade-off between performance and efficiency, and context quantization further optimizes memory by compressing

@technovangelist · 00:12:09

• Why this video: This video provides a clear, high-level explanation of quantization. It illustrates how mapping floating-point values to lower-bit spaces (like INT8) reduces file size, decreases energy use, and speeds up computation on edge devices without sacrificing accuracy.

• Knowledge Checkpoint:

  • Explain the difference between FP32, FP16, and INT8 precision representations in neural networks.
  • Describe how quantizing a model's weights and activations reduces memory footprint and computational requirements.
  • Explain how Post-Training Quantization (PTQ) calibration differs from Quantization-Aware Training (QAT).

how to install yolo v8 on raspberry pi bookworm 64 bit & create your own custom model yolov8

@freedomtech530700:32:1634,298

how to install yolo v8 on raspberry pi bookworm 64 bit & create your own custom model yolov8

This comprehensive section covers the entire YOLO V8 custom object detection pipeline on Raspberry Pi OS Bookworm 64-bit. The workflow includes: (1) Installing all dependencies including OpenCV (with pip3 fix for fresh installations), Ultralytics, torch, torchvision, and torchaudio; (2) Implementing basic object detection using YOLOv8n.pt nano model optimized for Raspberry Pi hardware; (3) Capturing training images of custom objects (arduino-uno, esp32) at multiple angles; (4) Installing and con

@freedomtech5307 · 00:32:16

• Why this video: A comprehensive guide to deploying YOLOv8 on a Raspberry Pi. It walks you through setting up Python environments, installing dependencies on the 64-bit Bookworm OS, and configuring your setup to achieve the best possible performance on a CPU-only edge device.

• Knowledge Checkpoint:

  • Install the Ultralytics package and its dependencies within a Python virtual environment on Raspberry Pi OS.
  • Configure and run camera live stream inference locally on your Raspberry Pi.
  • Export your custom YOLOv8 model to ONNX format using the CLI export tool (yolo export model=best.pt format=onnx).

Ultralytics Live Session 6: Deploy YOLOv8 on NVIDIA Jetson Edge Device

@Ultralytics00:52:548,193

Ultralytics Live Session 6: Deploy YOLOv8 on NVIDIA Jetson Edge Device

YOLOv8 can be efficiently deployed on NVIDIA Jetson edge devices using TensorRT optimization, which enables real-time object detection by leveraging hardware acceleration. The Jetson lineup ranges from the Nano (0.5 TOPS) to the AGX Orin (275 TOPS), with performance scaling non-linearly with TOPS. TensorRT export in FP16 precision doubles inference speed with minimal accuracy loss, while INT8 quantization requires calibration to maintain accuracy. The Ultralytics and Seeed Studio partnership pro

@Ultralytics · 00:52:54

• Why this video: This deep-dive tutorial from the creators of YOLOv8 teaches you how to deploy models on NVIDIA Jetson devices. It explains how to set up CUDA acceleration, compile models using TensorRT, and benchmark inference performance to ensure real-time speeds in production.

• Knowledge Checkpoint:

  • Set up the NVIDIA Jetpack SDK environment and verify that PyTorch is configured to use CUDA (torch.cuda.is_available()).
  • Convert your trained model (best.pt) to a compiled TensorRT engine utilizing FP16 precision (yolo export model=best.pt format=engine half=True device=0).
  • Run inference using the compiled .engine file, log the frame processing latency, and compare the FPS performance against the standard .pt model.

Course Map

Key People Index

• Joseph Redmon (@TED Talk: "How computers learn to recognize objects instantly"): The original visionary behind the YOLO architecture. He introduced the single-stage regression approach to object detection, proving that real-time computer vision was possible.
• Andrew Ng (@Stanford Online Lectures): Co-founder of Coursera and Google Brain, and founder of DeepLearning.AI. He is a premier deep learning educator who helped popularize basic neural network concepts worldwide.
• Grant Sanderson (@3Blue1Brown): Created the popular mathematical animation series. His intuitive, visual explanations of linear algebra, calculus, and neural network foundations are widely used across academic and engineering communities.
• Glenn Jocher (@Ultralytics Live Sessions): Founder and CEO of Ultralytics, the organization behind the development of YOLOv5 and YOLOv8. He is a key advocate for accessible, open-source computer vision.

Final Self-Assessment

Complete this comprehensive final checklist to verify that you have successfully met the course learning goals:

• Python Foundations: You can write custom multi-step scripts, define modular functions, handle runtime errors, and manage packages inside a virtual environment.
• OpenCV Operations: You can read images/videos, display live feeds, extract frame metadata, apply spatial transforms (resize, crop), and draw overlays like custom bounding boxes.
• Deep Learning Foundations: You can explain how weights, biases, and activation functions work, and can describe the feature-extraction process inside a CNN.
• YOLO Theory: You can explain how YOLO's grid-based prediction system operates, and understand how Non-Maximum Suppression (NMS) and Intersection over Union (IoU) clean up redundant boxes.
• Custom Training: You can curate a balanced dataset, label classes, configure a dataset .yaml file, and train a YOLOv8 model to high precision on custom objects.
• Evaluation Metrics: You can read training validation logs and analyze precision-recall curves, confusion matrices, and mAP scores to gauge performance.
• Multi-Object Tracking: You can explain the core mechanics of tracking algorithms like ByteTrack and DeepSORT, and understand how Kalman filters predict motion to maintain consistent object IDs.
• Real-World Tracking Applications: You can implement a Python script that tracks objects and counts them as they cross spatial lines.
• Optimization Concepts: You can explain how model quantization reduces the precision of model weights (e.g., from FP32 to INT8) to optimize execution on low-resource devices.
• Hardware-Accelerated Compilation: You can convert raw PyTorch models (.pt) to ONNX and compile them into optimized TensorRT (.engine) files.
• Edge Deployment: You can successfully deploy a compiled model to run real-time camera inference on an edge device (such as a Raspberry Pi or NVIDIA Jetson).
• Performance Benchmarking: You can profile your system’s performance and document the FPS, latency, and memory footprint differences before and after model optimization.