datasets/

[giscus[bot]]

datasets/

Explore various computer vision datasets supported by Ultralytics for object detection, segmentation, pose estimation, image classification, and multi-object tracking.

https://docs.ultralytics.com/datasets/

[RudeNinja]

What is the format of the labels text files and are they related to annotations file?

[glenn-jocher]

@RudeNinja hello! 🌟 The format for the label text files typically involves one .txt file per image, with each line in the file corresponding to one object. The line format usually follows the pattern [class x_center y_center width height], with all values normalized between 0 and 1 relative to the image size. These label files are indeed related to the annotations for each image.

For example, if you have an image image1.jpg and an object of class 0 (assuming class indices start at 0) located at the center of the image and occupying about half of the image area, the corresponding label file image1.txt might look like this:

0 0.5 0.5 0.5 0.5

This means there's an object of class 0 at the center (0.5, 0.5) of the image, with a width and height each taking up 50% of the image's dimensions.

Label files are crucial for training and validating models, as they provide the ground truth data that models learn from. Hope that helps! 😊

[joyshch]

The example above for the custom dataset structure is the following:
dataset/
├── train/
│ ├── images/
│ └── labels/
└── val/
├── images/
└── labels/

I am trying to use a custom dataset to train a classification model. It kept erroring for not finding the data. For classification, should I structure like the following?
dataset/
├── train/
│ |-- Class_1/
| ├── images/
│ └── labels/
│ |-- Class_2/
| ├── images/
│ └── labels/
└── val/
│ |-- Class_1/
| ├── images/
│ └── labels/
│ |-- Class_2/
| ├── images/
│ └── labels/

What's the correct data structure?

[pderrenger]

Hello! For training a classification model with a custom dataset, the structure you've proposed with separate class directories isn't necessary. Instead, you should organize your dataset like this for classification tasks:

dataset/
├── train/
│   ├── images/
│   └── labels.txt
└── val/
    ├── images/
    └── labels.txt

Here, labels.txt should contain lines with image_path class_id, associating each image with its class. Remember, class IDs start at 0. Here's an example line in labels.txt:

train/images/img1.jpg 0

For more details, please refer to our Datasets Overview document. This structure keeps things simple and in line with how our models expect the data. Let us know if you need further assistance! 😊

[yjh1314yjh]

Does the pixel size of the dataset picture have to be 640x640?

[pderrenger]

@yjh1314yjh hey there! 🌟

Nope, the pictures in your dataset do not need to have a fixed size of 640x640. YOLOv8 can handle varying image sizes. During training or inference, images are resized to the specified dimension (imgsz parameter), which defaults to 640 but can be adjusted to suit your needs. For example, if you wish to train or predict at a different size, you can specify it like so:

For training:

yolo detect train data=coco128.yaml model=yolov8n.pt imgsz=320

For prediction:

yolo detect predict model=yolov8n.pt source='https://path/to/image.jpg' imgsz=320

This flexibility allows the model to adapt to datasets with diverse image resolutions. Feel free to experiment with different sizes that best fit your model's performance and accuracy requirements. Happy modeling! 😊

[dnnxl]

Hi! In case I would like to train on one channel object detection images, what is the best way to load the dataset? Thanks ahead

[glenn-jocher]

@dnnxl hello! Training on single-channel (grayscale) images for object detection can be done by modifying your dataset loading process slightly. YOLO expects 3-channel images by default, so ensure your grayscale images are converted into a 3-channel format by replicating the single channel across RGB. Here’s how you can adjust the loader to handle grayscale images correctly:

When using a custom PyTorch DataLoader, you can use a transform to convert grayscale images to three channels:

from torchvision import transforms

transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=3),  # Convert 1 channel grayscale to 3 channel
    transforms.ToTensor(),
])

Make sure your dataset annotations (bounding boxes, classes) are correctly formatted and the paths are properly set in your data.yaml file.

This setup should allow you to train your model on grayscale images effectively! If you run into any specific issues, feel free to ask. 😊

[chamovdmitrij]

@glenn-jocher

Hi. Thank you. I would like to train YOLA11 on images with 4 channels (RGBA).
I already realized that in the configuration file of the model, you can specify ch:4 so that the first layer expects an image with 4 channels, but YOLO converts them to 3 channels somewhere by default. I can write my own data loader, but I can't figure out how to submit my images to training, validation, or predicate so that the model takes into account all 4 channels. I would be grateful for help

[glenn-jocher]

Hi! To train YOLO11 on RGBA images, ensure your custom data loader maintains the 4-channel format throughout the process. You can modify the model's first layer to accept 4 channels by setting ch: 4 in the model configuration. If you need further assistance, feel free to ask!

[Rupesh-Kataria]

Hey I need some help . Actually I am doing an object detection and I have only 3 images. So I do data augmentation on these 3 images ang generate 90 images. Now in every image there are around 200 objects which are of very small size and are attached to each other. So it took me more than half hour to annotate a single image. It is very time consuming and boring. I have one idea I take those original 3 images and do labelling for those 3 images and then do data augmentation on these 3 images and my label also get augmentated according to the generated images automatically. Please help me. Actually I see these feature on roboflow website but it is paid.

[Rupesh-Kataria]

Hey Guys thanks a lot , You guys are really very helpful. I have one small doubt like when I predict on some image its result get store in predict folder with images having bounding box and there is written categories name and confidence score. I do now want categories name and confidence score return there I only want the bounding box there. With no confidence score and bounding box there on the predicted image . Instead there I only want that there are total number of object of each categories should be written on top left corner of image. So lets if i have given an image in which there are 2 dogs and 3 cats . It bounded the box around the object but should not show dog and cat there and should not show confidence there. In the top left corner it should show Dog-2 Cat -3. I have one other doubt how to reduce the the thickness of bounded box

[pderrenger]

Hey there! Thanks for reaching out with your question. 😊

To customize the output on your predicted images, you'll need to modify the display settings in the code where predictions are visualized. Here's a quick guide on how to adjust the display of category names, confidence scores, and bounding box thickness:

1. Remove Category Names and Confidence Scores: You'll need to adjust the part of your code that handles the drawing of bounding boxes and text. If you're using the standard YOLOv8 visualization, look for the function that calls cv2.putText() and modify or remove it to stop displaying text.

2. Display Total Number of Objects: You can count the occurrences of each category in your detections and then use cv2.putText() to display these counts on the top left corner of the image.

3. Adjust Bounding Box Thickness: This can be done by changing the thickness parameter in the cv2.rectangle() function that draws the bounding boxes.

Here's a simplified example of how you might modify your code:

import cv2
import numpy as np

# Assuming 'results' is your model output
for img, pred in zip(images, results.pred):
    counts = {}
    for *xyxy, conf, cls in pred:
        label = names[int(cls)]
        counts[label] = counts.get(label, 0) + 1
        cv2.rectangle(img, (int(xyxy[0]), int(xyxy[1])), (int(xyxy[2]), int(xyxy[3])), color=(255,0,0), thickness=2)  # Adjust thickness here

    # Display counts
    text = ' '.join([f'{k}-{v}' for k, v in counts.items()])
    cv2.putText(img, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)

    # Save or display image
    cv2.imwrite('path_to_save.jpg', img)

This code snippet removes labels and confidence scores from the bounding boxes and instead displays a count of detected objects by category at the top left of the image. Adjust the paths and parameters as needed for your specific setup.

Hope this helps streamline your image processing! Let me know if there's anything else you need. 🚀

[Rupesh-Kataria]

Hey there is an error coming

 model2=YOLO("runs/detect/train2/weights/best.pt")
 results=model2.predict("img_006.png")


 import cv2

import numpy as np

Assuming 'results' is your model output

for img, pred in zip("img_006.png", results.pred):
counts = {}
for *xyxy, conf, cls in pred:
label = names[int(cls)]
counts[label] = counts.get(label, 0) + 1
cv2.rectangle(img, (int(xyxy[0]), int(xyxy[1])), (int(xyxy[2]), int(xyxy[3])), color=(255,0,0), thickness=2) # Adjust thickness here

# Display counts
text = ' '.join([f'{k}-{v}' for k, v in counts.items()])
cv2.putText(img, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)

# Save or display image
cv2.imwrite('path_to_save.jpg', img)


  4 # Assuming 'results' is your model output

----> 5 for img, pred in zip("img_006.png", results.pred):
6 counts = {}
7 for *xyxy, conf, cls in pred:

AttributeError: 'list' object has no attribute 'pred'

The error is due to there is not attribute pred for results

[Rupesh-Kataria]

Hey, I have made some modification in your code and it works fine now. I need your help. Actually there are many or we can say that two bounding boxes plotted for a single object . So that counts a single object to two. I want only one bounding box for a single object . I do not want multiple bounding boxes around a single object .So that a single object do not count as two or many object . Please make change in the below code. Below code is the right modified code. Please make change such that every object have one bounding box which bestly covers the object. Thanks

counts = {}
names = ['Soap']
img = cv2.imread("img_006.png") # Load the image

for r in results:
for x1, y1, x2, y2, conf, cls in zip(r.boxes.xyxy[:, 0], r.boxes.xyxy[:, 1], r.boxes.xyxy[:, 2], r.boxes.xyxy[:, 3], r.boxes.conf, r.boxes.cls):
label = names[int(cls)]
counts[label] = counts.get(label, 0) + 1
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), color=(255, 0, 0), thickness=2)

Display counts

text = ' '.join([f'{k}-{v}' for k, v in counts.items()])
cv2.putText(img, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

Save or display image

cv2.imwrite('path_to_save.jpg', img)

[pderrenger]

Hey there! 👋

It sounds like you're encountering issues with overlapping bounding boxes, which can indeed result in counting a single object multiple times. To address this, you can implement Non-Maximum Suppression (NMS) in your code. NMS helps in reducing overlaps and ensures that each detected object is counted only once by keeping only the bounding box with the highest confidence score while removing others that have a high overlap with it.

Here's a simple way to integrate NMS into your existing code:

import cv2
import numpy as np
from ultralytics import non_max_suppression  # Assuming you have an NMS function

# Load the image
img = cv2.imread("img_006.png")

# Process results and apply NMS
bboxes = []  # List to hold all bounding boxes and their scores and class IDs
for r in results:
    for x1, y1, x2, y2, conf, cls in zip(r.boxes.xyxy[:, 0], r.boxes.xyxy[:, 1], r.boxes.xyxy[:, 2], r.boxes.xyxy[:, 3], r.boxes.conf, r.boxes.cls):
        bboxes.append([x1, y1, x2, y2, conf, cls])

# Convert to a numpy array and apply NMS
bboxes = np.array(bboxes)
indices = non_max_suppression(bboxes, iou_threshold=0.5)  # Adjust the threshold as needed
bboxes = bboxes[indices]

# Count unique objects and draw bounding boxes
counts = {}
for x1, y1, x2, y2, conf, cls in bboxes:
    label = names[int(cls)]
    counts[label] = counts.get(label, 0) + 1
    cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), color=(255, 0, 0), thickness=2)  # Adjust thickness here

# Display counts
text = ' '.join([f'{k}-{v}' for k, v in counts.items()])
cv2.putText(img, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

# Save or display image
cv2.imwrite('path_to_save.jpg', img)

This modification should help ensure that each object is only counted once and is represented by the best bounding box. Adjust the iou_threshold in the NMS function to fine-tune the overlap criteria.

Hope this helps! Let me know if there's anything else you need. 😊

[AlexZhao2020]

I'm trying to use yolov8 to train my own dataset. But I have a question about the labels. There are 5 values in the label .txt file, that is c,x,y,w,h. Here x,y mean the center or the top-left postion of the anchor ? Thanks !

[pderrenger]

@AlexZhao2020 in the YOLO label .txt files, the values x and y represent the center coordinates of the bounding box, not the top-left position. The coordinates are normalized by the dimensions of the image, meaning they are relative to the width and height and should range between 0 and 1. If you have any more questions or need further clarification, feel free to ask! 😊

[AlexZhao2020]

Thanks for your answering. I still have a question about the original coordinate of the image label,that is,(0,0)point. It is the top-left or the bottom-right position？Thanks a lot！

…

---Original--- From: "Paula ***@***.***> Date: Fri, May 31, 2024 20:29 PM To: ***@***.***>; Cc: ***@***.******@***.***>; Subject: Re: [ultralytics/ultralytics] datasets/ (Discussion #9215) @AlexZhao2020 in the YOLO label .txt files, the values x and y represent the center coordinates of the bounding box, not the top-left position. The coordinates are normalized by the dimensions of the image, meaning they are relative to the width and height and should range between 0 and 1. If you have any more questions or need further clarification, feel free to ask! 😊 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: ***@***.***>

[pderrenger]

@AlexZhao2020 hello Paula,

In the YOLO labeling system, the origin point (0,0) is located at the top-left corner of the image. This means all coordinates are measured from the top-left, moving rightward and downward across the image.

If you have any more questions or need further assistance, feel free to ask. Happy coding! 😊

[mysterious588]

Is there a way to have another split "test"?, I believe having the train/test/val splits could help avoid overfitting, I'm facing that right now.

[mysterious588]

PS: I'm using classification and using dataset.yaml throws an error:
I believe there is a bug in loading the dataset.yaml, it thinks it's a folder not a file and this doesn't happen in object detection:

RuntimeError: Dataset 'dataset-256/Floor/dataset.yaml' error  [WinError 3] The system cannot find the path specified: 'G:\\my data\\My Work\\sword\\4insites\\datasets\\dataset augmentation\\datasets\\dataset-256\\Floor\\dataset.yaml\\train'

Using the folder directly works but it can't detect the test folder.

[mysterious588]

Oh got it Fixed, for anyone facing that problem, you have to specify the folder that has the .yaml file, not the file directly.

[glenn-jocher]

Great to hear you resolved the issue, and thank you for sharing the solution with the community! Specifying the directory containing the .yaml file rather than the file itself is indeed the correct approach for setting up the dataset path in our system. This clarification will surely help others facing similar issues. If you have any more insights or need further assistance, feel free to reach out. Happy coding! 🚀

[mariem158]

comment je peux entrainer dans mon code dataset visdrone pour détecter les véhicules avec des drones ??

[glenn-jocher]

@mariem158 bonjour! Pour entraîner un modèle YOLO avec le dataset VisDrone pour détecter les véhicules, vous pouvez suivre ces étapes:

1. Préparer le Dataset:

   • Assurez-vous que votre dataset VisDrone est bien organisé avec des dossiers train/images, train/labels, val/images, et val/labels.

   • Créez un fichier data.yaml dans le répertoire racine de votre dataset. Ce fichier doit contenir les chemins vers vos images et annotations, ainsi que les classes à détecter. Voici un exemple de fichier data.yaml:

     train: path/to/VisDrone/train/images
     val: path/to/VisDrone/val/images
     nc: 10  # Nombre de classes
     names: ['pedestrian', 'people', 'bicycle', 'car', 'van', 'truck', 'tricycle', 'awning-tricycle', 'bus', 'motor']

2. Entraîner le Modèle:

   • Utilisez la CLI Ultralytics pour lancer l'entraînement. Voici un exemple de commande pour entraîner un modèle YOLOv8 sur le dataset VisDrone:

     yolo detect train data=path/to/data.yaml model=yolov8n.pt epochs=100 imgsz=640

   • Vous pouvez également utiliser le code Python pour entraîner le modèle:

     from ultralytics import YOLO
     
     # Charger un modèle pré-entraîné
     model = YOLO('yolov8n.pt')
     
     # Entraîner le modèle sur le dataset VisDrone
     model.train(data='path/to/data.yaml', epochs=100, imgsz=640)

3. Vérifier les Versions:

   • Assurez-vous d'utiliser les versions les plus récentes de torch et ultralytics. Vous pouvez mettre à jour vos packages avec les commandes suivantes:

     pip install --upgrade torch ultralytics

Pour plus de détails sur la préparation des datasets et l'entraînement des modèles, vous pouvez consulter notre documentation complète ici: Ultralytics Datasets Overview.

N'hésitez pas à revenir vers nous si vous avez d'autres questions! 😊

[mariem158]

donne moi svp les étapes avec détails comme je peux intégrer ce dataset https://sites.google.com/view/grli-uavdt/%E9%A6%96%E9%A1%B5 sur google colab et le combiner avec visdrone

[glenn-jocher]

Bonjour @mariem158,

Merci pour votre question! Voici les étapes détaillées pour intégrer le dataset UAVDT avec VisDrone sur Google Colab pour détecter les véhicules:

1. Préparer les Datasets

Télécharger et organiser les datasets:

1. UAVDT:

   • Téléchargez le dataset UAVDT depuis ce lien.
   • Décompressez le fichier et organisez-le dans les répertoires train/images, train/labels, val/images, et val/labels.

2. VisDrone:

   • Téléchargez le dataset VisDrone depuis ce lien.
   • Décompressez le fichier et organisez-le de la même manière.

2. Créer le fichier data.yaml

Créez un fichier data.yaml pour décrire les datasets combinés. Voici un exemple:

train: path/to/combined/train/images
val: path/to/combined/val/images
nc: 10  # Nombre de classes
names: ['pedestrian', 'people', 'bicycle', 'car', 'van', 'truck', 'tricycle', 'awning-tricycle', 'bus', 'motor']

3. Télécharger et Préparer les Datasets sur Google Colab

Voici un exemple de code pour télécharger et préparer les datasets sur Google Colab:

import os
from google.colab import drive

# Monter Google Drive
drive.mount('/content/drive')

# Définir les chemins
uavdt_path = '/content/drive/MyDrive/UAVDT'
visdrone_path = '/content/drive/MyDrive/VisDrone'
combined_path = '/content/drive/MyDrive/CombinedDataset'

# Créer les répertoires nécessaires
os.makedirs(combined_path, exist_ok=True)
os.makedirs(f'{combined_path}/train/images', exist_ok=True)
os.makedirs(f'{combined_path}/train/labels', exist_ok=True)
os.makedirs(f'{combined_path}/val/images', exist_ok=True)
os.makedirs(f'{combined_path}/val/labels', exist_ok=True)

# Copier les fichiers des datasets UAVDT et VisDrone dans le répertoire combiné
!cp -r {uavdt_path}/train/images/* {combined_path}/train/images/
!cp -r {uavdt_path}/train/labels/* {combined_path}/train/labels/
!cp -r {uavdt_path}/val/images/* {combined_path}/val/images/
!cp -r {uavdt_path}/val/labels/* {combined_path}/val/labels/

!cp -r {visdrone_path}/train/images/* {combined_path}/train/images/
!cp -r {visdrone_path}/train/labels/* {combined_path}/train/labels/
!cp -r {visdrone_path}/val/images/* {combined_path}/val/images/
!cp -r {visdrone_path}/val/labels/* {combined_path}/val/labels/

4. Entraîner le Modèle

Utilisez le fichier data.yaml pour entraîner le modèle YOLOv8 sur le dataset combiné:

from ultralytics import YOLO

# Charger un modèle pré-entraîné
model = YOLO('yolov8n.pt')

# Entraîner le modèle sur le dataset combiné
model.train(data='path/to/combined/data.yaml', epochs=100, imgsz=640)

5. Vérifier les Versions

Assurez-vous d'utiliser les versions les plus récentes de torch et ultralytics:

pip install --upgrade torch ultralytics

Pour plus de détails sur la préparation des datasets et l'entraînement des modèles, vous pouvez consulter notre documentation complète ici: Ultralytics Datasets Overview.

N'hésitez pas à revenir vers nous si vous avez d'autres questions! 😊

Cordialement,
L'équipe Ultralytics

[Llll0l0l]

Hello, I'm new to machine learning, is it possible to train videos? i turned them into imgs however will it understand that the label belongs to continuous imgs that are sequential ?

Thank you for reading

[pderrenger]

@Llll0l0l hello,

Welcome to the world of machine learning! 🌟 Yes, it is indeed possible to train models using video data. Converting videos into sequential images is a common practice. However, to ensure that the model understands the temporal context (i.e., that the images are sequential and belong to a continuous video), you might want to consider using multi-object tracking (MOT) techniques.

In multi-object tracking, the model not only detects objects in each frame but also assigns a unique ID to each detected object, maintaining this ID across frames. This way, the model can track the movement and changes of objects over time, understanding the sequential nature of the data.

Here’s a brief overview of how you can approach this:

1. Convert Video to Frames: You’ve already done this step by converting your video into images.
2. Annotate Frames: Ensure that your images are annotated correctly. Each frame should have annotations that indicate the presence and location of objects.
3. Use a Multi-Object Tracking Model: Ultralytics supports various models and configurations for multi-object tracking. You can use models like YOLOv8 with trackers such as BoT-SORT or ByteTrack.

Here’s a simple example of how you can set up multi-object tracking using YOLOv8:

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # Load an official model

# Perform tracking on a video source
results = model.track("path/to/your/video.mp4", show=True)  # Tracking with default tracker

For more detailed guidance, you can refer to the Ultralytics documentation on multi-object tracking.

If you encounter any issues or need further assistance, please ensure you are using the latest version of the Ultralytics packages. Additionally, providing a minimum reproducible example can greatly help in diagnosing and resolving any problems. You can find more information on creating a reproducible example here.

Happy experimenting, and feel free to reach out if you have more questions! 😊

[Llll0l0l]

Thank you very much)

[pderrenger]

Hello @Llll0l0l,

Thank you for your kind words! 😊

Regarding your question about training on video data: converting videos into sequential images is a great start. However, to ensure the model understands the temporal context, you might want to explore multi-object tracking (MOT) techniques. These techniques help the model maintain object identities across frames, effectively understanding the continuity in the sequence.

Here's a brief guide on how to proceed:

1. Convert Video to Frames: As you've done, convert your video into individual frames.
2. Annotate Frames: Ensure each frame is annotated correctly. This involves labeling objects in each frame.
3. Use Multi-Object Tracking: Utilize models like YOLOv8 with trackers such as BoT-SORT or ByteTrack to maintain object identities across frames.

Here’s an example of how you can set up multi-object tracking using YOLOv8:

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # Load an official model

# Perform tracking on a video source
results = model.track("path/to/your/video.mp4", show=True)  # Tracking with default tracker

For more detailed guidance, you can refer to the Ultralytics documentation on multi-object tracking.

If you encounter any issues, please ensure you are using the latest version of the Ultralytics packages. Providing a minimum reproducible example can also greatly help in diagnosing and resolving any problems. You can find more information on creating a reproducible example here.

Feel free to reach out if you have more questions. Happy experimenting! 🚀

[1729asraful]

I have 47 classes csv file. each file contains 100 images in csv formate with label. now how I can traine it?

[glenn-jocher]

@1729asraful hi there!

To train your model using a CSV file containing 47 classes and 100 images per class, you'll need to follow a few steps to prepare your data and then use the Ultralytics YOLO framework for training. Here’s a concise guide to get you started:

Step 1: Convert CSV to YOLO Format

First, you need to convert your CSV annotations into the YOLO format. Each image should have a corresponding .txt file with annotations in the format:

<class> <x_center> <y_center> <width> <height>

Where:

• <class> is the class index (0 to 46 for your 47 classes).
• <x_center>, <y_center>, <width>, and <height> are normalized values (between 0 and 1) relative to the image dimensions.

Step 2: Organize Your Dataset

Organize your dataset into the following structure:

dataset/
├── train/
│   ├── images/
│   └── labels/
└── val/
    ├── images/
    └── labels/

Place your images in the images/ directories and the corresponding YOLO format annotation files in the labels/ directories.

Step 3: Create a data.yaml File

Create a data.yaml file in the root of your dataset directory with the following content:

train: path/to/dataset/train/images
val: path/to/dataset/val/images

nc: 47  # number of classes
names: [class0, class1, ..., class46]  # list of class names

Step 4: Train Your Model

You can now train your model using the Ultralytics YOLO framework. Here’s an example using the CLI:

yolo detect train data=path/to/data.yaml model=yolov8n.pt epochs=100 imgsz=640

Or using Python:

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.pt')  # load a pretrained model

# Train the model
results = model.train(data='path/to/data.yaml', epochs=100, imgsz=640)

Additional Resources

For more detailed information on dataset preparation and training, please refer to the Ultralytics Datasets Documentation.

If you encounter any issues, please provide a minimum reproducible example so we can assist you better. You can find more details on how to create one here.

Happy training! 🚀

[1729asraful]

Thanks a lot

[glenn-jocher]

@1729asraful you're welcome! 😊

To train your model using a CSV file containing 47 classes and 100 images per class, you'll need to convert your CSV annotations into the YOLO format and organize your dataset accordingly. Here’s a step-by-step guide:

Step 1: Convert CSV to YOLO Format

First, convert your CSV annotations into the YOLO format. Each image should have a corresponding .txt file with annotations in the format:

<class> <x_center> <y_center> <width> <height>

Where:

• <class> is the class index (0 to 46 for your 47 classes).
• <x_center>, <y_center>, <width>, and <height> are normalized values (between 0 and 1) relative to the image dimensions.

Step 2: Organize Your Dataset

Organize your dataset into the following structure:

dataset/
├── train/
│   ├── images/
│   └── labels/
└── val/
    ├── images/
    └── labels/

Place your images in the images/ directories and the corresponding YOLO format annotation files in the labels/ directories.

Step 3: Create a data.yaml File

Create a data.yaml file in the root of your dataset directory with the following content:

train: path/to/dataset/train/images
val: path/to/dataset/val/images

nc: 47  # number of classes
names: [class0, class1, ..., class46]  # list of class names

Step 4: Train Your Model

You can now train your model using the Ultralytics YOLO framework. Here’s an example using the CLI:

yolo detect train data=path/to/data.yaml model=yolov8n.pt epochs=100 imgsz=640

Or using Python:

from ultralytics import YOLO

# Load a model
model = YOLO('yolov8n.pt')  # load a pretrained model

# Train the model
results = model.train(data='path/to/data.yaml', epochs=100, imgsz=640)

For more detailed information on dataset preparation and training, please refer to the Ultralytics Datasets Documentation.

If you encounter any issues, please provide a minimum reproducible example so we can assist you better. You can find more details on how to create one here.

Happy training! 🚀

[WARHE8D]

Hello,
how can i update my model and dataset to public?
I only see 2 options private and anyone with link.
thanks!

[pderrenger]

@WARHE8D to make your model and dataset public, you need to ensure they are properly shared on a platform that supports public access. Currently, the options you mentioned ("private" and "anyone with link") are likely platform-specific settings. If you're using a service like Google Drive or Dropbox, you may need to adjust the sharing settings to "public" or "anyone with the link can view." For more detailed steps on contributing datasets to Ultralytics, please refer to the Contribute New Datasets section in our documentation.

[toxanbi]

I am absolute newbiew in machine learning coming from the world of low-level and system programming (drivers, firmware, electronics and so on). I have some questions.

1. Is my understanding correct that in machine learning there is a term 'model' which denotes an interconnect of neurons, i.e. the topogy of a neural network, a data structure describing how neurons are connected to each other, and, on the other hand, there is a 'weights' or 'weight file' which holds coefficients describing how signals (stymulus, activations) of a particular neuron influences on other neurons? If this is correct, which one of these two is represented by .pt-file? Or .pt file holds both of these? What is anatomy of .pt-files and where can I learn about it?

2. Let's assume that we are going to make a NN which can classify or detect three types of objects: cats, frogs and birds. What is optimal strategy of mastering a dataset to learn it:
   a) A given images must contain either one of these object (annotated by bounding box)
   b) A given image must contain multiple objects of the same type.
   c) It's better for every image to have all three instances of these kinds on it
   c-a) And it's better to not overlap.
   c-b) And, countrary, it's better to have overlapping to learn NN to handle such cases.

Should I feed NN with a pictures which doesn't have objects of interest at all or it is useless?

3. Now instead of having three categories (cats, frogs and birds) we are going to add yet another one which is "other live-forms". Is it a good practive to feed NN with tonns of images of completely different (visually) animals all tagged (annotated) as "other live-forms" or it's better to annotate each animal (other than cat, frog or bird) by setting a class corresponding to their real-world kind? Won't it confuse a NN if crocodiles and kangooros are all annotated as the object of same class? I presume that a process of learning/training is all about finding a features which uniquelly distinguish one class of objects from the others by finding proper weights/coefficients and if vast variety of totally different objects must be considered all having the same type, it may be impossible to find proper weights at all. Or it's not the case? If it is, seems that for that particular task one should use two different NNs: one to distinguisth alive objects for non-alive, and the second stage NN to detect cats/frogs/dogs (and if the second one doesn't detect either of these, but the first one detected a life-form, then it is considered "other life-form").

4. It's stated that default YOLO models which are available on this website are pretrained on COCO dataset. I saw a discussion on whether it's better to learn your NN from scratch or use a model pretrained on COCO. From my point of view traning a model (which was originally trained on COCO dataset) on your own dataset does only make sense if your custom dataset has exactly the same combinartion of 80 classes as COCO? And if you have less categories than COCO or more categories or even exactly 80 but of completely different types (e.g. you are learning NN to distinguish 80 kinds of vehicle motors), then the only option is learning from scratch?

5. I can't find a complete and strict definition of that the term 'val' or 'validation' means in context of training a model? Does it affects behaviour of the model or it is just a way to see how well training went?

6. When we learn a model to detect cats we feed it with images of what is DEFINITELY a cat. But is there a way to show it depiciting objects that are DEFINITELY NOT a cat to avoid false-positives? Other than introducing separate categories for objects that looks very similar to a cat and may be confused with cats but are not really a cat.

7. Many articles and videos tell us that YOLO format of labels is just s plain-text file with separate line for every label and each line consists of 5 fields; class-id and normalized coordinates of a bounding-box. But what about instance segmentation tasks? Oriented boundong box detection? Bone prediction (aka post)? Doesn't it require completely different and more complex format of annotations (compared to just specifying bounding box)?

[glenn-jocher]

@toxanbi 1. Your understanding is correct. The .pt file in PyTorch contains both the model architecture and the weights. You can learn more about the anatomy of .pt files in the PyTorch documentation.

2. For optimal dataset creation, include diverse scenarios: single objects, multiple objects, overlapping objects, and images without objects. This helps the model generalize better.

3. It's better to have specific classes for different animals rather than a generic "other live-forms" class. This avoids confusion and improves model accuracy.

4. Pretraining on COCO is beneficial even if your dataset differs. Transfer learning can help the model learn faster and perform better, even with different categories.

5. Validation (val) is used to evaluate the model's performance on a separate dataset during training. It doesn't affect the model's behavior but helps monitor training progress.

6. To reduce false positives, you can include images without the target object in your training dataset. This helps the model learn what not to detect.

7. For tasks like instance segmentation, oriented bounding boxes, and pose estimation, the annotation format is more complex. Refer to the specific task documentation for details on the required annotation formats.

[MehrsaMashhadi]

Hello. I hope you are doing well. I have paired RGB and thermal images, and I want to train yolov9 with 4 channel data. I want the model to read the first 3 channels from the RGB folder, and the thermal image from the thermal folder. all of the paired images have the same name, they are in different folders named ir, and vi. can you please help me how I should address this to the model?

[glenn-jocher]

@MehrsaMashhadi to train YOLOv9 with 4-channel data, you'll need to modify the data loading process to combine RGB and thermal images into a single input. You can create a custom dataset class that reads images from both folders and concatenates them into a 4-channel tensor. Ensure your model architecture supports 4-channel input. For more details, refer to the dataset customization section in the Ultralytics documentation.

[Andriw75]

I am usually interested in understanding what data I am adding to my dataset, as this can be beneficial or harmful depending on the project. I am trying to initialize the YOLO dataset to apply transformations required by the training parameters, but I often encounter errors. Thank you in advance for your help!

from ultralytics.data.dataset import YOLODataset, v8_transforms
from ultralytics.engine.trainer import check_det_dataset

class Hyperparameters:
def init(self, hyp_dict):
for key, value in hyp_dict.items():
setattr(self, key, value)

Initialize the YOLO dataset

dataset = YOLODataset(
img_path="path/to/images", # Replace with your image path
data=check_det_dataset("path/to/dataset.yaml"), # Replace with your dataset configuration
imgsz=640,
batch_size=1
)

Define hyperparameters for transformations

hyp = {
"mosaic": 1.0,
"copy_paste": 0.5,
"degrees": 10.0,
"translate": 0.2,
"scale": 0.9,
"shear": 0.5,
"perspective": 0.4,
"copy_paste_mode": 'flip',
'mixup': 0.5,
'hsv_h': 0.1,
'hsv_s': 0.1,
'hsv_v': 0.1,
'flipud': 0.1,
'fliplr': 0.1
}

hyperparams = Hyperparameters(hyp)

Apply transformations to the dataset

transforms = v8_transforms(dataset, imgsz=640, hyp=hyperparams)

Attempt to augment data

augmented_data = transforms(dataset[0])

albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))

Error Encountered
When I run the code, I encounter the following error:
ValueError: could not broadcast input array from shape (0,640,640) into shape (364,640,640)
the size always changes

[glenn-jocher]

@Andriw75 it seems like the error might be due to mismatched image sizes. Ensure all images in your dataset are correctly sized to 640x640 before applying transformations. If the issue persists, double-check your dataset paths and configuration. For further details, you can refer to the Ultralytics documentation on datasets.

[rakezshre]

Hi, I wanted to use MVTec dataset for training in Ultralytics framework with yolo. But the dataset doesnt have labelling but instead it has ground_truth with some parameters and masking. Is it possible to make a yaml file for the MVTec dataset (most easiest way)?
If there is any method. Please let me know.

Thanks.

[glenn-jocher]

To use the MVTec dataset with YOLO, you'll need to convert the ground truth and masks into YOLO format. This involves creating bounding box annotations and a data.yaml file. You can refer to the Ultralytics documentation for guidance on dataset preparation and formatting. If you have further questions, feel free to ask!

[rakezshre]

Is there any easyway to convert MVTec dataset with YOLO with ground truth and masks. It consists of large dataset and creating bounding box annotation seems time consuming. I can see the ultralytics format for data.yaml. But issue is with the bounding box consversion.

[glenn-jocher]

To convert the MVTec dataset for YOLO, you'll need to create bounding box annotations from the masks and ground truth. Tools like LabelImg can help with manual annotation. Once you have the annotations, you can format them into YOLO's required structure and create a data.yaml file. For more details, visit the Ultralytics documentation on dataset preparation.

[D3RK0]

Hi,

Introduction

For a couple of days now, I am trying to set YOLOv8 in classification mode in order to classify flowers in the images of the Oxford Flower dataset (i.e. https://www.robots.ox.ac.uk/~vgg/data/flowers/102/).
I am using ImageNet pretrained weights to start my training.

The error

However, I am the obtaining error:

Dataset not found ⚠️, missing path C:\Users\ <'my_path'> \Oxford-Flower-dataset\oxford_flower.yaml, attempting download...
Downloading https://ultralytics.com/assets/C://Users/ <'my_path'> /Oxford-Flower-dataset/oxford_flower.yaml.zip to 'C:\Users\ <'my_path'> \Oxford-Flower-dataset\oxford_flower.yaml.zip'...

My code

• Creation of model object:
  model = YOLO("yolov8m-cls.pt")

• Model.training:
  model.train(mode="classify",
  data=data_file_path,
  epochs=num_epochs,
  batch=batch_size,
  imgsz=256,
  lr0=lr,
  optimizer="AdamW",
  cos_lr=True,
  momentum=0.937,
  weight_decay=weight_decay)

• Note that variable "data_file_path" is the path to my .yaml file I created for the Oxford Flower dataset

My yaml file

The content of my .yaml file is:

names:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
  ....
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
  nc: 102
  path: C:/Users/ <'my_path'> /Oxford-Flower-dataset/jpg
  train: train/images
  train_label_dir: train/labels
  val: val/images
  val_label_dir: val/labels

Data directories

The directories of my data is exactly the way your colleague / member "pderrenger" describes it in her message of March 30th 2024. It looks like:

dataset/
├── train/
│ ├── images/
│ └── labels.txt
└── val/
├── images/
└── labels.txt

Labels.txt content

The content of labels.txt is:

image_06734.txt 1
image_06735.txt 1
image_06737.txt 1
image_06742.txt 1
image_06743.txt 1
image_06745.txt 1
image_06746.txt 1
image_06748.txt 1
image_06751.txt 1
image_06752.txt 1
....

Question

Why is it unable to find the data? What I am I missing

[glenn-jocher]

Ensure each image has a corresponding label file with the same name in the labels directory. The label files should contain the class index. If the issue persists, double-check the paths in your YAML file and ensure they match your directory structure.

[D3RK0]

@glenn-jocher Thanks for responding!

I have solved the previous problem. I have another problem, however.

Output by the YOLOv8 model

YAML file created at: C:/Users/derk_/Documents/Universiteit/IRP/Research_Project/Oxford-Flower-dataset/jpg\oxford_flower.yaml
New https://pypi.org/project/ultralytics/8.3.28 available 😃 Update with 'pip install -U ultralytics'
engine\trainer: task=classify, mode=train, model=yolov8m-cls.pt, data=C:/Users/derk_/Documents/Universiteit/IRP/Research_Project/Oxford-Flower-dataset/jpg, epochs=1, time=None, patience=100, batch=16, imgsz=224, save=True, save_period=1, cache=False, device=cpu, workers=8, project=None, name=train38, exist_ok=False, pretrained=True, optimizer=AdamW, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=True, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=True, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.01, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, copy_paste_mode=flip, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=C:\runs\classify\train38
train: C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\Oxford-Flower-dataset\jpg\train... found 6149 images in 102 classes: ERROR ❌️ requires 2 classes, not 102
val: C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\Oxford-Flower-dataset\jpg\val... found 1020 images in 102 classes: ERROR ❌️ requires 2 classes, not 102
test: C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\Oxford-Flower-dataset\jpg\test... found 1020 images in 102 classes: ERROR ❌️ requires 2 classes, not 102
Overriding model.yaml nc=1000 with nc=2
from n params module arguments
0 -1 1 1392 ultralytics.nn.modules.conv.Conv [3, 48, 3, 2]
1 -1 1 41664 ultralytics.nn.modules.conv.Conv [48, 96, 3, 2]
2 -1 2 111360 ultralytics.nn.modules.block.C2f [96, 96, 2, True]
3 -1 1 166272 ultralytics.nn.modules.conv.Conv [96, 192, 3, 2]
4 -1 4 813312 ultralytics.nn.modules.block.C2f [192, 192, 4, True]
5 -1 1 664320 ultralytics.nn.modules.conv.Conv [192, 384, 3, 2]
6 -1 4 3248640 ultralytics.nn.modules.block.C2f [384, 384, 4, True]
7 -1 1 2655744 ultralytics.nn.modules.conv.Conv [384, 768, 3, 2]
8 -1 2 7084032 ultralytics.nn.modules.block.C2f [768, 768, 2, True]
9 -1 1 988162 ultralytics.nn.modules.head.Classify [768, 2]
YOLOv8m-cls summary: 141 layers, 15,774,898 parameters, 15,774,898 gradients

The problem

The "[...] ERROR ❌️ requires 2 classes, not 102 [...]" is giving for all my data splits.

My yaml file.

The content of my yaml file:

names: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102]
nc: 102
path: C:/Users/my_several_folders/Oxford-Flower-dataset/jpg
test: test/images
test_label_dir: test/labels
train: train/images
train_label_dir: train/labels
val: val/images
val_label_dir: val/labels

The length of names is equal to the value of nc, 102, so that is not disparate.

My folder structure

jpg/
├── train/
│ ├── 1/
│ │ ├── img1.jpg
│ │ └── img2.jpg
│ ├── 2/
│ └── ...
├── val/
│ ├── 1/
│ ├── 2/
│ └── ...
└── test/
├── 1/
├── 2/
└── ...

The names of the classes should thus correctly correspond to folder names of the folder wherein the images of that given class are stored.

Question

Are you familiar with the "[...] ERROR ❌️ requires 2 classes, not 102 [...]" error? What are the most common solutions to this problem?

Many thanks!

[glenn-jocher]

@D3RK0 it seems the model configuration is set to expect 2 classes instead of 102. Ensure that the nc parameter in your model configuration matches the number of classes in your dataset. Adjust the model configuration to nc: 102 to resolve this issue.

[D3RK0]

@glenn-jocher Many thanks for your quick response!

How can I do that? I mean, as you can see from the content of my .yaml-file, the nc parameter is already set to 102 and nc is not an accepted hyperparameter in the YOLO() or model.train() function.

[glenn-jocher]

@D3RK0 ensure the model is correctly configured by setting nc: 102 in the model's YAML file before training. If the issue persists, verify that the model weights are compatible with the number of classes.