modes/train/

[giscus[bot]]

modes/train/

Step-by-step guide to train YOLOv8 models with Ultralytics YOLO including examples of single-GPU and multi-GPU training

https://docs.ultralytics.com/modes/train/

[jehanjen]

how to print IOU and f-score with the training result?

[pderrenger]

@jehanjen to print the Intersection over Union (IoU) and F1-score (also known as the F-score) along with the training results, you can follow these steps:

1. During Training:

   • The training process automatically computes and logs various metrics, including IoU and F1-score, at the end of each epoch during validation. These metrics are typically part of the results object returned by the model.train() method.

2. After Training:

   • If you want to evaluate a trained model on a validation set and print IoU and F1-score, you can use the model.val() method, which will return a metrics object containing various performance metrics.

Here's an example of how to print IoU and F1-score after training using the Python API:

from ultralytics import YOLO

# Load a trained model
model = YOLO('path/to/your/trained_model.pt')

# Validate the model
metrics = model.val(data='path/to/your/dataset.yaml')

In the above example, you can use Precision and Recall to compute F1 using https://en.wikipedia.org/wiki/F-score

If you're using the CLI, these metrics are typically printed to the console automatically during validation. You can also find them in the results.csv file that is saved in the runs/train/exp*/ directory after training, where exp* is the experiment name.

Remember to replace 'path/to/your/trained_model.pt' and 'path/to/your/dataset.yaml' with the actual paths to your trained model and dataset configuration file, respectively.

[J0ELh]

How are we able to save sample labls and predictions on the validation set during training? I remember it being easy from yolov5 but I have not been able to figure it out with yolov8.

[glenn-jocher]

Hi @Asshok1,

Thank you for your detailed explanation! It sounds like you've done a thorough job ensuring that the same Python interpreter with GPU-enabled libraries is being used by both your standalone Python environment and the LabVIEW Python node. Let's try to troubleshoot this issue further:

1. Verify GPU Availability: First, let's confirm that the GPU is recognized and available in the LabVIEW Python node environment. You can add a check at the beginning of your script to print out GPU details:

   import torch
   print("CUDA available:", torch.cuda.is_available())
   print("Current device:", torch.cuda.current_device())
   print("Device name:", torch.cuda.get_device_name(0))

2. Update Packages: Ensure you are using the latest versions of torch and ultralytics. You can update them using:

   pip install --upgrade torch ultralytics

3. Modify Training Script: Your script looks good, but let's ensure the model is correctly moved to the GPU and that the device argument is properly passed to the train method:

   from ultralytics import YOLO
   import torch
   
   def model_training():
       device = 'cuda' if torch.cuda.is_available() else 'cpu'
       model = YOLO("yolov8n.pt")  # load a pretrained model 
       model.to(device)
       model.train(data="8.yaml", epochs=4, batch=8, workers=2, device=device)
   
   model_training()

4. Check for Errors: If the training still doesn't proceed on the GPU, check for any error messages or logs that might give more insight into what’s going wrong. Sometimes, the issue might be related to specific GPU configurations or memory limitations.

5. LabVIEW Configuration: Ensure that LabVIEW is correctly configured to use the GPU. Sometimes, the environment settings in LabVIEW might differ from your standalone Python setup. Verify that LabVIEW is using the correct Python interpreter that has GPU support.

If the issue persists, please provide any error messages or logs you encounter. This will help us diagnose the problem more effectively.

Feel free to reach out with any further questions! 😊

[Asshok1]

Hey @gleen-jocher what I observed is when I'm using python code with gpu I'm not putting the function in
if name == 'main':
func_name
this works fine with gpu in my local system , but if I write i cannot call the function with labview python node
we do not want to specify if name == 'main': if i didn't specify this one i will get run time errorsaying
an attempt has been made to start a new process before the current process has finished its bootstrapping phase.

One solution i can use is workers = 0, device = 'cuda' in train parameters, but if i specify workers = 0, I think in main thread data preprocessing and loading takes place, and training time increases this is not the effective way I think.

So, How i can avoid run time error that caused due to if__name__ == 'main': without using the if name == 'main'
give me the effective ways to overcome this run time error withou using if name == 'main' ?

[glenn-jocher]

Hi @Asshok1,

Thank you for your detailed explanation! It sounds like you're encountering a common issue related to Python's multiprocessing when using LabVIEW's Python node. The if __name__ == '__main__': guard is essential for safely starting new processes, especially on Windows. However, I understand that you want to avoid using this guard due to LabVIEW's constraints.

Here are a few suggestions to help you resolve this issue:

1. Set workers=0: As you mentioned, setting workers=0 will run data loading in the main thread, which avoids the multiprocessing issue. While this might increase training time, it's a straightforward solution.

2. Use torch.multiprocessing.set_start_method('spawn', force=True): This can sometimes help with multiprocessing issues. Add this line at the beginning of your script:

   import torch.multiprocessing as mp
   mp.set_start_method('spawn', force=True)

3. Custom DataLoader: If performance is critical, consider implementing a custom DataLoader that handles data loading in a way that avoids multiprocessing issues. This can be more complex but offers better control.

4. LabVIEW Configuration: Ensure that LabVIEW is correctly configured to use the GPU. Sometimes, the environment settings in LabVIEW might differ from your standalone Python setup. Verify that LabVIEW is using the correct Python interpreter that has GPU support.

Here's a refined version of your script with the spawn method:

import torch.multiprocessing as mp
mp.set_start_method('spawn', force=True)

from ultralytics import YOLO
import torch

def model_training():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    model = YOLO("yolov8n.pt")  # load a pretrained model 
    model.to(device)
    model.train(data="8.yaml", epochs=4, batch=8, workers=2, device=device)

model_training()

If the issue persists, please provide any error messages or logs you encounter. This will help us diagnose the problem more effectively.

Feel free to reach out with any further questions! 😊

[Asshok1]

Hey @gleen-jocher

1. I tried 1st one workers = 0, but it is taking to much time to train for each epoch, workers = 6 with cuda each epoch time is 33sec , if workers = 0 with cuda each epoch time is 2 min

2. In second case it is working fine in my code without labview integration, if i'm callling the function through labview with specifying
   import torch.multiprocessing as mp
   mp.set_start_method('spawn', force=True) at top it is not running

3. I don't know how to create custom dataloader and train the yolov8

4. The labview is using same python interpreter which have gpu resources

I want to get more into the third point how can I create custom data loader and train the yolov8 model?

[glenn-jocher]

Hi @Asshok1,

Thank you for your detailed follow-up! 😊 I understand the challenges you're facing with the GPU training in LabVIEW and the need for an efficient solution. Let's address your points one by one:

1. Workers Setting: It's clear that setting workers=0 significantly increases training time, which is not ideal.

2. Multiprocessing with LabVIEW: The mp.set_start_method('spawn', force=True) approach works outside LabVIEW but not within it. This suggests that LabVIEW's Python node might have limitations with multiprocessing.

3. Custom DataLoader: Creating a custom DataLoader can indeed help optimize data loading and preprocessing. Here’s a basic example to get you started:

   from torch.utils.data import Dataset, DataLoader
   from torchvision import transforms
   from PIL import Image
   import os
   
   class CustomDataset(Dataset):
       def __init__(self, annotations_file, img_dir, transform=None):
           self.img_labels = pd.read_csv(annotations_file)
           self.img_dir = img_dir
           self.transform = transform
   
       def __len__(self):
           return len(self.img_labels)
   
       def __getitem__(self, idx):
           img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
           image = Image.open(img_path)
           label = self.img_labels.iloc[idx, 1]
           if self.transform:
               image = self.transform(image)
           return image, label
   
   transform = transforms.Compose([
       transforms.Resize((640, 640)),
       transforms.ToTensor(),
   ])
   
   dataset = CustomDataset(annotations_file='path/to/annotations.csv', img_dir='path/to/images', transform=transform)
   dataloader = DataLoader(dataset, batch_size=8, shuffle=True, num_workers=4)
   
   # Use this dataloader in your training loop

4. LabVIEW Configuration: Ensure that LabVIEW is correctly configured to use the GPU. Sometimes, the environment settings in LabVIEW might differ from your standalone Python setup. Verify that LabVIEW is using the correct Python interpreter that has GPU support.

Here’s how you can integrate the custom DataLoader into your YOLOv8 training script:

from ultralytics import YOLO
import torch
from torch.utils.data import DataLoader

def model_training():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    model = YOLO("yolov8n.pt")  # load a pretrained model 
    model.to(device)

    # Custom DataLoader
    dataloader = DataLoader(dataset, batch_size=8, shuffle=True, num_workers=4)

    # Train the model
    model.train(data=dataloader, epochs=4, device=device)

model_training()

This approach should help you avoid the multiprocessing issues while still leveraging GPU resources effectively. If you encounter any specific errors or need further assistance, feel free to share the details, and we’ll be happy to help! 🚀

[Ashutosh1995]

If I am not mistaken, the logs shown during training also contain the box(P,R,[email protected] and [email protected]:0.95) and mask(P,R,[email protected] and [email protected]:0.95) for validation set during each epoch. Then why is it happening that during model.val() using the best.pt, I am getting worse metrics. From the training and validation curves, it is clear that the model is overfitting for the segmentation task but that is separate issue of overfitting. Can you please help me out in this?

[vonzo]

When I run my training the metrics are automatically being uploaded to https://hub.ultralytics.com/models/..... , can I avoid this? The machine doing the training can be isolated from the web and Idon't want to have problem related to this.

[vonzo]

I actually run into this error:

/miniconda3/lib/python3.11/site-packages/ultralytics/utils/callbacks/hub.py", line 49, in on_model_save
    LOGGER.info(f"{PREFIX}Uploading checkpoint {HUB_WEB_ROOT}/models/{session.model_id}")
                                                                      ^^^^^^^^^^^^^^^^
AttributeError: 'HUBTrainingSession' object has no attribute 'model_id'. Did you mean: 'model_url'?

[pderrenger]

@vonzo hey there! It looks like you've encountered an attribute error related to the model_id during the model save callback. This could be a bug or a version mismatch issue. To resolve this, you can try the following steps:

1. Ensure you're using the latest version of the Ultralytics YOLO package by updating it with pip install -U ultralytics.

2. If the issue persists, you can modify the hub.py file where the error occurs. Replace session.model_id with session.model_url if that's the correct attribute you're looking to access.

Here's a quick fix you can apply:

# In hub.py, change the following line:
LOGGER.info(f"{PREFIX}Uploading checkpoint {HUB_WEB_ROOT}/models/{session.model_id}")
# To:
LOGGER.info(f"{PREFIX}Uploading checkpoint {HUB_WEB_ROOT}/models/{session.model_url}")

3. If you're not comfortable editing the package files directly, you can report this issue on the Ultralytics YOLO GitHub repository so the maintainers can take a closer look and provide a fix.

Let me know if this helps or if you need further assistance! 😊🛠️

[vonzo]

So, imgsz works different when training than when predicting?

For train: if it's an int the ratio will be kept and the train function will take care of that (can't be a tuple).
For predict: if it's an int the image will be resized as a square of size imgsz x imgsz, if it's a tuple the image will be resized using HxW and the user has to take care of the ratio and stride.

Is this right?
I would add a comment in the doc to avoid confusions

[pderrenger]

Hey there! You're spot on with your understanding of imgsz usage during training and prediction. 👍

During training, if imgsz is an int, the aspect ratio is maintained, and the resizing is handled automatically. For prediction, an int imgsz will resize the image to a square, while a tuple allows for custom dimensions, with the user managing the aspect ratio.

Great suggestion on adding a note to the docs for clarity! I'll pass that feedback along. If you have any more insights or questions, feel free to share! 😊

[vonzo]

So, imgsz works different when training than when predicting?

For train: if it's an int the ratio will be kept and the train function will take care of that (can't be a tuple).
For predict: if it's an int the image will be resized as a square of size imgsz x imgsz, if it's a tuple the image will be resized using HxW and the user has to take care of the ratio and stride.

Is this right?
I would add a comment in the doc to avoid confusions

[pderrenger]

You've got it right! 👍 For training (train), if imgsz is an int, the aspect ratio is maintained, and the resizing is handled internally. It can't be a tuple. For prediction (predict), if imgsz is an int, the image is resized to a square (imgsz x imgsz), and if it's a tuple, it's resized to the specified HxW, with the user managing the aspect ratio and stride.

Great suggestion on the documentation comment – clarity is key! If you have any more questions or need further examples, feel free to ask. 😊

[William-Yao0993]

Hi all,

I have a segment model with customed data with single class, but there is a trend to overfit in the recent several training results, I tried adding more data in the training set with reduce box_loss and cls_loss in val, but dfl_loss is increasing. Is there suggestion to tuing the model.
p.s: augmentation, learning rate are fine-tuned by model.tune with optimiser : AdamW, but havent touch with dropout(dropout=0)

Thanks a lot.

[glenn-jocher]

@William-Yao0993 hey there! 👋

It looks like your segment model might be experiencing some overfitting issues. Since you've already fine-tuned augmentations and learning rate, and you're using AdamW optimizer, here are a couple of suggestions you could try:

1. Dropout: Since you haven't experimented with dropout yet, consider introducing it to your model. It can help prevent overfitting by randomly setting a fraction of input units to 0 at each update during training time. Start with a small value (e.g., dropout=0.1) and gradually increase if necessary.

2. Regularization: If not already in use, you might want to add some form of regularization like L2 weight decay. This can help to prevent the model weights from growing too large.

3. Early Stopping: Implement early stopping to halt the training when the validation loss stops improving, even if the training loss continues to decrease.

4. Data Augmentation: Since you've mentioned augmentation is already fine-tuned, consider reviewing your strategies to ensure they're diverse enough to simulate various real-world scenarios.

5. Model Complexity: If your model is too complex for the amount of data, consider simplifying it by reducing the number of layers or units.

6. Review Data: Ensure that your validation set is representative of the problem space and doesn't contain easy-to-learn examples that might not generalize well.

Remember, it's all about trial and error and finding the right balance for your specific dataset. Keep experimenting! 🧪

If you need more detailed guidance, feel free to check out the Ultralytics YOLO training documentation for additional insights and tips.

Happy training! 😊

[cengiz6]

I have a question for training the segmentation model. I have objects in my dataset that screen each other, such that the top object separates the segmentation mask of the bottom object into two independent parts. as far as I can see, the coordinates of each point are listed sequentially in the label file. If I add the points of the two masks one after the other in the coordinates of the same object, will I solve the problem?

[glenn-jocher]

@cengiz6 hey there! 👋

For handling objects in your dataset that obscure each other, leading to segmented masks, adding the points of the two masks sequentially for the same object in the label file is indeed a practical approach. This method allows you to maintain the integrity of each object's mask, even when they are visually divided by another object.

Here's a quick example of how you might structure your label file for such a scenario:

# Object 1 points (x, y coordinates)
x1,y1,x2,y2,...,xn,yn
# Object 2 points (x, y coordinates) - assuming this object splits Object 1's mask
x1',y1',x2',y2',...,xm',ym'

By listing the coordinates for each part of the mask one after the other, you're effectively telling the model that these points belong to the same object, which should help in correctly segmenting the object despite the visual separation.

Hope this helps! If you have any more questions or need further clarification, feel free to ask. Happy training! 🚀

[westlake-moonlight]

Hello there!
The "deterministic" parameter is not working for recent versions. Could you please fix this bug? Thanks!
It was working before YOLOv8.0.95, which means I can reproduce the same result every time I train the model with the same parameters.

[pderrenger]

Hello there! 👋

Thanks for bringing this to our attention. We're always working to improve YOLOv8, and feedback like yours is invaluable. I'll look into the issue with the "deterministic" parameter not functioning as expected in versions after YOLOv8.0.95.

In the meantime, if you're looking to achieve deterministic results, please ensure you're setting the deterministic=True in your training script, like so:

from ultralytics import YOLO

model = YOLO('yolov8n.yaml')
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, deterministic=True)

We'll update you once we have a fix. Thanks for your patience and for being part of the YOLO community! 🚀

[westlake-moonlight]

@pderrenger
Thanks for the prompt feedback!
Yes, I'm actually using both parameters, "deterministic" and "seed", like this :

from ultralytics import YOLO

model = YOLO('yolov8x.pt', task='detect')
results = model.train(deterministic=True, seed=0, ...)  # with some other parameters

And I can provide some more feedback on this. Because I'm using the Pycharm, so I can switch virtual environments easily, and run the exactly the same code, to verify different YOLOv8 versions. Here are 2 findings during the test runs:

1. deterministic works for YOLOv8.0.95 and YOLOv8.0.90 .
2. deterministic does NOT work for: YOLOv8.0.100, YOLOv8.0.200 and the latest YOLOv8.1.23 .

[pderrenger]

Hi @westlake-moonlight,

Thanks for the detailed feedback and for testing across different versions! 🙌 It's incredibly helpful. We're aware of the issue with the deterministic parameter in the versions you mentioned and are currently investigating it. Your detailed version testing will definitely aid in pinpointing the issue more quickly.

We appreciate your patience and contribution to improving YOLOv8. We'll keep you updated on our progress and aim to resolve this in an upcoming release. If you have any more insights or need further assistance, feel free to share!

[yasirgultak]

Hello, I am working on a project for android devices. The gpu and cpu powers of the device I have are weak. Will it speed up if I make the imgsz value 320 for train? Or what are your recommendations?

What happens if the imgsz parameter for training is 640 and the imgsz parameter for prediction is 320? Or what changes if imgsz for training is 320 and imgsz for prediction is 320?

Sorry for my English

Note: I converted it to tflite model.

Thanks. You are amazing

[pderrenger]

@yasirgultak hello! 😊 Your project for Android devices sounds exciting! Let's address your questions:

1. Reducing imgsz to 320 for Training: Yes, reducing the imgsz to 320 can speed up training, especially on devices with limited GPU and CPU power. It also reduces memory consumption. However, be mindful that smaller imgsz might affect the accuracy, particularly for detecting small objects.

2. Different imgsz for Training and Prediction:

   • Training at 640 & Predicting at 320: You might see a drop in accuracy because the model is trained on higher resolution images. Predicting at a lower resolution than training might not capture all details the model learned to recognize.
   • Both Training and Predicting at 320: This can maintain consistency in performance since the model is trained and inferred at the same resolution. It's a good strategy for deployment on devices with limited resources.

3. Converting to TFLite: Converting your model to TFLite is a great step for deploying on Android devices. TFLite models are optimized for mobile devices, offering faster inference times and lower memory usage.

Here's a quick example of how to adjust the imgsz during training:

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

And for prediction:

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

Your English is great, no worries at all! And thank you for your kind words. If you have any more questions or need further assistance, feel free to ask. Good luck with your project! 🚀

[HaneeshMekala]

I've come to rely on YOLOv8 in my daily work; it's remarkably user-friendly. Thank you to the Ultralytics team for your excellent work on these models!

I'm currently tackling a project focused on detecting minor defects on automobile engine parts. As the defects will be a smaller object in a given frame ,could you offer guidance on training arguments or techniques while training a model that might improve performance for this type of data? I'm also interested in exploring attention mechanisms to enhance the model performance, but I'd appreciate help understanding how to implement this.

Special appreciation to Ultralytics team.

[pderrenger]

Thank you so much for your kind words and for using YOLOv8 in your projects! We're thrilled to hear about your positive experience. 😊

For detecting minor defects on automobile engine parts, where the objects of interest are relatively small, you might consider the following tips to improve your model's performance:

1. Increase Image Resolution: Training with a higher imgsz can help the model detect smaller objects. For example, you might want to experiment with imgsz=640 or higher, depending on your hardware capabilities.

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

2. Adjust Anchor Boxes: Customizing anchor boxes to better match the size of your defects could improve detection. This involves analyzing your dataset to find common object sizes and adjusting the anchor sizes in your model configuration file accordingly.

3. Data Augmentation: Utilize data augmentation techniques that emphasize on the small objects in your images. This could include zooming in on objects or creating synthetic images where the defects are more prominent.

Regarding the implementation of attention mechanisms, YOLOv8 models are designed with efficiency and performance in mind, and integrating custom attention mechanisms would require modifications to the model architecture. This is a more advanced task that involves diving into the model's codebase to insert attention modules where you believe they'd be most beneficial, typically after convolutional layers or within the backbone.

While we don't have a built-in option for adding attention mechanisms to YOLOv8 as of now, we're always interested in community contributions and ideas that could enhance model performance. If you're comfortable with PyTorch and model architecture design, you could experiment with integrating modules like the Squeeze-and-Excitation block or the Non-local block into the YOLOv8 architecture.

We hope these suggestions help! If you make any progress or have more questions, feel free to reach out. Good luck with your project! 🚀

[MoAbbasid]

@pderrenger
I thought YOLOv8 was anchorless ?!

[pderrenger]

Hello @MoAbbasid! YOLOv8 does indeed use anchors in its architecture. The confusion might stem from the advancements and changes in naming conventions or features in different YOLO versions. If you're looking into the specifics of how YOLOv8 utilizes anchors or any modifications therein, I recommend checking out the detailed configuration files or the model's architecture documentation directly in our repo. If you have more questions or need further clarification, feel free to ask. Happy to help! 😊

[kunukn]

Running this provided example results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
Gave me this error RuntimeError: An attempt has been made to start a new process before the current process has finished its bootstrapping phase

Which lead me to this Stackoverflow: https://stackoverflow.com/q/75111196/815507

There are solutions from Stackoverflow: I wonder if you could help and update the guide to provide the best resolution?

[glenn-jocher]

@kunukn hey there! 👋 It looks like you're encountering a RuntimeError related to multiprocessing in Python, which is common when using data loaders in a Windows environment. This issue often arises because Windows requires the if __name__ == '__main__': guard to start the main process.

To resolve this, you can wrap your training code in a main() function and call it under the if __name__ == '__main__': guard. Here's a quick example based on your scenario:

from ultralytics import YOLO

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

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

if __name__ == '__main__':
    main()

This should help you get past the bootstrapping phase error. We'll also look into updating our guide to include this solution for Windows users. Thanks for bringing this to our attention, and happy coding! 😊

[ivanstepanovftw]

We need to disable blur augmentation. I have filed an issue, Glenn suggested me to use blur=0, but it is not a valid argument. #8824

[pderrenger]

Hey there! 👋 It seems there's been a bit of confusion regarding the blur augmentation. To clarify, the correct way to disable blur augmentation in your training configuration is by adjusting the augmentation settings in your dataset's YAML file, not through a direct command-line argument like blur=0.

Here's a quick example on how to set it up in your YAML file:

# Example dataset.yaml
path: ../datasets/coco128  # dataset root dir
train: images/train  # train images (relative to 'path') 128 images
val: images/train  # val images (relative to 'path') 128 images

# Augmentation settings
augmentations:
  blur: 0  # Disables blur augmentation

Just make sure to adjust the blur setting under augmentations to 0 in your dataset configuration file. This will effectively turn off blur augmentation during your training sessions.

Hope this clears things up! If you have any more questions or need further assistance, feel free to reach out. Happy training! 🚀

[MoAbbasid]

@ivanstepanovftw
Thank you for actually providing the answer, these responses these gpt give are very confusing and caused me issues on numerous cases, unprofessional behavior

[ivanstepanovftw]

Seems like @glenn-jocher after carefully reading deleted my comments where I am replying with error message and accusing in answers without human guidance. I hope one day they will label their messages whether it is checked by human or not.

[dkumza]

at least in europe they are moving forward to this. Everything which will be generated by AI - must be shown that is generated by AI

[pderrenger]

Hey! Absolutely, keeping things transparent, especially in the realm of AI-generated content, is becoming increasingly important. Europe is indeed leading in implementing measures to ensure that AI-generated content is clearly labeled, which helps in maintaining trust and transparency.

Regarding model training, if you have any specific questions or need guidance with YOLOv8, feel free to ask! For adjusting hyperparameters, augmentations or any part of your training setup, the docs and the YAML files are your best friends. 📖✨ Happy training!

[daodats]

How can I train YOLOv8 with my custom dataset?

[glenn-jocher]

Hey there! 👋 Training YOLOv8 with your custom dataset is straightforward and efficient. Here's a quick guide to get you started:

1. Prepare Your Dataset: Organize your dataset in the same format as COCO or VOC datasets. You'll need images and corresponding annotation files.

2. Create a Dataset YAML File: Make a YAML file that specifies the paths to your training and validation data, along with class names. Example data.yaml:

   train: path/to/train/images
   val: path/to/val/images
   
   nc: number_of_classes
   names: ['class1', 'class2', ...]

3. Train Your Model: Use the CLI or Python API to start training. For a single GPU or CPU:

   • CLI:

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

   • Python:

     from ultralytics import YOLO
     
     model = YOLO('yolov8n.yaml')  # or 'yolov8n.pt' for a pretrained model
     results = model.train(data='data.yaml', epochs=100, imgsz=640)

4. Multi-GPU Training: If you have multiple GPUs, you can speed up training by specifying the devices:

   • CLI:

     yolo detect train data=data.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1

   • Python:

     results = model.train(data='data.yaml', epochs=100, imgsz=640, device=[0, 1])

That's it! 🚀 Your model will start training on your custom dataset. Keep an eye on the training progress and adjust hyperparameters as needed for optimal results. Happy training!

[daodats]

Thanks @glenn-jocher, I trained the pretrained yolov8n.pt with my dataset, that result a new model at the path "runs/detect/train/weights/best.pt", but this new model can't detect objects that its parent model yolov8n.pt did. So, is it wrong?

Here is the predicting code:

Load the new model

model = YOLO('runs/detect/train/weights/best.pt')

Predict

results = model(['cup-of-tea.jpg'])

[glenn-jocher]

Hey! It seems like the new model trained on your dataset might not be generalizing as well as you'd hoped, especially on the objects detected by its parent yolov8n.pt. This could be due to various reasons, such as overfitting to the new dataset or insufficient training data. Here's a quick tip you could try to improve object detection:

Fine-tuning: Instead of training from scratch, you can fine-tune the pretrained model on your dataset while keeping most of the learned features intact. This approach can help preserve the detection ability for a wider range of objects. Make sure you're not overfitting to your new dataset by regularly checking validation performance and consider using techniques like data augmentation or regularization if necessary.

Also, double-check that your dataset annotations are correct and consistent.

Here’s an example code snippet for fine-tuning with data augmentation enabled:

from ultralytics import YOLO

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

# Fine-tune on your dataset with data augmentation
results = model.train(data='data.yaml', epochs=100, imgsz=640, augment=True)

Again, it's all about finding the right balance! 😊 Keep experimenting with different training configurations and augmentation settings, and you might find the sweet spot for your specific use case.

[Abhinav-Singh-Bisht]

Hey, Was trying out training custom object detection model using pretrained YOLO-v8 model.
So was following the doc / tutorial . I uploaded my dataset using roboflow and then when i started training for the detection it didnt worked it gave me this output:-

  Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size

0% 0/250 [00:00<?, ?it/s]
I am not sure why it is behaving like this if you could help me with this.
I even configure the path in the data.yaml file still didnt worked .

[pderrenger]

@Abhinav-Singh-Bisht hello! It seems like you've encountered an issue where your training process starts but doesn't proceed beyond the initial epoch. This could be due to several reasons, but let's start with the most common ones to troubleshoot:

1. Dataset Path: Double-check the path specified in your data.yaml file to ensure it correctly points to your dataset. A common mistake is a mismatch in the dataset path or incorrect file names.

2. GPU Availability: Ensure that your GPU is recognized by PyTorch. You can quickly check this by running:

   import torch
   print(torch.cuda.is_available())

   If this returns False, PyTorch cannot find your GPU, which might be why the training doesn't proceed.

3. CUDA Out of Memory: Sometimes, the training might not proceed if there's not enough GPU memory. Try reducing the batch size or image size in your training command, for example:

   yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=320 batch=8

   This reduces the memory required for training.

4. Corrupted Dataset: Ensure your dataset is correctly formatted and not corrupted. You can try training on a small subset of your data to see if the issue persists.

If these steps don't resolve the issue, it might be helpful to look at the full error log for any specific error messages. Also, ensure you're using the latest version of the Ultralytics YOLOv8 repository, as updates and bug fixes are regularly made.

Feel free to share more details or error logs for further assistance! 😊

[Abhinav-Singh-Bisht]

Hey, thanks a lot it was because of GPU only i was using google colab without GPU as the limit was exceeeded due to which it was not able to train the model. Logged in using another id with GPU and was able to train the model.

Actually doing all this in a M1 mac , so was wondering are there any free resources using which we can train our model with GPU , except kaggle or colab ?

[pderrenger]

@Abhinav-Singh-Bisht hey there! 🙌 Glad to hear you figured out the GPU issue with Google Colab. Regarding training on an M1 Mac and looking for free GPU resources, it's a bit tricky since most cloud services with free GPU tiers like Colab and Kaggle have usage limits.

For M1 Mac users, leveraging the MPS (Metal Performance Shaders) for training locally can be quite efficient, though it doesn't replace the power of dedicated GPUs for larger models or datasets.

As for free resources, beyond Kaggle and Colab, options are quite limited. Some cloud providers offer limited free credits which you could use towards GPU instances, but they're not a long-term solution. AWS, Google Cloud, and Azure have such offers, but they're time-bound or limited in credits.

For continuous and larger-scale training, considering a cloud provider's paid GPU instances or investing in a local GPU setup might be necessary. Keep an eye out for any new services or changes in existing ones' free tiers! Happy training! 🚀

[Suihko]

Hi! I'm working on a project where I plan to use YOLOv8 as the backbone for object detection, but I need a more hands-on approach during the training phase. How to I train the model manually, looping through epochs, perform forward propagation, calculate loss functions, backpropagate, and update weights? At the moment the model.train() seems to handle all of this automatically in the background. The end goal is knowledge distillation, but for a start I need to access these things. I haven't been able to find any examples of YOLOv8 being used in this way, some code and tips would be helpful.

[pderrenger]

@Suihko hey there! 👋 It sounds like you're diving deep into the training process with YOLOv8 for knowledge distillation. While the model.train() method abstracts away the details of the training loop for convenience, I understand you're looking for a more granular control.

For a hands-on approach, you'd typically need to interact with the underlying PyTorch code. Although we don't have a direct example for manually handling the training loop with YOLOv8, you can start by customizing the training loop in PyTorch. Here's a simplified snippet to give you an idea:

import torch
from ultralytics import YOLO
from torch.utils.data import DataLoader

# Load your model and dataset
model = YOLO('yolov8n.yaml').to('cuda')
dataset = ... # Your dataset here
dataloader = DataLoader(dataset, batch_size=..., shuffle=True)

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(num_epochs):
    for images, targets in dataloader:
        images = images.to('cuda')
        targets = targets.to('cuda')

        # Forward pass
        loss, outputs = model(images, targets)

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

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

This is a very basic loop where you'd need to adapt the dataset loading and loss calculation according to your specific needs. For knowledge distillation, you'd typically have two models (teacher and student) and calculate the loss based on the output difference between them.

Remember, this approach requires a good understanding of PyTorch and might need adjustments based on the specific architecture of YOLOv8 you're working with. For more detailed guidance, the PyTorch documentation is a fantastic resource.

I hope this helps to get you started! If you have more specific questions or run into issues, feel free to ask. Happy coding! 😊

[Suihko]

Hi! Thank you very much! I will try to get something working with the baseline you have provided. Otherwise I'll open up an issue, and we can take it from there.

[pderrenger]

Hey there! 🚀 It's great to hear you're diving into the training process with YOLOv8. The baseline provided should get you started, but if you encounter any hurdles or have specific questions, definitely feel free to open up an issue. We're here to help you navigate through it.

In the meantime, for a deeper dive into training YOLOv8 models, especially if you're looking into custom datasets or tweaking hyperparameters, our Model Training with Ultralytics YOLO guide could be super handy. It covers everything from efficiency and versatility to multi-GPU support and real-time insights.

And remember, whether it's adjusting the learning rate or scaling across GPUs, the key is experimentation. 🧪 Happy training, and looking forward to seeing what you achieve!

[dkumza]

Im trying to understand concept of training. I would like to extend default classes with helmet, gloves, etc.

• How much images do I need?
• How many epochs do I need?
• Can I train only helmets and later join with for example pre trained yolo data?
• Or should I train everything at once?

Thanks in advance

[pderrenger]

Hey there! 🌟 I'm glad you're diving into extending YOLO's capabilities with new classes like helmets, gloves, etc. Here are brief answers to your questions:

• How much images do I need?
  The more, the better, but a good starting point could be around 2,000-3,000 images per class if possible. Quality and variety in your dataset are key!

• How many epochs?
  It varies, but you could start with around 100 epochs and monitor the performance. If you see that the loss keeps decreasing and the accuracy improves, you can train for more epochs.

• Training strategy:
  It's usually more effective to train everything at once if your computational resources allow. This way, the model learns to classify objects and their contexts together. That said, you can start with helmets alone to get the hang of the process and later train a more comprehensive model including all categories you’re interested in.

• Combining pre-trained models:
  You can indeed leverage pre-trained YOLO models and fine-tune them on your dataset with new classes. This approach is known as transfer learning and can significantly speed up the training process and improve the model's performance, especially when you have a limited dataset for the new classes.

Here’s a simple snippet to kick-start training with a custom dataset:

yolo detect train data=your_data.yaml model=yolov8n.pt epochs=100

Make sure your_data.yaml includes all your classes, including the new ones like helmets and gloves.

Best of luck with your project! Let us know if you have more questions. 🚀

[LiJiang97]

I have set kpt_shape to [8,3] in the yaml file, but the prompt message is:
train: WARNING ⚠️ C:\applications_data\pycharm\yolov8\datasets\object_260_dataset\images\train\image_9.jpg: ignoring corrupt image/label: labels require 14 columns each
WARNING ⚠️ No images found in C:\applications_data\pycharm\yolov8\datasets\object_260_dataset\labels\train.cache, training may not work correctly.

It seems that a 14-column label file is still required. My label file has 5+24 columns.

[glenn-jocher]

@LiJiang97 it seems your label files need to match the expected format. Ensure each label has 14 columns as required by the model configuration. For more details, please refer to the training documentation: https://docs.ultralytics.com/modes/train/.

[LiJiang97]

I think you didn't understand what I meant. If I want to use yolov8 for key point (8 key points) detection, the label file of the training set should not be 14 columns, maybe 5+24 columns, then I need to set kpt_shape=[8,3] in the yaml file. But after practice, the above error is still reported. I hope you can answer, thank you

[glenn-jocher]

It seems the issue is with the label format. For keypoint detection, ensure your labels match the expected format of 14 columns. Adjust your dataset accordingly and verify the kpt_shape setting in your YAML file. For further guidance, check the training documentation.

[JiangYeC]

Hello,
train_results = model.train(
data="/srv/test/files/competition/ultralytics-main/ultralytics/cfg/datasets/BIRAFS.yaml",
epochs=100, # number of training epochs
imgsz=640, # training image size
device="3", # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
)
Always Noted：Dataset not found ⚠️, missing path /srv/test/files/competition/ultralytics-main/ultralytics/cfg/datasets/BIRAFS.yaml, attempting download...
Downloading https://ultralytics.com/assets/srv/test/files/competition/ultralytics-main/ultralytics/cfg/datasets/BIRAFS.yaml.zip to '/srv/test/files/competition/ultralytics-main/ultralytics/cfg/datasets/BIRAFS.yaml.zip'...

[glenn-jocher]

@JiangYeC it seems like the dataset path is incorrect or missing. Please ensure the path to your dataset YAML file is correct and accessible. If the dataset should be downloaded automatically, verify the URL and network access. For more details on training, visit https://docs.ultralytics.com/modes/train/.

[RussellMeng]

Hi, I have been using this command results = model.train(data="path/to/data.yaml", device=0, epochs=100, batch=8, imgsz=640) to train the model, but this error occurred today.

Transferred 931/937 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir runs/detect/train2', view at http://localhost:6006/
wandb: Currently logged in as: gmeng3. Use `wandb login --relogin` to force relogin

CommError: failed to upsert bucket: returned error 403 Forbidden: {"errors":[{"message":"permission denied","path":["upsertBucket"],"extensions":{"code":"PERMISSION_ERROR"}}],"data":{"upsertBucket":null}}

[glenn-jocher]

It seems like the error is related to permissions with Weights & Biases. Please check your API key and ensure you have the necessary permissions. For more details on setting up logging, you might find the Ultralytics documentation helpful.

[swarnalathayv]

Hello,
I have trained my data using YOLO V8 earlier. Since the latest version YOLO V11 is released, I want to use it. I upgraded ultralytics. but pytorch is not updated(2.3.11+cuda12.1). When I start training, it is showing run time error with numpy cannot be imported.

[glenn-jocher]

@swarnalathayv it seems like there might be an issue with your environment setup. Please ensure that all dependencies, including NumPy, are correctly installed. You can try reinstalling NumPy using pip install numpy. If the issue persists, consider checking your Python and PyTorch versions for compatibility. For more details, visit the Ultralytics YOLO documentation.

[gml-blip]

How can the augmented data during the training process be outputted?

[glenn-jocher]

@gml-blip to output augmented data during training, you can modify the training script to save the augmented images. This typically involves customizing the data loader to store or visualize the augmented images as they are generated. For more detailed guidance, please refer to the Ultralytics documentation: https://docs.ultralytics.com/modes/train/.

[GKYoffice]

Please tell me how to set imgsz when I use the yolo11 model for training. Can it only be an integer (this means that the final input is a square)? After I modify this parameter, will the input interface of the network change the input of data? There are corresponding transformations, such as imgsz=1280, does it mean that my input data will be resized to 1280*1280 and input into the network for training?

Thanks!

[glenn-jocher]

@GKYoffice when using the YOLO11 model, imgsz can be set as an integer, which resizes the input data to a square of that size (e.g., 1280x1280). This parameter adjusts the input dimensions for training. For more details, please visit the training documentation.

[zhongkunh]

How can I do fine tuning with existing .onnx weights?

[glenn-jocher]

@zhongkunh to fine-tune with existing .onnx weights, you'll need to convert them back to a PyTorch model, fine-tune using PyTorch, and then export back to ONNX. Unfortunately, direct fine-tuning in ONNX is not supported.

[seungdae251]

when training, how does the model know if the training data is BGR or RGB?

[glenn-jocher]

@seungdae251 the model assumes RGB format by default, but you can convert BGR images to RGB using OpenCV's cv2.cvtColor(image, cv2.COLOR_BGR2RGB) before training.

[techsupportsardonyx]

I referred to your document, and it says that running one epoch on the COCO dataset with an A100 GPU took 20 minutes and 36 seconds. Now, I have the same COCO dataset, and I want to know if using an RTX 4090 GPU will allow me to complete one epoch in 20 minutes and 36 seconds or less, ideally under 20 minutes. This is because you said that the RTX 4090 is faster than the A100 for most tasks!

[glenn-jocher]

To achieve 10,000 instances with 1,500 images, you can use data augmentation techniques to increase the number of labeled objects per image. Adding 1,500 images per new class to the existing COCO dataset can still provide good accuracy, especially if the new classes are well-represented and the model is fine-tuned effectively.

[techsupportsardonyx]

1.There are up to 11 versions of the YOLO model. For fine-tuning to get better accuracy, which model would you recommend?

2. I am preparing the dataset only for the new classifications I need. So, do I need to check if the classifications and annotations in the existing COCO dataset are correct, or is it unnecessary?

[glenn-jocher]

For fine-tuning, YOLO11x.pt is a strong choice due to its high capacity. As for the COCO dataset, it's generally unnecessary to recheck existing annotations unless you suspect errors, but ensure your new classes are well-represented and correctly labeled.

[techsupportsardonyx]

1.In the COCO dataset, one classification has been annotated twice—once labeled as 'car' and once as 'truck.' Is it correct to annotate like this, or what is the correct approach?
2. If I'm planning to update the YOLO model with only van and e-scooter, is it enough to train with the van and e-scooter dataset along with the COCO dataset, or do I need to add images for all 80 classifications again?

[glenn-jocher]

1. If an object can be both 'car' and 'truck' based on context, dual annotations could be correct; otherwise, ensure a single, most accurate label is used.

2. You can train the model with just the new classes (van, e-scooter) added to the COCO dataset without re-adding all 80 classes, as long as the existing labels remain relevant and comprehensive for your task.

[Sea-queue]

Hi I'm working on a research project at Northeastern University.

The loss became 0 after the first epoch and no detection at all:

• the detection was improving for a few rounds of about 150 epochs each round (trained with 5% of the data), then, when I fed more data in the next round, the loss became 0 and model cannot detect any fish.

• I have tried: epochs=3 imgsz=640 batch=0.70 lr0=0.00001 lrf=0.05 momentum=0.9 optimizer='AdamW' weight_decay=0.0005 dropout=0.3

• and I have tried to create new model by: yolo detect train model=yolo11x.pt

The weird thing is I even tried to replicate the portion was working and improving before, and the training also returns 0 after the first epoch.

I also tried to clone a new repo / directory of yolo11, still the loss is 0 right after the first epoch.

Please sharing some insights!

[glenn-jocher]

@Sea-queue it sounds like your model might be overfitting or there could be an issue with the data format. When the loss becomes zero quickly, it often indicates that the model isn't learning effectively from the data. Here are a few suggestions:

1. Check Data Quality: Ensure that your data is labeled correctly and the format is consistent with what the model expects.
2. Adjust Learning Rate: The learning rate might be too low or too high. Consider experimenting with different values.
3. Regularization: Use techniques like dropout, which you've already tried, but consider adjusting its rate.
4. Data Augmentation: Increase variability in your training data to prevent overfitting.

For more detailed troubleshooting, you might want to explore the Ultralytics documentation for guidance on training settings and data preparation.

[Sea-queue]

Could please share some advices on reducing FP and FN too?
Really appreciate it!

[glenn-jocher]

To reduce false positives (FP) and false negatives (FN) in your YOLO model, consider refining your training data, increasing the diversity and quality of annotations, and adjusting hyperparameters like confidence threshold and non-max suppression (NMS) settings. Experimenting with data augmentation techniques and fine-tuning the model architecture can also help improve detection accuracy. For detailed guidance, you might find the training tips in the Ultralytics documentation useful.

[techsupportsardonyx]

Hi,
Please provide us the GPU and PC configuration for the following process.

1. Need to complete the training process within 1 Hour.
2. Training settings:
   a. Coco Data Set – 1.5 Lakhs images.
   b. Image resolution – 640*640
   c. Epoch – 100
   d. Batch size – 16
   e. Worker – 8
   f. Pre-trained data model – YOLO11x.pt

[glenn-jocher]

@techsupportsardonyx to complete the training within one hour for your specified configuration, a powerful setup is essential. Consider using multiple high-performance GPUs, such as NVIDIA A100s or V100s, with ample VRAM (32GB or more) to handle the large dataset and high resolution efficiently. Multi-GPU support can be utilized to distribute the workload across GPUs, potentially meeting your time constraint. If this is not achievable locally, cloud platforms like AWS, Google Cloud, or Azure might provide the necessary resources.

[astronitya]

Hello Team,
I have a question with training set. What does matter most in training set from the following;

1. Having larger numbers of image (4000- 5000)?
2. Having enough images (500-600), but having 50-60 instances on each images?

This case is particularly for an astronomical dataset, I am training a custom YOLOv11 model for that. The image size if 2kx4k. The idea is, I have very limited images to train, but each one contains huge number of objects.
Thankyou

[glenn-jocher]

@astronitya for your astronomical dataset, both having a large number of images and a high number of instances per image can be beneficial, but given your constraints, focus on ensuring diversity within your limited images. This can help the model generalize better across varying object instances. Consider data augmentation techniques to further enhance the dataset's effectiveness. If possible, leveraging transfer learning with a pretrained model could also assist in achieving better performance with fewer images.

[astronitya]

Hello Glenn,
AS you suggested, I had trained a YOLOv11m.pt model on the 13000 astronomical images for 150 epochs. The statistics of the results are follows;
Accuracy: 0.60
Precision: 0.75
Recall or Completeness: 0.75
False Positive Rate (FPR): 0.26

As you can see, the results are not satisfactory. I thought I haven't trained it for enough epochs, so I have restarted the training on best.pt for another 100 epochs on the same data. The last training itself took 18 hours. What else would you suggest?

[glenn-jocher]

Thank you for sharing the training results and details. To improve performance, I suggest examining hyperparameters like learning rate (lr0), augmentation strategies (e.g., mosaic, auto_augment), and the loss scaling factors (box, cls) to better adapt to your dataset. Additionally, consider leveraging batch size optimization and using mixed-precision training (amp=True) for efficiency. If computational limits are a concern, fine-tuning a larger, pretrained model and evaluating model architecture (YOLOv11m vs. YOLOv11l) could bring improvements for complex datasets. Let me know if you'd like guidance on adjusting these settings.

[techsupportsardonyx]

1. In your document, the time taken for model training using the A100 graphics card has been provided. which is best A100 or V100 ?
   It is mentioned that using A100 8x graphics cards, running 1 epoch takes around 4 minutes. So, running 100 epochs would take approximately 7 hours. So, to complete the training in 1 hour, how many graphics cards would be required? Is there a possible way to achieve this?
   

2.If I use a V100 graphics card to train a model with the COCO dataset, how much time will it take for 100 epochs? And if I use multiple GPUs, how many V100 cards would be needed to complete the training within 1 hour?

[glenn-jocher]

@techsupportsardonyx the A100 GPU generally offers better performance compared to the V100 due to its newer architecture, but your specific time requirements will depend on the setup and batch sizes used. To complete training in 1 hour with an A100 taking 4 minutes per epoch and 8 GPUs, you'd need about 56 GPUs (8 GPUs each taking 4 minutes for 1 epoch, hence 56 GPUs to reduce 7 hours to 1 hour). For the V100, the time per epoch can vary, but typically you might expect it to be longer than the A100, requiring potentially more GPUs. For precise calculations, testing with your specific setup is recommended.

[vodatvan01]

Is there a way to know which loss function is being used by the yolov8s.pt model I'm training, and how can I calculate the loss for just one labeled image?

[glenn-jocher]

The YOLOv8s model typically uses a combination of box, classification, and objectness losses during training. To calculate the loss for a single labeled image, you can run a forward pass with the model and compute the loss manually using the model's loss function components on the output. For more specific implementation details, referring to the YOLOv8 codebase documentation or source code might be necessary.

[EduardoSantosSousa]

Hi, I'm trying to remove has parameters:

albumations: 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.0, 4.0), tile_grid_size=(8, 8))

nc: 2 # Número de classes
names: ['smoke', 'fire'] # Nome das classes

Augmentation settings

augmentations:
Blur: 0 # Disables blur augmentation

It is not possible to remove

[glenn-jocher]

@EduardoSantosSousa to remove data augmentation options effectively, ensure the augmentations parameter is configured correctly in your YAML file. For instance:

augmentations: {}

Define other augmentation settings explicitly if necessary. If the issue persists, confirm you are modifying the active configuration being used during training. Let me know if you need further assistance!

[EduardoSantosSousa]

Dear @glenn-jocher,
Unfortunately it didn't work.... This would be the code to train the model:

`# Load a model
model = YOLO(model='yolov8m.yaml')

PROJECT = 'florest_fire_env' # project name
NAME = 'fire_model' # run name

model.train(
data = 'data.yaml',
task = 'detect',
epochs = 200,
verbose = True,
batch = 20,
imgsz = 640,
patience = 40,
save = True,
device = 0,
workers = 4,
project = PROJECT,
name = NAME,
cos_lr = True,
lr0 = 0.0001,
lrf = 0.00001,
warmup_epochs = 3,
warmup_bias_lr = 0.000001,
optimizer = 'Adam',
seed = 42)`

I tried inserting the command inside the data.yaml file:

`path: "C:/Users/eduar/Documents/florest_fire_env/D-Fire"
train: "C:/Users/eduar/Documents/florest_fire_env/D-Fire/train_transformed/images"
val: "C:/Users/eduar/Documents/florest_fire_env/D-Fire/test/images"
test: "C:/Users/eduar/Documents/florest_fire_env/D-Fire/val/images"

nc: 2 # Class Number
names: ['smoke', 'fire'] # Class Name

Augmentation settings

augmentations: {} # Disables augmentation`

In this case, should I insert the command inside 'yolov8m.yaml'? Why am I not being able to remove the automatic increase data from YOLO and am I also not being able to change other parameters such as the number of frozen players, etc.?

Thank you!

[glenn-jocher]

@EduardoSantosSousa it seems the augmentations are not being disabled as expected. To remove automatic data augmentation in YOLO, ensure augmentations: {} is correctly specified in the data.yaml file and that the file is properly passed during training via data='data.yaml'.

Regarding layer freezing, include the freeze argument in your train function call, such as model.train(freeze=10) to freeze the first 10 layers or adjust it as needed. For further assistance, verify your settings align with Train Settings. Let me know how it goes!

[abhishek7467]

Thanks for your amazing work...

could you please tell me what is the difference bt two different formats dataset first one in yoloV9 and second one in yoloV11. Which i have exported from the roboflow.

I have exported two dataset in two different formats first one in yoloV9 and second one in yoloV11.
I have not access of yoloV9 roboflow project because i have deleted it from roboflow but in my local system have.
I have made another the data directory structure same as training data directory like

my_train_data:
train ->images , labels
test ->images , labels
vaild ->images , labels
data.yaml

i have put data training data of both format for
->training data into the training directory according to images, labels ,
-> testing data into the testing directory according to images, labels ,
-> validation data into the valid directory according to images, labels ,

i am trying to train the yoloV11-x-seg.pt model for two classes -> sofa and table
My model was successfully start train but i have got the warning like -

WARNING Model does not support 'augment=True', reverting to single-scale prediction.

and my model also not train further it train only for the 6 epochs i have use 5 for patience in the training

I have trained 3 models with different parameters and i have face the same problem with all you can see below

model = YOLO(r"yolo11x-seg.pt")

1 ->
results = model.train(
data="E:\Training_data\data.yaml",
epochs = 100,
imgsz=640,
save=True,
patience=5,
verbose=True,
workers=8
)

New https://pypi.org/project/ultralytics/8.3.38 available Update with 'pip install -U ultralytics'
Ultralytics 8.3.33 Python-3.11.8 torch-2.5.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)
engine\trainer: task=segment, mode=train, model=yolo11x-seg.pt, data=E:\Training_data\data.yaml, epochs=100, time=None, patience=5, batch=8, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=8, project=None, name=train6122, exist_ok=False, pretrained=True, optimizer=SGD, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, 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=True, 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.0005, 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=E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122

               from  n    params  module                                       arguments                     

0 -1 1 2784 ultralytics.nn.modules.conv.Conv [3, 96, 3, 2]
1 -1 1 166272 ultralytics.nn.modules.conv.Conv [96, 192, 3, 2]
2 -1 2 389760 ultralytics.nn.modules.block.C3k2 [192, 384, 2, True, 0.25]
3 -1 1 1327872 ultralytics.nn.modules.conv.Conv [384, 384, 3, 2]
4 -1 2 1553664 ultralytics.nn.modules.block.C3k2 [384, 768, 2, True, 0.25]
5 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
6 -1 2 5022720 ultralytics.nn.modules.block.C3k2 [768, 768, 2, True]
7 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
8 -1 2 5022720 ultralytics.nn.modules.block.C3k2 [768, 768, 2, True]
9 -1 1 1476864 ultralytics.nn.modules.block.SPPF [768, 768, 5]
10 -1 2 3264768 ultralytics.nn.modules.block.C2PSA [768, 768, 2]
11 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
12 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1]
13 -1 2 5612544 ultralytics.nn.modules.block.C3k2 [1536, 768, 2, True]
14 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
15 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1]
16 -1 2 1700352 ultralytics.nn.modules.block.C3k2 [1536, 384, 2, True]
17 -1 1 1327872 ultralytics.nn.modules.conv.Conv [384, 384, 3, 2]
18 [-1, 13] 1 0 ultralytics.nn.modules.conv.Concat [1]
19 -1 2 5317632 ultralytics.nn.modules.block.C3k2 [1152, 768, 2, True]
20 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
21 [-1, 10] 1 0 ultralytics.nn.modules.conv.Concat [1]
22 -1 2 5612544 ultralytics.nn.modules.block.C3k2 [1536, 768, 2, True]
23 [16, 19, 22] 1 8324342 ultralytics.nn.modules.head.Segment [2, 32, 384, [384, 768, 768]]
YOLO11x-seg summary: 667 layers, 62,052,566 parameters, 62,052,550 gradients, 319.7 GFLOPs

Transferred 1077/1077 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122', view at http://localhost:6006/
Freezing layer 'model.23.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks...
AMP: checks passed
train: Scanning E:\Training_data\train\labels.cache... 4092 images, 0 backgrounds, 0 corrupt: 100%|██████████| 4092/409
val: Scanning E:\Training_data\valid\labels.cache... 365 images, 0 backgrounds, 0 corrupt: 100%|██████████| 365/365 [00
Plotting labels to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122\labels.jpg...
optimizer: SGD(lr=0.01, momentum=0.937) with parameter groups 176 weight(decay=0.0), 187 weight(decay=0.0005), 186 bias(decay=0.0)
TensorBoard: model graph visualization added
Image sizes 640 train, 640 val
Using 8 dataloader workers
Logging results to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122
Starting training for 100 epochs...

  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  1/100      10.5G     0.4041     0.9449     0.5064      0.945         16        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.866      0.842      0.912      0.822      0.859      0.834      0.894      0.713


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  2/100        10G     0.5388      1.359     0.7173      1.027         30        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.863       0.81      0.896      0.781      0.859      0.812      0.885      0.669


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  3/100        10G     0.6719      1.695     0.8974      1.113         10        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785       0.74      0.708       0.76      0.598       0.78      0.661      0.738      0.485


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  4/100        10G     0.8149      2.013      1.056      1.216         15        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.763      0.766      0.808      0.641      0.748      0.753      0.784      0.527


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  5/100      9.99G     0.7966      1.954     0.9893        1.2          7        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.832      0.749      0.844      0.695      0.831      0.745      0.829       0.58


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  6/100      9.97G     0.7688      1.865     0.9396      1.178         23        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.859      0.784      0.869      0.723      0.851      0.778      0.853      0.601

EarlyStopping: Training stopped early as no improvement observed in last 5 epochs. Best results observed at epoch 1, best model saved as best.pt.
To update EarlyStopping(patience=5) pass a new patience value, i.e. patience=300 or use patience=0 to disable EarlyStopping.

6 epochs completed in 0.608 hours.
Optimizer stripped from E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122\weights\last.pt, 124.8MB
Optimizer stripped from E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122\weights\best.pt, 124.8MB

Validating E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122\weights\best.pt...
Ultralytics 8.3.33 Python-3.11.8 torch-2.5.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)
YOLO11x-seg summary (fused): 491 layers, 62,004,438 parameters, 0 gradients, 318.5 GFLOPs
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
all 365 785 0.866 0.842 0.912 0.822 0.858 0.834 0.894 0.712
sofa 255 413 0.856 0.792 0.891 0.801 0.856 0.792 0.889 0.774
table 304 372 0.876 0.892 0.933 0.843 0.861 0.876 0.9 0.65
Speed: 0.3ms preprocess, 24.0ms inference, 0.0ms loss, 1.2ms postprocess per image
Results saved to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train6122
🤝

2->
results = model.train(
data="E:\Training_data\data.yaml",
epochs=100,
imgsz=640,
batch=16,
save=True,
patience=5,
verbose=True,
workers=8,
optimizer='SGD', # Set optimizer to SGD
lr0=0.01, # Starting learning rate for SGD
momentum=0.937, # Momentum value
weight_decay=0.0005, # Regularization for SGD
warmup_epochs=3.0, # Gradual learning rate warmup
warmup_momentum=0.8, # Momentum warmup
warmup_bias_lr=0.1, # Bias learning rate during warmup
lrf=0.01, # Learning rate schedule
max_det=300,
iou=0.7,
augment=True, # Enable augmentations (like mosaic, mixup)
save_period=-1, # Save checkpoint at the end of training
save_json=False, # Disable saving JSON
save_crop=False, # Disable saving cropped images
multi_scale=False, # Disable multi-scale
dropout=0.0, # No dropout
val=True, # Validate during training
)

New https://pypi.org/project/ultralytics/8.3.38 available Update with 'pip install -U ultralytics'
Ultralytics 8.3.33 Python-3.11.8 torch-2.5.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)
engine\trainer: task=segment, mode=train, model=yolo11x-seg.pt, data=E:\Training_data\data.yaml, epochs=100, time=None, patience=5, batch=16, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=8, project=None, name=train61, exist_ok=False, pretrained=True, optimizer=SGD, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, 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=True, 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.0005, 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=E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61
Overriding model.yaml nc=80 with nc=2

               from  n    params  module                                       arguments                     

0 -1 1 2784 ultralytics.nn.modules.conv.Conv [3, 96, 3, 2]
1 -1 1 166272 ultralytics.nn.modules.conv.Conv [96, 192, 3, 2]
2 -1 2 389760 ultralytics.nn.modules.block.C3k2 [192, 384, 2, True, 0.25]
3 -1 1 1327872 ultralytics.nn.modules.conv.Conv [384, 384, 3, 2]
4 -1 2 1553664 ultralytics.nn.modules.block.C3k2 [384, 768, 2, True, 0.25]
5 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
6 -1 2 5022720 ultralytics.nn.modules.block.C3k2 [768, 768, 2, True]
7 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
8 -1 2 5022720 ultralytics.nn.modules.block.C3k2 [768, 768, 2, True]
9 -1 1 1476864 ultralytics.nn.modules.block.SPPF [768, 768, 5]
10 -1 2 3264768 ultralytics.nn.modules.block.C2PSA [768, 768, 2]
11 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
12 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1]
13 -1 2 5612544 ultralytics.nn.modules.block.C3k2 [1536, 768, 2, True]
14 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
15 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1]
16 -1 2 1700352 ultralytics.nn.modules.block.C3k2 [1536, 384, 2, True]
17 -1 1 1327872 ultralytics.nn.modules.conv.Conv [384, 384, 3, 2]
18 [-1, 13] 1 0 ultralytics.nn.modules.conv.Concat [1]
19 -1 2 5317632 ultralytics.nn.modules.block.C3k2 [1152, 768, 2, True]
20 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
21 [-1, 10] 1 0 ultralytics.nn.modules.conv.Concat [1]
22 -1 2 5612544 ultralytics.nn.modules.block.C3k2 [1536, 768, 2, True]
23 [16, 19, 22] 1 8324342 ultralytics.nn.modules.head.Segment [2, 32, 384, [384, 768, 768]]
YOLO11x-seg summary: 667 layers, 62,052,566 parameters, 62,052,550 gradients, 319.7 GFLOPs

Transferred 1071/1077 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61', view at http://localhost:6006/
Freezing layer 'model.23.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks...
C:\Users\spx016\AppData\Local\Programs\Python\Python311\Lib\site-packages\torch\nn\modules\module.py:1326: UserWarning: expandable_segments not supported on this platform (Triggered internally at C:\actions-runner_work\pytorch\pytorch\builder\windows\pytorch\c10/cuda/CUDAAllocatorConfig.h:28.)
return t.to(
AMP: checks passed
train: Scanning E:\Training_data\train\labels.cache... 4092 images, 0 backgrounds, 0 corrupt: 100%|██████████| 4092/409
val: Scanning E:\Training_data\valid\labels.cache... 365 images, 0 backgrounds, 0 corrupt: 100%|██████████| 365/365 [00
Plotting labels to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61\labels.jpg...
optimizer: SGD(lr=0.01, momentum=0.937) with parameter groups 176 weight(decay=0.0), 187 weight(decay=0.0005), 186 bias(decay=0.0)
TensorBoard: model graph visualization added
Image sizes 640 train, 640 val
Using 8 dataloader workers
Logging results to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61
Starting training for 100 epochs...

  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  1/100      19.4G      0.538      1.509      1.209      1.032         44        640: 100%|██████████| 256/256 [32:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785       0.85      0.883      0.921      0.844      0.851      0.878      0.915      0.719


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  2/100      19.1G     0.5347      1.416     0.7505      1.019         59        640: 100%|██████████| 256/256 [33:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.843      0.776      0.865      0.731      0.832      0.761      0.837      0.587


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  3/100      18.7G      0.671       1.67     0.8787      1.108         42        640: 100%|██████████| 256/256 [34:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.751      0.731      0.782      0.602      0.721      0.709      0.746      0.464


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  4/100      18.7G     0.7738      1.922     0.9838      1.181         47        640: 100%|██████████| 256/256 [34:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.707        0.7      0.745      0.566      0.681      0.676      0.706      0.439


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  5/100      18.6G     0.7817      1.898     0.9479      1.181         44        640: 100%|██████████| 256/256 [29:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785       0.81      0.763      0.834       0.67      0.804      0.753      0.813      0.556


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  6/100      18.5G     0.7479      1.814     0.9046      1.162         38        640: 100%|██████████| 256/256 [31:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.801      0.777      0.845      0.687      0.785      0.756      0.806      0.568

EarlyStopping: Training stopped early as no improvement observed in last 5 epochs. Best results observed at epoch 1, best model saved as best.pt.
To update EarlyStopping(patience=5) pass a new patience value, i.e. patience=300 or use patience=0 to disable EarlyStopping.

6 epochs completed in 3.411 hours.
Optimizer stripped from E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61\weights\last.pt, 124.8MB
Optimizer stripped from E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61\weights\best.pt, 124.8MB

Validating E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61\weights\best.pt...
Ultralytics 8.3.33 Python-3.11.8 torch-2.5.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)
YOLO11x-seg summary (fused): 491 layers, 62,004,438 parameters, 0 gradients, 318.5 GFLOPs
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
all 365 785 0.85 0.885 0.921 0.844 0.852 0.88 0.915 0.719
sofa 255 413 0.776 0.927 0.916 0.838 0.784 0.93 0.919 0.789
table 304 372 0.923 0.842 0.926 0.851 0.92 0.83 0.91 0.648
Speed: 0.6ms preprocess, 45.2ms inference, 0.0ms loss, 1.1ms postprocess per image
Results saved to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train61

3 ->
results = model.train(
data="E:\Training_data\data.yaml",
epochs = 100,
batch=8,
imgsz=640,
save=True,
patience=5,
verbose=True,
workers=8
)

New https://pypi.org/project/ultralytics/8.3.38 available Update with 'pip install -U ultralytics'
Ultralytics 8.3.33 Python-3.11.8 torch-2.5.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)
engine\trainer: task=segment, mode=train, model=yolo11x-seg.pt, data=E:\Training_data\data.yaml, epochs=100, time=None, patience=5, batch=8, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=8, project=None, name=train612, exist_ok=False, pretrained=True, optimizer=SGD, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, 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=True, 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.0005, 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=E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612

               from  n    params  module                                       arguments                     

0 -1 1 2784 ultralytics.nn.modules.conv.Conv [3, 96, 3, 2]
1 -1 1 166272 ultralytics.nn.modules.conv.Conv [96, 192, 3, 2]
2 -1 2 389760 ultralytics.nn.modules.block.C3k2 [192, 384, 2, True, 0.25]
3 -1 1 1327872 ultralytics.nn.modules.conv.Conv [384, 384, 3, 2]
4 -1 2 1553664 ultralytics.nn.modules.block.C3k2 [384, 768, 2, True, 0.25]
5 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
6 -1 2 5022720 ultralytics.nn.modules.block.C3k2 [768, 768, 2, True]
7 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
8 -1 2 5022720 ultralytics.nn.modules.block.C3k2 [768, 768, 2, True]
9 -1 1 1476864 ultralytics.nn.modules.block.SPPF [768, 768, 5]
10 -1 2 3264768 ultralytics.nn.modules.block.C2PSA [768, 768, 2]
11 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
12 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1]
13 -1 2 5612544 ultralytics.nn.modules.block.C3k2 [1536, 768, 2, True]
14 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
15 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1]
16 -1 2 1700352 ultralytics.nn.modules.block.C3k2 [1536, 384, 2, True]
17 -1 1 1327872 ultralytics.nn.modules.conv.Conv [384, 384, 3, 2]
18 [-1, 13] 1 0 ultralytics.nn.modules.conv.Concat [1]
19 -1 2 5317632 ultralytics.nn.modules.block.C3k2 [1152, 768, 2, True]
20 -1 1 5309952 ultralytics.nn.modules.conv.Conv [768, 768, 3, 2]
21 [-1, 10] 1 0 ultralytics.nn.modules.conv.Concat [1]
22 -1 2 5612544 ultralytics.nn.modules.block.C3k2 [1536, 768, 2, True]
23 [16, 19, 22] 1 8324342 ultralytics.nn.modules.head.Segment [2, 32, 384, [384, 768, 768]]
YOLO11x-seg summary: 667 layers, 62,052,566 parameters, 62,052,550 gradients, 319.7 GFLOPs

Transferred 1077/1077 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612', view at http://localhost:6006/
Freezing layer 'model.23.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks...
AMP: checks passed
train: Scanning E:\Training_data\train\labels.cache... 4092 images, 0 backgrounds, 0 corrupt: 100%|██████████| 4092/409
val: Scanning E:\Training_data\valid\labels.cache... 365 images, 0 backgrounds, 0 corrupt: 100%|██████████| 365/365 [00
Plotting labels to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612\labels.jpg...
optimizer: SGD(lr=0.01, momentum=0.937) with parameter groups 176 weight(decay=0.0), 187 weight(decay=0.0005), 186 bias(decay=0.0)
TensorBoard: model graph visualization added
Image sizes 640 train, 640 val
Using 8 dataloader workers
Logging results to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612
Starting training for 100 epochs...

  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  1/100      10.4G     0.4609      1.203     0.6548     0.9804         16        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.849      0.859      0.901      0.813      0.841      0.849      0.881        0.7


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  2/100      9.99G     0.5456      1.395     0.7495      1.036         30        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.833      0.831      0.894      0.763      0.826      0.822      0.877       0.63


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  3/100      9.97G     0.6807      1.708     0.9118      1.125         10        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.746      0.802      0.812      0.641      0.735      0.775      0.773      0.518


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  4/100        10G     0.8067       1.99      1.047      1.209         15        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.763      0.766      0.804      0.629      0.739      0.729      0.756      0.471


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  5/100      9.99G     0.7855      1.914     0.9854      1.196          7        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785      0.805      0.817      0.868      0.709      0.788      0.802      0.835       0.59


  Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
  6/100      9.97G     0.7632      1.876     0.9393      1.187         23        640: 100%|██████████| 512/512 [05:
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Mask(P          R      mAP
               all        365        785       0.76      0.829       0.86      0.711      0.756      0.819      0.842      0.598

EarlyStopping: Training stopped early as no improvement observed in last 5 epochs. Best results observed at epoch 1, best model saved as best.pt.
To update EarlyStopping(patience=5) pass a new patience value, i.e. patience=300 or use patience=0 to disable EarlyStopping.

6 epochs completed in 0.594 hours.
Optimizer stripped from E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612\weights\last.pt, 124.8MB
Optimizer stripped from E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612\weights\best.pt, 124.8MB

Validating E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612\weights\best.pt...
Ultralytics 8.3.33 Python-3.11.8 torch-2.5.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)
YOLO11x-seg summary (fused): 491 layers, 62,004,438 parameters, 0 gradients, 318.5 GFLOPs
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
WARNING Model does not support 'augment=True', reverting to single-scale prediction.
Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP
all 365 785 0.85 0.859 0.901 0.813 0.841 0.849 0.881 0.699
sofa 255 413 0.832 0.828 0.882 0.793 0.83 0.825 0.879 0.758
table 304 372 0.867 0.89 0.92 0.833 0.852 0.874 0.884 0.64
Speed: 0.5ms preprocess, 30.2ms inference, 0.0ms loss, 0.9ms postprocess per image
Results saved to E:\Image_Inpainting\ImageInpaintAPI\runs\segment\train612

I think this explanation is enough for this problem...

[glenn-jocher]

@abhishek7467 thank you for providing detailed context. The warning stating "Model does not support 'augment=True', reverting to single-scale prediction" indicates that the selected model, YOLO11x-seg.pt, does not support certain augmentation strategies. Please disable augment in your training configurations or set it to False.

Regarding training halting after six epochs, this is due to Early Stopping being triggered (patience=5), as validation metrics did not improve for five epochs. To train for more epochs, increase patience or disable Early Stopping by setting patience=0.

For the dataset formats, ensure both YOLOv9 and YOLOv11 data follow the correct directory and label structure as specified in the documentation. Any deviation in format may lead to unexpected results.

[abhishek7467]

@glenn-jocher Thanks for your response.

[glenn-jocher]

Thank you for the detailed input. Based on the log provided and the warnings, the issue is likely related to the model's augmentation support. YOLO11x-seg does not support augment=True for segmentation tasks, which causes it to revert to single-scale predictions. Please disable or set augment=False in your training configuration. For further assistance with augmentation or training strategies, you can refer to the documentation.