models/yolov9/

[giscus[bot]]

models/yolov9/

了解 YOLOv9，它是实时物体检测系统的最新成员，利用可编程梯度信息和 GELAN 架构实现了无与伦比的性能。

https://docs.ultralytics.com/models/yolov9/?h=yolov9

[sunmooncode]

I am looking forward to using it in Ultralytics!

[pderrenger]

@sunmooncode hey there! 🚀

We're thrilled to hear about your excitement for YOLOv9 and its potential integration with Ultralytics! YOLOv9 indeed marks a significant leap in object detection technology, thanks to its innovative use of Programmable Gradient Information (PGI) and the Generalized Efficient Layer Aggregation Network (GELAN).

For those eager to dive in, here's a quick example on how you might use YOLOv9 once it's integrated:

from ultralytics import YOLO

# Load the YOLOv9 model
model = YOLO('yolov9.pt')

# Run predictions
results = model.predict('path/to/your/image.jpg')

# Display results
results[0].show()

Stay tuned for more updates on the integration, and feel free to reach out if you have any questions or ideas! 🌟

[Branchverse]

how long till it will be implemented?

[pderrenger]

Hey there! 🌟

We're just as excited as you are about implementing the new features! While I can't give an exact timeline, our team is working hard to bring YOLOv9's advancements into Ultralytics as smoothly and quickly as possible. Keep an eye on our GitHub repo for updates. In the meantime, here's a sneak peek at how you might use YOLOv9 once it's ready:

from ultralytics import YOLO

# Load YOLOv9 model
model = YOLO('yolov9.pt')

# Predict with the model
results = model.predict('path/to/image.jpg')

# Enjoy the results!
results.show()

Stay tuned, and thanks for your enthusiasm! 🚀

[miladfa7]

I am looking forward to using it in Ultralytics!

[pderrenger]

We're thrilled to hear about your excitement for YOLOv9! 🚀 Stay tuned for more updates on its integration into the Ultralytics package! If you have any questions or need further assistance, feel free to reach out. Happy detecting! 🌟

[ArgoHA]

Are you planning to integrate only inference, or training and export too?

[glenn-jocher]

@ArgoHA hopefully we'll integrate everything, probably rolling out inference and training first!

[navidTerraNova]

Can it be used for pose task?

[glenn-jocher]

Not yet, but possibly in a future release!

[Shadowfear36]

What's the timeline look like for Yolov9 training pipeline? Excited to see further optimization on this project.

[pderrenger]

Hey there! 🚀 We're thrilled about your enthusiasm for YOLOv9 and its training pipeline. While we're pushing hard to optimize and refine the pipeline, we don't have a fixed timeline to share just yet. Rest assured, we're as excited as you are to see YOLOv9 reach its full potential and we'll definitely keep the community updated with any progress. Stay tuned!

[Burhan-Q]

@Shadowfear36 if you want to track the progress, you can check out the GitHub Project here

[abubow]

Intriguing improvements in the architecture. I'm quite excited to use this in my projects.

[glenn-jocher]

That's fantastic to hear! 🎉 YOLOv9 indeed introduces some groundbreaking improvements that can enhance object detection projects. If you're looking to get started with YOLOv9, here's a quick example on how to use it for predictions (if you clone the branch):

yolo detect predict model=yolov9.pt source='path/to/your/image.jpg'

This will run the model on your specified image. Make sure to explore the new features like PGI and GELAN for even better performance. The integration is still a work in progress, so it might not yet be stable. Happy coding!

[thecetin]

For video processing with yolov9, im using this function:
"def run_detection(frame_path, model_path, confidence_threshold):
command = f"python /content/yolov9/detect.py --weights {model_path} --source {frame_path} --conf {confidence_threshold} --device 0"
# Execute the command and capture the output
output = subprocess.check_output(command, shell=True, text=True)
return output"
But processing for every frame taking at least 8 seconds. So slow for videos for now. :(

[Burhan-Q]

@thecetin why use subprocess? If you use it this way, the model will have to load every time you input a new frame and will be very slow. You should initialize the model in python and then use the model.predict method instead. See the Predict Mode section of the docs for code examples.

[thecetin]

Hello, "model.predict" works with my yolov8 trained model but did not work for yolov9 trained model.

[glenn-jocher]

@thecetin hey there! 😊 It seems like you're encountering an issue where model.predict works fine with your YOLOv8 trained model but not with the YOLOv9 model. This could be due to differences in the model architecture or the way the models are loaded and used in the code.

For YOLOv9, ensure you're following the updated usage examples and documentation specific to YOLOv9, as there might be slight differences in the API or model handling compared to YOLOv8. Here's a quick example on how you might load and use a YOLOv9 model for prediction:

from ultralytics import YOLO

# Load your YOLOv9 trained model
model = YOLO('path/to/your/yolov9_trained_model.pt')

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

# Process your results here

Make sure your YOLOv9 model file path is correct and that you're using the latest version of the Ultralytics library that supports YOLOv9. If you're still facing issues, it might be helpful to check the official YOLOv9 documentation or GitHub repo for any specific instructions or requirements for using YOLOv9 models. 📚

Hope this helps! If you have any more questions or need further assistance, feel free to ask.

[yanxinlei]

I am interested in knowing when yolo v9 might be expected to be available for image segmentation tasks.

[glenn-jocher]

@yanxinlei hey there! 🌟 YOLOv9 is indeed an exciting development in object detection, including advancements for segmentation tasks. As of now, we don't have a specific release date for YOLOv9 tailored for image segmentation. The team is actively working on it, aiming to incorporate the latest innovations for enhanced performance and efficiency.

For updates and more information, keep an eye on our GitHub repo and official documentation. Your interest and support mean a lot to us! If you have any more questions or need further assistance, feel free to reach out. Happy coding! 🚀

[20CE034]

Can this be used for multiclass classification ?

[pderrenger]

Yes, YOLOv8 can be used for multiclass classification! 🌟 When training your model, simply ensure your dataset is labeled with the multiple classes you're interested in detecting. Here's a quick example on how to train a YOLOv8 model on a dataset with multiple classes:

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

Make sure your_dataset.yaml is properly set up with paths to your training and validation data, and that your data is labeled for all the classes you wish to classify. Happy training! 🚀

[20CE034]

Thanks for the reply, i have used yolov8, i was asking about the new release yolov9!

[pderrenger]

Hey there! 👋 It seems like you're interested in YOLOv9, which indeed brings some exciting advancements to object detection with its Programmable Gradient Information (PGI) and Generalized Efficient Layer Aggregation Network (GELAN). These innovations help YOLOv9 achieve remarkable efficiency and accuracy improvements. 🚀

For using YOLOv9 in Python, you can load a pre-trained model like this:

from ultralytics import YOLO

# Load a pre-trained YOLOv9 model
model = YOLO('yolov9c.pt')  # Example for YOLOv9-C

# Run inference
results = model('path/to/your/image.jpg')

And for CLI usage:

# Run inference with YOLOv9
yolo predict model=yolov9c.yaml source=path/to/your/image.jpg

These snippets should get you started with YOLOv9. If you have more specific questions or need further assistance, feel free to ask! Happy detecting! 🌟

[herrig]

Can I train Yolov9 using p2.yaml configuration file?

[glenn-jocher]

Yes, you can train YOLOv9 using a p2.yaml configuration file that you create. Just make sure to adjust any specific parameters in the YAML file to match the requirements of YOLOv9, such as input size or model architecture specifics if needed. Here's a quick example on how to start your training:

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

Happy training! 😊

[Burhan-Q]

@herrig in case there was a misunderstanding, if you meant yolov9-p2 there is no such model structure at the moment.

[Joshikarank]

Hi , i would like to know when you guys will integrate yolov9 with uralytics , thanks

[Burhan-Q]

It is done! YOLOv9 was added to ultralytics in version 8.1.23 🚀

[Joshikarank]

Im very glad to hear that, can i know where can i find the documentations or downloads , can you provide a link for it , please i cant find it anywhere

[Burhan-Q]

@Joshikarank documentation is here (which is the page these comments or GitHub discussion are posted) and you can download the pretrained weights from the table in the section "Performance on MS COCO Dataset" or the pretrained weights will be downloaded automatically when you use

from ultralytics import YOLO

model = YOLO("yolov9c.pt")

[Varun3713-creator]

8.1.23

hello @Joshikarank ,
i am trying trying to import yolov9 model from few days but i am facing the issue:- No module named 'models'
can you help me with this?
code:
from ultralytics import YOLO

Load a model

model = YOLO('/content/drive/MyDrive/yolov9/runs/train/exp6/weights/best.pt')

[martonbodo]

Hello,

I am training a custom model using Yolov9. I could not find any documentation about how to get the bounding box coordinates from the predictions. Could anybody help me with that? I am predicting using the detect.py script from the official Git repo.

With Yolov8 I was able to use model.predict(), however if I use this on Yolov9 I get this error: TypeError: BaseModel.fuse() got an unexpected keyword argument 'verbose'

Thank you in advance.

[iMadhur]

@martonbodo You mentioned that you made it work. Can you help me with how to retrieve the bounding box coordinates? I have a similar requirement.

[martonbodo]

@iMadhur, yes I did manage to fix it.
I essentially changed the detect.py so it saves my results in a txt. I changed the save_txt param in the run function to True, then you just have to specify where to save the results and what information you would like to save. If you are using the same repo as I linked, at line 137 you can find the line 'if save txt:'. If you edit the line param (few lines bellow), you can define what you want to save. I personally saved the frame, cls and the *xywh (coordinates). Make sure that if you want all results in 1 txt (and not as many txts as detections) that you set the txt_path as a fixed variable.

I hope that helps. Good luck!

[Kamal-Moha]

Hello @martonbodo, I'm facing the same problem. You said you managed to fix it and I would like to get your help. And I clone this repo: https://github.com/SkalskiP/yolov9.git during my training.

Below is the code trying to do the model inference;

from ultralytics import YOLO

# Load the YOLOv9 model
model = YOLO('/content/yolov9/runs/train/exp/weights/best.pt')

# Perform inference on an image
results = model('/content/IMAGES_1024/008876A9.JPG')

# Extract bounding boxes, classes, names, and confidences
boxes = results[0].boxes.xyxy.tolist()
classes = results[0].boxes.cls.tolist()
names = results[0].names
confidences = results[0].boxes.conf.tolist()

# Iterate through the results
for box, cls, conf in zip(boxes, classes, confidences):
    x1, y1, x2, y2 = box
    confidence = conf
    detected_class = cls
    name = names[int(cls)]

Please help

[swagatamr]

Same thing I am facing. If anyone can help me it would be great

[glenn-jocher]

Hello @swagatamr,

It looks like you're facing a similar issue with retrieving bounding box coordinates from YOLOv9 predictions. Here's a concise way to achieve this using the Ultralytics YOLOv9 model:

1. Load the Model:

   from ultralytics import YOLO
   
   # Load the YOLOv9 model
   model = YOLO('path/to/yolov9c.pt')  # Ensure you have the correct path to your model

2. Perform Inference:

   # Perform inference on an image
   results = model('path/to/your/image.jpg')

3. Extract Bounding Box Coordinates:

   # Extract bounding boxes, classes, names, and confidences
   boxes = results[0].boxes.xyxy.tolist()
   classes = results[0].boxes.cls.tolist()
   names = results[0].names
   confidences = results[0].boxes.conf.tolist()
   
   # Iterate through the results
   for box, cls, conf in zip(boxes, classes, confidences):
       x1, y1, x2, y2 = box
       confidence = conf
       detected_class = cls
       name = names[int(cls)]
       print(f"Class: {name}, Confidence: {confidence}, Box: {x1, y1, x2, y2}")

This approach should help you retrieve the bounding box coordinates along with class names and confidence scores. If you encounter any issues, please ensure you are using the latest versions of torch and ultralytics packages. You can update them using:

pip install --upgrade torch ultralytics

For more detailed documentation and examples, you can refer to the YOLOv9 documentation.

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

[Joshikarank]

Hi , I'm really glad that yolo v9 has released, I have a pcb(circuit board) ,I use to detect defects in it.I have took image of it and annotated the defected areas , the defects is only 1 one means only one class , I have no idea how to train with only one image of that one PCB , all I want is to predict the defect in that particular image which I used for training , can you help me with this about how many epochs should I use or any other ways ? Please help I've been trying this for hours today , thank you

[pderrenger]

Hey there! 🙌 It's fantastic to hear about your interest in YOLOv9 for detecting defects on PCBs. Training on a single image, especially for defect detection, can be quite challenging due to the limited data. However, here's a simplified approach you might consider:

1. Data Augmentation: Since you're working with only one image, augmenting this image to create multiple variations can help. This includes rotations, flips, and slight distortions. This way, you can artificially increase your dataset size.

2. Transfer Learning: Utilize a pre-trained YOLOv9 model and fine-tune it on your augmented dataset. This leverages the model's learned features and applies them to your specific task.

3. Epochs and Training: Start with a moderate number of epochs, say 50 to 100, and monitor the model's performance. If the model is overfitting (performing too well on the training data but not on new, unseen data), you might need to adjust the number of epochs or augment your dataset further.

Here's a quick example of how you might start training with YOLOv9:

from ultralytics import YOLO

# Load a pre-trained YOLOv9 model
model = YOLO('yolov9c.pt')

# Train the model on your dataset
results = model.train(data='your_dataset.yaml', epochs=100, imgsz=640)

Remember, the key with such a small dataset is to prevent overfitting while still allowing the model to learn the defect features. Keep an eye on the validation loss and adjust your approach as needed.

Good luck with your project, and don't hesitate to reach out if you have more questions!

[Joshikarank]

thank you so much after using rotation images, and training 10 epochs it worked as i expected, thanks for the help and developing yolov9

[pderrenger]

@Joshikarank hey there! 🎉 I'm thrilled to hear that the rotation augmentation and training for 10 epochs worked out perfectly for your PCB defect detection project using YOLOv9. Your success story is exactly why we do what we do, and it's fantastic to see our tools being put to great use. Thanks for your kind words and for being part of our community. If you have any more questions or need further assistance, feel free to reach out. Happy detecting! 🚀

[Branchverse]

Also looking forward to the tfjs export

[glenn-jocher]

Hey there! 🌟 We're thrilled to hear you're excited about the TensorFlow.js (tfjs) export capability. While we're constantly working to expand our export options to accommodate a wide range of platforms and frameworks, tfjs export isn't currently supported directly out of the box.

However, you can first export the model to TensorFlow SavedModel format and then convert it to TensorFlow.js using the TensorFlow.js converter. Here's a quick example of how you might do this:

1. Export your YOLOv8 model to TensorFlow SavedModel:

yolo export model=yolov8n.pt format=saved_model

2. Convert the SavedModel to TensorFlow.js format:

tensorflowjs_converter --input_format=tf_saved_model --output_node_names='Add,Softmax' /path/to/saved_model /path/to/tfjs_model

Please replace /path/to/saved_model and /path/to/tfjs_model with your actual paths. Keep an eye on our updates; we're always looking to improve and add more features based on community feedback! 🚀

[tysonw662]

I'm currently planning to use YOLOv5 for a project, what would the benefits and drawbacks be of switching to YOLOv9? I'm partictularly interested in fps and speed

[glenn-jocher]

Switching from YOLOv5 to YOLOv9 could offer several benefits, particularly in terms of fps and speed, thanks to its innovative use of Programmable Gradient Information (PGI) and the Generalized Efficient Layer Aggregation Network (GELAN) architecture. These advancements help YOLOv9 achieve remarkable efficiency and accuracy improvements. However, it's essential to consider the potential need for more computational resources or adjustments in your workflow due to these architectural changes. Here's a quick comparison:

Benefits:

• Improved Efficiency: YOLOv9's design enhancements lead to better parameter utilization and computational efficiency.
• Higher Accuracy: The introduction of PGI and GELAN contributes to superior detection performance.
• Adaptability: Flexible architecture makes YOLOv9 suitable for a wide range of applications without sacrificing speed.

Drawbacks:

• Resource Requirements: The advanced features of YOLOv9 might demand more from your hardware, especially for larger models.
• Adjustment Period: Transitioning to a new model architecture may require some time to adapt, especially if custom modifications were made to YOLOv5.

In summary, if your project can benefit from the latest advancements in object detection and you're equipped to handle the potential increase in resource requirements, switching to YOLOv9 could be a worthwhile move. 🚀

[Burhan-Q]

@tysonw662 to add on to what Glenn mentioned, migrating to the ultralytics library is going to provide you with a lot more functionality, ease of use, and continual developments. For model deployment, if an Nvidia GPU is available, exporting your model to TensorRT will give you an exceptional uplift in FPS performance and is made extremely easy to do with the ultralytics library.

[jamesparkskku]

Dear YOLOV9 Developer,

I hope this message finds you well.

I am writing to request assistance with running YOLOV9 in combination with a transformer. I would like to incorporate a transformer module into the existing YOLOV9 model to enhance its capabilities. Could you please add the necessary module and provide guidance on how to train the model with this additional component?

Your help in integrating the transformer with YOLOV9 would be greatly appreciated.

Thank you for your support.

Best regards,
James Park

[glenn-jocher]

@jamesparkskku hi James,

Thank you for reaching out and for your interest in enhancing YOLOv9 with a transformer module! Integrating a transformer into YOLOv9 can indeed provide significant improvements in model performance.

To get started, you'll need to modify the YOLOv9 architecture to include the transformer module. Here's a high-level approach to guide you through the process:

1. Modify the Model Architecture:

   • You can start by editing the YOLOv9 configuration file (yolov9c.yaml or yolov9e.yaml) to include the transformer module. This involves defining the transformer layers and integrating them into the existing YOLOv9 layers.

2. Implement the Transformer Module:

   • Create a custom transformer module in your codebase. Here's a simple example of how you might define a transformer block in PyTorch:

   import torch
   import torch.nn as nn
   
   class TransformerBlock(nn.Module):
       def __init__(self, embed_dim, num_heads, ff_dim):
           super(TransformerBlock, self).__init__()
           self.attention = nn.MultiheadAttention(embed_dim, num_heads)
           self.feed_forward = nn.Sequential(
               nn.Linear(embed_dim, ff_dim),
               nn.ReLU(),
               nn.Linear(ff_dim, embed_dim)
           )
           self.layer_norm1 = nn.LayerNorm(embed_dim)
           self.layer_norm2 = nn.LayerNorm(embed_dim)
   
       def forward(self, x):
           attn_output, _ = self.attention(x, x, x)
           x = self.layer_norm1(x + attn_output)
           ff_output = self.feed_forward(x)
           x = self.layer_norm2(x + ff_output)
           return x

3. Integrate the Transformer Block:

   • Incorporate the transformer block into the YOLOv9 model. You can add the transformer block after certain layers to enhance feature extraction.

4. Training the Enhanced Model:

   • Once the model architecture is updated, you can train the model as usual. Here's an example of how to train the modified YOLOv9 model:

   from ultralytics import YOLO
   
   # Load the modified YOLOv9 model
   model = YOLO("path/to/modified_yolov9.yaml")
   
   # Train the model on the COCO dataset
   results = model.train(data="coco.yaml", epochs=100, imgsz=640)

5. Inference with the Enhanced Model:

   • After training, you can run inference using the enhanced model:

   results = model("path/to/image.jpg")

For more detailed guidance on modifying the model architecture and training, you can refer to the Ultralytics documentation.

If you encounter any issues or need further assistance, please provide a minimum reproducible example of your code and ensure you are using the latest versions of torch and ultralytics. This will help us better understand and address any problems you might face.

[youssefoumate]

The new model scales are a fantastic addition! Upgrading my app from Yolov8 to Yolov9 was completely effortless. I’m guessing it’ll be just as smooth when Yolov10 is fully supported. Beautiful work 🔥

[glenn-jocher]

@youssefoumate thank you for your enthusiastic feedback! 🌟 We're thrilled to hear that your upgrade from YOLOv8 to YOLOv9 was seamless and that you're enjoying the new model scales. Our team is dedicated to making these transitions as smooth as possible, and it's great to know that our efforts are paying off.

As for YOLOv10, we aim to maintain the same level of ease and efficiency in future updates. Stay tuned for more exciting advancements!

If you have any specific questions or run into any issues, feel free to reach out. The YOLO community and the Ultralytics team are always here to help.

Happy coding! 🚀

For more details on YOLOv9, you can visit the YOLOv9 documentation.

[ShreyasChhetri]

Hi can you provide me anything regarding training my custom dataset using YoloV9 as I'm not able to see anything right now in the docs

[DevilANANDGupta]

Hi @ShreyasChhetri you can train by using ultralytics.

1. Additionally, please ensure that you are using the latest versions of torch and ultralytics. You can update your packages using the following commands:

pip install --upgrade torch
pip install --upgrade ultralytics

2.Training

from ultralytics import YOLO
# Load the modified YOLOv9 model
model = YOLO("yolov9e.pt")
# Train the model on the COCO dataset
results = model.train(data="coco.yaml", epochs=100, imgsz=640) #use your custom data.yaml path

3. Inference with the Model:

After training, you can run inference using the enhanced model:

results = model("path/to/image.jpg")

[ShreyasChhetri]

Thanks

[glenn-jocher]

Hi @ShreyasChhetri,

Thank you for your interest in training YOLOv9 on your custom dataset! Here’s a concise guide to get you started:

1. Ensure Latest Versions:
   Make sure you have the latest versions of torch and ultralytics installed:

   pip install --upgrade torch
   pip install --upgrade ultralytics

2. Training on Custom Dataset:
   You can train YOLOv9 using the ultralytics package. Here’s a Python example:

   from ultralytics import YOLO
   
   # Load the YOLOv9 model
   model = YOLO("yolov9e.pt")  # or yolov9c.yaml for a model from scratch
   
   # Train the model on your custom dataset
   results = model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

3. Inference with the Model:
   After training, you can run inference using the trained model:

   results = model("path/to/image.jpg")

For more detailed information, including configuration options and advanced usage, please refer to the YOLOv9 documentation.

If you encounter any issues, please ensure you provide a minimum reproducible example as outlined here. This will help us investigate and provide a solution more efficiently.

Happy training! 🚀

[ShreyasChhetri]

Hi @glenn-jocher can you explain me what is the values suitable for increased accuracy I'm getting this after training my dataset with Yolov9s
Class Images Instances Box(P R mAP50 mAP50-95): 100% 2/2 [00:00<00:00, 2.27it/s]
all 45 1559 0.0304 0.0239 0.016 0.00618

higher the mAP50 is good or bad ? and also what does the mAP50-95 mean ?

[glenn-jocher]

Hi @ShreyasChhetri,

Thank you for reaching out! Let's break down your questions:

1. mAP50 and mAP50-95:

   • mAP50: This metric represents the mean Average Precision (mAP) at an Intersection over Union (IoU) threshold of 50%. A higher mAP50 value indicates better performance, as it means the model is more accurate in detecting objects with at least 50% overlap with the ground truth.
   • mAP50-95: This is a more comprehensive metric that averages mAP across multiple IoU thresholds (from 50% to 95% in increments of 5%). It provides a better overall picture of the model's performance across different levels of detection strictness.

2. Improving Accuracy:

   • To improve your model's accuracy, consider the following:
     • Data Quality: Ensure your dataset is well-annotated and diverse.
     • Hyperparameters: Experiment with different learning rates, batch sizes, and other hyperparameters.
     • Augmentation: Use data augmentation techniques to make your model more robust.
     • Model Size: If computational resources allow, try using a larger model variant like YOLOv9m or YOLOv9e.

Here's a quick example of how you can train your YOLOv9 model using the Python API:

from ultralytics import YOLO

# Load a YOLOv9 model
model = YOLO("yolov9s.pt")

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

And using the CLI:

yolo train model=yolov9s.pt data=path/to/your_dataset.yaml epochs=100 imgsz=640

For more detailed information, you can refer to the YOLOv9 documentation.

If you encounter any issues or need further assistance, please ensure you are using the latest versions of torch and ultralytics. If the issue persists, providing a minimum reproducible example would be very helpful. You can find guidelines on creating one here.

Best of luck with your training! 🚀

[rahul97jp]

Hi, I have trained YOLOv9 to detect text on images. The detections are word by word (means for each word a bounding box is created). My input will be kind of small document where there will be lines of text. I want a line by line detection. So I am thinking of post processing step, to merge the bounding boxes on the same line. Below is the code which I have implemented, it works but it has some problems like even if there is lot of space between the words (columns of 2 products) one bounding box will be drawn for the entire line. So, is there any particular method to merge the bounding boxes or am I missing something in my code.

def detect_text(self, image_data):
image = cv2.imdecode(np.frombuffer(image_data, np.uint8), cv2.IMREAD_COLOR)
results = self.model.predict(image, imgsz=640, conf=self.confidence_threshold, save=False)
text_regions = []

    for result in results:
        boxes = result.boxes.xyxy  # Access bounding boxes
        for box in boxes:
            x1, y1, x2, y2 = box[:4].int().tolist()  # Convert bounding box coords to int
            text_region = {
                'xmin': x1,
                'ymin': y1,
                'xmax': x2,
                'ymax': y2,
            }
            text_regions.append(text_region)

    return text_regions

def merge_bounding_boxes(self, text_regions, eps=0.5):
    if not text_regions:
        return []

    # Convert bounding boxes to (x1, y1, x2, y2) format
    bboxes_xyxy = [(region['xmin'], region['ymin'], region['xmax'], region['ymax']) for region in text_regions]

    # Extract the vertical midpoints of the bounding boxes
    bbox_verticals = [(y1 + y2) / 2 for x1, y1, x2, y2 in bboxes_xyxy]

    # Calculate the height of each bounding box
    bbox_heights = [(y2 - y1) for x1, y1, x2, y2 in bboxes_xyxy]

    # Scale the eps parameter based on the median height of the bounding boxes
    median_height = np.median(bbox_heights)
    eps_scaled = eps * median_height

    # Perform DBSCAN clustering
    db = DBSCAN(eps=eps_scaled, min_samples=1, metric='euclidean').fit(np.array(bbox_verticals).reshape(-1, 1))
    labels = db.labels_

    # Print debug information
    print(f"DBSCAN labels: {labels}")

    # Merge bounding boxes for each cluster
    merged_bboxes = []
    unique_labels = set(labels)
    for label in unique_labels:
        if label == -1:
            continue  # Skip noise points

        cluster_indices = [i for i, lbl in enumerate(labels) if lbl == label]
        cluster_bboxes = [bboxes_xyxy[i] for i in cluster_indices]

        x1 = min(b[0] for b in cluster_bboxes)
        y1 = min(b[1] for b in cluster_bboxes)
        x2 = max(b[2] for b in cluster_bboxes)
        y2 = max(b[3] for b in cluster_bboxes)

        merged_bboxes.append((x1, y1, x2, y2))

        # Print debug information for each cluster
        print(f"Cluster {label}: {cluster_bboxes} -> Merged: ({x1}, {y1}, {x2}, {y2})")

    return merged_bboxes

[glenn-jocher]

@rahul97jp hi there,

Thank you for sharing your implementation and the detailed explanation of your issue. It's great to see your proactive approach to post-processing YOLOv9 detections for line-by-line text detection.

To address the problem of merging bounding boxes with excessive spacing, you might consider incorporating additional heuristics to refine the clustering process. Here are a few suggestions:

1. Horizontal Distance Threshold: Introduce a horizontal distance threshold to ensure that only closely spaced words are merged. This can be done by comparing the horizontal distances between bounding boxes and merging only those within a certain threshold.

2. Adaptive Clustering: Instead of a fixed eps parameter in DBSCAN, consider an adaptive approach where eps is dynamically adjusted based on the average width of the bounding boxes in each cluster.

3. Bounding Box Aspect Ratio: Use the aspect ratio of bounding boxes to filter out those that are likely to be part of different lines or columns.

Here's an updated version of your merge_bounding_boxes function incorporating a horizontal distance threshold:

def merge_bounding_boxes(self, text_regions, eps=0.5, horizontal_threshold=0.5):
    if not text_regions:
        return []

    bboxes_xyxy = [(region['xmin'], region['ymin'], region['xmax'], region['ymax']) for region in text_regions]
    bbox_verticals = [(y1 + y2) / 2 for x1, y1, x2, y2 in bboxes_xyxy]
    bbox_heights = [(y2 - y1) for x1, y1, x2, y2 in bboxes_xyxy]
    median_height = np.median(bbox_heights)
    eps_scaled = eps * median_height

    db = DBSCAN(eps=eps_scaled, min_samples=1, metric='euclidean').fit(np.array(bbox_verticals).reshape(-1, 1))
    labels = db.labels_

    merged_bboxes = []
    unique_labels = set(labels)
    for label in unique_labels:
        if label == -1:
            continue

        cluster_indices = [i for i, lbl in enumerate(labels) if lbl == label]
        cluster_bboxes = [bboxes_xyxy[i] for i in cluster_indices]

        # Apply horizontal distance threshold
        cluster_bboxes.sort(key=lambda b: b[0])  # Sort by x1
        merged_cluster = []
        current_box = cluster_bboxes[0]
        for box in cluster_bboxes[1:]:
            if box[0] - current_box[2] < horizontal_threshold * median_height:
                current_box = (current_box[0], min(current_box[1], box[1]), box[2], max(current_box[3], box[3]))
            else:
                merged_cluster.append(current_box)
                current_box = box
        merged_cluster.append(current_box)

        merged_bboxes.extend(merged_cluster)

    return merged_bboxes

This approach should help in reducing the merging of bounding boxes that are too far apart horizontally. Additionally, you can tweak the horizontal_threshold parameter to better suit your specific use case.

For further details on YOLOv9 and its capabilities, you can refer to the YOLOv9 documentation.

Feel free to test this and let us know if you encounter any issues or need further assistance. Happy coding! 😊

[akhilesh99sharma]

I am trying to counting using YOLOv9 but it is not even accepting my model. The error is telling me that i have trained a yolov5 model.

from ultralytics import YOLO
from ultralytics.solutions import object_counter
import cv2

Load your model -trained on 3 classes

MODEL= "/content/drive/MyDrive/YOLOcontrolratings/v9/runs/train/exp2/weights/best.pt"
from ultralytics import YOLO

model = YOLO(MODEL)
model.fuse()

classes_to_count = [0,1,2]

Setup video capture

cap = cv2.VideoCapture("/content/drive/MyDrive/DJI_0490.MP4")
assert cap.isOpened(), "Error opening video stream or file"

Define your line points for counting

#line_points = [(1126, 1118), (2786, 1118)] # Adjust these points as needed
line_points = [(914,1200), (2580,1200)]

Initialize Object Counter with desired settings

counter = object_counter.ObjectCounter()
counter.set_args(view_img=True, reg_pts=line_points, classes_names=model.names)

Define the output video path and parameters

output_video_path = "/content/drive/MyDrive/newresult490.mp4"
fps = int(cap.get(cv2.CAP_PROP_FPS))
frame_size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))

Initialize VideoWriter

fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out_video = cv2.VideoWriter(output_video_path, fourcc, fps, frame_size)

Process video frames

while cap.isOpened():
success, frame = cap.read()
if not success:
break
tracks = model.track(frame, persist=True, show=False, classes=classes_to_count)
frame = counter.start_counting(frame, tracks)

# Write the frame to the output video
out_video.write(frame)

Release the VideoWriter

out_video.release()

for class_id in classes_to_count:
in_count = counter.in_counts if isinstance(counter.in_counts, int) else counter.in_counts.get(class_id, 0)
out_count = counter.out_counts if isinstance(counter.out_counts, int) else counter.out_counts.get(class_id, 0)

print(f"In count for {model.names[class_id]}: {in_count}")
print(f"Out count for {model.names[class_id]}: {out_count}")

cap.release()
cv2.destroyAllWindows()

ModuleNotFoundError Traceback (most recent call last)
/usr/local/lib/python3.10/dist-packages/ultralytics/nn/tasks.py in torch_safe_load(weight)
774 ):
--> 775 ckpt = torch.load(file, map_location="cpu")
776

8 frames
ModuleNotFoundError: No module named 'models'

The above exception was the direct cause of the following exception:

TypeError Traceback (most recent call last)
/usr/local/lib/python3.10/dist-packages/ultralytics/nn/tasks.py in torch_safe_load(weight)
777 except ModuleNotFoundError as e: # e.name is missing module name
778 if e.name == "models":
--> 779 raise TypeError(
780 emojis(
781 f"ERROR ❌️ {weight} appears to be an Ultralytics YOLOv5 model originally trained "

TypeError: ERROR ❌️ /content/drive/MyDrive/YOLOcontrolratings/v9/runs/train/exp2/weights/best.pt appears to be an Ultralytics YOLOv5 model originally trained with https://github.com/ultralytics/yolov5.
This model is NOT forwards compatible with YOLOv8 at https://github.com/ultralytics/ultralytics.
Recommend fixes are to train a new model using the latest 'ultralytics' package or to run a command with an official YOLOv8 model, i.e. 'yolo predict model=yolov8n.pt'

[glenn-jocher]

@akhilesh99sharma hello!

Thank you for reaching out. It appears that the model you are trying to load is a YOLOv5 model, which is not compatible with YOLOv9. The error message indicates that the model was trained using YOLOv5, and YOLOv9 requires models trained specifically with its architecture.

To resolve this issue, you have two options:

1. Train a new model using YOLOv9: You can train a new model using the latest YOLOv9 architecture. Here's a quick example to get you started:

   from ultralytics import YOLO
   
   # Train a YOLOv9 model
   model = YOLO("yolov9c.yaml")  # or use a pretrained model with "yolov9c.pt"
   model.train(data="coco8.yaml", epochs=100, imgsz=640)

2. Verify the model compatibility: Ensure that the model you are using is trained with YOLOv9. If you have access to the training scripts, you can retrain the model using YOLOv9.

Additionally, please make sure you are using the latest version of the Ultralytics package to avoid any compatibility issues. You can update the package using:

pip install --upgrade ultralytics

For more detailed guidance on YOLOv9, you can refer to the YOLOv9 documentation.

If you encounter any further issues, providing a minimum reproducible example can greatly help in diagnosing the problem. You can find more information on creating one here.

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

[akhilesh99sharma]

@glenn-jocher Thank you for your response. I finetuned the yolov9e.pt on my training data. I already updated and checked the ultralytics package and it is the latest version.

[glenn-jocher]

Hello @akhilesh99sharma,

Thank you for your response and for confirming that you have updated to the latest version of the Ultralytics package. It's great to hear that you've fine-tuned the yolov9e.pt model on your training data.

Given that you are encountering issues with the model, could you please provide a minimum reproducible example of the code that leads to the error? This will help us diagnose the problem more effectively. You can find guidelines on how to create a reproducible example here.

Additionally, please ensure that the model file path and the environment setup are correct. Sometimes, issues can arise from mismatched versions or incorrect paths.

If you have any specific error messages or logs, sharing those would also be very helpful in troubleshooting the issue.

Looking forward to your response so we can assist you further! 😊

[Quanzan04]

Hello, I have the same error, I did upgrade the ultralytics but it doesn't help.
Here all the log error if it can help : ModuleNotFoundError Traceback (most recent call last)
File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/ultralytics/nn/tasks.py:781, in torch_safe_load(weight)
770 with temporary_modules(
771 modules={
772 "ultralytics.yolo.utils": "ultralytics.utils",
(...)
779 },
780 ):
--> 781 ckpt = torch.load(file, map_location="cpu")
783 except ModuleNotFoundError as e: # e.name is missing module name

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/torch/serialization.py:1025, in load(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args)
1024 raise pickle.UnpicklingError(UNSAFE_MESSAGE + str(e)) from None
-> 1025 return _load(opened_zipfile,
1026 map_location,
1027 pickle_module,
1028 overall_storage=overall_storage,
1029 **pickle_load_args)
1030 if mmap:

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/torch/serialization.py:1446, in _load(zip_file, map_location, pickle_module, pickle_file, overall_storage, **pickle_load_args)
1445 unpickler.persistent_load = persistent_load
-> 1446 result = unpickler.load()
1448 torch._utils._validate_loaded_sparse_tensors()

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/torch/serialization.py:1439, in _load..UnpicklerWrapper.find_class(self, mod_name, name)
1438 mod_name = load_module_mapping.get(mod_name, mod_name)
-> 1439 return super().find_class(mod_name, name)

ModuleNotFoundError: No module named 'models'

The above exception was the direct cause of the following exception:

TypeError Traceback (most recent call last)
Cell In[2], line 7
4 from torchvision import models
5 from ultralytics import YOLO
----> 7 yolov9 = YOLO('/home/thibaud/Documents/Python/Modele_importe/yolov9/gelan-c-seg.pt')
9 learner = BYOL(
10 resnet,
11 image_size = 256,
12 hidden_layer = 'avgpool'
13 )
15 opt = torch.optim.Adam(learner.parameters(), lr=3e-4)

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/ultralytics/models/yolo/model.py:23, in YOLO.init(self, model, task, verbose)
20 self.dict = new_instance.dict
21 else:
22 # Continue with default YOLO initialization
---> 23 super().init(model=model, task=task, verbose=verbose)

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/ultralytics/engine/model.py:149, in Model.init(self, model, task, verbose)
147 self._new(model, task=task, verbose=verbose)
148 else:
--> 149 self._load(model, task=task)

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/ultralytics/engine/model.py:230, in Model._load(self, weights, task)
227 weights = checks.check_model_file_from_stem(weights) # add suffix, i.e. yolov8n -> yolov8n.pt
229 if Path(weights).suffix == ".pt":
--> 230 self.model, self.ckpt = attempt_load_one_weight(weights)
231 self.task = self.model.args["task"]
232 self.overrides = self.model.args = self._reset_ckpt_args(self.model.args)

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/ultralytics/nn/tasks.py:855, in attempt_load_one_weight(weight, device, inplace, fuse)
853 def attempt_load_one_weight(weight, device=None, inplace=True, fuse=False):
854 """Loads a single model weights."""
--> 855 ckpt, weight = torch_safe_load(weight) # load ckpt
856 args = {**DEFAULT_CFG_DICT, **(ckpt.get("train_args", {}))} # combine model and default args, preferring model args
857 model = (ckpt.get("ema") or ckpt["model"]).to(device).float() # FP32 model

File ~/Documents/anaconda3/envs/Thibaud1/lib/python3.11/site-packages/ultralytics/nn/tasks.py:785, in torch_safe_load(weight)
783 except ModuleNotFoundError as e: # e.name is missing module name
784 if e.name == "models":
--> 785 raise TypeError(
786 emojis(
787 f"ERROR ❌️ {weight} appears to be an Ultralytics YOLOv5 model originally trained "
788 f"with https://github.com/ultralytics/yolov5.\nThis model is NOT forwards compatible with "
789 f"YOLOv8 at https://github.com/ultralytics/ultralytics."
790 f"\nRecommend fixes are to train a new model using the latest 'ultralytics' package or to "
791 f"run a command with an official Ultralytics model, i.e. 'yolo predict model=yolov8n.pt'"
792 )
793 ) from e
794 LOGGER.warning(
795 f"WARNING ⚠️ {weight} appears to require '{e.name}', which is not in Ultralytics requirements."
796 f"\nAutoInstall will run now for '{e.name}' but this feature will be removed in the future."
797 f"\nRecommend fixes are to train a new model using the latest 'ultralytics' package or to "
798 f"run a command with an official Ultralytics model, i.e. 'yolo predict model=yolov8n.pt'"
799 )
800 check_requirements(e.name) # install missing module

TypeError: ERROR ❌️ /home/thibaud/Documents/Python/Modele_importe/yolov9/gelan-c-seg.pt appears to be an Ultralytics YOLOv5 model originally trained with https://github.com/ultralytics/yolov5.
This model is NOT forwards compatible with YOLOv8 at https://github.com/ultralytics/ultralytics.
Recommend fixes are to train a new model using the latest 'ultralytics' package or to run a command with an official Ultralytics model, i.e. 'yolo predict model=yolov8n.pt'
I'm looking forward for some explanation if you have one, my yolov9 folder is just the clone from github and gelan comes form the github as well. Hope it can help

[glenn-jocher]

Hello @Quanzan04,

Thank you for reaching out and providing the detailed error logs. It seems like you're encountering a ModuleNotFoundError related to the 'models' module, which indicates that the model you are trying to load might be a YOLOv5 model. YOLOv5 models are not forwards compatible with YOLOv9.

To resolve this issue, please ensure the following:

1. Verify Model Compatibility: Double-check that the model you are using (gelan-c-seg.pt) is indeed a YOLOv9 model. If it was trained using YOLOv5, you will need to retrain it using YOLOv9.

2. Update Ultralytics Package: Ensure you are using the latest version of the Ultralytics package. You can update it using:

   pip install --upgrade ultralytics

3. Provide a Reproducible Example: If the issue persists, providing a minimum reproducible example can greatly help in diagnosing the problem. You can find guidelines on how to create one here.

Here is a quick example to get you started with YOLOv9:

from ultralytics import YOLO

# Load a YOLOv9 model
model = YOLO("yolov9c.pt")

# Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

# Run inference with the YOLOv9c model on an image
results = model("path/to/image.jpg")

If you have any further questions or need additional assistance, feel free to ask. We're here to help! 😊

[ShreyasChhetri]

Hi @glenn-jocher I want to train a YoloV9 custom segmentation model. So i have a question regarding the annotation since for detection model we simply use rectangle and extract the .txt file with label number and x,y coordinates so but in segmentation annotation I'm using a polygon which is allowing only JSON format extraction so I have to use .txt file type files only in Segmentation model also ? If yes can you suggest me a good software or library for this type of annotation and extraction.
Thanks

[glenn-jocher]

Hi @ShreyasChhetri,

Great question! For YOLOv9 segmentation models, you can indeed use polygon annotations, which are typically stored in JSON format. However, YOLOv9 supports both JSON and TXT formats for annotations, so you can choose the one that best fits your workflow.

If you prefer to use JSON format for polygon annotations, tools like LabelMe and COCO Annotator are excellent choices. These tools allow you to create and export annotations in JSON format, which can then be used directly with YOLOv9.

Here's a quick example of how you might set up your training with JSON annotations:

from ultralytics import YOLO

# Load a YOLOv9 segmentation model
model = YOLO("yolov9c-seg.pt")

# Train the model on your custom dataset with JSON annotations
results = model.train(data="path/to/your_dataset.json", epochs=100, imgsz=640)

If you still prefer using TXT files, you can convert your JSON annotations to TXT format. There are several scripts available online for this conversion, or you can write a custom script to parse the JSON and output the required TXT format.

For more details on setting up your dataset and annotations, you can refer to our documentation.

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

[ShreyasChhetri]

Hi @glenn-jocher Thank You for your reply but I have one more doubt in this particular line

Train the model on your custom dataset with JSON annotations

results = model.train(data="path/to/your_dataset.json", epochs=100, imgsz=640)
it says here in the data varialble path to dataset .json that means I can only give one JSON file not entire so can you share some light on it
if I have a folder of many JSON files then what can I do ? how will I define the path to my dataset ?

[skyceeee]

Hello, I am using object detection via Jetson Nano with Yolo 9T. But the fps is so bad compared to Yolov8, I wonder why?

[glenn-jocher]

@skyceeee hello,

Thank you for your question! The performance difference you're experiencing between YOLOv9T and YOLOv8 on the Jetson Nano is likely due to the increased complexity and computational demands of YOLOv9. YOLOv9 introduces advanced techniques such as Programmable Gradient Information (PGI) and the Generalized Efficient Layer Aggregation Network (GELAN), which, while improving accuracy and efficiency, can also increase the computational load.

Here are a few steps you can take to potentially improve the FPS:

1. Model Optimization: Consider using TensorRT for model optimization. TensorRT can significantly speed up inference on NVIDIA hardware.

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov9t.pt")
   
   # Export the model to TensorRT
   model.export(format="engine")

2. Batch Size and Image Size: Reducing the batch size and image size can help improve FPS. Ensure you are using the smallest image size that still meets your accuracy requirements.

   yolo predict model=yolov9t.pt source=path/to/video.mp4 imgsz=320 batch=1

3. Precision Mode: Use FP16 precision if your hardware supports it. This can reduce the computational load and improve inference speed.

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov9t.pt")
   
   # Export the model to TensorRT with FP16 precision
   model.export(format="engine", half=True)

4. Ensure Latest Versions: Make sure you are using the latest versions of the Ultralytics package and dependencies. This ensures you benefit from the latest performance improvements and bug fixes.

If you continue to experience issues, please provide a minimum reproducible example so we can better assist you. You can find more information on creating a reproducible example here.

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

[ShreyasChhetri]

Hi can anyone please help me with YoloV9 segmentation training as I'm not able to understand if it requires .txt file or JSON file for the training because I'm only able to extract JSON file from the software I've been using , and if yes can someone please suggest me with what software I can use to extract .txt files for segmentation models ?

[ShreyasChhetri]

Hi @pderrenger I did what you suggested pip install labelme and labelme_json_to_dataset annotation.json running this line for my JSON it just gave me a folder with 3 images the original image the masked image and the annotated image with a txt file with just class names and no annotations at all so how does this work ?
this was just there in the txt file
background
Corrosion
Oxidation
Plating Issue
Scratches

[pderrenger]

Hi @ShreyasChhetri,

Thank you for your detailed follow-up. It looks like the labelme_json_to_dataset command is generating the necessary images but not the expected annotation .txt files. Let's address this step-by-step to ensure you get the correct format for YOLOv9 segmentation training.

Step-by-Step Guide to Convert JSON to YOLO Format

1. Install labelme:

   pip install labelme

2. Convert JSON to Dataset:
   Run the following command to convert your JSON annotation to a dataset:

   labelme_json_to_dataset your_annotation.json

   This will create a directory with the same name as your JSON file, containing the images and a label_names.txt file.

3. Convert to YOLO Format:
   You will need a script to convert the polygon annotations in the JSON file to the YOLO format. Here is a Python script that can help with this conversion:

   import json
   import os
   
   def convert_labelme_to_yolo(json_file, output_dir):
       with open(json_file, 'r') as f:
           data = json.load(f)
   
       image_height = data['imageHeight']
       image_width = data['imageWidth']
       label_file = os.path.join(output_dir, os.path.splitext(os.path.basename(json_file))[0] + '.txt')
   
       with open(label_file, 'w') as f:
           for shape in data['shapes']:
               label = shape['label']
               points = shape['points']
               polygon = []
   
               for point in points:
                   x = point[0] / image_width
                   y = point[1] / image_height
                   polygon.append((x, y))
   
               # Convert polygon to bounding box
               x_coords = [p[0] for p in polygon]
               y_coords = [p[1] for p in polygon]
               x_min = min(x_coords)
               x_max = max(x_coords)
               y_min = min(y_coords)
               y_max = max(y_coords)
               bbox_width = x_max - x_min
               bbox_height = y_max - y_min
               x_center = x_min + bbox_width / 2
               y_center = y_min + bbox_height / 2
   
               # Write to file in YOLO format
               f.write(f"{label} {x_center} {y_center} {bbox_width} {bbox_height}\n")
   
   # Example usage
   json_file = 'path/to/your_annotation.json'
   output_dir = 'path/to/output_directory'
   convert_labelme_to_yolo(json_file, output_dir)

4. Run the Script:
   Save the script as convert_to_yolo.py and run it:

   python convert_to_yolo.py

This script will generate a .txt file for each JSON file, containing the annotations in the YOLO format.

Verify and Use the Generated Files

• Ensure that the generated .txt files are in the same directory as your images.
• The .txt files should have the same name as the corresponding images but with a .txt extension.
• Each line in the .txt file should follow the format: class_id x_center y_center width height.

Additional Resources

For more detailed information on YOLOv9 and its capabilities, you can refer to the YOLOv9 documentation.

If you encounter any further issues or need additional assistance, please feel free to ask. We're here to help! 😊

[ShreyasChhetri]

Hi @pderrenger it is working but it giving me a txt file like this
Scratches 0.07291666666666667 0.5538194444444444 0.13811728395061731 0.03587962962962954
Scratches 0.1122685185185185 0.37499999999999994 0.21682098765432098 0.09722222222222221
Scratches 0.13040123456790123 0.3252314814814815 0.02520576131687241 0.030092592592592615
Scratches 0.14684959349593496 0.4725609756097561 0.03624661246612465 0.015243902439024404
Scratches 0.27625338753387535 0.5177845528455285 0.01795392953929542 0.013211382113821113
Scratches 0.15138888888888888 0.489375 0.006666666666666654 0.009583333333333277
Oxidation 0.40390625 0.6167968749999999 0.07656250000000003 0.13828125000000002
Plating Issue 0.6977163461538461 0.6207932692307692 0.046875 0.033653846153846145
Corrosion 0.5290464743589743 0.8335336538461537 0.18149038461538458 0.058894230769230727
Oxidation 0.44155092592592593 0.7126736111111112 0.3148148148148148 0.10069444444444464
so what to do with the labels id ? like 0 , 1, 2, which we require for training what will we do now ?

[ShreyasChhetri]

Hi @pderrenger
import json
import os

Define the mapping from label names to label IDs

label_to_id = {
'Corrosion': 0,
'Oxidation': 1,
'Plating Issue': 2,
'Scratches': 3
}

def convert_labelme_to_yolo(json_file, output_dir):
with open(json_file, 'r') as f:
data = json.load(f)

image_height = data['imageHeight']
image_width = data['imageWidth']
label_file = os.path.join(output_dir, os.path.splitext(os.path.basename(json_file))[0] + '.txt')

with open(label_file, 'w') as f:
    for shape in data['shapes']:
        label = shape['label']
        points = shape['points']
        polygon = []

        for point in points:
            x = point[0] / image_width
            y = point[1] / image_height
            polygon.append((x, y))

        # Convert polygon to bounding box
        x_coords = [p[0] for p in polygon]
        y_coords = [p[1] for p in polygon]
        x_min = min(x_coords)
        x_max = max(x_coords)
        y_min = min(y_coords)
        y_max = max(y_coords)
        bbox_width = x_max - x_min
        bbox_height = y_max - y_min
        x_center = x_min + bbox_width / 2
        y_center = y_min + bbox_height / 2

        # Get the label ID
        label_id = label_to_id.get(label, -1)  # Default to -1 if label not found

        # Write to file in YOLO format
        f.write(f"{label_id} {x_center} {y_center} {bbox_width} {bbox_height}\n")

Example usage

json_file = r'C:\Users\scc921555\Desktop\json_ex\annotation.json'
output_dir = r'C:\Users\scc921555\Desktop\json_ex'
convert_labelme_to_yolo(json_file, output_dir)

will this code work I have manually mapped an ID to the labels I'm using and now it is giving me
3 0.07291666666666667 0.5538194444444444 0.13811728395061731 0.03587962962962954
3 0.1122685185185185 0.37499999999999994 0.21682098765432098 0.09722222222222221
3 0.13040123456790123 0.3252314814814815 0.02520576131687241 0.030092592592592615
3 0.14684959349593496 0.4725609756097561 0.03624661246612465 0.015243902439024404
3 0.27625338753387535 0.5177845528455285 0.01795392953929542 0.013211382113821113
3 0.15138888888888888 0.489375 0.006666666666666654 0.009583333333333277
1 0.40390625 0.6167968749999999 0.07656250000000003 0.13828125000000002
2 0.6977163461538461 0.6207932692307692 0.046875 0.033653846153846145
0 0.5290464743589743 0.8335336538461537 0.18149038461538458 0.058894230769230727
1 0.44155092592592593 0.7126736111111112 0.3148148148148148 0.10069444444444464
2 0.7953125 0.770703125 0.07499999999999996 0.030468749999999933
1 0.83984375 0.6984375 0.2567708333333334 0.12187500000000007
like this so this will work right ?

[pderrenger]

Hi @ShreyasChhetri,

Your approach to manually mapping label names to IDs is correct and essential for YOLO training. The updated script you provided should work well for converting your JSON annotations to the required YOLO format. Here’s a refined version of your script to ensure everything is clear and efficient:

import json
import os

# Define the mapping from label names to label IDs
label_to_id = {
    'Corrosion': 0,
    'Oxidation': 1,
    'Plating Issue': 2,
    'Scratches': 3
}

def convert_labelme_to_yolo(json_file, output_dir):
    with open(json_file, 'r') as f:
        data = json.load(f)

    image_height = data['imageHeight']
    image_width = data['imageWidth']
    label_file = os.path.join(output_dir, os.path.splitext(os.path.basename(json_file))[0] + '.txt')

    with open(label_file, 'w') as f:
        for shape in data['shapes']:
            label = shape['label']
            points = shape['points']
            polygon = []

            for point in points:
                x = point[0] / image_width
                y = point[1] / image_height
                polygon.append((x, y))

            # Convert polygon to bounding box
            x_coords = [p[0] for p in polygon]
            y_coords = [p[1] for p in polygon]
            x_min = min(x_coords)
            x_max = max(x_coords)
            y_min = min(y_coords)
            y_max = max(y_coords)
            bbox_width = x_max - x_min
            bbox_height = y_max - y_min
            x_center = x_min + bbox_width / 2
            y_center = y_min + bbox_height / 2

            # Get the label ID
            label_id = label_to_id.get(label, -1)  # Default to -1 if label not found

            # Write to file in YOLO format
            f.write(f"{label_id} {x_center} {y_center} {bbox_width} {bbox_height}\n")

# Example usage
json_file = r'C:\Users\scc921555\Desktop\json_ex\annotation.json'
output_dir = r'C:\Users\scc921555\Desktop\json_ex'
convert_labelme_to_yolo(json_file, output_dir)

Key Points:

• Label Mapping: Ensure that the label_to_id dictionary correctly maps all the labels present in your dataset.
• Output Verification: Verify that the generated .txt files are correctly formatted and contain the expected label IDs and bounding box coordinates.

Next Steps:

1. Verify the Output: Check the generated .txt files to ensure they match the expected YOLO format.
2. Training: Use these .txt files along with your images to train your YOLOv9 segmentation model.

For more detailed information on YOLOv9 and its capabilities, you can refer to the YOLOv9 documentation.

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

[Varun3713-creator]

Hi @pderrenger ,
i am trying to load my trained yolov9 model on custom dataset, but I am facing the issue as

ModuleNotFoundError: No module named 'models'

TypeError: ERROR readyall60epgelan.pt appears to be an Ultralytics YOLOv5 model originally trained with https://github.com/ultralytics/yolov5.
This model is NOT forwards compatible with YOLOv8 at https://github.com/ultralytics/ultralytics.
Recommend fixes are to train a new model using the latest 'ultralytics' package or to run a command with an official Ultralytics model, i.e. 'yolo predict model=yolov8n.pt'

but my ultralytics version is upto date: 8.2.48 . can you please help my with this. I have share my code below for reference

code:

from ultralytics import YOLO
import cv2
import cvzone
import math

def image():
model = YOLO('readyall60epgelan.pt')
img = input("add address:")
results = model("images/" + img, show=True)
cv2.waitKey(0)

image()

[pderrenger]

Hi @Varun3713-creator,

Thank you for reaching out! It looks like you're encountering an issue with loading your trained YOLOv9 model. The error message indicates that the model you're trying to load (readyall60epgelan.pt) is recognized as a YOLOv5 model, which is not forward-compatible with YOLOv8.

To help resolve this, please ensure the following:

1. Verify Model Compatibility: Make sure that your model is indeed a YOLOv9 model. If it was trained using the YOLOv5 framework, it won't be compatible with YOLOv8 or YOLOv9. You may need to retrain your model using the latest Ultralytics package.

2. Update Ultralytics Package: Although you mentioned your Ultralytics version is up-to-date, please double-check by running:

   pip install --upgrade ultralytics

3. Reproducible Example: Providing a minimum reproducible example can greatly assist in diagnosing the issue. You can refer to our guide on creating a reproducible example here: Minimum Reproducible Example.

4. Code Example: Here's a basic example to load a YOLOv9 model and run inference:

   from ultralytics import YOLO
   import cv2
   
   def image():
       model = YOLO('yolov9c.pt')  # Ensure this is a YOLOv9 model
       img = input("add address:")
       results = model("images/" + img, show=True)
       cv2.waitKey(0)
   
   image()

If the issue persists, please share more details about how the model was trained and any additional error messages you might be seeing. This will help us provide more targeted assistance.

For more information on YOLOv9 and its capabilities, you can visit our documentation: YOLOv9 Documentation.

[Varun3713-creator]

Hi @pderrenger,
Thank you for replying ,I indeed train it with YOLOv9,I cloned repository from the below link.

!git clone https://github.com/SkalskiP/yolov9.git

and my ultralytics library is up-to-date ; it's version:8.2.48

I used the weights gelan-c:
!wget -P {HOME}/weights -q https://github.com/WongKinYiu/yolov9/releases/download/v0.1/yolov9-e.pt
!wget -P {HOME}/weights -q https://github.com/WongKinYiu/yolov9/releases/download/v0.1/gelan-c.pt

code that I used to train:
!python train.py
--batch 16 --epochs 50 --img 640 --device 0 --min-items 0 --close-mosaic 15
--data /content/drive/MyDrive/readyallclasses/data.yaml
--weights {HOME}/weights/gelan-c.pt
--cfg models/detect/gelan-c.yaml
--hyp hyp.scratch-high.yaml

kindly check if anything is wrong and please share if any code or modifications that I should do.

[pderrenger]

Hi @Varun3713-creator,

Thank you for providing additional details. It looks like you're using the YOLOv9 repository from SkalskiP and training with weights from WongKinYiu. Given that you're encountering compatibility issues, let's ensure everything is set up correctly.

Steps to Resolve the Issue:

1. Verify YOLOv9 Model Compatibility:
   Ensure that the model you're using is indeed compatible with the Ultralytics framework. The error suggests a potential mismatch between the model architecture and the framework version.

2. Check for Latest Updates:
   Even though your Ultralytics library is up-to-date, please ensure that the YOLOv9 repository and the weights you're using are also the latest versions. Sometimes, updates in the repository can resolve compatibility issues.

3. Reproducible Example:
   Providing a minimum reproducible example can greatly assist in diagnosing the issue. You can refer to our guide on creating a reproducible example here: Minimum Reproducible Example.

Example Code for Loading and Running YOLOv9:

Here's an example of how you can load and run inference with a YOLOv9 model using the Ultralytics framework:

from ultralytics import YOLO
import cv2

def image():
    model = YOLO('yolov9c.pt')  # Ensure this is a YOLOv9 model
    img = input("Add address: ")
    results = model("images/" + img, show=True)
    cv2.waitKey(0)

image()

Training Example:

If you need to retrain your model, here's a basic example:

from ultralytics import YOLO

# Load the YOLOv9c model configuration
model = YOLO("yolov9c.yaml")

# Train the model on your custom dataset
results = model.train(data="/content/drive/MyDrive/readyallclasses/data.yaml", epochs=50, imgsz=640)

Additional Resources:

For more detailed information on YOLOv9 and its capabilities, you can visit our documentation: YOLOv9 Documentation.

If the issue persists, please share more details about how the model was trained and any additional error messages you might be seeing. This will help us provide more targeted assistance.

[emira99]

How do I know performance evaluation of test for each class exist in my custom data set ?

[glenn-jocher]

@emira99 hi there!

To evaluate the performance of your YOLOv9 model for each class in your custom dataset, you can use the validation mode which provides detailed metrics including mean Average Precision (mAP) for each class. Here’s how you can do it:

Using Python:

from ultralytics import YOLO

# Load your trained model
model = YOLO("path/to/your_model.pt")

# Validate the model on your custom dataset
metrics = model.val(data="path/to/your_dataset.yaml")

# Access class-specific metrics
for class_name, class_metrics in metrics.items():
    print(f"Class: {class_name}, mAP: {class_metrics['map']}")

Using CLI:

# Validate your trained model on your custom dataset
yolo val model=path/to/your_model.pt data=path/to/your_dataset.yaml

This will output detailed performance metrics for each class in your dataset. If you encounter any issues, please ensure you are using the latest version of the Ultralytics package and provide a minimum reproducible example if the problem persists. You can find more information on how to create one here: Minimum Reproducible Example.

For further details, you can refer to the YOLOv9 documentation.

Best of luck with your project! 🚀

[Varun3713-creator]

@emira99 hi there!

To evaluate the performance of your YOLOv9 model for each class in your custom dataset, you can use the validation mode which provides detailed metrics including mean Average Precision (mAP) for each class. Here’s how you can do it:

Using Python:

from ultralytics import YOLO

# Load your trained model
model = YOLO("path/to/your_model.pt")

# Validate the model on your custom dataset
metrics = model.val(data="path/to/your_dataset.yaml")

# Access class-specific metrics
for class_name, class_metrics in metrics.items():
    print(f"Class: {class_name}, mAP: {class_metrics['map']}")

Using CLI:

# Validate your trained model on your custom dataset
yolo val model=path/to/your_model.pt data=path/to/your_dataset.yaml

This will output detailed performance metrics for each class in your dataset. If you encounter any issues, please ensure you are using the latest version of the Ultralytics package and provide a minimum reproducible example if the problem persists. You can find more information on how to create one here: Minimum Reproducible Example.

For further details, you can refer to the YOLOv9 documentation.

Best of luck with your project! 🚀

Hai @glenn-jocher ,
Can you share the code for testing the model on test inages for the train ed model
Code:
from ultralytics import YOLO

Load a YOLOv9 model

model = YOLO("yolov9s.pt")

Train the model on your dataset

results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)

[glenn-jocher]

Hi @Varun3713-creator,

Thank you for your question! To test your trained YOLOv9 model on test images, you can use the predict mode. This will allow you to run inference on your test dataset and evaluate the model's performance. Here's how you can do it:

Using Python:

from ultralytics import YOLO

# Load your trained model
model = YOLO("path/to/your_model.pt")

# Run inference on your test images
results = model.predict(source="path/to/your/test_images", save=True)

# Access and print the results
for result in results:
    print(result)

Using CLI:

# Run inference on your test images
yolo predict model=path/to/your_model.pt source=path/to/your/test_images save

This will output the predictions for each image in your test set and save the results if you set save=True. If you encounter any issues, please ensure you are using the latest version of the Ultralytics package. Additionally, providing a minimum reproducible example can help us diagnose any problems more effectively. You can find more information on how to create one here: Minimum Reproducible Example.

For further details, you can refer to the YOLOv9 documentation.

Best of luck with your testing! 🚀

[ShreyasChhetri]

Hi @pderrenger @glenn-jocher
I went with your python script suggestion of changing JSON to YOLO and it is giving me this kind of a result
3 0.07291666666666667 0.5538194444444444 0.13811728395061731 0.03587962962962954
3 0.1122685185185185 0.37499999999999994 0.21682098765432098 0.09722222222222221
3 0.13040123456790123 0.3252314814814815 0.02520576131687241 0.030092592592592615
3 0.14684959349593496 0.4725609756097561 0.03624661246612465 0.015243902439024404
3 0.27625338753387535 0.5177845528455285 0.01795392953929542 0.013211382113821113
3 0.15138888888888888 0.489375 0.006666666666666654 0.009583333333333277
1 0.40390625 0.6167968749999999 0.07656250000000003 0.13828125000000002
2 0.6977163461538461 0.6207932692307692 0.046875 0.033653846153846145
0 0.5290464743589743 0.8335336538461537 0.18149038461538458 0.058894230769230727

and also after surfing for a while I came across labelme2yolo library of python and it changed the JSON file into something like this
2 0.3526234567901234 0.6168981481481481 0.3611111111111111 0.6168981481481481 0.37345679012345673 0.6157407407407407 0.37654320987654316 0.6238425925925926 0.37114197530864196 0.6400462962962963 0.36033950617283944 0.6423611111111112 0.3533950617283951 0.6331018518518519 0.3479938271604938 0.6273148148148148
2 0.7561728395061729 0.3449074074074074 0.7615740740740741 0.33564814814814814 0.7723765432098766 0.3368055555555556 0.7716049382716049 0.3460648148148148 0.7646604938271605 0.35763888888888884
2 0.7299382716049382 0.6064814814814814 0.7276234567901234 0.5902777777777777 0.7384259259259259 0.5717592592592592 0.7476851851851851 0.5810185185185185 0.746141975308642 0.5914351851851852
2 0.7314814814814815 0.6458333333333333 0.7376543209876544 0.6342592592592592 0.7453703703703702 0.6388888888888888 0.7391975308641975 0.6504629629629629
2 0.5509259259259259 0.3680555555555556 0.5509259259259259 0.35648148148148145 0.5555555555555555 0.35185185185185186 0.5655864197530864 0.35416666666666663 0.558641975308642 0.3680555555555556
0 0.38811728395061723 0.7175925925925926 0.37885802469135804 0.7025462962962962 0.3858024691358024 0.6782407407407408 0.39814814814814814 0.6539351851851852 0.4251543209876543 0.6504629629629629 0.46296296296296285 0.6504629629629629 0.4915123456790123 0.6597222222222221 0.5354938271604939 0.6712962962962963 0.558641975308642 0.6828703703703703 0.5648148148148149 0.6956018518518517 0.5609567901234567 0.7164351851851852 0.51929012345679 0.7175925925925926 0.4645061728395062 0.7210648148148148 0.4328703703703703 0.7256944444444444
so what do you think I should go for the above one or the below one ??
please help
Thanks

[glenn-jocher]

Hi @ShreyasChhetri,

Thank you for sharing your results and the different outputs from the JSON to YOLO conversion. It looks like you're getting two different formats for your annotations, which can indeed be confusing.

The first format you shared:

3 0.07291666666666667 0.5538194444444444 0.13811728395061731 0.03587962962962954
...

This format represents the YOLO annotation format, where each line corresponds to an object in the image with the following structure:

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

The values are normalized between 0 and 1.

The second format you shared from the labelme2yolo library:

2 0.3526234567901234 0.6168981481481481 0.3611111111111111 0.6168981481481481 ...
...

This format appears to be for instance segmentation, where the coordinates represent the polygon points of the segmented object.

To determine which format to use, consider the task you are working on:

• Object Detection: Use the first format, which is the standard YOLO format for bounding boxes.
• Instance Segmentation: Use the second format if you are working with segmentation tasks, as it includes the polygon points for each object.

If you are working with YOLOv9 for object detection, the first format is the appropriate choice. For instance segmentation tasks, the second format would be more suitable.

Additionally, ensure you are using the latest version of the Ultralytics packages to avoid any compatibility issues. If you encounter any further issues, providing a minimum reproducible example can 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!

[ShreyasChhetri]

Hi I was able to train my custom dataset with Yolov9 segmentation model ,
I just want to know that the in the result which we will get
how many parameters can be extracted from that particular result ?
like for object detection it was bounding box coordinates normalised coordinates etc so what can I expect from the segmentation model result ?

[pderrenger]

@ShreyasChhetri hi there!

Great to hear that you've successfully trained your custom dataset with the YOLOv9 segmentation model! 🎉

When you run inference with a YOLOv9 segmentation model, you can expect to extract several key parameters from the results, similar to object detection but with additional segmentation-specific outputs. Here are the main parameters you can extract:

1. Bounding Box Coordinates: These are the coordinates of the bounding boxes around detected objects, similar to object detection models.
2. Normalized Coordinates: The bounding box coordinates normalized to the image dimensions.
3. Class Labels: The predicted class labels for each detected object.
4. Confidence Scores: The confidence scores associated with each detection.
5. Segmentation Masks: The pixel-wise masks for each detected object, which provide a detailed outline of the object within the bounding box.

Here’s a quick example of how you can access these parameters in Python:

from ultralytics import YOLO

# Load your trained YOLOv9 segmentation model
model = YOLO("path/to/your/yolov9-seg.pt")

# Run inference on an image
results = model("path/to/your/image.jpg")

# Extracting parameters
for result in results:
    boxes = result.boxes  # Bounding boxes
    masks = result.masks  # Segmentation masks
    classes = result.names  # Class labels
    confidences = result.boxes.conf  # Confidence scores

    # Example: Print bounding box coordinates and class labels
    for box, cls, conf in zip(boxes.xyxy, classes, confidences):
        print(f"Class: {cls}, Confidence: {conf}, Box: {box}")

For more detailed information on the YOLOv9 model and its capabilities, you can refer to the YOLOv9 documentation.

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

[Varun3713-creator]

Hai @pderrenger ,
I have initalized epochs as 200 at the beginning pf the training but model is model is achieving precision of 0.99 at the 80 epochs .so I want to change the epochs from 200 to 100 can I do that??

[pderrenger]

Hi @Varun3713-creator,

Great to hear about your progress with the training! If your model is achieving a precision of 0.99 at 80 epochs and you want to stop training early, you can certainly do that. Here's how you can adjust the training process:

1. Early Stopping: If you want to stop the training manually, you can simply interrupt the process. However, for a more automated approach, you can use early stopping by setting the patience parameter. This will stop the training if the model's performance does not improve for a specified number of epochs.

2. Resume Training: If you want to resume training later or adjust the number of epochs, you can use the resume argument. For example:

   yolo train resume model=path/to/your/model.pt epochs=100

3. Adjusting Epochs in Code: If you are using Python, you can adjust the epochs directly in your training script:

   from ultralytics import YOLO
   
   # Load your model
   model = YOLO('path/to/your/model.pt')
   
   # Resume training with adjusted epochs
   results = model.train(data='coco128.yaml', epochs=100, imgsz=640)

For more details on training and other functionalities, you can refer to the YOLOv9 documentation.

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

[Varun3713-creator]

Hai @pderrenger ,
I have initially specified 200 but the below command is applicable if we want to increase nimber of epochs right??.
yolo train resume model=path/to/your/model.pt epochs=100

but I want to reduce not increase and if I interrupt manually I won't be able to get the graph and confusion matrix.So I am bit confused.

[pderrenger]

Hi @Varun3713-creator,

Thank you for your question! If you want to reduce the number of epochs from 200 to 100, you can indeed interrupt the training manually. However, to ensure you still get the graphs and confusion matrix, you can use the early stopping mechanism or adjust the training script accordingly.

Option 1: Early Stopping

You can set the patience parameter to stop training early if the model's performance plateaus. For example:

from ultralytics import YOLO

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

# Train with early stopping
results = model.train(data='coco128.yaml', epochs=200, patience=20, imgsz=640)

This will stop training if there is no improvement in the validation metrics for 20 epochs.

Option 2: Adjusting Epochs in Code

If you prefer to manually adjust the epochs, you can resume training with fewer epochs:

from ultralytics import YOLO

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

# Resume training with adjusted epochs
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)

This will effectively reduce the total number of epochs to 100.

Option 3: Manual Interruption

If you manually interrupt the training, you can still generate the graphs and confusion matrix by running the validation script on the saved model:

from ultralytics import YOLO

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

# Validate the model to generate metrics and graphs
results = model.val(data='coco128.yaml', imgsz=640)

I hope this helps! Feel free to reach out if you have any more questions. 😊

[Quanzan04]

Hello !
I want to know if we can combine some yolo model : I trained 5 yolov9 models on different dataset (each dataset is only composed by one class), so that each trained yolo model is very good at his task. Now I want to combine this 5 in one model in order for me to have to do only one inference to detect my five classes and not having to put my images in 5 differents models.
Thanks in advance for your help

[glenn-jocher]

@Quanzan04 hello!

Combining multiple YOLO models into a single model to handle multiple classes is a great idea for efficiency. Here’s how you can approach this:

1. Unified Dataset: Combine your datasets into one, ensuring each image is labeled with the appropriate class. This way, you can train a single model that recognizes all classes.

2. Training: Train a new YOLOv9 model on this unified dataset. This will allow the model to learn to detect all classes in one go.

Here’s a quick example in Python:

from ultralytics import YOLO

# Load a YOLOv9 model
model = YOLO('yolov9c.yaml')  # or yolov9c.pt for pretrained weights

# Train the model on the combined dataset
results = model.train(data='combined_dataset.yaml', epochs=100, imgsz=640)

And using CLI:

yolo train model=yolov9c.yaml data=combined_dataset.yaml epochs=100 imgsz=640

Ensure your combined_dataset.yaml file correctly references your unified dataset.

For more details, you can refer to the YOLOv9 documentation.

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