Last Updated on 22/04/2026 by Eran Feit
Traditional object detection often fails in sports analytics because bounding boxes overlap in crowded scenes, making it impossible to calculate precise player distances or pitch coverage. To solve this, we must move to pixel-level understanding. In this YOLOv8 Multi-Class Segmentation Tutorial for Football Analytics , you will learn how to build a model that doesn’t just see players, but understands the exact boundaries of the pitch, the ball, and the athletes. We will walk through building an end-to-end pipeline that transforms raw football footage into a rich, segmented data source ready for professional tactical analysis.
To see how this fits into a broader curriculum, explore the complete Image Segmentation category for more deep-dive workflows.
YOLOv8 Multi-Class Segmentation Tutorial for Football Analytics The Shift from Detection to Multi-Class Instance Segmentation Training a multi-class model for image segmentation means teaching YOLOv8 to paint different pixel masks for different objects in the same frame—players vs. pitch vs. lines vs. ads vs. ball.
If you want more hands-on guides on pixel-level masks and real-world projects, explore my dedicated Image Segmentation tutorials collection for more step-by-step workflows.
Link for the video tutorial : https://youtu.be/iXaq4OXNwSs
You can download the code here : https://eranfeit.lemonsqueezy.com/buy/77dc4418-e8c2-4fc3-a621-e5908f177780
or here : https://ko-fi.com/s/1ed1ea7299
Link for the post in Medium : https://medium.com/@feitgemel/yolov8-segmentation-tutorial-for-multi-class-football-2b7996cda945
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 → What This Tutorial Will Build (Tutorial Intro) In this YOLOv8 segmentation tutorial , you’ll:
Create a dedicated environment with compatible PyTorch, CUDA, and Ultralytics YOLOv8 versions. Prepare a football segmentation dataset and YOLO-format labels for multiple classes. Train yolov8l-seg on your custom config for multi-class segmentation. Run inference on a test image, generate per-class colored masks, and visualize results side-by-side with the original image. Everything is structured so you can switch datasets, adjust classes, or point this exact pipeline at different sports or domains with minimal changes.
For developers looking for different architectures, see my guide on Detectron2 Custom Dataset Training to compare performance with YOLOv8.
1. Configuring Your YOLOv8 Multi-Class Segmentation Environment Setting up a dedicated environment is more than just avoiding library conflicts; it’s about optimizing the bridge between your GPU and the Ultralytics framework. Using a specific CUDA 11.8 stack with PyTorch ensures that the heavy tensor computations required for mask generation are offloaded efficiently, preventing the dreaded “Out of Memory” errors often seen during high-resolution segmentation training.
Before training any serious YOLOv8 segmentation tutorial pipeline, you want an isolated environment.
### Create a new Conda environment dedicated to YOLOv8 segmentation. conda create -- name YoloV8 python = 3.8 ### Activate the YOLOv8 environment so all packages install in isolation. conda activate YoloV8 ### Verify that CUDA toolkit is visible so PyTorch can use your GPU. nvcc -- version ### Install PyTorch, TorchVision and TorchAudio compiled for CUDA 11.8. 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 YOLO package for detection and segmentation. pip install ultralytics == 8.1 . 0 ### Remove conflicting headless OpenCV builds that may break cv2. pip uninstall opencv - python - headless - y ### Remove any existing OpenCV install to avoid version clashes. pip uninstall opencv - python - y ### Install a compatible OpenCV build with GUI support. pip install " opencv-python>=4.6.0 " Summary (Part 1) yolov8 segmentation tutorial runs consistently on both your machine and future projects.
New to the YOLOv8 ecosystem? Start with my Complete YOLOv8 Classification Tutorial for Beginners to understand the core workflow before diving deeper into segmentation.
2. Curating and Labeling Multi-Class Datasets for Sports Vision Want the exact dataset so your results match mine? If you want to reproduce the same training flow and compare your results to mine, I can share the dataset structure and what I used in this tutorial. Send me an email and mention the name of the tutorial / dataset , so I know what you’re requesting.
🖥️ Email: feitgemel@gmail.com
High-quality segmentation starts with clean labels.
### Create a root folder for your football segmentation project. mkdir - p " C:/Data-sets/Football-Seg.v1i.yolov8 " ### Create a folder where all cleaned training images will live. mkdir - p " C:/Data-sets/Football-Seg.v1i.yolov8/images " ### Create a folder for YOLOv8 segmentation label files in TXT format. mkdir - p " C:/Data-sets/Football-Seg.v1i.yolov8/labels " ### (After exporting from your annotation tool) move all images into the images directory. move " path_to_exported_images\*.jpg " " C:/Data-sets/Football-Seg.v1i.yolov8/images " ### Move all YOLOv8 TXT label files into the labels directory. move " path_to_exported_labels\*.txt " " C:/Data-sets/Football-Seg.v1i.yolov8/labels " ### Open your dataset YAML file in a text editor to update image and label paths. notepad " Best-Semantic-Segmentation-models/Yolo-V8/Segment-Multi-Class-Football-Segmentation/config.yaml " Summary (Part 2) multiclass image segmentation yolo projects.
If you are new to the YOLO ecosystem, it is helpful to master the basics of Object Detection before moving into the complexities of pixel-level masks.
3. Fine-Tuning YOLOv8-Seg: Hyperparameters and Training Mastery Understanding Your config.yaml – The Brain of Your YOLOv8 Segmentation Setup When selecting a backbone, we utilize yolov8l-seg.pt (the Large variant) because sports analytics requires a high degree of precision for small, fast-moving objects like the football. While the “Small” or “Nano” versions offer faster inference, the “Large” model provides the necessary depth to distinguish between a player’s limb and the pitch markings, which is critical for accurate spatial data.
Before YOLOv8 can train a powerful multi-class segmentation model, it needs clear instructions on where your data lives and what each class means .config.yaml file does: it acts as the central blueprint that connects your images, label files, and class names into one consistent configuration that YOLOv8 can trust.
Inside this file, you define the paths for your train, val, and optional test image folders, making sure they match the structure created when you exported your dataset and YOLO TXT labels.
A clean, well-structured config.yaml is often the difference between a smooth yolov8 segmentation tutorial experience and hours of silent bugs or wrong predictions.
Inside the YAML, set train/val/test paths to your YOLOv8-ready folders :
“Config.yaml”
train: C:/Data-sets/Football-Seg.v1i.yolov8/train/images val: C:/Data-sets/Football-Seg.v1i.yolov8/valid/images test: C:/Data-sets/Football-Seg.v1i.yolov8/test/images nc: 10 names: ['Advertisements', 'Audience', 'Ball', 'Goal Bar', 'Goalkeeper A', 'Goalkeeper B', 'Ground', 'Referee', 'Team A', 'Team B']
If you are working with polygon masks and custom datasets, you may also like my Detectron2 Custom Dataset Training Made Easy tutorial, which covers a similar annotation-to-training pipeline.
Now you fine-tune yolov8l-seg.pt on your football dataset.
### Import the YOLO class from the Ultralytics package to handle training and inference. from ultralytics import YOLO ### Define the main function to keep the training pipeline organized and reusable. def main (): ### Load the pretrained YOLOv8 large segmentation model as a strong starting point. model = YOLO ( ' yolov8l-seg.pt ' ) ### Set the base directory where training runs, logs, and weights will be stored. project = " C:/Data-sets/Football-Seg.v1i.yolov8 " ### Name this specific experiment so multiple runs stay neatly separated. experiment = " My-model " ### Choose a batch size that balances speed and GPU memory usage. batchSize = 16 ### Launch model training with your custom YAML configuration. results = model . train ( ### Path to the dataset configuration file with classes and paths. data = " Best-Semantic-Segmentation-models/Yolo-V8/Segment-Multi-Class-Football-Segmentation/config.yaml " , ### Number of epochs to allow the model to learn complex patterns. epochs = 200 , ### Folder where results will be saved. project = project , ### Subfolder name inside the project directory. name = experiment , ### Batch size for each training step. batch = batchSize , ### Device index: 0 means first GPU; use 'cpu' if no GPU is available. device = 0 , ### Training and inference image size (square). imgsz = 640 , ### Early stopping patience to halt when validation stops improving. patience = 30 , ### Print rich training logs to monitor progress. verbose =True , ### Enable validation during training to track real performance. val =True ) ### Standard Python entry point to run training when this script is executed. if __name__ == ' __main__ ' : main () Summary (Part 3) yolov8 instance segmentation model tuned for football scenes.
For another practical example of YOLOv8 segmentation in action, check out my YOLOv8 Segmentation Tutorial for Real Flood Detection , where the same concepts are applied to satellite and map imagery.
4. Advanced Inference: Visualizing and Interpreting Multi-Class Masks Training is only useful if you can see what the model actually predicts.
Here is our test image :
YOLOv8 Multi-Class Segmentation Tutorial for Football Analytics 9 ### Import YOLO for loading the trained segmentation model. from ultralytics import YOLO ### Import NumPy for numerical operations on masks and arrays. import numpy as np ### Import OpenCV for image loading, resizing, and saving. import cv2 ### Import random to generate distinct colors for each class. import random ### Define the path to the trained YOLOv8 segmentation weights. model_path = " C:/Data-sets/Football-Seg.v1i.yolov8/My-model/weights/best.pt " ### Define the path to a sample football image for visualization. image_path = " Best-Semantic-Segmentation-models/Yolo-V8/Segment-Multi-Class-Football-Segmentation/football_test.png " ### Read the input image from disk in BGR format. img = cv2 . imread ( image_path ) ### Extract the image height, width, and number of channels. H , W , _ = img . shape ### Print the image shape to verify it loaded correctly. print ( img . shape ) ### Load the trained YOLOv8 segmentation model from disk. model = YOLO ( model_path ) ### Run inference on the image to get segmentation predictions. results = model ( img ) ### Select the first (and only) result from the prediction list. result = results [ 0 ] ### Access the class name mapping stored inside the model. names = model . names ### Print all class names to confirm the index-to-label mapping. print ( names ) ### Define the expected number of classes used during training. num_classes = 10 ### Create an empty list that will store a unique color for each class. random_colors = [] ### Generate random BGR colors for each class index. for _ in range ( num_classes ): ### Sample a random blue channel value. blue = random . randint ( 0 , 255 ) ### Sample a random green channel value. green = random . randint ( 0 , 255 ) ### Sample a random red channel value. red = random . randint ( 0 , 255 ) ### Pack the three values into a BGR color tuple. color = ( blue , green , red ) ### Append the generated color to the list. random_colors . append ( color ) ### Print the list of random colors to verify the mapping. print ( random_colors ) ### Create an empty color image to accumulate all predicted masks. final_mask = np . zeros (( H , W , 3 ), dtype = np . uint8 ) ### Extract the predicted class IDs from the detection boxes. predicted_classes = result . boxes . cls . cpu (). numpy () ### Print the list of predicted class IDs for debugging. print ( predicted_classes ) ### Iterate over each predicted mask and its corresponding index. for j , mask in enumerate ( result . masks . data ): ### Move the mask tensor to CPU, convert to NumPy, and scale to 0-255. mask = mask . cpu (). numpy () * 255.0 ### Read the class ID for the current instance. classId = int ( predicted_classes [ j ]) ### Print which object index maps to which class. print ( " Object " + str ( j ) + " detected as " + str ( classId ) + " - " + names [ classId ]) ### Resize the mask to match the original image dimensions. mask = cv2 . resize ( mask , ( W , H )) ### Select the color associated with this class ID. color = random_colors [ classId ] ### Create an empty image for the colored mask of this instance. colored_mask = np . zeros (( H , W , 3 ), dtype = np . uint8 ) ### Color all pixels where the mask is active. colored_mask [ mask > 0 ] = color ### Merge this instance mask into the final accumulated mask. final_mask = np . maximum ( final_mask , colored_mask ) ### Build a unique filename for saving the individual instance mask. file_name = " output " + str ( j ) + " .png " ### Save the colored mask for this instance to disk. cv2 . imwrite ( " C:/Data-sets/Football-Seg.v1i.yolov8/My-model/ " + file_name , colored_mask ) ### Save the combined final mask image containing all instances. cv2 . imwrite ( " C:/Data-sets/Football-Seg.v1i.yolov8/My-model/final_mask.png " , final_mask ) ### Display the original image in an OpenCV window. cv2 . imshow ( " img " , img ) ### Display the final combined mask in another window. cv2 . imshow ( " final mask " , final_mask ) ### Wait for a key press before closing the OpenCV windows. cv2 . waitKey ( 0 ) ### Import Matplotlib for side-by-side visualization inside notebooks. import matplotlib . pyplot as plt ### Create a figure with one row and two columns for comparison. fig , axes = plt . subplots ( 1 , 2 , figsize = ( 12 , 6 )) ### Show the original image on the left, converted from BGR to RGB. axes [ 0 ]. imshow ( cv2 . cvtColor ( img , cv2 . COLOR_BGR2RGB )) ### Set a descriptive title for the original image. axes [ 0 ]. set_title ( " Original image " ) ### Hide axis ticks for a cleaner look. axes [ 0 ]. axis ( ' off ' ) ### Show the final segmentation mask on the right, also converted to RGB. axes [ 1 ]. imshow ( cv2 . cvtColor ( final_mask , cv2 . COLOR_BGR2RGB )) ### Set a descriptive title for the mask visualization. axes [ 1 ]. set_title ( " Final mask " ) ### Hide axis ticks for consistency. axes [ 1 ]. axis ( ' off ' ) ### Render the Matplotlib figure to visualize both images. plt . show () The core logic of this visualization script lies in the handling of the mask tensors. By normalizing the mask data and using bitwise operations to overlay random colors, we preserve the original image’s texture while providing a clear visual representation of model confidence. This “Mask Over Background” approach is the standard for creating the tactical heatmaps and broadcast overlays used by modern sports analysts.
Summary (Part 4) football player segmentation YOLOv8 masks, and visualizes them clearly.
If you want to bootstrap high-quality masks even faster, follow my Segment Anything tutorial: Generate YOLOv8 Masks Fast to combine SAM with YOLOv8 for rapid mask generation.
FAQ : Can YOLOv8 handle multi-class football segmentation in one model? Yes, YOLOv8 can learn multiple football classes in a single segmentation model as long as your labels and YAML configuration are consistent.
Do I need polygon masks for YOLOv8 segmentation? Yes, YOLOv8 segmentation expects polygon-style mask annotations converted into its TXT format for accurate pixel-level predictions.
What backbone is used in this YOLOv8 segmentation tutorial? This tutorial uses yolov8l-seg.pt, a strong large backbone suitable for high-quality multi-class segmentation tasks.
How many epochs should I train my YOLOv8 segmentation model? Around 100–200 epochs with early stopping is a solid range; monitor validation loss and mAP to decide when to stop.
Common causes are noisy labels, incorrect class IDs, unbalanced data, or too aggressive augmentations; fix these first.
An image size of 640 is a practical default; increase it for finer lines if your GPU memory allows.
Can I visualize each class with a different color mask? Yes, you can map each class ID to a unique color and overlay masks to quickly inspect predictions.
Is this tutorial suitable for beginners in segmentation? Yes, it uses copy-paste code, explains each command, and is approachable for beginners while still useful for advanced users.
Can I adapt this pipeline to video segmentation? Yes, run inference frame by frame, apply the same segmentation model, and optionally track objects over time.
Export to ONNX or TensorRT and integrate into your inference pipeline for real-time match analysis or broadcast overlays.
Conclusion Training a multi-class YOLOv8 segmentation model for football gives you far more than pretty masks—it gives you structured, pixel-level understanding of every frame.
This tutorial is deliberately practical, so you can clone the structure for any sport or domain: swap the dataset, adjust the classes, keep the same proven yolov8 segmentation tutorial backbone, and ship real models instead of just reading about them.
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 
