Last Updated on 29/04/2026 by Eran Feit
The bottleneck of every computer vision project isn’t the architecture—it’s the data. Manually drawing thousands of bounding boxes is slow, prone to human error, and expensive. In this guide, you will master auto-labeling YOLOv8 datasets with Autodistill , a revolutionary “teacher-student” framework. By leveraging massive foundation models like Grounding DINO to “teach” your compact YOLOv8 model, you will transform raw images into a fully annotated, production-ready dataset in minutes. Whether you are building a real-time detector or a custom AI pipeline, this automated workflow eliminates the manual grind.
In modern workflows, automatic image annotation usually sits between raw data collection and model training.
As models get better, automatic image annotation becomes more accurate and flexible.
This approach scales incredibly well.
If you want a complete YOLOv8 YouTube object detection workflow (auto-labeling, training, and live inference), follow this step-by-step guide: https://eranfeit.net/how-to-use-yolov8-for-object-detection-on-youtube-videos/
Why automatic image annotation is a game changer Automatic image annotation gives you a practical way to turn unstructured visual data into training-ready datasets.
At a high level, a typical workflow begins with defining what you want to detect.
The next goal is quality.
Finally, everything feeds directly into training.
Auto annotation Walking through the code for automatic image annotation This tutorial is built as a complete, end-to-end pipeline that shows how to go from raw horse-race videos to a trained YOLOv8 model, using automatic image annotation instead of manual labeling.
Once the environment is ready, the code focuses on creating a dataset from real videos.
The core of the tutorial is the automatic annotation step.
After the dataset is created, the tutorial moves on to training and evaluation.
Taken together, the code in this tutorial teaches you how to build a practical automatic image annotation workflow around Autodistill and YOLOv8.
Link for the video tutorial : https://youtu.be/ujEDpRmaOaU
Link for the code here : https://eranfeit.lemonsqueezy.com/buy/e9168c31-06c1-4a8c-b544-ee2ad07173dc or here : https://ko-fi.com/s/553a125fa6
Link for the post for Medium users : https://medium.com/@feitgemel/automatic-image-annotation-with-autodistill-and-yolov8-86822349c735
Master Computer Vision
Follow my latest tutorials and AI insights on my
Personal Blog .
Beginner Complete CV Bootcamp
Foundation using PyTorch & TensorFlow.
Get Started → Interactive Deep Learning with PyTorch
Hands-on practice in an interactive environment.
Start Learning → Advanced Modern CV: GPT & OpenCV4
Vision GPT and production-ready models.
Go Advanced →
Automatic Image Annotation with Autodistill and YOLOv8 Automatic image annotation is one of the easiest ways to turn raw videos into training data without spending weeks drawing bounding boxes.
The code below is organized into six logical parts so you can follow the flow step by step.
🚀 Recommended for You: Ready to take your object detection skills to the next level? Learn how to handle live data with our latest guide: YouTube Stream Frame Extraction and Real-Time YOLOv8 Detection .
Eliminate stream lag with advanced buffer management. Connect YOLOv8 directly to any YouTube URL. Optimized for low-latency real-time inference. Setting Up Your Python Environment for Automated Annotation Before you touch any Python code, it is worth isolating the project in a dedicated Conda environment.
### Create a new Conda environment dedicated to automatic image annotation. conda create -- name Autodistill python = 3.8 ### Activate the environment so that all new packages are installed into this isolated space. conda activate Autodistill ### Check the NVIDIA CUDA compiler version to confirm that CUDA is available on your system. nvcc -- version ### Install PyTorch, Torchvision, and Torchaudio with CUDA 11.8 support from the official PyTorch and NVIDIA channels. conda install pytorch == 2.1 . 1 torchvision == 0.16 . 1 torchaudio == 2.1 . 1 pytorch - cuda = 11.8 - c pytorch - c nvidia ### Install the Ultralytics package that provides the YOLOv8 implementation. pip install ultralytics == 8.1 . 0 ### Install the Supervision library to handle listing files, reading video frames, and plotting image grids. pip install supervision == 0.9 . 0 ### Install the Autodistill framework that powers automatic image annotation. pip install autodistill ### Install the Grounding DINO integration that lets Autodistill use a vision-language model for detection. pip install autodistill_grounding_dino ### Install scikit-learn for any utility functions or potential metrics you might want later. pip install scikit - learn ### Install the Roboflow client library, which can help with dataset management if you choose to upload data there. pip install roboflow After running these commands you have a self-contained environment that is ready for automatic image annotation with GPU-accelerated PyTorch, YOLOv8, Autodistill, and Grounding DINO.
Turning horse-race videos into a clean image dataset The next goal is to convert your horse-race videos into a set of still images that you can annotate automatically.
### Import the supervision library, which provides utilities for working with videos and images. import supervision as sv ### Import tqdm's notebook-friendly progress bar in case you want to monitor long operations. from tqdm . notebook import tqdm ### Define the directory where your source horse-race videos are stored. VIDEO_DIR_PATH = " C:/Data-sets/Horse-race/Source-Data/videos " ### Define the directory where all extracted frames will be saved as images. IMAGE_DIR_PATH = " C:/Data-sets/Horse-race/Source-Data/All-images " ### Set the frame stride so that every tenth frame is extracted from each video. FRAME_STRIDE = 10 ### Collect all video paths with .mov or .mp4 extensions from the source directory. video_paths = sv . list_files_with_extensions ( directory = VIDEO_DIR_PATH , extensions = [ " mov " , " mp4 " ]) ### Print the list of video paths to confirm that the videos were found correctly. print ( video_paths ) ### Initialize a counter to keep track of how many images have been extracted. image_numerator = 0 ### Loop over every video path found in the directory. for video_path in video_paths : ### Print the name of the current video being processed for easier tracking. print ( " Extracted video name : " + str ( video_path )) ### Extract the stem of the video path to use as a prefix for image file names. video_name = video_path . stem ### Build a pattern for naming images that includes the video name and a zero-padded index. image_name_pattern = video_name + " - { :05d } .png " ### Open an ImageSink context manager that will save frames into the target image directory. with sv . ImageSink ( target_dir_path = IMAGE_DIR_PATH , image_name_pattern = image_name_pattern ) as sink : ### Iterate over frames from the video using the chosen frame stride. for image in sv . get_video_frames_generator ( source_path = str ( video_path ), stride = FRAME_STRIDE ): ### Increment the image counter for each extracted frame. image_numerator = image_numerator + 1 ### Print the index of the extracted frame so you can follow the progress in the console. print ( " Extract image no. " + str ( image_numerator )) ### Save the current frame as an image file using the sink. sink . save_image ( image = image ) ### Define the directory containing all extracted images so we can visualize them. IMAGE_DIR_PATH = " C:/Data-sets/Horse-race/Source-Data/All-images " ### List all image paths with .png or .jpg extensions from the extracted frames directory. image_paths = sv . list_files_with_extensions ( directory = IMAGE_DIR_PATH , extensions = [ " png " , " jpg " ]) ### Print the total number of images found so you understand the dataset size. print ( " image count : " , len ( image_paths )) ### Set how many sample images you want to display in the grid. SAMPLE_SIZE = 16 ### Define the grid layout as four rows by four columns. SAMPLE_GRID_SIZE = ( 4 , 4 ) ### Define the overall plot size for the image grid in inches. SAMPLE_PLOT_SIZE = ( 16 , 16 ) ### Import OpenCV, which will be used to read images from disk. import cv2 ### Create a list of titles based on the stem of each image path for the first SAMPLE_SIZE images. titles = [ image_path . stem for image_path in image_paths [: SAMPLE_SIZE ] ] ### Read the first SAMPLE_SIZE images from disk into memory using OpenCV. images = [ cv2 . imread ( str ( image_path )) for image_path in image_paths [: SAMPLE_SIZE ] ] ### Plot the sample images in a grid so you can visually inspect the extracted frames. sv . plot_images_grid ( images = images , titles = titles , grid_size = SAMPLE_GRID_SIZE , size = SAMPLE_PLOT_SIZE ) After this block you should have a folder of nicely named PNG or JPG images and a visual confirmation that the frames cover different moments of the race.
Using Autodistill and Grounding DINO for automatic image annotation Defining the Caption Ontology: Mapping Prompts to YOLO Classes Now that you have raw images, it is time to apply automatic image annotation.
### Import CaptionOntology from Autodistill's detection module to define your label names. from autodistill . detection import CaptionOntology ### Create a caption ontology mapping natural language prompts to class names for the horse race domain. ontology = CaptionOntology ({ " horse race " : " horse race " , " horse " : " horse " , " horse in a race " : " horse in a race " , " horse racing " : " horse racing " , }) ### Define the path to the folder containing all extracted image frames. IMAGE_DIR_PATH = " C:/Data-sets/Horse-race/Source-Data/All-images " ### Define the root path where the auto-labeled dataset will be created. DATASET_DIR_PATH = " C:/Data-sets/Horse-race/dataset " ### Set the detection box confidence threshold used by Grounding DINO. BOX_THRESHOLD = 0.6 ### Set the text confidence threshold for matching prompts to detections. TEXT_THRESHOLD = 0.50 ### Import the GroundingDINO base model wrapper used by Autodistill. from autodistill_grounding_dino import GroundingDINO ### Initialize the GroundingDINO model with your ontology and chosen thresholds. base_model = GroundingDINO ( ontology = ontology , box_threshold = BOX_THRESHOLD , text_threshold = TEXT_THRESHOLD , ) ### Run automatic image annotation on all PNG images in the input folder and save YOLO labels into the dataset directory. dataset = base_model . label ( input_folder = IMAGE_DIR_PATH , extension = " .png " , output_folder = DATASET_DIR_PATH , ) When this block finishes, your automatic image annotation pipeline has generated YOLO-formatted label files under the dataset directory.
The Ontology acts as the bridge between natural language and computer vision labels. By using a CaptionOntology, you are essentially “prompting” a Zero-Shot model (like Grounding DINO) to locate objects it has never specifically been trained on.
Pro-Tip: If the model misses objects, try using more descriptive prompts in your ontology, such as “red plastic bottle” instead of just “bottle,” to help the foundation model disambiguate features.
Visualizing YOLO annotations to validate automatic labels Automatic image annotation is powerful, but you still want to spot-check the results.
### Import the os module for working with file paths and directory listings. import os ### Import the random module to randomly sample images for visualization. import random ### Import matplotlib for potential plotting needs, although here we mainly use OpenCV windows. import matplotlib . pyplot as plt ### Import OpenCV to read images and draw rectangles and text on them. import cv2 ### Define the human-readable label names that correspond to YOLO class indices. label_names = [ " horse race " , " horse " , " horse in a race " , " horse racing " ] ### Define a function that reads a YOLO-format label file and returns a list of annotations. def get_annotations ( original_img , label_file ): ### Open the label file and read all lines containing annotation data. with open ( label_file , ' r ' ) as file : lines = file . readlines () ### Initialize an empty list that will hold tuples of (label_index, x_center, y_center, width, height). annotations = [] ### Loop over each line in the label file. for line in lines : ### Split the line into separate values, starting with the label index. values = line . split () label = values [ 0 ] ### Convert the remaining values from strings into floating-point numbers. x , y , w , h = map ( float , values [ 1 :]) ### Append the parsed annotation as a tuple into the list. annotations . append (( label , x , y , w , h )) ### Return the full list of parsed annotations. return annotations ### Define a function that draws bounding boxes and labels on an image based on YOLO-format annotations. def put_annotations_in_image ( image , annotations ): ### Extract the image height and width from the shape. H , W , _ = image . shape ### Loop over each annotation tuple in the list. for annotation in annotations : ### Unpack the label index and normalized YOLO coordinates. label , x , y , w , h = annotation ### Print the raw values for debugging purposes. print ( label , x , y , w , h ) ### Convert the label index to a human-readable label name. label_name = label_names [ int ( label )] ### Convert YOLO normalized coordinates into pixel coordinates for the top-left corner. x1 = int (( x - w / 2 ) * W ) y1 = int (( y - h / 2 ) * H ) ### Convert YOLO normalized coordinates into pixel coordinates for the bottom-right corner. x2 = int (( x + w / 2 ) * W ) y2 = int (( y + h / 2 ) * H ) ### Draw a rectangle around the detected object on the image. cv2 . rectangle ( image , ( x1 , y1 ), ( x2 , y2 ), ( 200 , 200 , 0 ), 1 ) ### Draw the label text just above the top-left corner of the bounding box. cv2 . putText ( image , label_name , ( x1 , y1 - 5 ), cv2 . FONT_HERSHEY_SIMPLEX , 0.5 , ( 200 , 200 , 0 ), 2 ) ### Return the annotated image so it can be displayed or saved. return image ### Define a function that displays several random images from a folder together with their annotations. def display_random_images ( folder_path , num_images , label_folder ): ### Collect only file names from the folder path, skipping any subdirectories. image_files = [ f for f in os . listdir ( folder_path ) if os . path . isfile ( os . path . join ( folder_path , f ))] ### Randomly select the desired number of image file names. selected_images = random . sample ( image_files , num_images ) ### Loop over each selected image file for visualization. for i , image_file in enumerate ( selected_images ): ### Read the image from disk using OpenCV. img = cv2 . imread ( os . path . join ( folder_path , image_file )) ### Build the expected label file name by replacing the image extension with .txt. label_file = os . path . splitext ( image_file )[ 0 ] + " .txt " ### Join the label folder path with the label file name to get a full path. label_file_path = os . path . join ( label_folder , label_file ) ### Read and parse the YOLO-format annotations for this image. annotations_Yolo_format = get_annotations ( img , label_file_path ) ### Draw bounding boxes and labels on a copy of the image based on the annotations. image_with_annotations = put_annotations_in_image ( img , annotations_Yolo_format ) ### Print the shape of the annotated image for quick verification. print ( image_with_annotations . shape ) ### Display the annotated image in an OpenCV window. cv2 . imshow ( " img no. " + str ( i ), image_with_annotations ) ### Wait for a key press before moving on to the next image. cv2 . waitKey ( 0 ) ### Define the path to the training images generated by the automatic image annotation step. images_path = " C:/Data-sets/Horse-race/dataset/train/images " ### Define the path to the YOLO label files associated with the training images. label_folder = " C:/Data-sets/Horse-race/dataset/train/labels " ### Set how many random images you want to display with annotations. num_images = 8 ### Run the visualization function to inspect random annotated training images. display_random_images ( images_path , num_images , label_folder ) After checking a few randomly annotated images, you will quickly see whether the automatic image annotation step is doing a good job.
Training a YOLOv8 model on auto-labeled horse-race data With a validated dataset, the next step is to train YOLOv8 on the auto-labeled images.data.yaml file that describes the dataset, and run training with sensible defaults for epochs, batch size, and patience.best.pt file that you will later use for inference.
### Import the YOLO class from the Ultralytics library to handle training and inference. from ultralytics import YOLO ### Define a main function to encapsulate the training logic. def main (): ### Load a YOLOv8 large model configuration from the provided YAML file. model = YOLO ( " yolov8l.yaml " ) ### Define the path to the data configuration file that describes your dataset. config_file_path = " Best-Object-Detection-models/Yolo-V8/Auto-Annotation-YoloV8-Detecting-horses/data.yaml " ### Define the directory where YOLOv8 will store training runs and checkpoints. project = " C:/Data-sets/Horse-race/dataset/checkpoints " ### Set the experiment name to distinguish this run from others in the project folder. experiment = " My-Large-Model " ### Choose a batch size that fits your GPU memory and training speed. batch_size = 16 ### Start training the YOLOv8 model with your custom data and chosen hyperparameters. results = model . train ( data = config_file_path , epochs = 100 , project = project , name = experiment , batch = batch_size , device = 0 , patience = 40 , imgsz = 640 , verbose =True , val =True , ) ### Ensure that the main function only runs when this script is executed directly. if __name__ == " __main__ " : main ()
Here is the data.yaml
train : C : / Data - sets / Horse - race / dataset / train / images val : C : / Data - sets / Horse - race / dataset / valid / images # class names nc : 4 names : [ " horse race " , " horse " , " horse in a race " , " horse racing " ] When training finishes, YOLOv8 saves the best model weights into the checkpoints folder.
Running real-time horse-race detection on new videos The final piece of the pipeline is to take your trained YOLOv8 model and run it on a brand-new race video.
### Import OpenCV so you can read video frames and draw visual annotations. import cv2 ### Import the YOLO class from Ultralytics to load the trained model. from ultralytics import YOLO ### Import the os module to help build a path to the best model weights. import os ### Define the path to the test video you want to run the trained model on. video_path = " C:/Data-sets/Horse-race/Source-Data/Test-videos/video12.mp4 " ### Build the full path to the best model checkpoint saved during training. model_path = os . path . join ( " C:/Data-sets/Horse-race/dataset/checkpoints " , " My-Large-Model " , " weights " , " best.pt " , ) ### Load the trained YOLOv8 model from the checkpoint file. model = YOLO ( model_path ) ### Set a confidence threshold so that only sufficiently strong detections are drawn. threshold = 0.25 ### Create an OpenCV VideoCapture object to read frames from the test video. cap = cv2 . VideoCapture ( video_path ) ### Loop over frames from the video until there are no more frames to read. while True : ### Read the next frame from the VideoCapture object. ret , frame = cap . read () ### If no frame was read, break out of the loop because the video has finished. if not ret : break ### Run the YOLOv8 model on the current frame and take the first result object. results = model ( frame )[ 0 ] ### Loop over each detected box in the YOLOv8 results. for result in results . boxes . data . tolist (): ### Unpack the bounding box coordinates, score, and class ID from the result. x1 , y1 , x2 , y2 , score , class_id = result ### Convert floating-point coordinates into integer pixel positions. x1 = int ( x1 ) x2 = int ( x2 ) y1 = int ( y1 ) y2 = int ( y2 ) ### Only draw boxes for detections whose confidence score is above the chosen threshold. if score > threshold : ### Draw a green rectangle around the detected object. cv2 . rectangle ( frame , ( x1 , y1 ), ( x2 , y2 ), ( 0 , 255 , 0 ), 1 ) ### Draw the class name text just above the bounding box. cv2 . putText ( frame , results . names [ int ( class_id )]. upper (), ( x1 , y1 - 10 ), cv2 . FONT_HERSHEY_SIMPLEX , 0.5 , ( 0 , 255 , 0 ), 1 , ) ### Display the annotated frame in a window titled "Video". cv2 . imshow ( " Video " , frame ) ### Check for a key press and break if the 'q' key is pressed. if cv2 . waitKey ( 25 ) & 0x FF == ord ( " q " ): break ### Release the VideoCapture resource after the loop ends. cap . release () ### Close any OpenCV windows that were opened during visualization. cv2 . destroyAllWindows () When you run this script, you will see bounding boxes tracking horses and race scenes throughout the video.
Automated labels are rarely 100% perfect. Before deploying your model, always perform a manual “sanity check” on 5-10% of the generated images in the /dataset/train/labels folder. If you notice systematic errors (e.g., the model consistently confuses two classes), refine your ontology prompts rather than manually fixing individual boxes; this allows the automation to scale across thousands of images.
FAQ: Auto-labeling YOLOv8 datasets with Autodistill What does automatic image annotation mean in this project? In this project, automatic image annotation means using Autodistill with Grounding DINO to detect objects in images and automatically write YOLO-style label files, so you can skip manual box drawing.
Why are horse-race videos converted into frames first? Converting videos into frames turns them into a standard image dataset, which makes it easier to run automatic annotation, manage training splits, and debug individual examples.
How does Grounding DINO help with labeling? Grounding DINO links text prompts to visual regions, so when you provide phrases like “horse racing” it can detect matching objects and return bounding boxes that Autodistill converts into labels.
What is the purpose of the ontology in Autodistill? The ontology defines the list of classes and their associated prompts, ensuring that all detections are mapped to consistent class IDs and names for YOLOv8 training.
How do I check if the automatic labels are reliable? You can use the visualization code to overlay bounding boxes on random images and visually inspect whether the objects and labels align with what you see in the frame.
Why is YOLOv8 used for training instead of another model? YOLOv8 offers a simple training API, strong performance, and easy deployment to images and videos, making it a practical choice once your automatic image annotation dataset is ready.
Can I adapt this pipeline to detect different types of objects? Yes, you can change the ontology prompts, adjust the dataset paths, and retrain YOLOv8 to detect any objects that Grounding DINO can reliably identify from your images.
Do I need to modify the data.yaml file when I change classes? Whenever you change the set of classes or dataset folder structure, you should update the data.yaml file so that YOLOv8 knows the correct paths, class count, and class names.
Is a GPU required for training this model efficiently? A modern GPU is highly recommended because it significantly speeds up both automatic labeling and YOLOv8 training, especially when working with many video frames.
What are some good next steps after completing this tutorial? After you complete this tutorial, you can scale up to more videos, experiment with different YOLOv8 model sizes, or integrate segmentation-based auto-labeling to capture richer object details.
Wrapping up the automatic image annotation pipeline By the time you reach the end of this tutorial, you have walked through a complete pipeline that turns raw horse-race videos into a working object detector.
You saw how to extract frames with Supervision, define an ontology for your classes, and let Grounding DINO generate high-quality YOLO labels.
The same pattern scales to other domains with only minor changes.data.yaml file, you can reuse this automatic image annotation workflow for traffic analysis, sports analytics, industrial inspection, or any other problem where labeled images are hard to obtain.
Most importantly, you now have a repeatable system.
Connect : ☕ Buy me a coffee — https://ko-fi.com/eranfeit
🖥️ Email : feitgemel@gmail.com
🌐 https://eranfeit.net
🤝 Fiverr : https://www.fiverr.com/s/mB3Pbb
Enjoy,
Eran
Skip to content 
