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,mAP@0.5 and mAP@0.5:0.95) and mask(P,R,mAP@0.5 and mAP@0.5: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. 🚀

[scpoppin1207]

How to load all the parameters from "args.yaml" into the brackets of model.train()?

[pderrenger]

@scpoppin1207 hi there!

To load all the parameters from args.yaml into the model.train() method, you can use Python's built-in yaml library to read the YAML file and then pass the parameters as keyword arguments. Here's a concise example to illustrate this:

import yaml
from ultralytics import YOLO

# Load the parameters from args.yaml
with open('args.yaml', 'r') as file:
    args = yaml.safe_load(file)

# Load your model
model = YOLO('yolov8n.pt')  # or any other model you are using

# Train the model using the loaded parameters
results = model.train(**args)

This approach ensures that all parameters defined in your args.yaml file are correctly passed to the model.train() method.

If you encounter any issues or have further questions, please ensure you are using the latest version of the Ultralytics package. If the problem persists, providing a minimum reproducible example can greatly help in diagnosing the issue. You can find more information on creating a reproducible example here.

Happy training! 🚀

[jeongui31]

When the .train function is called, only class, images, installations, and Box(P, R, mAP50, mAP50-95) results by validation can be checked. How can I write the code to check the class, images, installations, and box(P, R, mAP50, mAP50-95) results by training?

Also, I would like to ask if it is correct to use the .val function even when I want to check the performance by the test dataset.
Thank you.

[glenn-jocher]

@jeongui31 hello!

Thank you for your questions. Let's address them one by one:

1. Checking Training Metrics:
   To monitor training metrics such as class, images, installations, and box (P, R, mAP50, mAP50-95) during training, you can utilize the results object returned by the .train function. This object contains detailed information about the training process. Here's an example of how you can access these metrics:

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov8n.pt")
   
   # Train the model
   results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
   
   # Access training metrics
   print("Training Metrics:")
   print(f"Precision: {results.metrics['precision']}")
   print(f"Recall: {results.metrics['recall']}")
   print(f"mAP50: {results.metrics['map50']}")
   print(f"mAP50-95: {results.metrics['map']}")

2. Using .val for Test Dataset:
   Yes, it is correct to use the .val function to evaluate your model's performance on a test dataset. The .val function is designed to validate the model on a specified dataset, which can be your test dataset. Here’s how you can do it:

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov8n.pt")
   
   # Validate the model on the test dataset
   results = model.val(data="path/to/test_dataset.yaml")
   
   # Access validation metrics
   print("Validation Metrics:")
   print(f"Precision: {results.metrics['precision']}")
   print(f"Recall: {results.metrics['recall']}")
   print(f"mAP50: {results.metrics['map50']}")
   print(f"mAP50-95: {results.metrics['map']}")

For more detailed information on training and validation, you can refer to the Ultralytics YOLO Training Documentation.

If you encounter any issues or need further assistance, please ensure you are using the latest version of the packages and provide a minimum reproducible example as outlined here. This helps us diagnose and resolve issues more effectively.

Happy training! 🚀

[jeongui31]

Thank you so much for your answer.
Does train_batch0.jpg, or val_batch0_labels.jpg, which is automatically stored in the runs/detect/train folder when the .train function is called, represent images per batch of the learning process?

I questioned that several images in the train_batch0.jpg picture are reversed, resolution adjusted, cropped, etc. unlike the actual image, even though the hyperparameter "augment" of .train is "False".

[glenn-jocher]

Hello @jeongui31,

Thank you for your detailed question!

Understanding train_batch0.jpg and val_batch0_labels.jpg

Yes, the images like train_batch0.jpg and val_batch0_labels.jpg stored in the runs/detect/train folder represent batches of images during the training and validation processes. These images are visualizations that help you understand how the model is seeing and processing the data.

Data Augmentation in Training

Regarding your observation about images being flipped, resized, or cropped even when the augment hyperparameter is set to False, it's important to note that some basic augmentations might still be applied by default to enhance the robustness of the model. These augmentations can include resizing, flipping, and cropping, which are standard practices in training deep learning models to improve generalization.

If you want to ensure that no augmentations are applied, you might need to explicitly set other augmentation-related parameters to False or 0. Here is an example of how you can disable these augmentations:

from ultralytics import YOLO

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

# Train the model with augmentations disabled
results = model.train(
    data="coco8.yaml",
    epochs=100,
    imgsz=640,
    augment=False,  # Disable general augmentations
    flipud=0.0,     # Disable vertical flip
    fliplr=0.0,     # Disable horizontal flip
    mosaic=0.0,     # Disable mosaic augmentation
    mixup=0.0       # Disable mixup augmentation
)

Using .val for Test Dataset

Yes, you can use the .val function to evaluate your model's performance on a test dataset. The .val function is designed to validate the model on any specified dataset, including your test dataset. Here’s how you can do it:

from ultralytics import YOLO

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

# Validate the model on the test dataset
results = model.val(data="path/to/test_dataset.yaml")

# Access validation metrics
print("Validation Metrics:")
print(f"Precision: {results.metrics['precision']}")
print(f"Recall: {results.metrics['recall']}")
print(f"mAP50: {results.metrics['map50']}")
print(f"mAP50-95: {results.metrics['map']}")

For more detailed information on training and validation, you can refer to the Ultralytics YOLO Training Documentation.

If you encounter any issues or need further assistance, please ensure you are using the latest version of the packages and provide a minimum reproducible example as outlined here. This helps us diagnose and resolve issues more effectively.

Happy training! 🚀

[NoviceAlchemist]

Hello, I have some questions to ask, the first is how to solve the automatic download yolov8n.pt this weight file, I create a new project every time will automatically download a yolov8n.pt. Second is that I trained the model want to convert to support RKNN ONNX model, the official code can not be converted to success, the follow-up in the git to find your company released the old version of the modified files Can support the conversion, because of the version problem project can only use the new version of the integrated file, so please ask if you have the latest version on your side.

[glenn-jocher]

@hpz98 hello,

Thank you for reaching out with your questions!

1. Automatic Download of yolov8n.pt:
   To prevent the automatic download of the yolov8n.pt weight file when creating a new project, you can specify a different model path or use a local model file. For instance, if you have a custom-trained model, you can load it directly to avoid downloading the default weights. Here’s an example:

   from ultralytics import YOLO
   
   # Load your custom model
   model = YOLO("path/to/your/custom_model.pt")

   Alternatively, if you want to start training from scratch without any pre-trained weights, you can specify a custom YAML configuration:

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

2. Converting to RKNN ONNX Model:
   For converting your trained model to an ONNX format that supports RKNN, ensure you are using the latest version of the Ultralytics YOLO package. If you encounter issues with the conversion, it might be due to specific version dependencies. Here’s a basic example of exporting to ONNX:

   from ultralytics import YOLO
   
   # Load your trained model
   model = YOLO("path/to/your/custom_model.pt")
   
   # Export to ONNX
   model.export(format="onnx")

   If you still face issues, please provide a minimum reproducible example of the error you encounter. This will help us diagnose the problem more effectively. You can find guidance on creating a reproducible example here: Minimum Reproducible Example.

Additionally, please ensure you are using the latest versions of the Ultralytics YOLO package and any related dependencies to avoid compatibility issues.

For more detailed guidance on training and exporting models, you can refer to our comprehensive documentation: Model Training with Ultralytics YOLO.

Feel free to reach out if you have any further questions or need additional assistance!

[SanketPotdar02]

I am trying to finetune yolov8 model for object detection class on parking lot images and security surveillance images specifically to detect persons and vehicles. During training process, there is a spike in all the losses for training during first 3 epochs after which it continuously decreases and follows ideal behavior. The initial spike in loss affects the model which makes our finetuned model perform slightly poor on f1-score metric as compared to original pre-trained yolov8 model, when trained for 50 epochs. Is there any explanation as to why does the spike occurs initially and how we can fix it to make our finetuned model perform better than the pre-trained model?

[Asshok1]

@SanketPotdar02 Basically the default parameters YOLO model works better in most cases, But if you want to fine tune based on your requirements try with different parameters majorly impact parameters are epochs, batch, learning rate, optimizer, momentum etc . Based on you data analyze the parameters how it will impact the results and use those ones to get better results that default model

[DurantLee]

if I run this code on my model 'best.pt' which has been trained for 20 epochs:

from ultralytics import YOLO
model = YOLO("models/best.pt")  
results = model.train(resume=True, data="coco128.yaml", epochs=50, imgsz=640, device="cpu", project="train", \
                      name="initial", exist_ok=True, optimizer="Adam", batch=4) 

the system will throw an error containing

“AssertionError: models\best.pt training to 20 epochs is finished, nothing to resume.
Start a new training without resuming, i.e. 'yolo train model=models\best.pt'”

Is there anyone who has encountered this situation and solved it???

[glenn-jocher]

@DurantLee hi there!

Thank you for reaching out with your issue. The error you're encountering indicates that the model has already completed training for the specified number of epochs (20 in your case), and thus, there's nothing left to resume.

To address this, you have a couple of options:

1. Start a New Training Session: If you want to continue training beyond the initial 20 epochs, you should start a new training session without the resume=True argument. This will allow you to extend the training from the current state of your model.

   from ultralytics import YOLO
   
   # Load the model
   model = YOLO("models/best.pt")
   
   # Continue training for an additional 30 epochs (total 50 epochs)
   results = model.train(data="coco128.yaml", epochs=30, imgsz=640, device="cpu", project="train", \
                         name="initial", exist_ok=True, optimizer="Adam", batch=4)

2. Verify Latest Versions: Ensure you are using the latest version of the Ultralytics package. Sometimes, updates include bug fixes and improvements that might resolve your issue. You can update the package using:

   pip install --upgrade ultralytics

3. Provide a Reproducible Example: If the issue persists, it would be very helpful to have a minimum reproducible example to diagnose the problem accurately. You can refer to our guide on creating a reproducible example here.

By following these steps, you should be able to continue training your model effectively. If you encounter any further issues, feel free to share more details, and we'll be happy to assist you further.

[DurantLee]

Thanks for your generous reply!
BTW, for the method 1 you've provided above, do you mean that my model will proceed to train for 30 epochs on top of the initial 20 epochs so the total epoch num is 50???

[glenn-jocher]

Hi @DurantLee,

Thank you for your follow-up! Yes, you are correct. By starting a new training session without the resume=True argument, your model will continue training for an additional 30 epochs on top of the initial 20 epochs, resulting in a total of 50 epochs.

Here’s a quick example to illustrate this:

from ultralytics import YOLO

# Load the model
model = YOLO("models/best.pt")

# Continue training for an additional 30 epochs (total 50 epochs)
results = model.train(data="coco128.yaml", epochs=30, imgsz=640, device="cpu", project="train", \
                      name="initial", exist_ok=True, optimizer="Adam", batch=4)

This approach ensures that your model will build upon the weights and learning from the first 20 epochs and continue to improve over the next 30 epochs.

If you encounter any further issues or have additional questions, feel free to ask. Happy training! 🚀

[MasoudDevelope]

Hello.
I have an issue with my image detection project.
I have annotated 90 images using CVAT.ai
There are 4807 instances / labels.
My model does not detect anything even on the training data set.
I have checked my annotations and I am sure the annotation is correct.
I have used augmentation but still get the same result.

could you please let me know what should I do? It's being frustrating :)
I can share the photos and their labels as well.

here is my code :

#path : YOLO Image Src
path : C:\Users\masou\Downloads\June29\

train : Images\Train

val : Images\Train


#CLASSES

names:

  0: Allo Disp
  1: FB Disp
  2: Vise Disp
  3: Stelth Disp
  4: Level_X Closed Pod
  5: Stelth Closed Pod
  6: Kraze Disp
  7: Geek_Bar Disp
  8: OX_Bar Disp
  9: Drip'n Disp
  10: MR Fog Disp
  11: Ripper Closed Pod
  12: Vuse Disp
  13: Flip
  14: Ripper Disp
  15: Vuse 2ml Pods
  16: FB E-Liq
  17: Allo E-Liq
  18: Stelth 2ml Pod
  19: Elfbar Disp
  20: Lost Mary Disp
  21: FB 2ml Pod
  22: Allo Sync Pod
  23: Vise CP

 #augmentation 

hsv_h : .5
hsv_s : .7
hsv_v : .8
degrees : 120
translate : .5
scale : .2
shear : .35
flipud : .3
fliplr : .5
bgr: .5
mixup : 1
crop_fraction : .5 
copy_paste : 0.5
agnostic_nms : False
cos_lr : True
augment: True

verbose: True
save_crop : True
save_conf : True
save_txt : True
save : True
show : True
exist_ok : True

and here is my training code:

model_HQ3 = YOLO("yolov8n.pt")
results = model_HQ3.train(data = "config.yaml", epochs = 10)

here is the result I got:

New https://pypi.org/project/ultralytics/8.2.48 available  Update with 'pip install -U ultralytics'
Ultralytics YOLOv8.2.38  Python-3.12.3 torch-2.3.1+cpu CPU (13th Gen Intel Core(TM) i7-1355U)
engine\trainer: task=detect, mode=train, model=yolov8n.pt, data=config.yaml, epochs=10, time=None, patience=100, batch=16, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=0, project=None, name=train272, exist_ok=False, pretrained=True, optimizer=auto, 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=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, 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.0, 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, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs\detect\train272

                   from  n    params  module                                       arguments                     
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]                 
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]                
  2                  -1  1      7360  ultralytics.nn.modules.block.C2f             [32, 32, 1, True]             
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                
  4                  -1  2     49664  ultralytics.nn.modules.block.C2f             [64, 64, 2, True]             
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  6                  -1  2    197632  ultralytics.nn.modules.block.C2f             [128, 128, 2, True]           
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  8                  -1  1    460288  ultralytics.nn.modules.block.C2f             [256, 256, 1, True]           
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]                 
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 12                  -1  1    148224  ultralytics.nn.modules.block.C2f             [384, 128, 1]                 
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 15                  -1  1     37248  ultralytics.nn.modules.block.C2f             [192, 64, 1]                  
 16                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
 17            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 18                  -1  1    123648  ultralytics.nn.modules.block.C2f             [192, 128, 1]                 
 19                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
...
Model summary: 225 layers, 3015528 parameters, 3015512 gradients, 8.2 GFLOPs

Transferred 355/355 items from pretrained weights
Freezing layer 'model.22.dfl.conv.weight'
Output is truncated. View as a [scrollable element](command:cellOutput.enableScrolling?c85ee9ed-32c2-4cff-87ab-8ee6ae9e89b6) or open in a [text editor](command:workbench.action.openLargeOutput?c85ee9ed-32c2-4cff-87ab-8ee6ae9e89b6). Adjust cell output [settings](command:workbench.action.openSettings?%5B%22%40tag%3AnotebookOutputLayout%22%5D)...
train: Scanning [C:\Users\masou\Downloads\June29\Images\Train.cache...](file:///C:/Users/masou/Downloads/June29/Images/Train.cache...) 90 images, 17 backgrounds, 0 corrupt: 100%|██████████| 90/90 [00:00<?, ?it/s]
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))

val: Scanning [C:\Users\masou\Downloads\June29\Images\Train.cache...](file:///C:/Users/masou/Downloads/June29/Images/Train.cache...) 90 images, 17 backgrounds, 0 corrupt: 100%|██████████| 90/90 [00:00<?, ?it/s]
Plotting labels to runs\detect\train272\labels.jpg... 

optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... 
optimizer: AdamW(lr=0.000357, momentum=0.9) with parameter groups 57 weight(decay=0.0), 64 weight(decay=0.0005), 63 bias(decay=0.0)
Image sizes 640 train, 640 val
Using 0 dataloader workers
Logging results to runs\detect\train272
Starting training for 10 epochs...
Closing dataloader mosaic
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       1/10         0G      3.097       5.29      1.498        506        640: 100%|██████████| 6/6 [02:17<00:00, 22.86s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:18<00:00, 26.22s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       2/10         0G      2.925      5.224       1.44        529        640: 100%|██████████| 6/6 [01:15<00:00, 12.51s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:21<00:00, 27.09s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       3/10         0G      2.812      5.165      1.342        440        640: 100%|██████████| 6/6 [01:18<00:00, 13.06s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:48<00:00, 36.26s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       4/10         0G      2.758      5.103      1.249        570        640: 100%|██████████| 6/6 [02:48<00:00, 28.05s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:42<00:00, 14.22s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       5/10         0G      2.723      5.078      1.232        418        640: 100%|██████████| 6/6 [01:04<00:00, 10.75s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:02<00:00, 20.93s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       6/10         0G      2.595      4.946      1.207        755        640: 100%|██████████| 6/6 [01:27<00:00, 14.58s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:07<00:00, 22.65s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       7/10         0G       2.55      4.911      1.211        354        640: 100%|██████████| 6/6 [01:14<00:00, 12.49s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:55<00:00, 18.35s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       8/10         0G      2.518       4.88      1.173        471        640: 100%|██████████| 6/6 [03:00<00:00, 30.12s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:16<00:00, 25.47s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       9/10         0G      2.462      4.796      1.161        587        640: 100%|██████████| 6/6 [03:09<00:00, 31.64s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:40<00:00, 13.56s/it]
                   all         90       4807          0          0          0          0


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      10/10         0G       2.47      4.742       1.15        315        640: 100%|██████████| 6/6 [01:29<00:00, 14.85s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:42<00:00, 14.04s/it]
                   all         90       4807    0.00192   0.000237   0.000966   0.000291


10 epochs completed in 0.502 hours.
Optimizer stripped from runs\detect\train272\weights\last.pt, 6.2MB
Optimizer stripped from runs\detect\train272\weights\best.pt, 6.2MB

Validating runs\detect\train272\weights\best.pt...
Ultralytics YOLOv8.2.38  Python-3.12.3 torch-2.3.1+cpu CPU (13th Gen Intel Core(TM) i7-1355U)
Model summary (fused): 168 layers, 3010328 parameters, 0 gradients, 8.1 GFLOPs
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:23<00:00,  7.88s/it]
                   all         90       4807    0.00195   0.000237    0.00098   0.000295
             Allo Disp         26        723          0          0          0          0
               FB Disp         27        575     0.0429    0.00522     0.0216     0.0065
             Vise Disp         35        460          0          0          0          0
           Stelth Disp         19        286          0          0          0          0
    Level_X Closed Pod         19        506          0          0          0          0
     Stelth Closed Pod          9         74          0          0          0          0
            Kraze Disp         14         92          0          0          0          0
         Geek_Bar Disp         14         82          0          0          0          0
           OX_Bar Disp         12        205          0          0          0          0
           Drip'n Disp         20        265          0          0          0          0
           MR Fog Disp         14        290          0          0          0          0
     Ripper Closed Pod          3         35          0          0          0          0
             Vuse Disp          7        150          0          0          0          0
                  Flip         16        168          0          0          0          0
           Ripper Disp          9         61          0          0          0          0
         Vuse 2ml Pods          6         53          0          0          0          0
        Stelth 2ml Pod         16        181          0          0          0          0
           Elfbar Disp         17        156          0          0          0          0
        Lost Mary Disp         18        123          0          0          0          0
            FB 2ml Pod         14        190          0          0          0          0
         Allo Sync Pod          5         81          0          0          0          0
               Vise CP          7         51          0          0          0          0
Speed: 3.3ms preprocess, 171.8ms inference, 0.0ms loss, 0.4ms postprocess per image
Results saved to runs\detect\train272

Even training the model with more epochs (35 out of 100 ) is not acceptable:

New https://pypi.org/project/ultralytics/8.2.48 available  Update with 'pip install -U ultralytics'
Ultralytics YOLOv8.2.38  Python-3.12.3 torch-2.3.1+cpu CPU (13th Gen Intel Core(TM) i7-1355U)
engine\trainer: task=detect, mode=train, model=yolov8n.pt, data=config.yaml, epochs=100, time=None, patience=100, batch=16, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=0, project=None, name=train2722, exist_ok=False, pretrained=True, optimizer=auto, 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=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, 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.0, 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=0.0, mixup=0.0, copy_paste=0.0, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs\detect\train2722

                   from  n    params  module                                       arguments                     
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]                 
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]                
  2                  -1  1      7360  ultralytics.nn.modules.block.C2f             [32, 32, 1, True]             
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                
  4                  -1  2     49664  ultralytics.nn.modules.block.C2f             [64, 64, 2, True]             
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  6                  -1  2    197632  ultralytics.nn.modules.block.C2f             [128, 128, 2, True]           
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  8                  -1  1    460288  ultralytics.nn.modules.block.C2f             [256, 256, 1, True]           
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]                 
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 12                  -1  1    148224  ultralytics.nn.modules.block.C2f             [384, 128, 1]                 
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 15                  -1  1     37248  ultralytics.nn.modules.block.C2f             [192, 64, 1]                  
 16                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
 17            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 18                  -1  1    123648  ultralytics.nn.modules.block.C2f             [192, 128, 1]                 
 19                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
...
Model summary: 225 layers, 3015528 parameters, 3015512 gradients, 8.2 GFLOPs

Transferred 355/355 items from pretrained weights
Freezing layer 'model.22.dfl.conv.weight'
Output is truncated. View as a [scrollable element](command:cellOutput.enableScrolling?d0e3d801-416e-464e-8c4d-a9698809e81e) or open in a [text editor](command:workbench.action.openLargeOutput?d0e3d801-416e-464e-8c4d-a9698809e81e). Adjust cell output [settings](command:workbench.action.openSettings?%5B%22%40tag%3AnotebookOutputLayout%22%5D)...
train: Scanning [C:\Users\masou\Downloads\June29\Images\Train.cache...](file:///C:/Users/masou/Downloads/June29/Images/Train.cache...) 90 images, 17 backgrounds, 0 corrupt: 100%|██████████| 90/90 [00:00<?, ?it/s]
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))

val: Scanning [C:\Users\masou\Downloads\June29\Images\Train.cache...](file:///C:/Users/masou/Downloads/June29/Images/Train.cache...) 90 images, 17 backgrounds, 0 corrupt: 100%|██████████| 90/90 [00:00<?, ?it/s]
Plotting labels to runs\detect\train2722\labels.jpg... 

optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... 
optimizer: AdamW(lr=0.000357, momentum=0.9) with parameter groups 57 weight(decay=0.0), 64 weight(decay=0.0005), 63 bias(decay=0.0)
Image sizes 640 train, 640 val
Using 0 dataloader workers
Logging results to runs\detect\train2722
Starting training for 100 epochs...

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      1/100         0G      2.466      4.725      1.136        562        640: 100%|██████████| 6/6 [01:10<00:00, 11.76s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:40<00:00, 13.57s/it]
                   all         90       4807     0.0132    0.00524    0.00687    0.00248


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      2/100         0G      2.566      4.706      1.137        488        640: 100%|██████████| 6/6 [01:05<00:00, 10.95s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:40<00:00, 13.62s/it]
                   all         90       4807      0.025     0.0262     0.0143     0.0073


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      3/100         0G      2.516      4.608      1.126        719        640: 100%|██████████| 6/6 [01:09<00:00, 11.61s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:07<00:00, 22.38s/it]
                   all         90       4807     0.0122     0.0473    0.00928    0.00397


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      4/100         0G      2.421       4.59      1.118        210        640: 100%|██████████| 6/6 [03:30<00:00, 35.00s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:09<00:00, 43.33s/it]
                   all         90       4807    0.00862     0.0564    0.00819    0.00368


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      5/100         0G      2.373      4.475      1.091        571        640: 100%|██████████| 6/6 [02:06<00:00, 21.07s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:50<00:00, 36.96s/it]
                   all         90       4807    0.00937     0.0734     0.0097    0.00461


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      6/100         0G      2.391      4.464      1.138        431        640: 100%|██████████| 6/6 [03:11<00:00, 31.92s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:06<00:00, 42.25s/it]
                   all         90       4807      0.011     0.0858     0.0118    0.00584


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      7/100         0G      2.325      4.397      1.097        668        640: 100%|██████████| 6/6 [02:57<00:00, 29.59s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:40<00:00, 13.62s/it]
                   all         90       4807     0.0125     0.0979     0.0139    0.00681


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      8/100         0G      2.435       4.18      1.074        726        640: 100%|██████████| 6/6 [01:05<00:00, 10.96s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:42<00:00, 14.07s/it]
                   all         90       4807     0.0143      0.112     0.0144    0.00634


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
      9/100         0G      2.274      4.157      1.063        338        640: 100%|██████████| 6/6 [01:08<00:00, 11.46s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:43<00:00, 14.43s/it]
                   all         90       4807      0.392     0.0776     0.0167    0.00743


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     10/100         0G      2.268       4.07      1.075        600        640: 100%|██████████| 6/6 [01:09<00:00, 11.54s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:45<00:00, 15.21s/it]
                   all         90       4807      0.357     0.0636     0.0206    0.00936


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     11/100         0G      2.247      3.939      1.066        659        640: 100%|██████████| 6/6 [01:08<00:00, 11.39s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:42<00:00, 14.28s/it]
                   all         90       4807      0.358     0.0762     0.0246     0.0112


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     12/100         0G      2.339      3.961      1.063        575        640: 100%|██████████| 6/6 [02:24<00:00, 24.14s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:08<00:00, 42.84s/it]
                   all         90       4807     0.0402      0.154     0.0335      0.016


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     13/100         0G      2.339       3.84      1.058        569        640: 100%|██████████| 6/6 [02:43<00:00, 27.26s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:18<00:00, 26.23s/it]
                   all         90       4807     0.0472      0.155     0.0377       0.02


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     14/100         0G       2.31      3.799      1.074        421        640: 100%|██████████| 6/6 [02:28<00:00, 24.78s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:06<00:00, 42.28s/it]
                   all         90       4807     0.0537      0.162     0.0441     0.0219


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     15/100         0G      2.293      3.617      1.093        435        640: 100%|██████████| 6/6 [01:56<00:00, 19.37s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:55<00:00, 18.43s/it]
                   all         90       4807     0.0474      0.169     0.0442     0.0216


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     16/100         0G      2.311      3.569      1.071        452        640: 100%|██████████| 6/6 [03:24<00:00, 34.07s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:03<00:00, 41.04s/it]
                   all         90       4807      0.291      0.119     0.0462     0.0224


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     17/100         0G      2.397      3.487      1.033        619        640: 100%|██████████| 6/6 [03:27<00:00, 34.60s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:06<00:00, 42.27s/it]
                   all         90       4807      0.358      0.102     0.0506     0.0239


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     18/100         0G      2.263      3.457      1.055        447        640: 100%|██████████| 6/6 [03:02<00:00, 30.39s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:51<00:00, 37.06s/it]
                   all         90       4807      0.384      0.104     0.0672     0.0304


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     19/100         0G       2.24      3.341      1.038        439        640: 100%|██████████| 6/6 [02:42<00:00, 27.17s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [01:46<00:00, 35.57s/it]
                   all         90       4807      0.377       0.11     0.0733     0.0322


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     20/100         0G      2.196      3.305      1.052        408        640: 100%|██████████| 6/6 [03:16<00:00, 32.71s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:12<00:00, 44.12s/it]
                   all         90       4807      0.283      0.127     0.0795     0.0357


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     21/100         0G       2.19      3.208      1.037        369        640: 100%|██████████| 6/6 [03:32<00:00, 35.45s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:10<00:00, 43.37s/it]
                   all         90       4807      0.266       0.15     0.0845     0.0393


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     22/100         0G      2.182      3.141      1.052        679        640: 100%|██████████| 6/6 [03:26<00:00, 34.48s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:12<00:00, 44.02s/it]
                   all         90       4807      0.199      0.175      0.099     0.0466


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     23/100         0G      2.215      3.075      1.031        441        640: 100%|██████████| 6/6 [02:52<00:00, 28.74s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [02:08<00:00, 42.89s/it]
                   all         90       4807      0.205      0.168      0.103     0.0478


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     24/100         0G      2.208      3.104      1.038        936        640: 100%|██████████| 6/6 [01:07<00:00, 11.20s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:47<00:00, 15.72s/it]
                   all         90       4807      0.215      0.186      0.108     0.0497


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     25/100         0G       2.28      3.021      1.033        379        640: 100%|██████████| 6/6 [01:07<00:00, 11.24s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:47<00:00, 15.79s/it]
                   all         90       4807      0.126      0.193      0.106     0.0492


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     26/100         0G      2.165      2.857      1.021        431        640: 100%|██████████| 6/6 [01:09<00:00, 11.61s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:45<00:00, 15.20s/it]
                   all         90       4807      0.294      0.167       0.11     0.0516


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     27/100         0G      2.182      2.874      1.043        555        640: 100%|██████████| 6/6 [01:08<00:00, 11.48s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:47<00:00, 15.91s/it]
                   all         90       4807      0.307      0.166       0.12     0.0571


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     28/100         0G      2.203       2.83      1.042        833        640: 100%|██████████| 6/6 [01:09<00:00, 11.65s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:46<00:00, 15.33s/it]
                   all         90       4807      0.271       0.19      0.132     0.0624


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     29/100         0G      2.166      2.844      1.052        597        640: 100%|██████████| 6/6 [01:09<00:00, 11.61s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:47<00:00, 15.82s/it]
                   all         90       4807      0.285      0.171      0.132      0.065


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     30/100         0G      2.111      2.816      1.038        402        640: 100%|██████████| 6/6 [01:06<00:00, 11.12s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:45<00:00, 15.29s/it]
                   all         90       4807      0.268      0.203      0.134      0.067


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     31/100         0G      2.058      2.652       1.03        769        640: 100%|██████████| 6/6 [01:09<00:00, 11.55s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:45<00:00, 15.25s/it]
                   all         90       4807      0.218      0.211       0.14     0.0699


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     32/100         0G        2.1      2.654      1.047        537        640: 100%|██████████| 6/6 [01:13<00:00, 12.19s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:46<00:00, 15.63s/it]
                   all         90       4807      0.265      0.215      0.156     0.0737


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     33/100         0G      2.195      2.637       1.06        639        640: 100%|██████████| 6/6 [01:06<00:00, 11.01s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:45<00:00, 15.18s/it]
                   all         90       4807      0.271      0.216       0.16     0.0761


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     34/100         0G      2.174      2.547      1.031        661        640: 100%|██████████| 6/6 [01:06<00:00, 11.10s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 3/3 [00:44<00:00, 14.87s/it]
                   all         90       4807      0.283      0.213       0.16     0.0775


      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     35/100         0G       2.08      2.582      1.011        684        640: 100%|██████████| 6/6 [01:07<00:00, 11.32s/it]
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95):  67%|██████▋   | 2/3 [00:33<00:16, 16.24s/it]
     ```

[pderrenger]

Hello,

Thank you for providing detailed information about your issue. I understand how frustrating it can be when your model doesn't perform as expected, especially after putting in significant effort to annotate your dataset. Let's work through this together.

Key Points to Check:

1. Annotation Verification:

   • Ensure that your annotations are in the correct format expected by YOLOv8. You can use tools like labelImg or Roboflow to visualize and verify your annotations.

2. Training Configuration:

   • Your configuration seems comprehensive, but let's ensure the settings are optimal. For instance, your augmentation settings are quite aggressive. Consider reducing the values for degrees, translate, scale, and shear to see if the model performs better with less augmentation.

3. Learning Rate and Epochs:

   • Sometimes, a learning rate that is too high or too low can cause the model not to learn effectively. You might want to experiment with different learning rates. Also, increasing the number of epochs beyond 10 might help the model learn better.

4. Class Imbalance:

   • Check if there is a significant class imbalance in your dataset. If certain classes are underrepresented, the model might struggle to learn them. You can address this by augmenting the underrepresented classes or using techniques like class weighting.

Steps to Troubleshoot:

1. Verify Annotations:

   • Ensure that your annotations are correctly formatted and that the bounding boxes are accurate. You can visualize your annotations using a tool like labelImg or a custom script.

2. Simplify Augmentation:

   • Try reducing the augmentation parameters to see if the model performs better. For example:

     hsv_h: 0.1
     hsv_s: 0.5
     hsv_v: 0.5
     degrees: 10
     translate: 0.1
     scale: 0.1
     shear: 0.1

3. Adjust Learning Rate:

   • Experiment with different learning rates. For instance:

     results = model_HQ3.train(data="config.yaml", epochs=50, lr0=0.001)

4. Check for Class Imbalance:

   • Ensure that your dataset is balanced. If not, consider augmenting the underrepresented classes.

5. Use Pretrained Weights:

   • Ensure you are using pretrained weights to start training. This can significantly improve performance, especially with smaller datasets.

Example Code Adjustments:

Here’s a simplified version of your training code with adjusted parameters:

from ultralytics import YOLO

# Load a pretrained model
model_HQ3 = YOLO("yolov8n.pt")

# Train the model with adjusted parameters
results = model_HQ3.train(
    data="config.yaml",
    epochs=50,
    lr0=0.001,
    batch=8,
    imgsz=640,
    augment=True
)

Additional Resources:

• Minimum Reproducible Example: If the issue persists, please provide a minimum reproducible example. This will help us diagnose the problem more effectively. You can find more information on how to create one here.
• Latest Version: Ensure you are using the latest version of the Ultralytics package. You can update it using:

  pip install -U ultralytics

Feel free to share any additional details or results after trying these suggestions. The community and the Ultralytics team are here to help! 😊

[MasoudDevelope]

Thanks a lot!
I ran the same model for more epochs and got this after around 250 epochs (in total):
FYI : Train and Val data sets are the same.

Now I have two questions:

1. how can I get the annotated images as the result of prediction?
2. how can I improve the model to:

• detect all brands (I think it is recall)
• detect brands more accurately (precision)

[pderrenger]

Hi there!

Great to hear that you've made progress with your model training! Let's address your questions:

1. Annotated Images as Prediction Results:
   To save the annotated images (predictions) from your model, you can use the save argument in the predict method. Here's an example:

   from ultralytics import YOLO
   
   # Load your trained model
   model = YOLO("path/to/your/trained_model.pt")
   
   # Run predictions and save annotated images
   results = model.predict(source="path/to/your/images", save=True)

   This will save the annotated images in the runs/predict directory by default.

2. Improving Model Performance:
   To enhance both recall (detecting all brands) and precision (detecting brands more accurately), consider the following strategies:

   • Data Augmentation: Ensure your augmentation settings are balanced. Overly aggressive augmentations can sometimes hinder model performance. You might want to reduce the augmentation parameters slightly.

   • Hyperparameter Tuning: Experiment with different learning rates, batch sizes, and optimizers. Sometimes, a different combination can yield better results.

     results = model.train(data="config.yaml", epochs=100, lr0=0.001, batch=16, optimizer='AdamW')

   • Class Balance: Check for class imbalance in your dataset. If certain classes are underrepresented, consider augmenting those classes or using class weights to balance the training.

   • Validation Split: Ensure your validation set is representative of the training set. Using the same data for training and validation might not give a true picture of the model's performance. Consider splitting your dataset into separate training and validation sets.

   • Longer Training: Sometimes, training for more epochs can help the model learn better. However, monitor for overfitting by checking the validation metrics.

   • Advanced Techniques: Consider using techniques like learning rate scheduling, early stopping, and model ensembling to improve performance.

Feel free to try these suggestions and let us know how it goes. If you encounter any further issues, providing a minimum reproducible example can help us diagnose the problem more effectively. You can find more information on creating one here.

Keep up the great work! 😊

[Yogurt2019]

What's the preprocess of YOLOv8 while training and inferencing? Such as the mean and std value of image. And how to set them?

[glenn-jocher]

@Yogurt2019 hello!

Great question! In YOLOv8, preprocessing steps for both training and inference are crucial for ensuring consistent and accurate results. Here's a breakdown of the preprocessing steps, including how to set mean and standard deviation values:

Preprocessing Steps

1. Image Resizing: Images are resized to the target input size specified by the imgsz parameter (default is 640x640).
2. Normalization: Images are normalized by dividing pixel values by 255 to scale them to a range of [0, 1].
3. Mean and Standard Deviation: By default, YOLOv8 does not apply mean and standard deviation normalization as seen in some other models (e.g., ImageNet models). However, you can customize this if needed.

Customizing Mean and Standard Deviation

If you want to apply custom mean and standard deviation normalization, you can modify the preprocessing steps in your training or inference pipeline. Here's an example using PyTorch:

import torch
from torchvision import transforms
from ultralytics import YOLO

# Define custom mean and std
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]

# Define the transform
transform = transforms.Compose([
    transforms.Resize((640, 640)),
    transforms.ToTensor(),
    transforms.Normalize(mean=mean, std=std)
])

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

# Example image
image_path = "path/to/your/image.jpg"
image = Image.open(image_path)

# Apply the transform
image = transform(image).unsqueeze(0)  # Add batch dimension

# Run inference
results = model(image)

Training with Custom Preprocessing

To integrate custom preprocessing into the training pipeline, you can modify the dataset loading part of your training script. Here's an example:

from ultralytics import YOLO
from torchvision import transforms

# Define custom mean and std
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]

# Define the transform
transform = transforms.Compose([
    transforms.Resize((640, 640)),
    transforms.ToTensor(),
    transforms.Normalize(mean=mean, std=std)
])

# Load a model
model = YOLO("yolov8n.yaml")

# Train the model with custom preprocessing
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, transform=transform)

Additional Resources

For more detailed information on training and preprocessing, you can refer to the Ultralytics YOLO Training Documentation.

If you encounter any issues or need further assistance, please provide a reproducible example as outlined here. This will help us diagnose and resolve the issue more effectively.

Happy training! 🚀

[Yogurt2019]

The training code you provided is wrong. It gives the following error:
SyntaxError: 'transform' is not a valid YOLO argument.
There is no such argument as transform in the train() function.
Is there any other way to modify the mean and standard value while training? Thanks for your help!

[glenn-jocher]

Hello @Yogurt2019,

Thank you for pointing that out! You are correct; the transform argument is not valid for the train() function in YOLOv8. My apologies for the confusion.

To modify the mean and standard deviation values during training, you can preprocess your dataset before feeding it into the YOLOv8 training pipeline. Here’s how you can do it:

Custom Dataset Preprocessing

1. Preprocess Images: Apply the desired mean and standard deviation normalization to your dataset images.
2. Save Preprocessed Images: Save these preprocessed images to a directory.
3. Update Dataset YAML: Update your dataset YAML file to point to the directory with the preprocessed images.

Here’s an example of how you can preprocess your images using PyTorch:

import os
from PIL import Image
from torchvision import transforms

# Define custom mean and std
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]

# Define the transform
transform = transforms.Compose([
    transforms.Resize((640, 640)),
    transforms.ToTensor(),
    transforms.Normalize(mean=mean, std=std)
])

# Directory paths
input_dir = 'path/to/original/images'
output_dir = 'path/to/preprocessed/images'
os.makedirs(output_dir, exist_ok=True)

# Preprocess and save images
for img_name in os.listdir(input_dir):
    img_path = os.path.join(input_dir, img_name)
    img = Image.open(img_path).convert('RGB')
    img = transform(img)
    img = transforms.ToPILImage()(img)
    img.save(os.path.join(output_dir, img_name))

print("Preprocessing complete!")

Update Dataset YAML

After preprocessing, update your dataset YAML file to point to the new directory with the preprocessed images:

train: path/to/preprocessed/images/train
val: path/to/preprocessed/images/val

nc: 80
names: ['class1', 'class2', ...]

Training with Preprocessed Dataset

Now, you can train your model using the updated dataset:

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.yaml")  # build a new model from YAML
model = YOLO("yolov8n.pt")  # load a pretrained model (recommended for training)

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

This approach ensures that your images are preprocessed with the desired mean and standard deviation values before being used for training.

If you encounter any further issues or need additional assistance, please ensure you are using the latest version of the Ultralytics package and provide a minimum reproducible example as outlined here.

Happy training! 🚀

[syrnike5]

I would like to check the changes in the numbers box_loss, cls_loss, dfl_loss, precision, recall, mAP50, and mAP50-95 of the training, val, and test data that are different for each epoch, and finally visualize them. Therefore, I am going to run the code using the model.train() function by putting all the data of training, val, and test, and box_loss, cls_loss, and dfl_loss are recorded in the result.csv file in the model.train(), and precision, recall, mAP50, and mAP50-95 are recorded as values of the value data in the model.train(), so I don't know how to visualize each data by looking at the changes in values. Please help me.

[syrnike5]

I have one more question, and the data I'm currently using is brain tumor data with kaggle. Here, how can I solve the problems where the so-called nms where different labels hold the same umor in yolo are not working and the problems that remain as a background in the confusion matrix without holding the umor at all? I know that the nms works for the yolo internal implementation, but I don't know why not.

[glenn-jocher]

@syrnike5 hi there!

To visualize the changes in metrics like box_loss, cls_loss, dfl_loss, precision, recall, mAP50, and mAP50-95 across epochs, you can leverage the logging capabilities provided by Ultralytics YOLOv8. Here's a step-by-step guide to help you achieve this:

1. Enable Logging: Use a logging platform like TensorBoard, Comet, or ClearML to track and visualize your training metrics. These platforms provide real-time tracking and visualization of your training progress.

2. Setup TensorBoard:

   • Google Colab:

     %load_ext tensorboard
     %tensorboard --logdir ultralytics/runs

   • Local Setup:

     tensorboard --logdir ultralytics/runs

3. Train Your Model:

   • Python:

     from ultralytics import YOLO
     
     # Load a model
     model = YOLO("yolov8n.pt")  # load a pretrained model
     
     # Train the model
     results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

   • CLI:

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

4. Access Training Metrics: After training, you can access the metrics stored in the results.csv file or directly from the logging platform you set up.

5. Visualize Metrics:

   • Using Pandas and Matplotlib:

     import pandas as pd
     import matplotlib.pyplot as plt
     
     # Load the results.csv file
     df = pd.read_csv('path/to/results.csv')
     
     # Plot metrics
     plt.figure(figsize=(10, 6))
     plt.plot(df['epoch'], df['box_loss'], label='Box Loss')
     plt.plot(df['epoch'], df['cls_loss'], label='Cls Loss')
     plt.plot(df['epoch'], df['dfl_loss'], label='DFL Loss')
     plt.plot(df['epoch'], df['precision'], label='Precision')
     plt.plot(df['epoch'], df['recall'], label='Recall')
     plt.plot(df['epoch'], df['mAP50'], label='mAP50')
     plt.plot(df['epoch'], df['mAP50-95'], label='mAP50-95')
     plt.xlabel('Epoch')
     plt.ylabel('Metric Value')
     plt.legend()
     plt.title('Training Metrics Over Epochs')
     plt.show()

For more detailed guidance, you can refer to the Ultralytics YOLO Training Documentation.

If you encounter any issues or need further assistance, please ensure you are using the latest version of the Ultralytics package and provide a minimum reproducible example as outlined here.

Happy training! 🚀

[syrnike5]

Thank you very much for your response!

[glenn-jocher]

@syrnike5 hi there!

Thank you for your detailed follow-up. To address your questions:

Visualizing Training Metrics

To visualize the changes in metrics such as box_loss, cls_loss, dfl_loss, precision, recall, mAP50, and mAP50-95 across epochs, you can use TensorBoard, which is integrated with Ultralytics YOLOv8. Here’s how you can set it up:

1. Enable TensorBoard Logging:

   • Google Colab:

     %load_ext tensorboard
     %tensorboard --logdir ultralytics/runs

   • Local Setup:

     tensorboard --logdir ultralytics/runs

2. Train Your Model:

   • Python:

     from ultralytics import YOLO
     
     # Load a model
     model = YOLO("yolov8n.pt")  # load a pretrained model
     
     # Train the model
     results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

   • CLI:

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

3. Access Training Metrics: After training, you can visualize the metrics using TensorBoard by navigating to the specified log directory.

4. Visualize Metrics with Pandas and Matplotlib:

   import pandas as pd
   import matplotlib.pyplot as plt
   
   # Load the results.csv file
   df = pd.read_csv('path/to/results.csv')
   
   # Plot metrics
   plt.figure(figsize=(10, 6))
   plt.plot(df['epoch'], df['box_loss'], label='Box Loss')
   plt.plot(df['epoch'], df['cls_loss'], label='Cls Loss')
   plt.plot(df['epoch'], df['dfl_loss'], label='DFL Loss')
   plt.plot(df['epoch'], df['precision'], label='Precision')
   plt.plot(df['epoch'], df['recall'], label='Recall')
   plt.plot(df['epoch'], df['mAP50'], label='mAP50')
   plt.plot(df['epoch'], df['mAP50-95'], label='mAP50-95')
   plt.xlabel('Epoch')
   plt.ylabel('Metric Value')
   plt.legend()
   plt.title('Training Metrics Over Epochs')
   plt.show()

Handling NMS and Confusion Matrix Issues

Regarding the NMS (Non-Maximum Suppression) and confusion matrix issues with your brain tumor dataset:

1. NMS Not Working:

   • Ensure that your model is correctly configured to handle overlapping bounding boxes. NMS is implemented internally in YOLO to suppress redundant detections. If different labels are holding the same tumor, you might need to adjust the NMS threshold.
   • You can modify the NMS threshold during inference:

     results = model.predict(source='path/to/image.jpg', iou=0.5)  # Adjust the IoU threshold

2. Confusion Matrix Issues:

   • If tumors are being missed or misclassified, consider the following:
     • Data Augmentation: Enhance your training data with augmentations to improve model robustness.
     • Class Imbalance: Ensure your dataset is balanced or use techniques like oversampling/undersampling.
     • Hyperparameter Tuning: Experiment with different hyperparameters to improve model performance.

For more detailed guidance, you can refer to the Ultralytics YOLO Training Documentation.

If you encounter any issues or need further assistance, please ensure you are using the latest version of the Ultralytics package and provide a minimum reproducible example as outlined here.

Happy training! 🚀

[jack-ready]

Why is it that when I train the DIOR dataset, the validation part cannot correctly change the image to 640640, but instead changes it to 672672? However, during the training process, I supervised an epoch and it was able to correctly change the image to 640*640. Could you help me understand if it's because my parameters are not set correctly?

[glenn-jocher]

@jack-ready hi there!

Thank you for reaching out. The issue you're experiencing with the image resizing during validation could be related to the rect argument, which enables rectangular training and validation. This setting optimizes batch composition for minimal padding, which might result in image sizes that are not exactly 640x640.

To ensure that your images are resized to 640x640 during both training and validation, you can explicitly set the rect argument to False. Here’s how you can do it:

Python Example

from ultralytics import YOLO

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

# Train the model
results = model.train(data="dior.yaml", epochs=100, imgsz=640, rect=False)

CLI Example

# Start training from a pretrained *.pt model
yolo detect train data=dior.yaml model=yolov8n.pt epochs=100 imgsz=640 rect=False

Additionally, please ensure you are using the latest version of the Ultralytics YOLO package, as updates often include important bug fixes and improvements. You can update the package using:

pip install --upgrade ultralytics

If the issue persists, providing a minimum reproducible example would be very helpful for further diagnosis. You can find more information on how to create one here: Minimum Reproducible Example.

Feel free to reach out if you have any more questions or need further assistance. Happy training! 🚀

[derrick20000]

Hi, I have one question, I have a trained model that contain classes building and tree as id 0 and id 1. Now, I have prepare another dataset from roboflow that contains trunk (id 2). The yaml file initially nc:1, names: ['truck'], should I change the nc to 3 and names add first two classes? Also the script to train in colab, I write like this, does it correct?

Import YOLO from ultralytics

from ultralytics import YOLO

Load the pre-trained YOLOv8 model

model = YOLO('/content/drive/MyDrive/runs/train/weight/best.pt')

Fine-tune the model with the new dataset

results = model.train(
data='/content/drive/MyDrive/tree.v2i.yolov8/data.yaml', # Path to your updated data.yaml
epochs=2, # Number of epochs for fine-tuning
imgsz=640, # Image size
device=0, # Device to use for training (0 for GPU)
project="/content/drive/MyDrive/runs_nano/train", # Project directory for saving results
exist_ok=True # Overwrite existing project
)

[pderrenger]

@derrick20000 hi there!

Great question! Yes, you should update your data.yaml file to reflect the new classes. Since your new dataset includes an additional class (trunk), you should set nc to 3 and update the names list to include all three classes. Your data.yaml should look something like this:

nc: 3
names: ['building', 'tree', 'trunk']

Your training script in Colab looks mostly correct. Here's a slightly refined version to ensure everything is set up properly:

from ultralytics import YOLO

# Load the pre-trained YOLOv8 model
model = YOLO('/content/drive/MyDrive/runs/train/weight/best.pt')

# Fine-tune the model with the new dataset
results = model.train(
    data='/content/drive/MyDrive/tree.v2i.yolov8/data.yaml',  # Path to your updated data.yaml
    epochs=2,  # Number of epochs for fine-tuning
    imgsz=640,  # Image size
    device=0,  # Device to use for training (0 for GPU)
    project="/content/drive/MyDrive/runs_nano/train",  # Project directory for saving results
    exist_ok=True  # Overwrite existing project
)

Make sure your data.yaml file is correctly updated and located at the specified path. This setup should allow you to fine-tune your model with the new dataset effectively.

If you encounter any issues, please ensure you are using the latest version of the Ultralytics YOLO package. You can update it using:

pip install -U ultralytics

For more detailed guidance on training, you can refer to the Ultralytics YOLO Training Documentation.

Feel free to reach out if you have any more questions! 😊

[underagetaikonaut]

Halo, I'm really impressed of YOLOv8's performance and I've just get started with it recently. But I've met a problem and I wonder if you can help me with it. It came up with the erorr followed:
Traceback (most recent call last):
File "", line 1, in
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\spawn.py", line 122, in spawn_main
exitcode = _main(fd, parent_sentinel)
^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\spawn.py", line 131, in _main
prepare(preparation_data)
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\spawn.py", line 246, in prepare
_fixup_main_from_path(data['init_main_from_path'])
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\spawn.py", line 297, in _fixup_main_from_path
main_content = runpy.run_path(main_path,
^^^^^^^^^^^^^^^^^^^^^^^^^
File "", line 291, in run_path
File "", line 98, in _run_module_code
File "", line 88, in _run_code
File "D:\Tongji\YOLO\safehat.py", line 10, in
model.train(data='trainDTongjidatasetyoloconstruction.yaml',epochs=100,batch=-1)
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\ultralytics\engine\model.py", line 650, in train
self.trainer.train()
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\ultralytics\engine\trainer.py", line 204, in train
self._do_train(world_size)
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\ultralytics\engine\trainer.py", line 323, in _do_train
self._setup_train(world_size)
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\ultralytics\engine\trainer.py", line 287, in _setup_train
self.train_loader = self.get_dataloader(self.trainset, batch_size=batch_size, rank=RANK, mode="train")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\ultralytics\models\yolo\detect\train.py", line 55, in get_dataloader
return build_dataloader(dataset, batch_size, workers, shuffle, rank) # return dataloader
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\ultralytics\data\build.py", line 135, in build_dataloader
return InfiniteDataLoader(
^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\ultralytics\data\build.py", line 39, in init
self.iterator = super().iter()
^^^^^^^^^^^^^^^^^^
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\torch\utils\data\dataloader.py", line 439, in iter
return self._get_iterator()
^^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\torch\utils\data\dataloader.py", line 387, in _get_iterator
return _MultiProcessingDataLoaderIter(self)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742\AppData\Roaming\Python\Python311\site-packages\torch\utils\data\dataloader.py", line 1040, in init
w.start()
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\process.py", line 121, in start
self._popen = self._Popen(self)
^^^^^^^^^^^^^^^^^
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\context.py", line 224, in _Popen
return _default_context.get_context().Process._Popen(process_obj)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\context.py", line 336, in _Popen
return Popen(process_obj)
^^^^^^^^^^^^^^^^^^
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\popen_spawn_win32.py", line 46, in init
prep_data = spawn.get_preparation_data(process_obj._name)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\spawn.py", line 164, in get_preparation_data
_check_not_importing_main()
File "C:\Users\50742.conda\envs\trial\Lib\multiprocessing\spawn.py", line 140, in _check_not_importing_main
raise RuntimeError('''
RuntimeError:
An attempt has been made to start a new process before the
current process has finished its bootstrapping phase.

    This probably means that you are not using fork to start your
    child processes and you have forgotten to use the proper idiom
    in the main module:

        if __name__ == '__main__':
            freeze_support()
            ...

    The "freeze_support()" line can be omitted if the program
    is not going to be frozen to produce an executable.

    To fix this issue, refer to the "Safe importing of main module"
    section in https://docs.python.org/3/library/multiprocessing.html

Could you tell me how to deal with it?

[pderrenger]

Hello!

Thank you for your kind words about YOLOv8! 😊 I'm glad to hear you're enjoying it. Regarding the error you're encountering, it seems to be related to the multiprocessing module in Python, which often requires specific handling when running scripts, especially on Windows.

To resolve this issue, please ensure that your script includes the following block to safely handle the multiprocessing start method:

if __name__ == '__main__':
    from ultralytics import YOLO

    # Load a model
    model = YOLO("yolov8n.pt")  # load a pretrained model (recommended for training)

    # Train the model
    results = model.train(data='trainDTongjidatasetyoloconstruction.yaml', epochs=100, batch=-1)

This ensures that the multiprocessing module initializes correctly. Additionally, please verify that you are using the latest version of the Ultralytics package and other dependencies to ensure compatibility and bug fixes.

For more detailed guidance, you can refer to the Minimum Reproducible Example documentation. This will help us assist you better if the issue persists.

Feel free to reach out if you have any more questions or need further assistance. Happy training!

[vivekbiragoni]

Hello, following is the loss function assigned for the task of classification only...

class v8ClassificationLoss:
"""Criterion class for computing training losses."""

 def __call__(self, preds, batch):
     """Compute the classification loss between predictions and true labels."""
     # loss = F.cross_entropy(preds, batch["cls"], reduction="mean")
     loss_items = loss.detach()
     return loss, loss_items

But I have a highly of imbalanced data. So how do I adapt the loss function using focal loss? Or any other solution?
The provided focal loss function which is on the same file is purely integrated only with other tasks.
so could you help me build a focal loss or any better solutions based on imbalance class classification.
FYI: I have already tried extensive oversampling based augmentation

[glenn-jocher]

@vivekbiragoni hello,

Thank you for your detailed question! To address the issue of imbalanced data in your classification task, adapting the loss function to use Focal Loss is a great approach. Focal Loss helps by focusing more on hard-to-classify examples, which can be particularly beneficial in imbalanced datasets.

Here's how you can modify your v8ClassificationLoss class to incorporate Focal Loss:

import torch
import torch.nn.functional as F

class v8ClassificationLoss:
    """Criterion class for computing training losses with Focal Loss."""

    def __init__(self, alpha=1, gamma=2):
        self.alpha = alpha
        self.gamma = gamma

    def __call__(self, preds, batch):
        """Compute the focal loss between predictions and true labels."""
        targets = batch["cls"]
        bce_loss = F.cross_entropy(preds, targets, reduction='none')
        pt = torch.exp(-bce_loss)
        focal_loss = self.alpha * (1 - pt) ** self.gamma * bce_loss
        loss = focal_loss.mean()
        loss_items = loss.detach()
        return loss, loss_items

# Example usage
# loss_fn = v8ClassificationLoss(alpha=1, gamma=2)
# loss, loss_items = loss_fn(preds, batch)

In this implementation:

• alpha is a balancing factor for class imbalance.
• gamma adjusts the rate at which easy examples are down-weighted.

You can adjust alpha and gamma based on your dataset's characteristics to find the optimal settings.

Additionally, if you haven't already, please ensure you are using the latest version of the Ultralytics YOLO repository to benefit from the latest updates and bug fixes. If the issue persists, providing a minimum reproducible example would be very helpful. You can find more information on creating one here: Minimum Reproducible Example.

Feel free to reach out if you have any more questions or need further assistance! 😊

[NoviceAlchemist]

May I ask if I am not able to filter out with warnings: WARNING ⚠️ no model scale passed. Assuming scale='s'. My initialization generally references the yolov8.yaml file

[NoviceAlchemist]

Because I want to train brand new models and don't want to use the weights from the pre-trained models

[pderrenger]

Hello!

Thank you for reaching out. If you want to train brand new models without using weights from pre-trained models, you can easily do so by specifying the model configuration file (e.g., yolov8.yaml) without loading any pre-trained weights. Here's how you can do it:

Using Python:

from ultralytics import YOLO

# Build a new model from YAML configuration
model = YOLO("yolov8.yaml")

# Train the model from scratch
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Using CLI:

# Build a new model from YAML and start training from scratch
yolo detect train data=coco8.yaml model=yolov8.yaml epochs=100 imgsz=640

This approach ensures that the model is initialized with random weights and trained from scratch on your dataset.

Regarding the warning message "WARNING ⚠️ no model scale passed. Assuming scale='s'", this typically occurs when the model scale is not explicitly defined. To avoid this, you can specify the scale directly in your YAML configuration or ensure that the correct model configuration is being used.

If you encounter any issues or need further assistance, please provide a minimum reproducible example so we can better understand and address the problem. You can find more details on creating a reproducible example here: Minimum Reproducible Example.

Lastly, make sure you are using the latest version of the Ultralytics packages to benefit from the latest features and fixes.

Happy training! 🚀

[SakaJoe]

Hi can I just ask in general, what are the necessary steps that you would recommend in order to improve the accuracy of the model for a custom dataset training small objects (in my case it is bird species). Which parameters would I recommend I look into and if possible can you provide with a link to the documentation that gives detailed explaination of the parameters. Thank you!

[pderrenger]

Hi there!

Thank you for your kind words! 😊 To speed up the training process on your Windows laptop with an AMD Ryzen 7 6800 processor and AMD Radeon graphics, here are a few strategies you can consider:

1. Reduce Image Size (imgsz): Lowering the image size can significantly speed up training, though it might slightly impact accuracy. For example:

   imgsz=320

2. Batch Size (batch): Adjust the batch size to optimize memory usage. You can use auto mode to find the optimal batch size:

   batch=-1  # Auto mode for 60% GPU memory utilization

3. Mixed Precision Training (amp): Enable Automatic Mixed Precision (AMP) to speed up training and reduce memory usage:

   amp=True

4. Use a Smaller Model: If possible, use a smaller model variant like YOLOv8n (nano) instead of larger models like YOLOv8m (medium) or YOLOv8l (large).

5. Data Caching (cache): Enable caching to speed up data loading:

   cache=True

6. Reduce Epochs (epochs): Train for fewer epochs initially to get quicker results and then fine-tune as needed:

   epochs=50

Here's a sample code snippet incorporating these suggestions:

from ultralytics import YOLO

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

# Train the model with optimized settings
results = model.train(
    data="path/to/your/dataset.yaml",
    epochs=50,
    imgsz=320,
    batch=-1,
    amp=True,
    cache=True
)

For more detailed guidance on training settings, you can refer to the Ultralytics YOLOv8 Training Documentation.

Feel free to experiment with these settings and monitor the results to find the optimal configuration for your specific setup. Happy training! 🚀

[SakaJoe]

Thank you so much for the quick and detailed response Paula.

[d-kleine]

For that reason, I have privately switched from an AMD graphics card to an Nvidia graphics card. CUDA (Nvidia) is much more supported than ROCm (AMD), and using a supported graphics card speeds up the training significantly.

[SakaJoe]

Hey Daniel I was not aware of this information. Thank you!!!

[pderrenger]

Hi Daniel,

Thank you for sharing your experience! Switching to an Nvidia graphics card and leveraging CUDA support can indeed significantly speed up the training process. If you encounter any issues or need further assistance, feel free to provide more details or a reproducible example. You can find guidance on creating a minimum reproducible example here.

Additionally, ensure you are using the latest versions of the Ultralytics packages to benefit from the latest features and improvements.

Happy training! 🚀

[d-kleine]

Is there an option to limit the output, for example printing the results only for every 10th epoch?

[glenn-jocher]

@d-kleine hello!

Yes, you can limit the output to print results only for every 10th epoch by using the save_period argument in the train method. This argument specifies the frequency of saving model checkpoints and printing results. Here’s how you can do it:

Python Example

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # load a pretrained model (recommended for training)

# Train the model and print results every 10 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, save_period=10)

CLI Example

# Start training from a pretrained *.pt model and print results every 10 epochs
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 save_period=10

This will ensure that the results are printed and checkpoints are saved every 10 epochs. If you have any further questions or need additional assistance, feel free to ask! 😊

For more detailed information, you can refer to the Ultralytics YOLO Training Documentation.

[d-kleine]

Thanks, but sorry, this still prints the output for each epoch for me:

Starting training for 400 epochs...

  Epoch    GPU_mem   box_loss  pose_loss  kobj_loss   cls_loss   dfl_loss  Instances       Size
  1/400      1.37G      1.898      6.604     0.7233      3.228      2.023         44        640: 100%|██████████| 1/1 [00:01<00:00,  1.82s/it]
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Pose(P          R      mAP50  mAP50-95): 100%|██████████| 1/1 [00:01<00:00,  1.66s/it]
               all          1          2    0.00673          1      0.524     0.0725          0          0          0          0


  Epoch    GPU_mem   box_loss  pose_loss  kobj_loss   cls_loss   dfl_loss  Instances       Size
  2/400      1.33G      2.245      6.219     0.7236      3.349      2.223         40        640: 100%|██████████| 1/1 [00:00<00:00,  3.96it/s]
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Pose(P          R      mAP50  mAP50-95): 100%|██████████| 1/1 [00:00<00:00, 10.28it/s]
               all          1          2    0.00673          1      0.531     0.0725          0          0          0          0


  Epoch    GPU_mem   box_loss  pose_loss  kobj_loss   cls_loss   dfl_loss  Instances       Size
  3/400      1.34G      2.155      6.591     0.7069      3.279      2.187         40        640: 100%|██████████| 1/1 [00:00<00:00,  4.75it/s]
             Class     Images  Instances      Box(P          R      mAP50  mAP50-95)     Pose(P          R      mAP50  mAP50-95): 100%|██████████| 1/1 [00:00<00:00, 12.10it/s]
               all          1          2    0.00672          1      0.533     0.0732          0          0          0          0

I only want the output for epoch 1, epoch 10 (or11), epoch 20 (or 21), etc.

[glenn-jocher]

Hello!

Thank you for your feedback. To achieve the desired behavior of printing results only for every 10th epoch, you can use the verbose argument to control the verbosity of the output. However, currently, there isn't a built-in option to limit the output to specific epochs directly.

A workaround is to modify the training script to include custom logging. Here’s an example of how you can achieve this in Python:

Python Example

from ultralytics import YOLO

# Custom callback to print results every 10 epochs
class CustomLogger:
    def __init__(self, interval=10):
        self.interval = interval

    def __call__(self, epoch, results):
        if epoch % self.interval == 0:
            print(f"Epoch {epoch}/{results['epochs']}")
            print(results)

# Load a model
model = YOLO("yolov8n.pt")  # load a pretrained model (recommended for training)

# Train the model with custom logging
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, callbacks=[CustomLogger(interval=10)])

CLI Example

For CLI, you might need to redirect the output to a file and then filter the lines you need:

# Start training and redirect output to a file
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 > output.log

# Filter the log to show only every 10th epoch
grep -E "Epoch (1|10|20|30|40|50|60|70|80|90|100)/" output.log

I hope this helps! If you have any further questions or need additional assistance, feel free to ask. 😊

For more detailed information, you can refer to the Ultralytics YOLO Training Documentation.

[d-kleine]

Sorry, but again, please stop using LLMs (I assume you are using Perplexity) to generate your responses, I have already checked that by myself.

There is no callbacks parameter for model.train(), see https://docs.ultralytics.com/modes/train/#train-settings
When executing this code, it says the same: SyntaxError: 'callbacks' is not a valid YOLO argument.

[glenn-jocher]

Hello,

Thank you for pointing that out. You are correct; the model.train() method does not support a callbacks parameter. I apologize for the confusion.

To achieve the desired behavior of printing results only for every 10th epoch, you can redirect the output to a file and then filter the lines you need. Here’s a workaround using the CLI:

# Start training and redirect output to a file
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 > output.log

# Filter the log to show only every 10th epoch
grep -E "Epoch (1|10|20|30|40|50|60|70|80|90|100)/" output.log

This will ensure that you only see the output for every 10th epoch. If you have any further questions or need additional assistance, feel free to ask! 😊