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")

[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.

[UttamMahapatraToni]

@Burhan-Q as you mentioned above 'GitHub you linked isn't the original author's GitHub' .
can you please suggest me, how to download the original Github repo and use it to train on my custom dataset?

[Burhan-Q]

@UttamMahapatraToni you can find the link to the author's GitHub repository on our Documentation page for YOLOv9. Of course we would invite you to use the Ultralytics implementation of YOLOv9 for the added benefits and stability that comes with using ultralytics.

[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

[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.

[Shoaibabidi]

I have trained a custom YOLOv9 model. and I need the coordinates of the detected objects. can someone help me get that coz I only get the images with bounding boxes and confidence score over it nothing else. I just need the labels and coordinates of the detected object.

here's how my results looks like:
image 1/1 /content/TEXT_Final.png: 640x640 1 2T, 2 Buss, 1 Cable, 1 DY, 1 Feeder, 1 Lamp, 1 Motor, 52.4ms
Speed: 6.1ms preprocess, 52.4ms inference, 1.8ms postprocess per image at shape (1, 3, 640, 640)
Results saved to runs/detect/predict

[glenn-jocher]

@Shoaibabidi hey there!

It looks like you need the labels and coordinates of the detected objects instead of just the visual output. You can achieve this by accessing the detection results programmatically.

Here's a simple example using Python:

from ultralytics import YOLO

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

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

# Accessing labels and bounding box coordinates
for result in results:
    labels = result.names  # Get the class names
    boxes = result.boxes  # Get the bounding boxes
    for i, box in enumerate(boxes):
        print(f'Label: {labels[box.cls]}, Coordinates: {box.xyxy}')

This code will print out the labels and the bounding box coordinates for each detected object in the format [x1, y1, x2, y2], where (x1, y1) are the coordinates of the top-left corner, and (x2, y2) are the coordinates of the bottom-right corner of the bounding box.

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

[ahsannadir]

I have trained a YOLOv9 model on a custom dataset. Now when I load the model weights with YOLO from ultralytics then it throws this error.

TypeError: ERROR ❌️ model/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'

[pderrenger]

Hello! It looks like you're trying to load a model trained with an earlier version of the YOLO architecture, which is unfortunately not forward-compatible with YOLOv8.

To resolve this issue, you have two main options:

1. Retrain your model using the latest model architecture provided by YOLOv8, which is available in the Ultralytics repository.
2. Use a compatible environment for your current model version.

If you opt for retraining and need to transfer what you've already trained, you can initialize the YOLOv8 model with your YOLOv9 weights where compatible, although full conversions might not carry over all elements due to changes in the architecture.

Here's a basic example of how you might load the weights in Python, making sure to handle any compatibility issues:

from ultralytics import YOLO

# Load your custom model with potential adjustments for compatibility
try:
    model = YOLO('path/to/best.pt')  # Adjust path as necessary
except RuntimeError as e:
    print("Compatibility issue:", e)

# Depending on the types of errors you encounter, you may need specific adaptations

Make sure to review the specifics of the models and compatibility considerations in the Ultralytics documentation or consider reaching out for support on specific issues! Hope this helps! 🚀

[ahsannadir]

Thank You. I managed it to work by updating torch and torchvision. Now when I use the model to predict an image I get this error:

TypeError: BaseModel.fuse() got an unexpected keyword argument 'verbose'

[pderrenger]

@ahsannadir hi there! 🚀

Thanks for updating torch and torchvision to resolve your earlier issue. Regarding the new error you're experiencing with BaseModel.fuse(), it seems like you're using an outdated method or an argument that does not exist in the current version of the model you are using.

To resolve the TypeError, make sure you are not using the verbose keyword in your fuse() method call. Since the latest fuse() method may not support that argument, simply calling fuse() without any arguments should work:

model.fuse()

If you still run into trouble, feel free to check the method documentation or ask here for more detailed assistance! Happy coding! 😊

[vm7608]

@ahsannadir @pderrenger hi there, i face the same issue, I train yolov9-e for detection problem based on the original repo of yolov9 at https://github.com/WongKinYiu/yolov9. Now, when i load the trained weights using ultralytics, i got this error:

TypeError: ERROR ❌️ model/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'

I also try load by yaml file but it return the error too:

Traceback (most recent call last):
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 830, in _smart_load
    return self.task_map[self.task][key]
KeyError: None

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

Traceback (most recent call last):
  File "/home/manhckv/manhckv/ultralytics/check_model_info.py", line 16, in <module>
    model = YOLO("/home/manhckv/manhckv/ultralytics/yolov9-custom.yaml")
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/models/yolo/model.py", line 23, in __init__
    super().__init__(model=model, task=task, verbose=verbose)
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 150, in __init__
    self._new(model, task=task, verbose=verbose)
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 219, in _new
    self.model = (model or self._smart_load("model"))(cfg_dict, verbose=verbose and RANK == -1)  # build model
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 834, in _smart_load
    raise NotImplementedError(
NotImplementedError: WARNING ⚠️ 'YOLO' model does not support '_new' mode for 'None' task yet.

How can i fix this?

[Kamal-Moha]

When I try using model.predict() in yolov9, I get this error: TypeError: BaseModel.fuse() got an unexpected keyword argument 'verbose'

Below is the code trying to do the model prediction;

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)] 

During the training, I have cloned the repo: https://github.com/SkalskiP/yolov9.git because the colab notebook in the official github(https://github.com/WongKinYiu/yolov9) suggested to that.

I also tried doing model.fuse() but still get the same error.

Please help me fix this error: TypeError: BaseModel.fuse() got an unexpected keyword argument 'verbose'

[glenn-jocher]

Hello! It seems like there might be an issue with a mismatch between the function definitions and their usage in your code. The BaseModel.fuse() method in your setup does not take a verbose keyword argument, which is causing the error you're experiencing.

To resolve this, try removing or commenting out any calls to model.fuse() in your code if you're not specifying any arguments to it. Usually, model.fuse() is not needed for making predictions unless you explicitly need to fuse the model for performance optimizations.

Here’s how your prediction code should look without model.fuse():

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)] 

Try running your prediction code again after making these adjustments. If you encounter further issues, don't hesitate to ask. Happy coding! 😊

[Kamal-Moha]

@glenn-jocher I still get the same error of "TypeError: BaseModel.fuse() got an unexpected keyword argument 'verbose' ". I still get the same BaseModel.fuse() error when I remove the model.fuse(). Kindly guide me on how to fix this, thanks

[glenn-jocher]

Hi there! It seems like you're encountering a persistent issue with the BaseModel.fuse() method. If you're still seeing the error even after removing the model.fuse() call, it's possible that the method is being invoked internally by another function in the library.

Here are a couple of steps you can take to troubleshoot and potentially resolve this issue:

1. Update Your Library: Ensure that you are using the latest version of the Ultralytics YOLO library. Sometimes, these types of errors are resolved in newer releases.

   pip install --upgrade ultralytics

2. Check for Internal Calls: Look through the code or documentation to see if model.fuse() is called internally within any methods you are using. If it is, you might need to modify the source code or wait for an update that fixes the issue.

3. Review Error Logs: If possible, check the full traceback of the error to see exactly where the verbose argument is being incorrectly passed to fuse(). This might give you more context on where the problem lies.

4. Contact Support: If you're still stuck, consider reaching out to the Ultralytics support or community forums with details of the issue. There might be others who have faced the same problem or updates on when a fix will be available.

If you need further assistance or have more details to share, feel free to reach out. Happy coding! 😊

[zohaibjan]

Is there a export weights py script for YOLOV9 ?. I tried using the one that was provided for yolov8 and it failed. Also, I could not find config_infer_primary_yolov9.txt. Can we use the same configs that were used for yolov8 ?

[pderrenger]

@zohaibjan hey there! Thanks for reaching out about the YOLOv9 model exporting. As of now, the export script for YOLOv9 differs from the one used for YOLOv8, and the configurations might not be directly compatible due to changes in model architecture and design.

If you’re looking for the configuration specific to YOLOv9 (config_infer_primary_yolov9.txt), it doesn’t appear to exist under the same naming convention or might not be required for YOLOv9. The configuration settings from YOLOv8 might need adjustments to work correctly with YOLOv9.

An excellent starting approach would be to directly use the YOLOv9 YAML files provided for training, as YOLOv9 builds upon the setup of YOLOv5, which also uses YAML files for configuration. If specific exporting features or further guidance is needed, it’s usually a good idea to check the latest updates in the official Ultralytics GitHub repo or the YOLOv9 documentation.

For exporting YOLOv9, you can generally follow the standard export procedures detailed for other models but customized for the YOLOv9 architecture. If any other questions come up, feel free to ask. Here's a quick outline of how you might do it:

from ultralytics import YOLO

# Load YOLOv9 model
model = YOLO('yolov9c.pt')  # Ensure you select the right model file

# Export the model to ONNX
model.export(format='onnx', imgsz=(640, 640))

Let me know if there's anything else I can help with! 😊

[zohaibjan]

The thing is I want to be able to integrate it within Deepstream like with YoloV8. Is there currently anyway to use it with the deepstream-app ?.

[pderrenger]

Hey there! Integrating YOLOv9 with DeepStream, similar to YOLOv8, is indeed a great way to leverage NVIDIA's optimizations for real-time streaming and inference on the edge. Currently, YOLOv9 should ideally connect with DeepStream using a custom parser for its output, considering the introduction of new model efficiencies and formats like PGI.

For YOLOv9, you might need to adapt or create new configuration files tailored to its specific architecture and output format. While some components from YOLOv8 configs might be reusable, such as transformations and pre-processing, the specific details related to output layers or custom layers added in YOLOv9 will need unique handling.

Here’s a general approach to get you started:

1. Ensure Your Model is in the Right Format: Convert YOLOv9 to an ONNX format as DeepStream supports this with NVIDIA's nvonnxparser.
2. Config File Adjustments: You'd have to tweak or write new custom parsers that understand YOLOv9’s output schema to integrate into config_infer_primary.txt for Deepstream.
3. DeepStream Integration: Use the adapted config files to run your model with DeepStream. Make sure it reflects any new layers or different output strategies used by YOLOv9.

# Sample command to convert model to ONNX might look like:
yolo export model=yolov9c.pt format=onnx imgsz=640,640

Keep an eye on the official repositories and documentation updates for more detailed guides specifically geared towards YOLOv9 and DeepStream compatibility. 🚀

[FaiqaShabbir]

Hi!
Is this possible to fine tune yolo for virtual try on ??

[glenn-jocher]

@FaiqaShabbir hello! Yes, fine-tuning a YOLO model like YOLOv8 for virtual try-on scenarios is definitely possible. YOLO models are often used for object detection tasks, which can be adapted to segment and identify clothing items on persons in images or video feeds.

For a virtual try-on application, you'd typically start by training the model to recognize different clothing items. Here’s a simple example of how you could begin fine-tuning a model with your custom dataset:

from ultralytics import YOLO

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

# Fine-tune the model on your custom dataset
results = model.train(data='your_dataset.yaml', epochs=50, imgsz=640)

Ensure your dataset is annotated properly to identify different clothing items. You might need additional post-processing steps to adapt the model outputs for a virtual try-on feature.

If you have any more specific questions or need further guidance on setting up your project, feel free to ask! 🚀

[FaiqaShabbir]

but as you know there are different files related to data of clothes here check the hierarchy [image: image.png] kindly guide me through the process

…

On Tue, May 14, 2024 at 6:30 PM Glenn Jocher ***@***.***> wrote: @FaiqaShabbir <https://github.com/FaiqaShabbir> hello! Yes, fine-tuning a YOLO model like YOLOv8 for virtual try-on scenarios is definitely possible. YOLO models are often used for object detection tasks, which can be adapted to segment and identify clothing items on persons in images or video feeds. For a virtual try-on application, you'd typically start by training the model to recognize different clothing items. Here’s a simple example of how you could begin fine-tuning a model with your custom dataset: from ultralytics import YOLO # Load a pretrained modelmodel = YOLO('yolov8n.pt') # Load the YOLOv8 model # Fine-tune the model on your custom datasetresults = model.train(data='your_dataset.yaml', epochs=50, imgsz=640) Ensure your dataset is annotated properly to identify different clothing items. You might need additional post-processing steps to adapt the model outputs for a virtual try-on feature. If you have any more specific questions or need further guidance on setting up your project, feel free to ask! 🚀 — Reply to this email directly, view it on GitHub <#8484 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AVWDKWLIRP5MPSI4M64KNZDZCIGXDAVCNFSM6AAAAABD3G5JQ2VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TIMZTHE2TK> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

Hi! It looks like you need some guidance on how your data directories should be structured for training on clothing datasets. The screenshot you've attached would be very helpful in pointing you in the right direction, but unfortunately, I can't view images directly here.

However, I can guide you on setting up your dataset configuration file, typically a YAML format, which you'll reference when training your model. Here’s a basic guide:

1. Ensure your dataset folder is organized, ideally with two subfolders, images and labels, where your image files and corresponding label files are stored, respectively.
2. Your label files should match the filenames of the image files but with a .txt extension.
3. Inside your YAML dataset configuration file, define the paths to your training and validation sets, class names, etc.

Here's a simple example of what your YAML file (data.yaml) could look like:

train: ./data/clothes/images/train/  # path to training images
val: ./data/clothes/images/val/  # path to validation images

nc: 5  # number of classes
names: ['T-shirt', 'Dress', 'Shorts', 'Shoes', 'Hat']  # class names

4. Finally, reference this YAML file when starting your training using:

from ultralytics import YOLO

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

# Start training
results = model.train(data='data.yaml', epochs=50, imgsz=640)

This setup will guide you through using your clothing dataset for training the YOLO model effectively. If you have any more questions or need further assistance, feel free to ask! 🌟

[FaiqaShabbir]

i need it i want to fine tune it i don't know how to do it On Tue, May 14, 2024 at 6:57 PM Faiqa Shabbir ***@***.***> wrote:

…

but as you know there are different files related to data of clothes here check the hierarchy [image: image.png] kindly guide me through the process On Tue, May 14, 2024 at 6:30 PM Glenn Jocher ***@***.***> wrote: > @FaiqaShabbir <https://github.com/FaiqaShabbir> hello! Yes, fine-tuning > a YOLO model like YOLOv8 for virtual try-on scenarios is definitely > possible. YOLO models are often used for object detection tasks, which can > be adapted to segment and identify clothing items on persons in images or > video feeds. > > For a virtual try-on application, you'd typically start by training the > model to recognize different clothing items. Here’s a simple example of how > you could begin fine-tuning a model with your custom dataset: > > from ultralytics import YOLO > # Load a pretrained modelmodel = YOLO('yolov8n.pt') # Load the YOLOv8 model > # Fine-tune the model on your custom datasetresults = model.train(data='your_dataset.yaml', epochs=50, imgsz=640) > > Ensure your dataset is annotated properly to identify different clothing > items. You might need additional post-processing steps to adapt the model > outputs for a virtual try-on feature. > > If you have any more specific questions or need further guidance on > setting up your project, feel free to ask! 🚀 > > — > Reply to this email directly, view it on GitHub > <#8484 (reply in thread)>, > or unsubscribe > <https://github.com/notifications/unsubscribe-auth/AVWDKWLIRP5MPSI4M64KNZDZCIGXDAVCNFSM6AAAAABD3G5JQ2VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TIMZTHE2TK> > . > You are receiving this because you were mentioned.Message ID: > ***@***.*** > com> >

[glenn-jocher]

Hi Faiqa,

Great to hear you're interested in fine-tuning a YOLOv8 model for your clothing data! Here’s a simple guide to get you started:

1. Prepare Your Dataset: Ensure your dataset is structured properly, with images and corresponding annotations. Your dataset directory should look something like this:

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

   Each image in the images folder should have a corresponding annotation file in the labels folder.

2. Create a Dataset YAML File: This file describes your dataset's path and classes. Here’s an example (clothes.yaml):

   train: dataset/images/train/
   val: dataset/images/val/
   
   nc: 10  # number of classes
   names: ['T-shirt', 'Dress', 'Jeans', ...]  # class names

3. Load and Fine-Tune the Model: Use the following Python code to fine-tune the model:

   from ultralytics import YOLO
   
   # Load a pretrained model
   model = YOLO('yolov8n.pt')
   
   # Fine-tune the model on your custom dataset
   results = model.train(data='clothes.yaml', epochs=50, imgsz=640)

4. Evaluate the Model: After training, you can evaluate the model's performance on your validation set:

   metrics = model.val()
   print(metrics.box.map50)  # Print mAP @FaiqaShabbir.5

5. Use the Model for Prediction: Finally, use the fine-tuned model to make predictions:

   results = model.predict('path/to/image.jpg')
   results.show()  # Display the predictions

This should help you get started with fine-tuning your YOLOv8 model on the clothing dataset. If you have any more questions or need further assistance, feel free to ask. Happy modeling! 🚀

[Muhammad-Irfan-Shahzad]

why yolov9s or yolov9m is not loading 😢? @pderrenger

[pderrenger]

Hey @Muhammad-Irfan-Shahzad 😊, currently, only the configurations for YOLOv9c and YOLOv9e are available. The other model scales like YOLOv9s and YOLOv9m haven't been released yet. The Ultralytics team is working on adding these configurations soon. Please keep an eye on the updates, and thank you for your patience! 🚀

[Muhammad-Irfan-Shahzad]

One more issue that I am facing is that I convert my yolov5 trained model on custom dataset to "tflite" using this code !python export.py --weights /content/yolov5/runs/train/exp/weights/best.pt --include tflite after that when I use this code in vs-code using this code tflite_model = YOLO('aabest_float32_with_metadata.tflite') results = tflite_model('ty.jpg') then I am facing this error " File "C:-----\AppData\Local\Programs\Python\Python39\lib\ast.py", line 69, in _convert_num
_raise_malformed_node(node)
File "C:----\AppData\Local\Programs\Python\Python39\lib\ast.py", line 66, in _raise_malformed_node
raise ValueError(f'malformed node or string: {node!r}')
ValueError: malformed node or string: <ast.Name object at 0x0000016A61AF7CA0>"
and tflite also not working in android environment😢😢

[pderrenger]

Hello @Muhammad-Irfan-Shahzad 👋,

It seems like you're encountering a Python ValueError related to the AST module, which is typically not directly related to YOLO or TensorFlow Lite model usage. This error might be due to incorrect handling or parsing of data in your script.

For your TensorFlow Lite model loading and inference in Python, ensure that you're using the appropriate libraries and methods for TFLite models. Here's a corrected approach using TensorFlow's TFLite interpreter:

import numpy as np
import tensorflow as tf

# Load the TFLite model and allocate tensors
interpreter = tf.lite.Interpreter(model_path="aabest_float32_with_metadata.tflite")
interpreter.allocate_tensors()

# Get input and output tensors
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Prepare your input data
input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32)

# Set the tensor to point to the input data to be inferred
interpreter.set_tensor(input_details[0]['index'], input_data)

# Run the inference
interpreter.invoke()

# Extract the output
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)

For Android, ensure that your TensorFlow Lite model is correctly integrated and that the Android environment is set up to use TensorFlow Lite. Check for any discrepancies in the model path or input data handling.

If the issue persists, consider checking the format and compatibility of your .tflite model or revisiting the model conversion steps to ensure they were completed without errors.

Hope this helps! Let me know if you have further questions. 😊

[Alikhermouche]

please how to calculate and print accuracy from yolo model ?

[pderrenger]

To calculate and print the accuracy of your YOLO model, you can use the validation metrics provided during the training or validation process. For YOLO models, the commonly used metric is mean Average Precision (mAP). Here's a simple example of how you can validate your model and print the mAP using the Ultralytics YOLO library:

from ultralytics import YOLO

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

# Validate the model
metrics = model.val()

# Print the mAP at IoU=0.5
print(f"mAP @Alikhermouche.5: {metrics.box.map50}")

This will output the mAP at an IoU threshold of 0.5, which is a standard metric for object detection accuracy. You can adjust the IoU threshold or other parameters as needed.

[mohabtarek96]

Can I train YOLO v9 with Polygon Annotated Dataset ?

[pderrenger]

Currently, YOLOv9 does not natively support training directly with polygon-annotated datasets. It primarily works with bounding box annotations (rectangular). If your dataset is in a polygon format, you would need to convert these annotations to bounding boxes before training. This conversion typically involves calculating the bounding rectangle that can fully contain the polygon.

For more details on YOLOv9 and its capabilities, you can visit the official documentation. If you need further assistance with annotation conversion or any other queries, feel free to ask! 😊

[mohabtarek96]

@pderrenger Same goes for Yolov5 and Yolov8 ? as I can see @glenn-jocher said before that You can use polygon annotation to train YOLOv5 model.

[mohabtarek96]

ultralytics/yolov5#10452 (comment)

[pderrenger]

Hi there! 👋

For YOLOv5 and YOLOv8, training with polygon-annotated datasets directly isn't supported out-of-the-box. These models typically require bounding box annotations. However, you can convert polygon annotations to bounding boxes to use them. This involves calculating the minimum bounding rectangle for each polygon.

For more detailed guidance on handling different annotation formats, you might find the documentation on data preparation helpful: Ultralytics Documentation.

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

[mohabtarek96]

Is it mandatory to make all the training data 640x640 ? Because my data is larger than this resolution and always rectangular.

[glenn-jocher]

@mohabtarek96 no, it's not mandatory to resize all training images to 640x640. YOLO models, including YOLOv8, can train on images of different sizes and aspect ratios. However, during training, images are often resized to a common dimension (like 640x640) to maintain consistency and optimize GPU utilization.

If your images are larger or have a different aspect ratio, you can adjust the imgsz parameter in your training configuration to better suit your data. This might involve using a rectangular training mode (--rect in CLI) to better handle non-square images without excessive padding or distortion.

Here's a quick example of how you might adjust the training command:

yolo train model=yolov8n.yaml data=your_dataset.yaml imgsz=640 rect=True

This command trains the model using a target size of 640 pixels on the longest side, applying rectangular training to better accommodate different image shapes.

[sozhoang]

Hi, I got a problem!
My yolo model (v8 and v9) take so long time in postprocess

Speed: 1.0ms preprocess, 45.0ms inference, 1241.5ms postprocess per image at shape (1, 3, 320, 256)

Could anyone help me, plz

[Boaruzhanchik]

Can you write down the configuration of your PC ( CPU GPU RAM)?

[glenn-jocher]

Sure, knowing your system configuration will help diagnose the issue. Could you please provide the specifications of your CPU, GPU, and RAM? This information will help in understanding the potential bottlenecks in the post-processing phase. 🖥️

[bmeagher]

I am trying to export the YOLOv9e model to TFLite format using the code:

model = YOLO('yolov9e.pt')
model.export(format='tflite')

However, I get an error:

...
Depth of input (1408) is not a multiple of input depth of filter (256) for '{{node tf.nn.convolution_107/convolution}} = Conv2D[T=DT_FLOAT, data_format="NHWC", dilations=[1, 1, 1, 1], explicit_paddings=[], padding="SAME", strides=[1, 1, 1, 1], use_cudnn_on_gpu=true](Placeholder, tf.nn.convolution_107/convolution/filter)' with input shapes: [1,80,80,1408], [1,1,256,256].
...
ERROR: onnx_op_name: /model.22/cv1/conv/Conv
...

When I look at the outputted ONNX model in Netron, the input shape for that node appears to be [1x256x80x80].

Am I missing something in the export? Exporting the YOLOv9c model to TFLite works without any issues. Any suggestions?

[glenn-jocher]

It seems like there might be an issue with the layer dimensions not matching during the export process. This could be due to specific configurations or layer setups in the YOLOv9e model that aren't fully compatible with the TFLite conversion requirements directly.

As a workaround, you might want to try exporting the model to ONNX first and then converting the ONNX model to TFLite. Here's how you can do it:

1. Export to ONNX:

   model = YOLO('yolov9e.pt')
   model.export(format='onnx')

2. Use a tool like ONNX-TensorFlow to convert the ONNX model to a TensorFlow model, and then convert it to TFLite.

This indirect method might handle the dimensionality issues better during the conversion process. If the problem persists, please check the layer configurations in your model or consider reaching out on the repository issues page for more specific guidance.

[maxcodesfast]

Hello :)
I have a question regarding the grid size in the yolov9e model. I tested my data with different image sizes. One time I used the original image size 1920x1080 and the other time I used 640x352 (not sure if exactly 352). I was supprised that the algorithm wasnt more accurate with the original image size. I have some small object in my dataset and thought it would detect them better with a higher resolution. On some of the "easy" objects the algorithm performed worse with the original image size. Is this due to higher complexity when I use the original image size? my dataset is quite small (2000 pictures).
What is the gridsize in Yolov9e with a resolution of 1920x1080 and what ist it with 640x352? Maybe that has something to do with it. How is the grid size calculated and how can I change it? I didnt find a parameter for the downsampling rate.
I have some objects which are quite far away and due to that quite small. maybe a higher resolution with a smaller grid size could improve the performance.

Thanks a lot!
Cheers Max

[glenn-jocher]

Hello Max 😊,

Great questions! When using higher resolution images like 1920x1080, the model may not necessarily perform better, especially with small objects. This can sometimes be due to the increased complexity and noise in the larger images, which might overwhelm the model, especially with a smaller dataset like yours.

The grid size in YOLO models, including YOLOv9e, is typically determined by the downsampling factor of the network's backbone. For instance, if the backbone downsamples the input by a factor of 32, then an input image of 640x640 would result in a grid size of 20x20. For your specific resolutions:

• At 1920x1080, the grid size would be 60x33 (approx).
• At 640x352, the grid size would be 20x11 (approx).

You can't directly change the downsampling rate as it's determined by the model's architecture. However, you can influence the detection of smaller objects by adjusting other parameters like anchor sizes or using image augmentation techniques to better train on small objects.

If you're looking to improve detection, consider using image pyramids or adjusting the input size to a more manageable resolution that balances detail and performance. Also, increasing your dataset size or using data augmentation might help the model generalize better on small objects.

Hope this helps! Let me know if you have more questions.

[vm7608]

Hi there, I have some question about loading YoloV9 pretrained weight in Ultralytics.

I have trained a yolov9 model (yolov9-e for detection problems) using code in the original repo of yolov9 at https://github.com/WongKinYiu/yolov9. Now, i want to load this weight using Ultralytics. But i have some error when loading it.

1. When i load the weights with the following code:

weight = "yolov9-e-best.pt"
model = YOLO(weight)

I got the following error.
i face the same issue, I train yolov9-e for detection problem based on the original repo of yolov9 at . Now, when i load the trained weights using ultralytics, i got this error:

TypeError: ERROR ❌️ /home/manhckv/manhckv/ultralytics/_project_weights/td/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'

2. So i try to load the model from the yaml file. I use the yaml file from the original repo of yolov9 too. Yaml file link: https://github.com/WongKinYiu/yolov9/blob/main/models/detect/yolov9-e.yaml

But it return the error too:

Traceback (most recent call last):
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 830, in _smart_load
    return self.task_map[self.task][key]
KeyError: None

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

Traceback (most recent call last):
  File "/home/manhckv/manhckv/ultralytics/check_model_info.py", line 16, in <module>
    model = YOLO("/home/manhckv/manhckv/ultralytics/yolov9-custom.yaml")
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/models/yolo/model.py", line 23, in __init__
    super().__init__(model=model, task=task, verbose=verbose)
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 150, in __init__
    self._new(model, task=task, verbose=verbose)
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 219, in _new
    self.model = (model or self._smart_load("model"))(cfg_dict, verbose=verbose and RANK == -1)  # build model
  File "/home/manhckv/miniconda3/envs/ultralytics/lib/python3.10/site-packages/ultralytics/engine/model.py", line 834, in _smart_load
    raise NotImplementedError(
NotImplementedError: WARNING ⚠️ 'YOLO' model does not support '_new' mode for 'None' task yet.

How can i fix this?

[glenn-jocher]

Hi there,

Thank you for reaching out! It looks like you're encountering issues loading YOLOv9 weights trained using the original repo into the Ultralytics framework. Unfortunately, YOLOv9 models trained with the original repository are not directly compatible with the Ultralytics YOLO framework due to differences in architecture and implementation.

To resolve this, you have two main options:

1. Retrain the Model Using Ultralytics: The most straightforward approach is to retrain your YOLOv9 model using the Ultralytics framework. This ensures compatibility and leverages the latest features and optimizations provided by Ultralytics.

   from ultralytics import YOLO
   
   # Load a YOLOv9 model configuration
   model = YOLO("yolov9c.yaml")
   
   # Train the model
   results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

2. Convert the Weights: If retraining is not feasible, you might consider converting the weights to a format compatible with Ultralytics. This process can be complex and may require custom scripts to map the weights correctly.

For more detailed guidance on YOLOv9 and its usage within Ultralytics, please refer to the YOLOv9 documentation.

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

[vm7608]

thank a lot!

[glenn-jocher]

You're welcome! 😊

It looks like you're diving deep into the capabilities of YOLOv9. If you have any more questions or need further assistance, feel free to ask. The YOLOv9 model indeed brings significant advancements in real-time object detection, and leveraging its full potential can be quite rewarding.

For more detailed information on YOLOv9, including training, inference, and its innovative features, you can refer to the comprehensive documentation provided. Happy experimenting with YOLOv9! 🚀