Classify - Ultralytics YOLOv8 Docs

[giscus[bot]]

Classify - Ultralytics YOLOv8 Docs

Check YOLO class label with only one class for the whole image, using image classification. Get strategies for training and validation models.

https://docs.ultralytics.com/tasks/classify/

[iRadhs]

Could you please share the command - transfer learning for classification. I tried to use the command which I'd used for object detection I am classifying more than one class.
!python train.py --batch 32 --weights yolov5m.pt --data '/content/gdrive/MyDrive/sample/data/images' --epochs 50 --cache --freeze 12
Error AssertionError: Multiple files match.

!python classify/train.py --batch 32 --weights yolov5m.pt --data '/content/gdrive/MyDrive/sample/data/images' --epochs 50 --cache --freeze 12
When I tried the above there is no freeze argument

[glenn-jocher]

@iRadhs you need to use classification models for classification, i.e. yolov8m-cls.pt, in your example above you've used a detection model yolov8m.pt.

[philhawkinsmc]

I am working primarily with video and a lot of my projects involve things like "is location outside?" "is it inside?" That sort of thing. When I run my script it is detecting those classes in a long stream of frame by frame detections. This is great for testing the quality of the model, but pretty redundant for what I'm hoping to achieve. Is there a way to simplify this to the point of saying that footage was detected outside or inside or both?

[glenn-jocher]

Higher level operations like you describe are up to you to create by handling inference results as you see fit.

[Longleaves]

Hello, In classification duty, I want to get output of predicted class that means when I input an image, it can print the predicted class of it. I found there is no attribute of results which names cls. How can I get such output from results? thanks.

[glenn-jocher]

You can use results[0].probs.top1 or results[0].probs.top5 to get the top class indices, and results[0].names to get the associated class names.

[Longleaves]

thanks, it work!

[pderrenger]

@Longleaves you're welcome! If you have any more questions or need further assistance, feel free to ask. Happy coding! 😊👍

[natsume-cute]

I want to perform Multi "label" classification using YOLOV8 in Python, instead of Multi "class." Could you please explain the configuration of the dataset (①) and the specific coding approach for the network (②)?

① Dataset Configuration:

Below is an example of the configuration for Multi "class" as described on the official website. However, in the case of Multi-label classification, there are images that belong to multiple classes. How should I handle such cases?

root/
|-- class1/
| |-- img1.jpg
| |-- img2.jpg
| |-- ...
|
|-- class2/
| |-- img1.jpg
| |-- img2.jpg
| |-- ...
|
|-- class3/
| |-- img1.jpg
| |-- img2.jpg
| |-- ...
|
|-- ...

② Specific Coding Approach for the Network:

The following code is provided on the official website, but how should I modify it accordingly? I would like to set the number of model outputs to num_class (number of multi-labels), change the loss to BCE (Binary cross entropy), compute BCE for each output, and take the average of losses for each label. Is that the right way to make these changes, or is there a simpler implementation method?

python
Copy code
from ultralytics import YOLO

Load a model

model = YOLO('yolov8n-cls.yaml') # build a new model from YAML
model = YOLO('yolov8n-cls.pt') # load a pretrained model (recommended for training)
model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # build from YAML and transfer weights

Train the model

model.train(data='mnist160', epochs=100, imgsz=64)

[pderrenger]

@natsume-cute for multi-label classification using YOLOv8, you'll need to adjust both the dataset configuration and the training approach. Here's how you can handle it:

① Dataset Configuration:

In a multi-label classification scenario, each image can have multiple labels. Instead of organizing your dataset into separate folders for each class, you would typically have a single folder with all images and an accompanying annotation file that lists the labels for each image. The annotation file could be a CSV or a text file where each line corresponds to an image and its labels. Here's an example structure:

root/
|-- images/
|   |-- img1.jpg
|   |-- img2.jpg
|   |-- ...
|
|-- labels.csv

And labels.csv might look like this:

img1.jpg, 0, 1, 0, ...
img2.jpg, 1, 0, 1, ...
...

Each row contains the image filename followed by a series of binary values indicating the presence or absence of each class.

② Specific Coding Approach for the Network:

For multi-label classification, you will indeed need to modify the loss function to Binary Cross-Entropy (BCE) since each class prediction is treated as an independent Bernoulli distribution. However, YOLOv8 is primarily designed for object detection tasks, and while it does support classification, it may not natively support multi-label classification out of the box.

Here's a general approach to how you might modify the training process for multi-label classification:

from ultralytics import YOLO
import torch
from torch import nn

# Load a model
model = YOLO('yolov8n-cls.yaml')  # build a new model from YAML

# Modify the last layer of the model to have the correct number of outputs for multi-label
num_classes = 10  # for example, if you have 10 labels
model.model[-1] = nn.Sequential(
    nn.Flatten(),
    nn.Linear(in_features=model.model[-1].in_features, out_features=num_classes),
    nn.Sigmoid()  # Use sigmoid activation for multi-label classification
)

# Replace the loss function with BCELoss
criterion = nn.BCELoss()

# Define your custom training loop
def train(model, criterion, data, epochs, imgsz):
    # Load your dataset here
    # ...

    optimizer = torch.optim.Adam(model.parameters())

    for epoch in range(epochs):
        for images, labels in data:  # Your data loader should yield images and multi-hot encoded labels
            # Forward pass
            outputs = model(images)
            loss = criterion(outputs, labels)

            # Backward and optimize
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item()}')

# Train the model
train(model, criterion, data='your_dataset_loader', epochs=100, imgsz=64)

Please note that this is a simplified example and assumes you have a dataset loader that yields images and their corresponding multi-hot encoded labels. You'll need to implement the data loading logic based on your dataset's structure.

Since YOLOv8 is not primarily designed for multi-label classification, you might need to make additional modifications or consider using a different framework that is more suited for this task, such as PyTorch Lightning or Hugging Face Transformers, which offer more flexibility for custom tasks.

[hoominchu]

Hello @pderrenger! Thanks for this answer. I have created my dataset in the multi-hot encoding format and trying to train a model for multi-label classification. As I am new to ML, I am trying to understand how the data should be loaded and the imgsz parameter should be used. Do you have an example of that? Or can you point me to some example code in the YOLOv8 codebase that I can refer to? Thanks!

[hoominchu]

Also tagging @natsume-cute, were you able to figure it out? Could you share the code/references? Thanks!

[zakenobi]

Hi I trained a classification model with 2 classes and every time a do a prediction I get a sum of the probability even with an image that contains both classes, ie:
0: 640x640 classe1 0.55, classe2 0.45
0: 640x640 classe1 0.60, classe2 0.40
0: 640x640 classe1 0.07, classe2 0.93
The expected behaviour would be:
0: 640x640 classe1 ~0.90, classe2 ~0.90
Is there an argument I'm missing for the training or the prediction to get result I'm hoping for ?

[hannaliavoshka]

As it comes from the description of yolov8 classification task (https://docs.ultralytics.com/tasks/classify/), it involves classifying an entire image into one of a set of predefined classes. So even if you have an image with objects of both classes, the model will classify the entire image only by one class, as it was taught. Prediction output for the single image always represents the probability trade-off between your classes to classify the entire image, so it is always equal to 1 in a sum.

[zakenobi]

Okay I see, the image on the page is a little misleading. I guess this has to do with the fact that this is not a multi-label model, is it possible to make such a model with ultralytics ?

[pderrenger]

@zakenobi yes, you're correct that the standard YOLOv8 classification models are not designed for multi-label classification out of the box, where an image can simultaneously belong to multiple classes. However, you can modify the model to perform multi-label classification by adjusting the final layer to not use softmax (which forces the probabilities to sum to 1) and instead use a sigmoid activation function, which treats each class independently.

To train a multi-label classification model with Ultralytics YOLO, you would need to customize the model architecture and the loss function accordingly. This typically involves changing the dataset preparation to handle multi-label annotations and modifying the network's output layer to support multi-label predictions.

While the Ultralytics YOLO repository primarily focuses on object detection, segmentation, and single-label classification, you can refer to the Ultralytics YOLO documentation and resources for guidance on customizing models. If you're comfortable with PyTorch and neural network architectures, you can implement these changes yourself.

Alternatively, you can look for other frameworks or implementations that support multi-label classification natively, or consider contributing to the Ultralytics repository if you develop a solution that could benefit the community.

[gillonba]

Classification looks like a great inclusion and I am hoping to use it in a project of mine, but I am a little confused by the sample image. The documentation clearly states "The output of an image classifier is a single class label and a confidence score." But the sample image right above has three labels, "Person", "Tripod", and "Safety Vest". Was this image evaluated by three separate classification models? Or perhaps this result was obtained by picking the top 3 results from Probs.top5?

Somewhat related, in the documentation for ImageNet ( https://docs.ultralytics.com/datasets/classify/imagenet/#sample-images-and-annotations ), the categories appear to be hierarchical.
Ex: mammal -> placental -> carnivore -> canine -> dog -> working dog -> husky
If I receive a classification of "husky" on an image, is it up to me to know that "husky" belongs to the other classifications higher on the hierarchy? Is there any way to know all the classifications that belong to "working dog"? The training documentation indicates a single level hierarchy of folders. If we had a multi-level hierarchy of folders, would we be able to train a model to classify multiple breeds each of working and non-working dog?

Thank you, I think Ultralytics classification will work for my project, but knowing the answers will definitely help plan things out

[pderrenger]

@gillonba hello! I'm glad to hear you're considering using Ultralytics YOLO for your project. Let me clarify your queries:

1. The sample image with multiple labels like "Person", "Tripod", and "Safety Vest" is likely from an object detection task rather than classification. In classification, each image is assigned a single label. The image you're referring to might be showcasing the detection capabilities of YOLO, where it can identify and label multiple objects within a single image. For classification, you would indeed get the top result from Probs.top1 or the top few results from Probs.top5.

2. Regarding the hierarchical categories in ImageNet, when you receive a classification like "husky", it typically does not provide the hierarchy information directly. It's generally up to the user to know the hierarchy or to create a mapping that relates specific classes to their broader categories. However, ImageNet does have a structure where synsets (synonym sets) are related to each other, and you can use this structure to understand the hierarchy. There are tools and datasets available that provide this hierarchical information for ImageNet.

3. For training a model with a multi-level hierarchy of folders, YOLO's classification models are typically trained with a single level of folders, where each folder corresponds to one class. If you want to classify multiple breeds within categories like working and non-working dogs, you would train the model with folders for each breed. To incorporate hierarchical classification, you would need to implement a custom approach where the model's predictions are mapped to a hierarchy post-inference, or you could potentially modify the training process to be aware of the hierarchy.

I hope this helps, and if you have any more questions or need further assistance, feel free to ask. Good luck with your project! 🚀

[GetSMARTI]

Hello, could you please tell, metrics in the process on training are metrics on the train or val data?

  Epoch    GPU_mem       loss  Instances       Size
 1/1000      10.4G      0.329          2        640: 100%|██████████| 165/165 [00:47<00:00,  3.48it/s]
           classes   top1_acc   top5_acc: 100%|██████████| 14/14 [00:02<00:00,  5.77it/s]
               all       0.76          1

[pderrenger]

@GetSMARTI the metrics displayed during training, such as loss, top1_acc, and top5_acc, are typically calculated on the validation data (val). This is because the primary purpose of these metrics is to evaluate the model's performance on a dataset that it has not seen during training, which helps in assessing how well the model generalizes to new data.

The loss is calculated during the training iterations, while top1_acc and top5_acc are accuracy metrics that are evaluated after each epoch on the validation set. The progress bar 100%|██████████| 14/14 [00:02<00:00, 5.77it/s] indicates that the validation step has completed for all batches in the validation dataset.

[PasinduShavinda]

Hi.. @glenn-jocher, Can you please explain the architecture different between YOLO version 8 object detection nano model and YOLO version 8 image classification nano model ?

[glenn-jocher]

@PasinduShavinda hello! The primary difference between the YOLOv8 object detection nano model (e.g., yolov8n.pt) and the YOLOv8 image classification nano model (e.g., yolov8n-cls.pt) lies in their output layers and the tasks they are designed to perform.

• YOLOv8 Object Detection Nano Model (yolov8n.pt): This model is designed to detect multiple objects within an image. It outputs bounding boxes, class labels, and confidence scores for each detected object. The architecture includes layers that predict the location, size, and class of objects, and it is trained on datasets like COCO, which contain annotations for object detection.

• YOLOv8 Image Classification Nano Model (yolov8n-cls.pt): This model is designed for image classification tasks, where the goal is to assign a single class label to the entire image. It does not output bounding boxes since it does not localize objects within the image. Instead, it outputs a class label and a confidence score for the image as a whole. The architecture is simplified compared to the detection model, focusing on classifying the image into one of the predefined classes. It is trained on datasets like ImageNet, which are used for image classification tasks.

Both models may share a common backbone for feature extraction, but the head of the network (the layers responsible for making predictions) is different, reflecting their respective tasks. The classification model typically has a global pooling layer followed by a fully connected layer that outputs class probabilities, while the detection model has several convolutional layers that output bounding box coordinates and class probabilities for each spatial location in the feature map.

If you're interested in the specific architectural details or if you have any more questions, feel free to check out the Ultralytics YOLOv8 documentation or ask here. 😊👍

[TeenaJO]

Hey Glen,i have trained yolov8 classification model and i am performing predictions with this code

from ultralytics import YOLO
import os

Load a pretrained YOLOv8n model

model = YOLO('weight.pt of custom trained yolov8 classification model')

Define path to directory containing images and videos for inference

source = 'path to directory'

Run inference on the source

results = model(source,stream=False)

My results are in this format
4 0.94, p 0.03, j 0.01, b 0.01, a 0.00, 8.3ms
now i only want 4 0.94 to be printed on the terminal and none of the other predictions should be visible in my output.

[glenn-jocher]

@TeenaJO to print only the top class and its confidence score for each prediction, you can access the top1 and top1conf attributes of the probs object within each Results object. Here's how you can modify your code:

from ultralytics import YOLO

# Load your custom trained YOLOv8 classification model
model = YOLO('path/to/weight.pt')

# Define path to directory containing images for inference
source = 'path/to/directory'

# Run inference on the source
results = model(source, stream=False)

# Iterate over the results and print only the top class and its confidence
for result in results:
    top_class = result.probs.top1
    top_confidence = result.probs.top1conf
    print(f"{top_class} {top_confidence:.2f}")

This will output the top predicted class and its confidence score for each image in the format you specified, like 4 0.94. The .2f in the print statement formats the confidence score to two decimal places. Make sure to replace 'path/to/weight.pt' and 'path/to/directory' with the actual paths to your model weights and inference directory.

[faisalimran2018]

how can print class name at the moment I am getting "829 0.63"

[glenn-jocher]

Hello! To print only the class name instead of the class ID, you'll need to refer to the names attribute of the model object, which contains the list of class names indexed by the class IDs. Here's how you can modify your prediction code:

from ultralytics import YOLO

# Load your custom trained YOLOv8 classification model
model = YOLO('path/to/weight.pt')

# Define path to directory containing images for inference
source = 'path/to/directory'

# Run inference on the source
results = model(source, stream=False)

# Iterate over the results and access the class name using the class ID
for result in results:
    top_class_id = result.probs.top1  # Get the top class ID
    class_name = model.names[top_class_id]  # Get the corresponding class name
    top_confidence = result.probs.top1conf
    print(f"{class_name} {top_confidence:.2f}")

This script will print the class name and the confidence, formatted as you specified, like apple 0.94. Make sure you replace 'path/to/weight.pt' and '# path/to/directory' with the actual paths. Let me know if you need further assistance! 😊

[wolverinex24]

i tried running this train.py for the classify model
does nothing no error or any thing else
please can any one help me to start it ,i want to run yolov8 from the git cloned please help me and provide step by step instruction after the clone git what i have to do
python train.py --batch 32 --weights 'E:\ml_start\samplemodel\yolov8x-cls.pt' --data 'E:\ml_start\samplemodel\datasets' --epochs 50

[pderrenger]

@wolverinex24 it looks like you're trying to train a YOLOv8 classification model using the command line.

1. Run the Training Command: Use the yolo command to start training. Make sure to adjust the paths to your dataset and weights accordingly. Here's an example command:

   yolo classify train batch=32 model='E:\ml_start\samplemodel\yolov8x-cls.pt' data='path/to/dataset' epochs=50

   Note: The train.py script is not used directly in YOLOv8. Instead, the yolo command is used.

2. Monitor Training: Check the terminal output for logs that indicate the training progress. You can also monitor the training process using TensorBoard if it's set up in the training script.

3. Troubleshooting: If the training does not start, ensure that:

   • The paths to the dataset and weights are correct and accessible.
   • You have the latest version of the repository and all requirements are installed.

If you continue to face issues, you might want to check the official Ultralytics YOLOv8 documentation or open an issue on the GitHub repository for more specific help.

[SacuraA]

hello ,in classify duty,when I run the validate code
Error: runs/classify/train10/weights/best.pt appears to require 'dill'

[pderrenger]

@SacuraA hello! It seems like you're encountering an issue where the model weights file best.pt requires the dill package, which is an extension to pickle that provides serialization of Python objects. To resolve this, you can install the dill package using pip:

pip install dill

After installing dill, try running the validation code again. If the issue persists or you encounter any other problems, please feel free to reach out, and we'll be happy to assist you further. 😊🛠️

[SacuraA]

How to set image classification to one result and then output the result to txt file

[pderrenger]

@SacuraA to perform image classification with a YOLOv8 model and output the result to a .txt file, you can follow these steps:

1. Load the Classification Model: Load your YOLOv8 classification model using the YOLO class from the ultralytics package.

2. Run Prediction: Use the predict method of the model to classify your image. The result will contain the top class predictions.

3. Save Results to TXT: Access the top prediction from the results and save it to a .txt file using Python's file I/O operations.

Here's a concise example in Python:

from ultralytics import YOLO

# Load a pretrained YOLOv8 classification model
model = YOLO('yolov8n-cls.pt')

# Run prediction on an image
results = model.predict('path/to/image.jpg')

# Get the top1 class index and score
top1_class = results[0].probs.top1
top1_score = results[0].probs.top1conf

# Save the top1 result to a txt file
with open('results.txt', 'w') as f:
    f.write(f"Class: {top1_class}, Confidence: {top1_score}\n")

Remember to replace 'path/to/image.jpg' with the actual path to your image and 'yolov8n-cls.pt' with the path to your classification model if it's different.

If you're using the CLI, you can redirect the output to a .txt file like this:

yolo classify predict model=yolov8n-cls.pt source='path/to/image.jpg' > results.txt

This will save the standard output of the prediction command to results.txt. However, note that the CLI method may include additional output, not just the classification result. You might need to parse the output accordingly.

[andyrey]

I organize folders with images for 2 classes classification in next way:
train:
-------class_0_train_sub-folder/images...
-------class_1_train_sub-folder/images...
val:
------class_0_val_sub-folder/images...
-------class_1_val_sub-folder/images...

So, there are 4 sub-folders for single dataset I divided for training.
How to be if I have several datasets with images, which I do not want to mix in same sub-folders?

[pderrenger]

@andyrey for multiple datasets with images that you don't want to mix in the same sub-folders, you can create separate dataset YAML files for each dataset. Each YAML file will specify the paths to the training and validation images for that particular dataset. Here's how you can organize it:

1. Create a separate dataset YAML file for each dataset. For example, dataset1.yaml, dataset2.yaml, etc.
2. In each YAML file, specify the paths to the training and validation sub-folders for that dataset.

Here's an example of what a dataset YAML file (dataset1.yaml) might look like:

# dataset1.yaml
train: /path/to/dataset1/train/
val: /path/to/dataset1/val/
nc: 2  # number of classes
names: ['class_0', 'class_1']

Repeat this process for each dataset, adjusting the paths and file names accordingly.

When training or validating your model, you can specify which dataset YAML file to use with the data argument:

yolo detect train data=dataset1.yaml model=yolov8n.pt epochs=100 imgsz=640
yolo detect val data=dataset1.yaml model=yolov8n.pt

This way, you can keep your datasets separate and avoid mixing images in the same sub-folders. 📁🔍

[miguelsonohara]

I trained a model with my windows11 laptop but I can not use that module for my classification work in my raspberry pi4, is there any exception?

[pderrenger]

@miguelsonohara for deploying your trained model on a Raspberry Pi 4, you might need to export the model to a compatible format that can be efficiently run on the Pi's hardware. Here's a concise guide:

1. Export to ONNX: Convert your model to ONNX format, which is a portable format compatible with many inference engines.

   yolo export model=path/to/your/model.pt format=onnx

2. Optimize for ARM: Consider using optimization tools like ONNX Runtime or convert the ONNX model to TensorFlow Lite, which is optimized for ARM devices like Raspberry Pi.
3. Check Dependencies: Ensure all required libraries and dependencies are installed on your Raspberry Pi.
4. Inference on Pi: Run inference using the exported model on your Raspberry Pi with the appropriate inference engine.

Remember to check the model's size and complexity, as the Raspberry Pi has limited computational resources. If you encounter performance issues, you may need to simplify your model or use a lighter architecture.

[nadaakm]

hello,I wanted to ask about my approach for product detection on shelves. I used the YOLOv8s-cls.pt model for training on a custom dataset containing photos of Product 1 and Product 2 without backgrounds of course with good structer of the dataset like it's mentioned in the docs. and for the detection i've used yoloworld i cropped the detected product and send it into yolov8-cls model
is it a good approach?

[glenn-jocher]

Hello! Your approach of using YOLOv8s-cls for classifying product images after cropping the detections with YOLO World seems reasonable and quite innovative. This dual-stage process, where you first detect and then classify the cropped objects, can potentially improve the accuracy of your classifications since the classification model will focus solely on the product details without background noise.

Just ensure that the classification model is well-trained on your specific product dataset and that the detection model precisely crops the relevant product portions. This will help maintain consistency and accuracy across different product detection scenarios. Nice work! 👍🙂 If you encounter any specific issues or need further optimization tips, feel free to ask!

[nadaakm]

Hey @glenn-jocher thnx for your response , i've another question , I'm working on training a classification model to distinguish between different sizes of the same product, like Coca-Cola in 1L and 50cl bottles. I'm seeking guidance on structuring my dataset effectively to train the model accurately.

Questions:

1-How should I organize my dataset to train a classification model for distinguishing between different product sizes?
2-What features should I consider including in my dataset to best represent the variations in product sizes?
3-Are there any specific techniques or best practices I should follow when preparing my dataset for training?

[glenn-jocher]

Hey there! Training a classification model to distinguish between different sizes of the same product, such as Coca-Cola bottles, is a great use case for image classification. Here’s a brief guide on how to structure and prepare your dataset:

1. Dataset Organization: Arrange your images into folders named after each class. For example, one folder for 1L and another for 50cl.

2. Features to Include: Ensure that the images capture distinguishing features clearly, like the label size, height, or volume marking. Taking pictures from similar angles and consistent lighting can help the model focus on size differences.

3. Best Practices:

   • Use a diverse set of images for each class to improve generalization.
   • If possible, include images with varying backgrounds and orientations.
   • Consistently resize your images during preprocessing to match the input size expected by your model, for example, 224x224 pixels.

Remember, having a well-labeled and organized dataset is crucial for training accuracy. Good luck! 🚀

For detailed instructions and model configurations, you can check our Classification Task Documentation.