SAM segmentation masks to YOLO format

[akashsateesha]

Hey Everyone !!

I have a dataset with only bounding box annotations . I wanted to generate Segmentation masks using the available bounding box and made us of SAM model . SAM gives Segmentation masks in binary format , when I plotted the masks the results very pretty impressive .
Now I want to built an instance segmentation model on the above dataset using YOLOV8 or YOLOV5 . But for this I want to convert my Segmentation masks in binary format to YOLO format. I have tried with the opencv"s find contour too but it was a failure . Can some one please guide me there !!

Thank You !!

[pderrenger]

@akashsateesha hello! It's great to hear that the SAM model has provided you with impressive segmentation masks from your bounding box annotations. To use these masks for instance segmentation with YOLOv8, you'll need to convert them into a format that YOLOv8 can understand for training.

YOLOv8 supports training on segmentation tasks, and the expected format for segmentation masks is one where each instance mask is encoded as a color-coded PNG image, with each color representing a different class. The conversion process from binary masks to the required format involves assigning unique color values to each instance and class in your dataset.

Here's a general outline of the steps you would take to convert your binary masks to the YOLOv8 segmentation format:

1. Load the binary mask image using a library like OpenCV or PIL.
2. Identify individual instances in the binary mask. You can use OpenCV's findContours function for this purpose.
3. Assign a unique color to each identified instance. Ensure that the color corresponds to the class ID as per the YOLOv8 segmentation format.
4. Save the color-coded mask as a PNG image.

Here's a simplified example of how you might perform this conversion in Python:

import cv2
import numpy as np

# Load binary mask
binary_mask = cv2.imread('path_to_binary_mask.png', 0)

# Find contours
contours, _ = cv2.findContours(binary_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Create an empty image for the color-coded mask
color_mask = np.zeros((binary_mask.shape[0], binary_mask.shape[1], 3), dtype=np.uint8)

# Assign a unique color to each instance
for i, contour in enumerate(contours):
    color = [int(c) for c in np.random.choice(range(256), size=3)]  # Random color for each instance
    cv2.drawContours(color_mask, [contour], -1, color, -1)  # Fill the contour with the color

# Save the color-coded mask
cv2.imwrite('path_to_color_mask.png', color_mask)

Please note that the above code is a basic example and may need to be adapted to your specific use case, especially regarding the assignment of class-specific colors and handling of multiple instances.

Once you have converted your masks, you can proceed to train your YOLOv8 model on the instance segmentation task using your dataset. For more detailed information on training YOLOv8 models for segmentation, please refer to the Segmentation Task Documentation.

If you encounter any issues or have further questions, feel free to reach out. Good luck with your instance segmentation model training! 🚀

[pderrenger]

@nicholas-aplin hey there!

It sounds like there's a bit of confusion with the dataset setup. No worries, let's sort it out! 😊

For your segmentation masks and images, they should be in the same directory. Each image should have a corresponding mask with the same filename but different extension (e.g., image.jpg and image.png for the mask).

You only need one classes.txt file for your entire dataset, not one for each image. This file should be referenced in your .yaml file, and it lists all your class names.

The error you're encountering suggests that the script is looking for labels in a labels folder, which is typical for detection tasks, not segmentation. For segmentation, your .yaml should point directly to the folders containing the images and masks, not a separate labels folder.

Here's a quick folder structure example:

dataset/
├── images/
│   ├── train/
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └── ...
│   └── val/
│       ├── image1.jpg
│       ├── image2.jpg
│       └── ...
└── masks/
    ├── train/
    │   ├── image1.png
    │   ├── image2.png
    │   └── ...
    └── val/
        ├── image1.png
        ├── image2.png
        └── ...

And your .yaml might look like this:

train: dataset/images/train/
val: dataset/images/val/

nc: 3
names: ['class0', 'class1', 'class2']

Make sure your .yaml doesn't point to a labels directory for a segmentation task. Give this a try, and you should be on the right track! If you hit any snags, the community is here to help. 🌟

Happy training!

[nicholas-aplin]

Hey,

Still stuck on this, I have the dataset setup as you described, my .yaml is:

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
train: path\to \test\images\train  # train images (relative to 'path') 4 images
val: path\to\test\images\val  # val images (relative to 'path') 4 images

nc: 7

names: ['background', 'disk', 'ins_hv_pin', 'ins_lv_pin', 'pole', 'shackle', 'xarm']

colors: [[0,0,0], [170,154,221], [105,106,23], [204,234,133], [96,160,160], [40,163,86], [81,28,63]]

my python code to train the model is:

# Load a model
model = YOLO('yolov8x-seg.pt')  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data=r'path\to\test\details.yaml', epochs=200, imgsz=640)

is there anything that I am missing, I keep getting the same error that I stated above,

Thank You!

[pderrenger]

Hey there! 👋

It looks like you're on the right track! Just a quick note: in your .yaml and Python code, make sure to use forward slashes / or double backslashes \\ for paths in Windows. Also, ensure the path to your .yaml in the Python code matches exactly with where your .yaml file is located. Here's a quick tweak to your Python code:

# Load a model
model = YOLO('yolov8x-seg.pt')  # load a pretrained model (recommended for training)

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

And in your .yaml, it should look like this:

train: path/to/test/images/train
val: path/to/test/images/val

Give this a try! If the issue persists, double-check the paths and ensure your dataset is accessible from the script's running directory. Keep me posted! 😊

[nicholas-aplin]

Hi,
Still not working for me, I'm getting the following:
train: Scanning path\to \test\labels\train... 0 images, 1 backgrounds, 0 corrupt: 100%|██████████| 1/
train: WARNING ⚠️ No labels found in path\to\test\labels\train.cache. See https://docs.ultralytics.com/datasets/detect for dataset formatting guidance.
train: WARNING ⚠️ Cache directory path\to\test\labels is not writeable, cache not saved.
WARNING ⚠️ No labels found in path\to\test\labels\train.cache, training may not work correctly. See https://docs.ultralytics.com/datasets/detect for dataset formatting guidance.
Im completely at a loss about what to try next

[pderrenger]

Hey there! 👋 It looks like there might be a slight mix-up with the dataset path or format. For segmentation tasks, ensure your dataset structure matches the expected format, and your .yaml file points directly to the images and masks directories, not a labels directory. Here's a quick example for clarity:

train: path/to/test/images/train
val: path/to/test/images/val

Also, double-check your file paths for any typos and ensure they use forward slashes / or double backslashes \\. If you're still facing issues, could you share a snippet of your dataset structure and .yaml file? That might help pinpoint the issue. Keep going, you're almost there! 🚀

[nahidalam]

I have the exact same issue as @nicholas-aplin

Here is my directory structure

dataset/
├── images/
│   ├── train/
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └── ...
│   └── val/
│       ├── image1.jpg
│       ├── image2.jpg
│       └── ...
└── masks/
    ├── train/
    │   ├── image1.png
    │   ├── image2.png
    │   └── ...
    └── val/
        ├── image1.png
        ├── image2.png
        └── ...

Here is my .yaml file

train: dataset/images/train
val: dataset/images/val

nc: 3

names: ['background', 'person', 'car']

colors: [[0,0,0], [170,154,221], [120, 48, 0]]

I have the masks in dataset/masks/train and dataset/masks/val Do we need to specify that somehow in the .yaml file above?

Here is my training code

from ultralytics import YOLO

# Load a model=
model = YOLO("yolov8n-seg.pt")  # load a pretrained segmentation model for finetuning


# Use the model
training_results = model.train(data="config.yaml", epochs=3, imgsz=416)  # train the model
metrics = model.val()  # evaluate model performance on the validation set
print("Training Results .....")
print(training_results)
print("Metrics")
print(metrics)

@pderrenger please suggest

[pderrenger]

Hey there! 😊 It looks like you're on the right track with your setup. For training a segmentation model with YOLOv8 using your own masks, you indeed need to specify the location of your masks in the .yaml file. However, the current structure of your .yaml file doesn't directly support specifying mask paths.

To incorporate masks into your training, you'll typically need to ensure that your dataset is prepared in a way that YOLOv8 can automatically associate each image with its corresponding mask. The expected convention is that the masks have the same filename as their corresponding images and are located in a parallel directory structure under the masks/ directory, as you've done.

While YOLOv8's training process automatically looks for masks in a masks/ folder mirroring the images/ folder structure, you don't need to explicitly specify the mask paths in the .yaml file. Your current setup should work as long as the mask filenames exactly match their corresponding image filenames.

If you're still encountering issues, ensure that:

• The mask and image filenames match exactly, including case sensitivity.
• The masks are in a format that YOLOv8 expects (typically grayscale images where pixel values correspond to class IDs).

Your training code looks good! If the masks are correctly placed and named, YOLOv8 should automatically find and use them during training. If issues persist, double-check the mask filenames and formats. Happy training! 🚀

[nahidalam]

Hi @pderrenger

Thanks for your quick response. You mentioned the mask format is "typically grayscale images where pixel values correspond to class IDs". If that is true then what is the purpose of specifying color in the .yml file like this?

names: ['background', 'person', 'car']

colors: [[0,0,0], [170,154,221], [120, 48, 0]]

[pderrenger]

Hi there! 😊 The colors specified in the .yaml file are primarily used for visualization purposes. When you're evaluating your model or using it for predictions, these colors help visually distinguish different classes in the output segmentation maps or bounding boxes. It makes it easier to interpret the results at a glance. The grayscale mask images used during training are for the model to understand which pixels belong to which class, while the colors in the .yaml file enhance the user experience during inference. Hope this clears things up!

[nahidalam]

I see, thank you for clarifying.

One more question - if the objects are defined by "grayscale images where pixel values correspond to class IDs" - will it be able to handle overlapping instances?

[pderrenger]

Absolutely, YOLOv8 can handle overlapping instances through instance segmentation models like YOLOv8-Seg. In these models, each instance of an object in an image is assigned a unique identifier, allowing the model to distinguish between overlapping objects of the same class. This is achieved by generating separate masks for each instance, rather than using a single mask per class. So, even if objects overlap, the model can identify and segment each one individually. Happy modeling! 😊

[quicksilver0]

Hi Dear Paula @pderrenger ,
First of all thank you for your clarifications, I've went thoroughly through all the thread.

Would you clarify on the snippet of code you've provided earlier, which suppose to convert binary masks to yolov8 png masks format.

import numpy as np

# Load binary mask
binary_mask = cv2.imread('path_to_binary_mask.png', 0)

# Find contours
contours, _ = cv2.findContours(binary_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Create an empty image for the color-coded mask
color_mask = np.zeros((binary_mask.shape[0], binary_mask.shape[1], 3), dtype=np.uint8)

# Assign a unique color to each instance
for i, contour in enumerate(contours):
    color = [int(c) for c in np.random.choice(range(256), size=3)]  # Random color for each instance
    cv2.drawContours(color_mask, [contour], -1, color, -1)  # Fill the contour with the color

# Save the color-coded mask
cv2.imwrite('path_to_color_mask.png', color_mask)

The confusion is: Your code creates a) 3 channel png mask, and b) colors are assigned randomly and uniquely for each instance in the image.

However later on in the thread you are saying that png mask should be a) greyscale and b) colors should correspond to class id's, not random.

Which way is correct then?

Say we have .yaml file with contents:

nc: 3
names: ['person', 'car', 'bycicle']

Shouldn't we create single channel png mask and assign colors as following:

# Create an empty image for the color-coded mask (notice, channel = 1)
color_mask = np.zeros((binary_mask.shape[0], binary_mask.shape[1], 1), dtype=np.uint8)

# Assign a unique color to each instance
for i, contour in enumerate(contours):
    color = 0  # zero stands for class 'person', 1 for 'car' and 2 for 'bycicle'
    cv2.drawContours(color_mask, [contour], -1, color, -1)  # Fill the contour with the color

Also you mention that there should be classes.txt file, referenced within .yaml file... but you never give example on how to reference it. Is such classes.txt file neccessary at all?

Kindly advice.

[pderrenger]

Hello @quicksilver0,

Thank you for your detailed question! You're correct in your understanding, and I apologize for any confusion caused by the earlier explanation.

For YOLOv8 instance segmentation, you should indeed use single-channel PNG masks where pixel values correspond to class IDs, not random colors. Here's how you can modify the code to fit this requirement:

import cv2
import numpy as np

# Load binary mask
binary_mask = cv2.imread('path_to_binary_mask.png', 0)

# Find contours
contours, _ = cv2.findContours(binary_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Create an empty image for the class-coded mask
class_mask = np.zeros((binary_mask.shape[0], binary_mask.shape[1]), dtype=np.uint8)

# Assign class ID to each instance
for i, contour in enumerate(contours):
    class_id = 0  # Assign class ID based on your class logic
    cv2.drawContours(class_mask, [contour], -1, class_id, -1)  # Fill the contour with the class ID

# Save the class-coded mask
cv2.imwrite('path_to_class_mask.png', class_mask)

Regarding the classes.txt file, it's not necessary if you define your classes directly in the .yaml file under names. If you have any more questions or need further clarification, feel free to ask!

Best regards!

[MnLgt]

When I read through the ultralytics dataset format documentation it said the labels have to be text files with each line denoting the class id followed by the normalized boundary coordinates. I can't find anything saying that colorized segmentation masks are an option. Am I missing something in the documentation?

[pderrenger]

Hello!

You're correct. For YOLO models, including YOLOv8, the labels are expected to be in text files with each line containing the class ID and normalized bounding box coordinates (xywh). As of now, YOLO does not natively support training directly from colorized segmentation masks.

If your project requires using segmentation masks, you'd need to convert those masks to the bounding box format that YOLO expects. This typically involves calculating the bounding boxes from your segmentation masks which can be achieved using image processing methods like contours in OpenCV.

Here's a small example in Python using OpenCV to find bounding boxes from masks:

import cv2
import numpy as np

# Load mask image
mask = cv2.imread('mask.png', 0)
contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

for cnt in contours:
    x, y, w, h = cv2.boundingRect(cnt)
    # Normalize the bounding box coordinates as required by YOLO
    # Save or use these bounding box coordinates as needed

This code snippet finds contours in a mask and computes the bounding box coordinates, which you would then need to normalize based on your image dimensions.

Thanks for reaching out!

[MnLgt]

Hi, thanks for your response. In the past I've converted the masks to this format, however, in your earlier post you said

YOLOv8 supports training on segmentation tasks, and the expected format for segmentation masks is one where each instance mask is encoded as a color-coded PNG image, with each color representing a different class. The conversion process from binary masks to the required format involves assigning unique color values to each instance and class in your dataset.

Does this mean that instead of using normalized points we can use color coded png masks as our label files?

[pderrenger]

Hello!

Thanks for your follow-up! Indeed, YOLOv8 supports instance segmentation tasks in which case it uses color-coded PNG images as inputs for training. However, for those tasks, the colored masks are mainly used in conjunction with bounding box information to perform instance segmentation rather than detection alone.

To clarify, while the YOLO training on detection tasks relies on text files with normalized bounding box values, instance segmentation training also involves using segmentation masks where every instance of an object is marked with a unique color corresponding to its class.

You would still maintain bounding box label files and have separate segmentation mask images for training instance segmentation models like YOLOv8's instance segmentation capabilities. So, you're not replacing the bounding box coordinates with masks, but rather using both where the masks provide the instance-specific segmentations.

I hope this clears up the usage! Let me know if you have other questions! 👍

[rabianaseem]

Hi. I am using/fine-tuning YOLOv8x-seg to segment (only one type of objects) in my images. So there is only one class in my images that I am interested in. When I test the model (after fine-tuning), it segments the objects in most cases, but the results are not fine. Sometimes extra area (other than objects) is included - or sometimes the entire object is not segmented. My code basically trains/fine-tunes like this:

yolo task=segment mode=train model=yolov8x-seg.pt data='C:\Users\user1\YOLO\ultralytics\ultralytics\config_new.yaml' epochs=5 imgsz=640

My data is structured as follows:

dataset/
├── images/
│ ├── train/
│ │ ├── image1.jpg
│ │ ├── image2.jpg
│ │ └── ...
│ └── val/
│ ├── image1.jpg
│ ├── image2.jpg
│ └── ...
└── labels/
├── train/
│ ├── image1.png
│ ├── image2.png
│ └── ...
└── val/
├── image1.png
├── image2.png
└── ...

If I put text files in ‘labels’ (train and val) (these files carry normalised coordinates of the rectangular object I want to segment), the training runs successfully. Although, I believe this is the format for detection task. But when I test after training on data like this, I get segmented images that are not good but at least segmented objects in my test images.
On the other hand, when I put binary masks in train and val in the ‘labels’ folder, my code gives an error that it didn't find labels. Now, I cannot understand what is the issue, because as far as I understand, I should place binary masks in the labels folder (for segmentation task).
Because I want to segment only one kind of objects in my images, my binary masks have white pixels corresponding to the objects i want to segment (their value is 255) and the other pixels (background) have value zero. The contents of my config.yaml file are as under:

path: C:\Users\user1\YOLO\ultralytics\ultralytics\datasets
train: C:\Users\user1\YOLO\ultralytics\ultralytics\datasets\images\train
val: C:\Users\user1\YOLO\ultralytics\ultralytics\datasets\images\val

nc: 1
names:
0: rect

I would highly appreciate any feedback on this.

[glenn-jocher]

@rabianaseem hello!

Thank you for reaching out and providing detailed information about your issue. It sounds like you're on the right track with your dataset structure and training process, but let's address the specific concerns you're facing with segmentation masks and training.

Segmentation Masks Format

For the segmentation task in YOLOv8, the labels should indeed be in the form of binary masks. However, these masks need to be in the correct format and location for the model to recognize them. Here are a few steps to ensure your setup is correct:

1. Label Format: Ensure that your binary masks are saved as .png files with the same name as the corresponding images. The masks should be in the labels directory, and each mask should have the same dimensions as its corresponding image.

2. Directory Structure: Your directory structure looks good, but make sure the paths in your config.yaml file are correctly pointing to the dataset directories. For example:

   path: C:\Users\user1\YOLO\ultralytics\ultralytics\datasets
   train: images/train
   val: images/val
   
   nc: 1
   names:
     0: rect

3. Binary Masks: Ensure that the binary masks are correctly formatted. The object pixels should be white (255) and the background pixels should be black (0).

Training Command

Your training command looks correct, but you might want to ensure that the model is correctly picking up the segmentation task. Here’s a refined version of your command:

yolo task=segment mode=train model=yolov8x-seg.pt data='C:\\Users\\user1\\YOLO\\ultralytics\\ultralytics\\config_new.yaml' epochs=5 imgsz=640

Troubleshooting Steps

1. Verify Mask Loading: Ensure that the masks are being loaded correctly. You can add a few print statements or use a debugger to check if the masks are being read properly during training.

2. Check for Errors: If you encounter errors about missing labels, double-check the file paths and ensure that the masks are in the correct format and location.

3. Model Performance: If the segmentation results are not satisfactory, consider the following:

   • Increase Epochs: Training for more epochs might help the model learn better.
   • Data Augmentation: Use data augmentation techniques to improve the robustness of your model.
   • Hyperparameter Tuning: Experiment with different learning rates, batch sizes, and other hyperparameters.

Example Code for Mask Conversion

If you need to convert bounding boxes to segmentation masks, you can use the following example code:

import cv2
import numpy as np

def bbox_to_mask(image_shape, bbox):
    mask = np.zeros(image_shape, dtype=np.uint8)
    x_min, y_min, x_max, y_max = bbox
    mask[y_min:y_max, x_min:x_max] = 255
    return mask

# Example usage
image_shape = (640, 640)  # Example image shape
bbox = [100, 150, 300, 400]  # Example bounding box [x_min, y_min, x_max, y_max]
mask = bbox_to_mask(image_shape, bbox)
cv2.imwrite('mask.png', mask)

Additional Resources

For more detailed troubleshooting and common issues, you can refer to our YOLO Common Issues Guide.

I hope this helps! If you have any further questions or run into any issues, feel free to ask. Happy training! 🚀

[mindmad]

hello, @glenn-jocher @pderrenger
I have followed the instructions in this issue, and prepared my data accordingly where :
My dataset structure as follows:

Crackseg9k_Mask/
├── images/
│   ├── train/
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └── ...
│   └── val/
│       ├── image1.jpg
│       ├── image2.jpg
│       └── ...
└── masks/
    ├── train/
    │   ├── image1.png
    │   ├── image2.png
    │   └── ...
    └── val/
        ├── image1.png
        ├── image2.png
        └── ...

my data.yaml as follows :

path: D:/phd/yolov8i/datasets/Crackseg9k_Mask
train: images/train
val: images/val

nc: 1

names: ['crack']

and my train code is a follow :

model = YOLO('ultralytics/cfg/models/v8/yolov8n-seg.yaml')
    model.load('yolov8n-seg.pt') # loading pretrain weights
    model.train(data='datasets/Crackseg9k_Mask/data.yaml',
                cache=False,
                imgsz=640,#[1280,720],
                epochs=100,
                device='0',
                optimizer='auto', # using SGD
                project='runs/Crackseg9k_Mask/train',
                name='expY8n-seg',
                ) 

however, I got this error when training :

Transferred 521/557 items from pretrained weights
Freezing layer 'model.27.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks with YOLOv8n...
AMP: checks passed
train: Scanning D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels\train... 0 images, 7327 backgrounds, 0 corrupt: 100%|███
train: WARNING  No labels found in D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels\train.cache. See https://docs.ultralytics.com/datasets/detect for dataset formatting guidance.
train: WARNING  Cache directory D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels is not writeable, cache not saved.
WARNING  No labels found in D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels\train.cache, training may not work correctly. See https://docs.ultralytics.com/datasets/detect for dataset formatting guidance.
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))
val: Scanning D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels\val... 0 images, 916 backgrounds, 0 corrupt: 100%|████████
val: WARNING  No labels found in D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels\val.cache. See https://docs.ultralytics.com/datasets/detect for dataset formatting guidance.
val: WARNING  Cache directory D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels is not writeable, cache not saved.
WARNING  No labels found in D:\phd\yolov8i\datasets\Crackseg9k_Mask\labels\val.cache, training may not work correctly. See https://docs.ultralytics.com/datasets/detect for dataset formatting guidance.
No module named 'seaborn'
optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically...
optimizer: SGD(lr=0.01, momentum=0.9) with parameter groups 76 weight(decay=0.0), 124 weight(decay=0.0005), 129 bias(decay=0.0)
Image sizes 640 train, 640 val
Using 8 dataloader workers
Logging results to runs\Crackseg9k_Mask\train\expY8n-seg-MHSA-ECA-DCNV3-sIoU
Starting training for 100 epochs...

      Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
      1/100      3.19G          0          0      24.56          0          0        640: 100%|██████████| 458/458 [01:
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP50  mAP50-95): 100%|██████████
Traceback (most recent call last):
  File "train2.py", line 9, in <module>
    model.train(data='datasets/Crackseg9k_Mask/data.yaml',
  File "D:\phd\yolov8i\ultralytics\engine\model.py", line 342, in train
    self.trainer.train()
  File "D:\phd\yolov8i\ultralytics\engine\trainer.py", line 192, in train
    self._do_train(world_size)
  File "D:\phd\yolov8i\ultralytics\engine\trainer.py", line 389, in _do_train
    self.metrics, self.fitness = self.validate()
  File "D:\phd\yolov8i\ultralytics\engine\trainer.py", line 493, in validate
    metrics = self.validator(self)
  File "D:\miniconda3\envs\y8i\lib\site-packages\torch\autograd\grad_mode.py", line 27, in decorate_context
    return func(*args, **kwargs)
  File "D:\phd\yolov8i\ultralytics\engine\validator.py", line 185, in __call__
    stats = self.get_stats()
  File "D:\phd\yolov8i\ultralytics\models\yolo\detect\val.py", line 146, in get_stats
    self.nt_per_class = np.bincount(stats[-1].astype(int), minlength=self.nc)  # number of targets per class
IndexError: list index out of range

I am not sure where I made a mistake or missing something any one has an idea???

[glenn-jocher]

@mindmad it looks like the issue stems from the absence of label files in your dataset. YOLOv8 requires label files in the labels directory, which should correspond to your images. These label files should contain the segmentation annotations in YOLO format.

To convert your binary segmentation masks to YOLO format, you can use the segments2boxes function to convert the segmentation masks into bounding boxes. Here’s a brief outline of the steps you need to follow:

1. Convert Segmentation Masks to Segments: Use the SAM model to generate segmentation masks and convert these masks into polygon segments.
2. Convert Segments to YOLO Format: Use the segments2boxes function to convert these segments into YOLO format bounding boxes.

Ensure that your label files are saved in the labels/train and labels/val directories, with each label file corresponding to an image file.

If you continue to face issues, please make sure you are using the latest version of the Ultralytics package. You can update it using:

pip install --upgrade ultralytics

For more detailed guidance, you can refer to the Ultralytics documentation. If the problem persists, please provide more details or any specific errors you encounter.

[s-fedyk]

Did u guys automate ur forum replies with GPT?

[glenn-jocher]

@s-fedyk i'm here to assist with Ultralytics-related questions. How can I help you today?