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.

[Jordan-Karangala]

Hi,

I hope someone will help clarifying my doubts.
I have few queries about using yolo models.

where to find or download yaml files, or else is it not necessary?
After installing ultralytics in my venv created, can see a folder named by it but could not open.

Thank you.

[zhYao07]

you can find it in ultralytics/cfg/models

[Jordan-Karangala]

you can find it in ultralytics/cfg/models

Got it, Than you very much.

[glenn-jocher]

@Jordan-Karangala you can find the YAML files in the ultralytics/cfg/models directory. If you're having trouble accessing the folder, ensure your environment is set up correctly. For more details on using YOLO models, please refer to the Ultralytics documentation.

[ge1mina023]

Are the outputs of YOLOV9 and YOLOV8 the same, and are they processed in the same way?

[glenn-jocher]

@ge1mina023 the outputs of YOLOv9 and YOLOv8 are similar in terms of object detection, but YOLOv9 introduces new techniques like Programmable Gradient Information (PGI) and GELAN, which enhance efficiency and accuracy. For more details, you can refer to the YOLOv9 documentation at https://docs.ultralytics.com/models/yolov9/.

[mudassir659]

Hi,

I’m working on a project to detect obstacles in the path of drones using aerial images. Specifically, I want to use YOLOv9 for this task, with a focus on detecting classes such as trees, vehicles, buildings, poles, and other moving objects.

I’m wondering if it's feasible to achieve highly accurate results using a pre-trained YOLOv9 model, or if it would be necessary to fine-tune or train the model on a specific dataset for this purpose. My priority is to ensure the model's accuracy in detecting these obstacles.

Any guidance on the best approach would be greatly appreciated.

Thanks

[glenn-jocher]

@mudassir659 hi,

For detecting obstacles like trees, vehicles, buildings, and poles using YOLOv9, fine-tuning or training the model on a specific dataset tailored to your application will likely yield the best results. Pre-trained models can provide a good starting point, but custom training ensures higher accuracy for your specific classes and environment.

Best of luck with your project! For more details, visit YOLOv9 documentation.

[NickC124513]

If this is the wrong place to ask this please let me know and Ill get it moved ASAP

I have been doing some work with yolov9e-seg, and had great results so far(super impressive on my custom data!). I have exported it to an onnx file for use within a cpp ROS node, and this is where the trouble is. I am getting images in to the model and getting a result, but I am having a hard time decoding the output tensors. Is there documentation anywhere on exactly what the output tensors should look like? I have included some of the relevant code below:

Python to export:
model = YOLO('yolov9e-seg.pt')
yaml = "custom_coco_simulation.yaml"
results = model.train(data=yaml, epochs=args.epochs, imgsz=640, device="cuda", batch=2, patience=25)
model.save('Saved_Models/trained_model.pt')
model.export(format="onnx")

CPP Processing data:
std::vector<std::vector<float>> outputs;
for (auto& tensor : output_tensors) {
float* float_array = tensor.GetTensorMutableData<float>();
std::vector<float> vec(float_array, float_array + tensor.GetTensorTypeAndShapeInfo().GetElementCount());
outputs.emplace_back(std::move(vec));
}
// Print the size of the output vector
std::cout << "Output tensor 0 size: " << outputs[0].size() << std::endl;
std::cout << "Output tensor 1 size: " << outputs[1].size() << std::endl;

I am using just two classes right now, and the output size is as follows:
Output tensor 0 size: 319200
Output tensor 1 size: 819200

Any help understanding how to decode these and extract the masks, confidence levels, etc would be greatly appreciated, been stuck here for a few days now. Cheers!

[glenn-jocher]

@NickC124513 thanks for your question! For decoding YOLOv9 ONNX output tensors, refer to the YOLOv9 documentation for detailed information on the output structure. Typically, the output includes bounding boxes, class scores, and masks. Ensure you correctly parse these elements to extract the necessary information for your application. If the issue persists, please verify with the latest package version.

[NickC124513]

Thanks for the reply! I have been scouring for a bit, and dont find anything on onnx output tensors. When I do a page search for "onnx", "tensor", or "output", I do not get any meaningful information on this topic. Is there any specific documentation I am missing, or perhaps a way to discern the models output structure given the onnx or pt files? I have been toying around with using a simple script to extract some info as shown below, but have only found very limited information is easily obtainable.

def extract_io_names(model_path):
model = onnx.load(model_path)

print("Input names:")
for input in model.graph.input:
print(input.name)

print("Output names:")
for output in model.graph.output:
print(output.name)

[glenn-jocher]

@NickC124513 to decode YOLOv9 ONNX output tensors, you'll typically find bounding boxes, class scores, and masks. The first tensor often contains bounding box coordinates and class probabilities, while the second might include segmentation masks. For precise details, examining the model's architecture in the original PyTorch implementation can help. If issues persist, ensure you're using the latest package version.

[NickC124513]

I have read everything you suggested, and tried a few things. My outputs are of the shapes [1, 38, 8400] and [1, 32, 160, 160]. The strange thing to me is that I only have 2 classes. I would be expecting the second dimension of the 1st tensor to be smaller given this, perhaps 6 or 7(containing something like 4 box vals then a confidence for each class). When I try treating every block of 38 values as a prediction like I normally would, it doesn't make sense. The first 33600 values are all outside the range of (-1, 1), and that neatly divides by 4 to get 8400, leading me to believe these are all box coordinates. So I am looking to extract them as follows:
float bx = output0_data[i]; // Center x (normalized)
float by = output0_data[i + num_detections]; // Center y (normalized)
float bw = output0_data[i + 2 * num_detections]; // Width (normalized)
float bh = output0_data[i + 3 * num_detections]; // Height (normalized)

From there, we move in to decimals that are also strange. I thought maybe I would find an objectness, class 1 confidence, class 2 confidence. Given the fact that the first chunk of the tensor is blocked off as (I assume) box coords, I tried to extract the next values in this way:
float objectness = output0_data[i + 4 * num_detections];
float class_prob_1 = output0_data[i + 5 * num_detections]; // Probability for class 1
float class_prob_2 = output0_data[i + 6 * num_detections]; // Probability for class 2

But this never results in an objectness above 0.1, when I know the model is recognizing objects in the frame. I know this because I ran the same exact image through the same model using the ultralytics library, and it worked. I did that by just adding a line to make a prediction to the python code I shared in my first question under "Python to export:". So I assume the same model, when exported as an onnx, is making the correct predictions and I just still am not reading them correctly.

Looking at the segmentation tensor, it is in a much more understandable format, and I would be able to parse it... if I had all of the boxes properly parsed. So to summarize, here are my questions:
Why would tensor 0 have a dimension 38 when there are only 2 classes - WTF is in that many channels?
Why does the tensor seem to be organized in such a strange way?
Is there obvious post processing that I am missing?

[glenn-jocher]

It seems like you're encountering issues with interpreting the output tensor dimensions. The first tensor likely contains bounding box coordinates and class probabilities, while the second tensor is for segmentation masks. The dimension 38 might include additional information like objectness scores or anchor box adjustments. Ensure you're correctly parsing these elements. For precise details, examining the model's architecture in the original PyTorch implementation can help. If issues persist, ensure you're using the latest package version.

[Umsh]

Can you add the CBAM attention layer in yolov9 ?

[glenn-jocher]

@Umsh currently, we do not have plans to add the CBAM attention layer to YOLOv9. However, you are welcome to modify the architecture and experiment with it. For more information on YOLOv9, please visit our documentation at https://docs.ultralytics.com/models/yolov9/.

[mehdi-bech]

Hi,

I've been trying to train a YOLOv9 model on a GPU using this code (i'm working on databricks) :

from ultralytics import YOLO
model = YOLO("yolov9c.pt")
results = model.train(data = "data.yaml", epochs=100, imgsz=640, device=0, plots=True)

But i'm getting this error :

Ultralytics YOLOv8.2.87 🚀 Python-3.10.12 torch-2.0.1+cpu CPU (Intel Xeon Platinum 8171M 2.60GHz)
Overriding model.yaml nc=80 with nc=5
Transferred 931/937 items from pretrained weights
TensorBoard: Start with 'tensorboard --logdir runs/detect/train53', view at http://localhost:6006/
Freezing layer 'model.22.dfl.conv.weight'
train: Scanning /dbfs/FileStore/all_data/train/labels.cache... 1675 images, 447 backgrounds, 0 corrupt: 100%|██████████| 1675/1675 [00:00<?, ?it/s]
RuntimeError: Default process group has not been initialized, please make sure to call init_process_group.
RuntimeError                              Traceback (most recent call last)
File <command-3832686779688058>, line 1
----> 1 results = model.train(data = "data.yaml", 
      2                       epochs=100, 
      3                       imgsz=640, 
      4                       device=0,
      5                       plots=True)   

File /local_disk0/.ephemeral_nfs/envs/pythonEnv-842ecf94-2f6d-42e0-9d7a-e6a0f5014a2a/lib/python3.10/site-packages/ultralytics/engine/model.py:815, in Model.train(self, trainer, **kwargs)
    812     self.model = self.trainer.model
    814 self.trainer.hub_session = self.session  # attach optional HUB session
--> 815 self.trainer.train()
    816 # Update model and cfg after training
    817 if RANK in {-1, 0}:

File /local_disk0/.ephemeral_nfs/envs/pythonEnv-842ecf94-2f6d-42e0-9d7a-e6a0f5014a2a/lib/python3.10/site-packages/ultralytics/engine/trainer.py:207, in BaseTrainer.train(self)
    204         ddp_cleanup(self, str(file))
    206 else:
--> 207     self._do_train(world_size)

File /local_disk0/.ephemeral_nfs/envs/pythonEnv-842ecf94-2f6d-42e0-9d7a-e6a0f5014a2a/lib/python3.10/site-packages/ultralytics/engine/trainer.py:327, in BaseTrainer._do_train(self, world_size)
    325 if world_size > 1:
    326     self._setup_ddp(world_size)
--> 327 self._setup_train(world_size)
    329 nb = len(self.train_loader)  # number of batches
    330 nw = max(round(self.args.warmup_epochs * nb), 100) if self.args.warmup_epochs > 0 else -1  # warmup iterations

File /local_disk0/.ephemeral_nfs/envs/pythonEnv-842ecf94-2f6d-42e0-9d7a-e6a0f5014a2a/lib/python3.10/site-packages/ultralytics/engine/trainer.py:291, in BaseTrainer._setup_train(self, world_size)
    289 # Dataloaders
    290 batch_size = self.batch_size // max(world_size, 1)
--> 291 self.train_loader = self.get_dataloader(self.trainset, batch_size=batch_size, rank=LOCAL_RANK, mode="train")
    292 if RANK in {-1, 0}:
    293     # Note: When training DOTA dataset, double batch size could get OOM on images with >2000 objects.
    294     self.test_loader = self.get_dataloader(
    295         self.testset, batch_size=batch_size if self.args.task == "obb" else batch_size * 2, rank=-1, mode="val"
    296     )

File /local_disk0/.ephemeral_nfs/envs/pythonEnv-842ecf94-2f6d-42e0-9d7a-e6a0f5014a2a/lib/python3.10/site-packages/ultralytics/models/yolo/detect/train.py:55, in DetectionTrainer.get_dataloader(self, dataset_path, batch_size, rank, mode)
     53     shuffle = False
     54 workers = self.args.workers if mode == "train" else self.args.workers * 2
---> 55 return build_dataloader(dataset, batch_size, workers, shuffle, rank)

File /local_disk0/.ephemeral_nfs/envs/pythonEnv-842ecf94-2f6d-42e0-9d7a-e6a0f5014a2a/lib/python3.10/site-packages/ultralytics/data/build.py:132, in build_dataloader(dataset, batch, workers, shuffle, rank)
    130 nd = torch.cuda.device_count()  # number of CUDA devices
    131 nw = min(os.cpu_count() // max(nd, 1), workers)  # number of workers
--> 132 sampler = None if rank == -1 else distributed.DistributedSampler(dataset, shuffle=shuffle)
    133 generator = torch.Generator()
    134 generator.manual_seed(6148914691236517205 + RANK)

File /databricks/python/lib/python3.10/site-packages/torch/utils/data/distributed.py:68, in DistributedSampler.__init__(self, dataset, num_replicas, rank, shuffle, seed, drop_last)
     66     if not dist.is_available():
     67         raise RuntimeError("Requires distributed package to be available")
---> 68     num_replicas = dist.get_world_size()
     69 if rank is None:
     70     if not dist.is_available():

File /databricks/python/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py:1196, in get_world_size(group)
   1193 if _rank_not_in_group(group):
   1194     return -1
-> 1196 return _get_group_size(group)

File /databricks/python/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py:576, in _get_group_size(group)
    572 """
    573 Helper that gets a given group's world size.
    574 """
    575 if group is GroupMember.WORLD or group is None:
--> 576     default_pg = _get_default_group()
    577     return default_pg.size()
    578 return group.size()

File /databricks/python/lib/python3.10/site-packages/torch/distributed/distributed_c10d.py:707, in _get_default_group()
    703 """
    704 Getting the default process group created by init_process_group
    705 """
    706 if not is_initialized():
--> 707     raise RuntimeError(
    708         "Default process group has not been initialized, "
    709         "please make sure to call init_process_group."
    710     )
    711 return GroupMember.WORLD

RuntimeError: Default process group has not been initialized, please make sure to call init_process_group.

I've tried to run it with different versions of torch. I tried also upgrading :
pip install --upgrade torch ultralytics but i'm always getting the same error.
I've used before the same code with these versions of libraries and it works :

!pip install ultralytics==8.2.33
!pip install torch==1.7.0
!pip install torchvision==0.8.1
!pip install numpy==1.21.6

but this time it didn't work.

Any help understanding what could be the problem. Would be greatly appreciated, been stuck here for a few days now.

Thanks

[glenn-jocher]

@mehdi-bech it looks like the error you're encountering is related to the initialization of the distributed process group. Ensure that you call torch.distributed.init_process_group before training. If you're not using distributed training, try setting device='cpu' or device='cuda' instead of device=0. Additionally, make sure you're using the latest versions of torch and ultralytics. For more details, visit YOLOv9 documentation.

[mehdi-bech]

Thank you for your response. The issue has been resolved by implementing the following code:

import torch.distributed as dist

# Initialize the process group
dist.init_process_group(backend='nccl')

results = model.train(data="data.yaml", epochs=100, imgsz=640, device=0, plots=True)

[glenn-jocher]

Great to hear the issue is resolved! If you need further assistance, feel free to reach out. For more details on YOLOv9, you can visit the YOLOv9 documentation.

[MarjanNoushinfar]

Why do I get: "" AttributeError: Can't get attribute 'AConv' on <module 'ultralytics.nn.modules.block' from ... I did train with same properties months ago but now it doesn't work

[glenn-jocher]

@MarjanNoushinfar the error you're encountering might be due to changes in the codebase or dependencies since your last training session. Ensure your environment is up-to-date with the latest Ultralytics YOLOv9 version. You may need to check for any updates or modifications in the ultralytics.nn.modules.block module. If the issue persists, consider reviewing the release notes or documentation for any breaking changes.

[mudassir659]

I am working with the YOLOv9 model and would like to evaluate its performance on a test dataset. While I understand how to use val.py for validation, I am unsure of the process for calculating performance metrics on a test dataset(there are 5 classess).

Could you please provide guidance on the following:

The recommended approach to calculate performance metrics (e.g., Precision, Recall, mAP) for a test dataset using YOLOv9.
If there are specific scripts or commands to use for testing and obtaining metrics, or if there are any additional configurations required.
I appreciate your assistance with this matter and look forward to your advice

[glenn-jocher]

@mudassir659 to evaluate YOLOv9 on a test dataset, you can use the val.py script with your test data configuration. This will calculate metrics like Precision, Recall, and mAP. Ensure your dataset is properly formatted, and specify the number of classes in your configuration. For detailed guidance, refer to the YOLOv9 documentation.

[yanxinlei]

Hello, Ultralytics team,

First of all, I would like to commend you on the outstanding work with the Ultralytics project. I have a few technical questions regarding image resolution and network size in the context of my application:

My annotated data has a resolution of 640x480, while the images I use for inference are 200x150. For optimal performance, should I resize my annotated images to 200x150 before training?

Currently, I have set the network input size to 480x480. Would adjusting it to 200x200 or 256x256 potentially yield better results, considering the resolution of my inference images?

When there is a discrepancy between the network input size and the actual image resolution, how does Ultralytics handle this? For instance, if the network input size is 480x480 but the input image is 200x150, does the model resize the image to 480x360 and then pad it to 480x480?

I appreciate your insights and look forward to your guidance.

[glenn-jocher]

@yanxinlei thank you for your kind words. For optimal performance, it's best to resize your annotated images to match the inference resolution of 200x150 before training. Adjusting the network input size to 200x200 or 256x256 could improve results, aligning with your inference images. Ultralytics automatically resizes and pads images to fit the network input size, ensuring consistent processing. For more details, you can refer to the YOLOv9 documentation.

[Umsh]

What is the loss used for YOLOv9? What is the formula?

[glenn-jocher]

@Umsh yOLOv9 uses a composite loss function that includes components for bounding box regression, object classification, and confidence score prediction. For detailed insights, please refer to the YOLOv9 documentation at Ultralytics YOLOv9.

[to505to505]

Hello! Are there any materials with the full explanation of implementing of PGI in the code? It is rather hard to understand it from the repository code only and the article gives just the conceptual guide. Thanks in advance!

[glenn-jocher]

@to505to505 hello! For a deeper understanding of implementing PGI in YOLOv9, I recommend reviewing the detailed documentation and code comments within the repository. Unfortunately, we don't have additional materials beyond what's provided. For further insights, you might explore community forums or discussions related to YOLOv9.

[muhammedavran]

PROBLEMMMMM :(((( HOW CAN I FİX THAT

PS C:\Users\Muhammed Nurullah\yoloooo> & "C:/Users/Muhammed Nurullah/AppData/Local/Programs/Python/Python312/python.exe" "c:/Users/Muhammed Nurullah/yoloooo/yolov9_3.py"
Traceback (most recent call last):
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\nn\tasks.py", line 836, in torch_safe_load
ckpt = torch.load(file, map_location="cpu")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\utils\patches.py", line 86, in torch_load
return _torch_load(*args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\torch\serialization.py", line 1097, in load
return _load(
^^^^^^
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\torch\serialization.py", line 1525, in _load
result = unpickler.load()
^^^^^^^^^^^^^^^^
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\torch\serialization.py", line 1515, in find_class
return super().find_class(mod_name, name)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
ModuleNotFoundError: No module named 'models'

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

Traceback (most recent call last):
File "c:\Users\Muhammed Nurullah\yoloooo\yolov9_3.py", line 11, in
model = YOLO('best9.pt')
^^^^^^^^^^^^^^^^
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\models\yolo\model.py", line 23, in init
super().init(model=model, task=task, verbose=verbose)
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\engine\model.py", line 145, in init
self._load(model, task=task)
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\engine\model.py", line 285, in _load
self.model, self.ckpt = attempt_load_one_weight(weights)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\nn\tasks.py", line 909, in attempt_load_one_weight
ckpt, weight = torch_safe_load(weight) # load ckpt
^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Users\Muhammed Nurullah\AppData\Local\Programs\Python\Python312\Lib\site-packages\ultralytics\nn\tasks.py", line 840, in torch_safe_load
raise TypeError(
TypeError: ERROR best9.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'
PS C:\Users\Muhammed Nurullah\yoloooo>

[muhammedavran]

for YOLOv9

[glenn-jocher]

@muhammedavran it seems you're trying to load a YOLOv5 model with YOLOv9 code, which isn't compatible. Please ensure you're using the correct model version for YOLOv9. You might need to retrain your model using the latest Ultralytics package. For more details, visit the YOLOv9 documentation.

[foskyblue]

I'm having issues with my Yolov9 model exported to tflite. Model was successfully exported to tflite but I cannot get the right bounding boxes. I'm following the steps listed here: https://stackoverflow.com/questions/76381317/yolov8-tflite-python-predictions-and-interpreting-output (for folov8) to make inference for my yolov9 tflite model.

1Step 1: Resizing and Padding (Letterboxing)
Step 2: Non-Maximum Suppression (NMS)
Step 3: Rescaling Bounding Boxes

However, when I draw the outputed bounding boxes on my image the boxes don't fit the objects in the image correctly.

The code I'm using can be seen below:

from tflite_runtime.interpreter import Interpreter
from PIL import Image
import numpy as np
from glob import glob
from typing import Tuple, List


interpreter = None
input_shape = (320, 576)  # Input tensor dimensions (width, height) in pixels
input_index = 0  # Input tensor index (from input details in model signature)
output_index = 409
model_path = 'model/saved_model.tflite'

def load_model():
    interpreter = None
    interpreter = Interpreter(model_path=model_path, num_threads=2)
    interpreter.allocate_tensors()

    input_details = interpreter.get_input_details()
    global input_shape
    input_shape = tuple(input_details[0]['shape'][1:3])
    global input_index
    input_index = input_details[0]['index']

    output_details = interpreter.get_output_details()
    global output_index
    output_index = output_details[0]['index']
    return interpreter


def letter_box(img: np.ndarray, new_shape: Tuple[int, int]) -> np.ndarray:
    """
    Resizes an image to fit within a new shape while maintaining the aspect ratio,
    and pads the remaining space with a constant value.

    Args:
        img (np.ndarray): The input image as a NumPy array.
        new_shape (Tuple[int, int]): The desired output shape (height, width).

    Returns:
        np.ndarray: The resized and padded image.
    """

    shape = img.shape[:2]

    # Calculate the scaling ratio to fit the image within the new shape
    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])

    # Calculate the new unpadded dimensions
    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))

    # Calculate the padding required on each side
    dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
    dw, dh = dw / 2, dh / 2

    # Resize the image if necessary
    if shape[::-1] != new_unpad:
        img = Image.fromarray(img).resize(new_unpad, Image.Resampling.BILINEAR)
        img = np.array(img)

    # Calculate the top, bottom, left, and right padding values
    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))

    # Add padding to the image
    img = np.pad(img, ((top, bottom), (left, right), (0, 0)), mode='constant', constant_values=114)

    return img


def non_max_suppression(
    prediction: np.ndarray,
    conf_thres: float = 0.25,
    iou_thres: float = 0.45,
    max_det: int = 300,
    max_wh: int = 7680,
):
    """
    Perform non-maximum suppression (NMS) on a single image prediction.

    Args:
        prediction (np.ndarray): A numpy array of shape (1, num_boxes, num_classes + 4 + num_masks)
            containing the predicted boxes, classes, and masks.
        conf_thres (float): Confidence threshold for filtering boxes (0.0 to 1.0).
        iou_thres (float): IoU threshold for NMS (0.0 to 1.0).
        max_det (int): Maximum number of boxes to keep after NMS.
        max_wh (int): Maximum box width and height in pixels.

    Returns:
        np.ndarray: Array containing kept boxes with format
        (x1, y1, x2, y2, confidence, class, mask1, mask2, ...).
    """

    # Input validation (can be removed if you're sure of your input)
    if 0 > conf_thres > 1:
        raise ValueError(f"Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0")
    if 0 > iou_thres > 1:
        raise ValueError(f"Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0")

    # Extract dimensions and metadata directly
    _, _, dims = prediction.shape
    nc = dims - 4 - prediction.shape[1]  # number of classes
    nm = dims - nc - 4  # number of masks
    mi = 4 + nc  # mask start index

    # Process the single image in the batch
    x = prediction[0]  # Extract the single image data

    # Move class scores to last axis and threshold
    x = np.transpose(x, (1, 0))
    xc = x[..., 4:mi].max(axis=-1) > conf_thres
    x = x[xc]

    if not x.shape[0]:  # No boxes left after confidence thresholding
        return np.zeros((0, 6 + nm))

    # Convert xywh to xyxy directly on the filtered boxes
    x[..., :4] = xywh2xyxy(x[..., :4])

    # Split and process boxes, classes, and masks
    # pylint: disable=unbalanced-tuple-unpacking
    box, cls, mask = np.split(x, (4, mi), 1)
    conf = cls.max(1)
    j = cls.argmax(1)
    x = np.concatenate((box, conf[:, None], j[:, None].astype(float), mask), 1)
    x = x[conf > conf_thres]

    n = x.shape[0]
    if not n:  # No boxes left after additional confidence thresholding
        return np.zeros((0, 6 + nm))

    # NMS (simplified since we're dealing with a single image)
    c = x[:, 5:6] * max_wh
    boxes, scores = x[:, :4] + c, x[:, 4]
    i = numpy_nms(boxes, scores, iou_thres)
    i = i[:max_det]

    return x[i]


def numpy_nms(boxes: np.ndarray, scores: np.ndarray, iou_threshold: float = 0.5) -> np.ndarray:
    """
    Perform Non-Maximum Suppression (NMS) on a set of bounding boxes.

    Args:
        boxes (np.ndarray): Array of shape (N, 4) representing N bounding boxes.
                            Each box is [x1, y1, x2, y2].
        scores (np.ndarray): Array of shape (N,) representing the confidence scores
                             for each box.

        iou_threshold (float): IoU threshold for suppressing overlapping boxes.
                               Defaults to 0.5.

    Returns:
        np.ndarray: Boolean array of shape (N,) indicating which boxes to keep.
    """
    # Sort boxes by score in descending order
    order = scores.argsort()[::-1]
    keep = np.ones(len(boxes), dtype=bool)

    # Calculate IoU matrix
    ious = box_iou_batch(boxes, boxes)
    np.fill_diagonal(ious, 0)  # Set self-IoU to 0

    for i, idx in enumerate(order):
        if not keep[idx]:
            continue

        # Suppress boxes with IoU > threshold
        overlap = ious[idx] > iou_threshold
        keep[order[i + 1:]] &= ~overlap[order[i + 1:]]

    return keep


def box_iou_batch(boxes_a: np.ndarray, boxes_b: np.ndarray) -> np.ndarray:
    """
    Calculate the Intersection over Union (IoU) between two sets of bounding boxes.

    Args:
        boxes_a (np.ndarray): Array of shape (N, 4) representing N bounding boxes.
        boxes_b (np.ndarray): Array of shape (M, 4) representing M bounding boxes.

    Returns:
        np.ndarray: Array of shape (N, M) containing IoU values for each pair of boxes.

    Note:
        Each bounding box is represented as [x1, y1, x2, y2], where (x1, y1) is the
        top-left corner and (x2, y2) is the bottom-right corner.
    """
    # Calculate areas of boxes_a
    area_a = (boxes_a[:, 2] - boxes_a[:, 0]) * (boxes_a[:, 3] - boxes_a[:, 1])

    # Calculate areas of boxes_b
    area_b = (boxes_b[:, 2] - boxes_b[:, 0]) * (boxes_b[:, 3] - boxes_b[:, 1])

    # Calculate intersection coordinates
    top_left = np.maximum(boxes_a[:, None, :2], boxes_b[:, :2])
    bottom_right = np.minimum(boxes_a[:, None, 2:], boxes_b[:, 2:])

    # Calculate intersection area
    area_inter = np.prod(np.clip(bottom_right - top_left, a_min=0, a_max=None), 2)

    # Calculate IoU
    return area_inter / (area_a[:, None] + area_b - area_inter)


def xywh2xyxy(box: np.ndarray) -> np.ndarray:
    """
    Convert bounding box coordinates from (x, y, width, height) format to (x1, y1, x2, y2) format where (x1, y1) is the
    top-left corner and (x2, y2) is the bottom-right corner.

    Args:
        x (np.ndarray): The input bounding box coordinates in (x, y, width, height) format.

    Returns:
        np.ndarray: The bounding box coordinates in (x1, y1, x2, y2) format.
    """
    if box.shape[-1] != 4:
        raise ValueError(f"input shape last dimension expected 4 but input shape is {box.shape}")

    # pylint: disable=unbalanced-tuple-unpacking
    xy, wh = np.split(box, [2], axis=-1)
    wh_half = wh / 2
    return np.concatenate([xy - wh_half, xy + wh_half], axis=-1)


def preprocess_image(pil_image: Image.Image, input_size: Tuple[int, int]) -> np.ndarray:
    """
    Preprocesses an image for inference with a TFLite model.

    Args:
        image_path (str): Path to the image file.
        input_size (Tuple[int, int]): Desired input size (height, width) for the model.

    Returns:
        np.ndarray: Preprocessed image as a NumPy array, ready for inference.
    """
    if pil_image.mode != "RGB":
        pil_image = pil_image.convert("RGB")

    im = np.asarray(pil_image)
    im = letter_box(im, new_shape=input_size)
    im = np.expand_dims(im, axis=0) # goal is to have the format (number of images, size of image, number of channnels)
    im = im.astype(np.float32) / 255.0  # Normalize to 0.0 - 1.0

    return im


def postprocess_results(output: np.ndarray, model_input_size: Tuple[int, int], image_original_size: Tuple[int, int]) -> np.ndarray:
    """
    Postprocesses the raw outputs from a TFLite model, including scaling bounding boxes back to the original image size.

    Args:
        output (np.ndarray): List of output tensors from the TFLite model.
        model_input_size (Tuple[int, int]): Desired input size (height, width) for the model.
        image_original_size (Tuple[int, int]): Original size (height, width) of the input image.

    Returns:
        np.ndarray: Postprocessed results with bounding boxes adjusted to original image size.
    """
    predictions = non_max_suppression(output, conf_thres=0.25, iou_thres=0.45, max_det=300, max_wh=1)
    return scale_boxes(image_original_size, predictions, model_input_size)

    
def scale_boxes(image_original_size: Tuple[int, int], boxes: np.ndarray, model_input_size: Tuple[int, int]):
    """
    Rescales bounding boxes (in the format of xyxy by default) from the shape of the image they were originally
    specified in (img1_shape) to the shape of a different image (img0_shape).

    Args:
        image_original_size (Tuple[int, int]): The shape of the image that the bounding boxes are for, in the format of (height, width).
        boxes (np.ndarray): the bounding boxes of the objects in the image, in the format of (x1, y1, x2, y2)
        model_input_size (Tuple[int, int]): the shape of the target image, in the format of (height, width).

    Returns:
        np.ndarray: The scaled bounding boxes, in the format of (x1, y1, x2, y2)
    """

    # calculate from img0_shape
    gain = min(model_input_size[0] / image_original_size[0], model_input_size[1] / image_original_size[1])  # gain  = old / new
    pad = (
        round((model_input_size[1] - image_original_size[1] * gain) / 2 - 0.1) / model_input_size[1],
        round((model_input_size[0] - image_original_size[0] * gain) / 2 - 0.1) / model_input_size[0],
    )  # wh padding

    inner_image_scale = (
        (1 - pad[0] * 2),
        (1 - pad[1] * 2),
    )  # wh scale

    boxes[..., 0] = (boxes[..., 0] - pad[0]) / inner_image_scale[0]  # x padding
    boxes[..., 1] = (boxes[..., 1] - pad[1]) / inner_image_scale[1]  # y padding
    boxes[..., 2] = (boxes[..., 2] - pad[0]) / inner_image_scale[0]  # x padding
    boxes[..., 3] = (boxes[..., 3] - pad[1]) / inner_image_scale[1]  # y padding

    boxes[..., [0, 2]] = boxes[..., [0, 2]].clip(0, 1)  # x1, x2
    boxes[..., [1, 3]] = boxes[..., [1, 3]].clip(0, 1)  # y1, y2
    return boxes


def prepare_input(image_pil):
    # Input image must match input shape (ex: 640x640 pixels) [note: only use BILINEAR here]
    resized = image_pil.copy().resize(input_shape, resample=Image.Resampling.BILINEAR)
    # SSD Mobilenet V2 FPNLite take as input pixels between [-1.0, 1.0]
    expanded = np.expand_dims(np.asarray(resized, dtype=np.float32) * 2. / 255. - 1., axis=0)
    del resized  # Enforce garbage collection sooner than later
    return expanded



def predict(tmp_images_dir):

    interpreter = load_model()
    model_predictions = []
    for img_path in tmp_images_dir:
        pil_image = Image.open(img_path)
        input_data = preprocess_image(pil_image, input_shape)
        interpreter.set_tensor(input_index, input_data)
        interpreter.invoke()
        output_data = interpreter.get_tensor(output_index)
        preds = postprocess_results(output_data, input_shape, (pil_image.size[1], pil_image.size[0]))
        model_predictions.append({
            'detection_classes': (preds[:, 5] + 1).tolist(),  # Class values are offset by +1.0
            'detection_boxes': preds[:, 0:4].tolist(),
            'detection_scores': preds[:, 4].tolist(),
        })
    print(model_predictions)

images_path = glob('utilities/images/*.JPG')
predict(images_path)

[glenn-jocher]

@foskyblue it seems like the issue might be related to the scaling and padding logic when converting bounding boxes. Ensure that the scale_boxes function correctly rescales the boxes to the original image size. For more detailed guidance, please refer to the YOLOv9 documentation: https://docs.ultralytics.com/models/yolov9/.

[foskyblue]

Hi Glen thanks for your response. Unfortunately I find it difficult to correctly scale the bounding boxes from the example script I mentioned above: https://stackoverflow.com/questions/76381317/yolov8-tflite-python-predictions-and-interpreting-output.

How can I implement the YOLOv9 TFLite model with an input ape of [1, 320, 576, 3] and output shape of [1, 19, 3780] in Python?

[glenn-jocher]

To correctly scale bounding boxes for your YOLOv9 TFLite model, ensure your scale_boxes function accurately adjusts the coordinates based on the original image size and model input size. Verify that padding and scaling calculations align with your preprocessing steps. For further details, please refer to the YOLOv9 documentation.

[Gnoot01]

I'm getting the following errors despite latest torch and ultralytics installs. Kindly assist

  File "C:\Users\.venv\lib\site-packages\ultralytics\engine\model.py", line 547, in predict
    self.predictor.setup_model(model=self.model, verbose=is_cli)
  File "C:\Users\.venv\lib\site-packages\ultralytics\engine\predictor.py", line 303, in setup_model
    self.model = AutoBackend(
  File "C:\Users\.venv\lib\site-packages\torch\utils\_contextlib.py", line 116, in decorate_context
    return func(*args, **kwargs)
  File "C:\Users\.venv\lib\site-packages\ultralytics\nn\autobackend.py", line 145, in __init__
    model = model.fuse(verbose=verbose)
TypeError: BaseModel.fuse() got an unexpected keyword argument 'verbose'

[glenn-jocher]

@Gnoot01 it seems like there's a compatibility issue with the fuse method. Please ensure you're using the latest version of the Ultralytics package. If the issue persists, consider checking for any updates or changes in the repository that might address this. For further assistance, you can explore the YOLOv9 documentation.

[Gnoot01]

@glenn-jocher Hi, I'm using the latest ultralytics 8.3.24 and latest torch. However, still facing this issue. Any suggestions?

[glenn-jocher]

@Gnoot01 i'm sorry you're experiencing this issue. Please ensure your Ultralytics package is up-to-date. If the problem persists, try reinstalling the package or checking for any recent updates in the repository. For more details, you can refer to the YOLOv9 documentation.

[jane7166]

Hello. I have retrained the YOLOv9 model, and I would like to deploy it as an API. How should I proceed?

[glenn-jocher]

@jane7166 to deploy your retrained YOLOv9 model as an API, you can use frameworks like FastAPI or Flask to build an endpoint and load your model using the Ultralytics Python package. Refer to the YOLOv9 documentation for guidance on inference, which can be integrated into your API logic. Let us know if you have further questions!