tasks/obb/

[giscus[bot]]

tasks/obb/

Learn how to use oriented object detection models with Ultralytics YOLO. Instructions on training, validation, image prediction, and model export.

https://docs.ultralytics.com/tasks/obb/

[krialm]

Hi, when I am using yolov8_obb model in results I always have
boxes: None
keypoints: None
masks: None

even when the model makes prediction. Did someone faced with this problem and if yes, what was the solution? Thank you.🙂

[pderrenger]

@kedardg absolutely, you can train OBB models like P2 or RTDETR from scratch even if they're not available pre-trained. You'd start by creating a new model from a YAML file, which defines the model architecture. Here's a quick example of how you might do it:

yolo obb train data=your_dataset.yaml model=your_model.yaml epochs=100 imgsz=640

Just replace your_dataset.yaml with your dataset configuration file and your_model.yaml with your model configuration file. Make sure your dataset is properly formatted for OBB tasks. Happy training! 😊🚀

[RumaisaIlyas]

model = YOLO("yolov8n-obb.pt")
results = model.predict(im0)
pred_boxes = results[0].obb

i did this but i want to draw bounding boxes on the test image and return it. how to do that?

my function is:

def count_detection(image):
if image is not None:
# Load the YOLO model
model = YOLO('bestobbv8s.pt')

    # Check the shape of the input image
    print("Input image shape:", image.shape)

    # Use the model to predict the wheat spikes in image
    results = model(image, save=True)

    # Count 
    count = sum(len(result) for result in results)
    print("count", count)

    # Draw bounding boxes for detected wheat heads
    for result in results:
        boxes = result.obb
        #here?
        
    return image

[pderrenger]

@RumaisaIlyas hey there! 😊 To draw bounding boxes on your test image and return it, you can use the plot() method available in the Results object. Here's how you can modify your function:

def count_detection(image):
    if image is not None:
        # Load the YOLO model
        model = YOLO('bestobbv8s.pt')

        # Check the shape of the input image
        print("Input image shape:", image.shape)

        # Use the model to predict
        results = model.predict(image)

        # Draw bounding boxes and return the annotated image
        annotated_image = results[0].plot()

        # Count detections
        count = len(results[0].obb)
        print("count", count)

        return annotated_image

In this updated function, after making predictions with model.predict(image), we use results[0].plot() to draw bounding boxes on the image. This method returns the annotated image, which we then return from the function. This should give you the visual feedback you're looking for! 🚀

Let me know if you need further assistance!

[RumaisaIlyas]

thankyou so much for your assistance. i am facing a problem that my runs folder is not created after i run the code provided. why is that? what should i do in code so that i get the runs folder with my predicted image

[pderrenger]

Hey there! 😊 It sounds like you're doing everything right, but if the runs folder isn't being created, it might be due to a small oversight. Here's a quick checklist:

1. Ensure you're using the latest version of the Ultralytics YOLO library. Sometimes, updates fix these kinds of issues.
2. Double-check your command and make sure it's complete. For predictions, it should look something like this:

from ultralytics import YOLO

# Load your model
model = YOLO('bestobbv8s.pt')

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

# Save results
results.save()  # This should automatically save your predictions in the 'runs' folder

3. If you're still not seeing the runs folder, try specifying the output directory explicitly in your code:

results.save(save_dir='runs/detect')  # Adjust the path as needed

4. Lastly, ensure you have the necessary write permissions in your working directory. Sometimes, permission issues can prevent the creation of new folders.

If you've checked all these and the issue persists, it might be helpful to share more details about your environment (like your operating system) or any error messages you're seeing. That way, the community can offer more targeted advice. 🚀

Hope this helps, and happy detecting!

[CaioZen]

Hi, how can I access the results from this new model so I can extract bounding box information

[glenn-jocher]

Hey there! 👋 It seems you're encountering an AttributeError because the results object doesn't have any detections, causing it to be None. This can happen if no objects were detected in the image, or the image wasn't loaded correctly.

To fix this, first ensure your image path is correct and the image is accessible. Then, adjust detection thresholds or input image size if necessary, as these can impact detection performance.

For accessing bounding boxes in an OBB model, you should use the .obb attribute for oriented bounding boxes:

# Ensure results is not None
if results[0] is not None:
    obb_boxes = results[0].obb.xyxy  # For OBB models
    for obb_box in obb_boxes:
        print(f"OBB Box: {obb_box}")
else:
    print("No detections.")

This snippet checks for detections before trying to access .obb. If there are detections, it will print out the OBB bounding boxes.

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

[felixho789]

If I used the code

from ultralytics import YOLO

model = YOLO('best.pt')

results = model('ganglongvideo.webm', show=True, save=True, stream=True)

if results[0] is not None:
obb_boxes = results[0].obb.xyxy # For OBB models
for obb_box in obb_boxes:
print(f"OBB Box: {obb_box}")
else:
print("No detections.")

It result in TypeError: 'generator' object is not subscriptable

[glenn-jocher]

The error occurs because results is a generator when stream=True. You need to iterate over the generator. Here's how you can modify your code:

from ultralytics import YOLO

model = YOLO('best.pt')

results = model('ganglongvideo.webm', show=True, save=True, stream=True)

for result in results:
    if result is not None:
        obb_boxes = result.obb.xyxy  # For OBB models
        for obb_box in obb_boxes:
            print(f"OBB Box: {obb_box}")
    else:
        print("No detections.")

This should resolve the TypeError.

[felixho789]

Thank you

[glenn-jocher]

Thank you for your interest! For detailed information on using YOLOv8 Oriented Bounding Boxes (OBB), including training, validation, and prediction, please refer to the Ultralytics OBB documentation. If you encounter any issues, ensure you're using the latest package version.

[huangjianxin38]

Hi，Could the heatmap functionality be used on YOLOv8-obb?

[pderrenger]

@huangjianxin38 hi! Yes, you can integrate heatmap functionality with YOLOv8-OBB models, although it might require some custom coding effort. The heatmap can usually be generated based on the final convolutional layer's outputs before the detection layer. While we don't have a ready-made function specifically for this in the documentation, you might look into visualizing the activation layers to get a sense of where the model is focusing within the OBB predictions.

Here's a conceptual example of how you might approach this with PyTorch:

from ultralytics import YOLO
import torch

# Load your YOLOv8-obb model
model = YOLO('yolov8n-obb.pt')

# Forward an image and get the features before the detection layer
img_path = 'path/to/your/image.jpg'
features = model.extract_features(img_path)

# Now, you can process 'features' to generate a heatmap
# This might include averaging across channels and applying a colormap

# Remember, this is just a conceptual guide. Details depend on your exact needs!

Please, remember to check the model's structure (model.model) to identify the best layer for heatmap generation and modify the extract_features method accordingly.

Hope this helps! Feel free to reach out with any further questions. 🚀

[dlwforever]

Hi,I have some questions when I use the DOTAv1.0 for OBB task.
mAPtest values are for single-model multiscale on DOTAv1 test dataset.
Reproduce by yolo val obb data=DOTAv1.yaml device=0 split=test and submit merged results to DOTA evaluation.
The test set don't have labels and how can you run the above command?

[glenn-jocher]

Hey there! 👋 It looks like you need to format your results by category for the DOTA online server submission. While the direct yolo val command might not apply due to the lack of test set labels, you can still prepare your submission effectively.

For DOTA, your prediction file format typically should be:

<class_name> <confidence> <x1> <y1> <x2> <y2> <x3> <y3> <x4> <y4>

To generate predictions for each image and organize them by category, you could use something like this after your prediction step:

predictions = model.predict('path/to/test/images')
for pred in predictions:
    with open(f'results/{pred.image_name}.txt', 'w') as f:
        for bbox in pred.boxes:
            line = f"{pred.class_name} {bbox.conf} {bbox.x1} {bbox.y1} {bbox.x2} {bbox.y2} {bbox.x3} {bbox.y3} {bbox.x4} {bbox.y4}\n"
            f.write(line)

Then, to format for submission, organize these .txt files by category, ensuring each category has its corresponding detection results.

Quick Tip: DOTA might require a specific format for the filename or the way the data is zipped. Ensure to check their submission guideline for those details. 😉

Hope this helps, and good luck with your submission! 🚀 If you have more queries, feel free to drop them.

[hencai]

orig_shape: (1024, 1024)
path: '/xiaying_ms/bp/Large-Selective-Kernel-Network/data/images/test/P0017__1024__1397___3296.png'
probs: None
save_dir: 'runs/obb/predict4'
speed: {'preprocess': 4.119634628295898, 'inference': 25.12645721435547, 'postprocess': 1.8546581268310547}
ultralytics.engine.results.Results object with attributes:

boxes: None
keypoints: None
masks: None
names: {0: 'plane', 1: 'ship', 2: 'storage tank', 3: 'baseball diamond', 4: 'tennis court', 5: 'basketball court', 6: 'ground track field', 7: 'harbor', 8: 'bridge', 9: 'large vehicle', 10: 'small vehicle', 11: 'helicopter', 12: 'roundabout', 13: 'soccer ball field', 14: 'swimming pool'}
obb: ultralytics.engine.results.OBB object
orig_img: array([[[127, 134, 137],

the result of print like this, have no boxes for iteration? or and no confidence value in predict .txt files just having class label and eight index value(having been nomalized) , but DOTA online server fomat requirement is not nomalized index value

[glenn-jocher]

Hey there! 👋 It seems like you're encountering an issue with getting predictions in the required unnormalized format for DOTA submission and missing confidence scores. Let's tackle these issues:

1. Unnormalized values: The DOTA evaluation server requires unnormalized corner points for the OBBs. You can achieve this by multiplying normalized values by the respective image dimensions.

2. Missing confidence values: Ensure your prediction output includes confidence scores. If they're missing, double-check your prediction code to ensure it's designed to output these values.

Here's a snippet to adjust your predictions for submission:

# Example: Convert normalized to absolute coordinates (unnormalized)
# Assuming 'pred' is your prediction object with normalized bbox corners
x1, y1, x2, y2, x3, y3, x4, y4 = pred['obb']  # normalized bbox corners
W, H = pred['orig_shape']  # Original image width and height

# Convert to absolute coordinates
x1, x2, x3, x4 = [x * W for x in [x1, x2, x3, x4]]
y1, y2, y3, y4 = [y * H for y in [y1, y2, y3, y4]]

# Ensure your prediction file includes confidence scores
confidence = pred['confidence']

# Format your prediction as per DOTA requirement (not normalized, includes confidence)
formatted_prediction = f"{pred['class_name']} {confidence} {x1} {y1} {x2} {y2} {x3} {y3} {x4} {y4}"

For generating .txt files, ensure each detected object in an image has its line in its class-specific file. Here's a pseudo-structure:

plane.txt
ship.txt
...

Each .txt should contain one detection per line in the unnormalized format. Accumulate these in a zip file respecting the DOTA required structure.

Hope this helps ease the process a bit! If anything remains unclear or if you encounter more hurdles, feel free to ask. Good luck with your submission! 🍀

[hencai]

from ultralytics import YOLO

file_names = {
    0: 'Task1_plane.txt',
    1: 'Task1_ship.txt',
    2: 'Task1_storage-tank.txt',
    3: 'Task1_baseball-diamond.txt',
    4: 'Task1_tennis-court.txt',
    5: 'Task1_basketball-court.txt',
    6: 'Task1_ground-track-field.txt',
    7: 'Task1_harbor.txt',
    8: 'Task1_bridge.txt',
    9: 'Task1_large-vehicle.txt',
    10: 'Task1_small-vehicle.txt',
    11: 'Task1_helicopter.txt',
    12: 'Task1_roundabout.txt',
    13: 'Task1_soccer-ball-field.txt',
    14: 'Task1_swimming-pool.txt'}

# Assuming yolov8n-obb.pt is your trained model
# model = YOLO('/xiaying_ms/bp/Large-Selective-Kernel-Network/runs/obb/train10/weights/best.pt')
model = YOLO('/xiaying_ms/bp/Large-Selective-Kernel-Network/runs/obb/yolov8n-obb.pt')
# predictions = model.val(data='/xiaying_ms/bp/Large-Selective-Kernel-Network/tools/yolov8/dotav1.yaml', device=[0, 1], split='test', save_json=True)
predictions = model.predict('/xiaying_ms/bp/Large-Selective-Kernel-Network/data/images/test/', save_txt=True)
txt_path = '/xiaying_ms/bp/Large-Selective-Kernel-Network/runs/obb/predict8'
sub_dir = os.path.join(txt_path, 'submission')
if not os.path.exists(sub_dir):
    os.mkdir(sub_dir)

for i in file_names:
    create_txt_path = os.path.join(sub_dir, file_names[i])
    with open(create_txt_path, "w") as file:
        file.write('')
for pred in predictions:
    # print(pred.obb)
    box_list = pred.obb.xyxyxyxy.tolist()
    confs = pred.obb.conf.tolist()
    for i in range(len(pred.obb.cls)):
        png_label = os.path.basename(pred.path)[:5]
        txt_file = os.path.join(sub_dir, file_names[int(pred.obb.cls[i])])
        str1 = ' '
        # x1, y1, x2, y2, x3, y3, x4, y4 = pred.obb.xyxyxyxy[i]
        # print(f'{x1} {y1} {x2} {y2} {x3} {y3} {x4} {y4}')
        box_list_item = box_list[i]
        box = [round(element, 2) for sublist in box_list_item for element in sublist]
        box = str1.join(map(str, box))
        conf = confs[i]
        with open(txt_file, 'a') as f:
            f.write(f'{png_label} {conf} {box}\n')

def zip_predictions_folder(folder_path):
if not os.path.exists(folder_path):
print(f"Folder '{folder_path}' does not exist.")
return

zip_file_name = "predictions.zip"

with zipfile.ZipFile(os.path.join(txt_path, zip_file_name), "w") as zipf:
    for foldername, subfolders, filenames in os.walk(folder_path):
        for filename in filenames:
            file_path = os.path.join(foldername, filename)
            zipf.write(file_path, os.path.relpath(file_path, folder_path))

print(f"Folder '{folder_path}' has been zipped and saved as '{zip_file_name}'.")

zip_predictions_folder(sub_dir)

i used this for generate DOTA online server format file ,but when i submit the result, the map is just 0.072, why
? could you give some advice ?

[glenn-jocher]

@hencai hey there! 🤗 It seems like your mAP score came out unexpectedly low. Here are a couple of things to check and some advice that might help improve your results:

• Double-check the label formats: Ensure that the bounding box coordinates are not normalized and match the DOTA format exactly as [x1, y1, x2, y2, x3, y3, x4, y4].
• Review Prediction Confidence Scores: Sometimes, filtering out detections with very low confidence can improve overall mAP. Consider applying a confidence threshold if you haven't already.
• Inspect Class Labels: Verify that the class labels in your prediction files match the DOTA dataset's expectations. Mislabeling can significantly impact scores.
• Preprocessing and Augmentation: Make sure that the images were preprocessed similarly during both training and prediction phases. Any discrepancy might affect model performance.
• Model Choice and Training: If issues persist, it might be worth re-evaluating the model's training phase. Ensure you're using an appropriate model architecture, and the model has been trained adequately.

For predictions not normalized and including the confidence score, here's an illustrative code adjustment:

# Assuming 'pred' includes correct non-normalized detections
for pred in predictions:
    box_list = pred.obb.xyxyxyxy.tolist()  # Assuming these are non-normalized
    confs = pred.obb.conf.tolist()
    for i in range(len(pred.obb.cls)):
        label = pred.names[pred.obb.cls[i]]
        png_label = os.path.basename(pred.path).split('.')[0]
        txt_file = os.path.join(sub_dir, f'{label}.txt')  # Adjust to save by label names
        box = ' '.join(map(str, [round(elem, 2) for sublist in box_list[i] for elem in sublist]))
        conf = round(confs[i], 2)
        with open(txt_file, 'a') as f:
            f.write(f'{png_label} {conf} {box}\n')

Remember, adapting to specific requirements, like unnormalized coordinates and including confidence scores, is key for successful DOTA submissions. Hope this helps! Feel free to reach out if you have more questions. Best of luck with your next submission! 😊

[zhouyizhuo]

how to do Model Ensembling on yolov8-obb models？

[pderrenger]

Model ensembling with YOLOv8-obb models involves combining the predictions from multiple trained models to improve the accuracy of your oriented objects detection. Currently, direct support for model ensembling within Ultralytics YOLO isn't provided out-of-the-box. However, you can manually implement ensembling by running predictions with each model separately and then combining these predictions.

One common approach is to average the bounding box coordinates and confidence scores of the same object detected by multiple models. Ensure to consider the rotating angle parameter unique to OBB models in your ensembling logic. Here's a basic conceptual example to get you started:

from ultralytics import YOLO

models = [
    YOLO('path/to/first_obb_model.pt'),
    YOLO('path/to/second_obb_model.pt'),
    # Add more models as needed
]

# Assuming you have a method to read your images/videos
image = 'path/to/image.jpg'

# List to store results from all models
all_preds = []

for model in models:
    results = model(image)
    all_preds.append(results.pandas().xyxy[0])  # Extracting predictions

# Assuming you have a method `combine_predictions(all_preds)`
# that combines predictions from all models
final_predictions = combine_predictions(all_preds)

# Process `final_predictions`...

This example loads each model, runs predictions on the same image, and stores the results. You'd then need to implement combine_predictions(all_preds) to handle the logic for combining these predictions based on criteria like IoU, confidence scores, etc., taking into account the angle for rotated bounding boxes.

Remember, ensembling may increase inference time due to processing with multiple models. Always weigh the benefits of improved accuracy against potential increases in computational cost. Happy coding! 😊

[dlwforever]

Hi, the YOLOv8n-obb test map-50 result on DOTAv1.0 is 78.0%. I split the train set and val set images to 1024*1024 and I wonder the 78% is the val set result given by the model.val()? or the test set result given by the DOTA server? And how to merge the result submitted to the server if the figure 78% is the test result given by the DOTA server?
Thank you for your answer.

[hencai]

Thank you very much for your suggestion. I can successfully submit the results to the official website of the Dota dataset. However, my training method involves cutting single scale images, all of which are 1024 in size. Using your OBB pre trained model weights, why did I only achieve an accuracy of 49% of the map on the test set when training 100 epochs? It is because of the size of my images? Can YOLO only cut 640 training or for other reasons? Note that I am training at a single scale, and the results on your official website are all training results under multi-scale cutting. I would like to know how many epochs need to be trained to achieve the accuracy of your official website?

model = YOLO('/xiaying_ms/bp/Large-Selective-Kernel-Network/tools/yolov8/yolov8n-obb.yaml').load('/xiaying_ms/bp/Large-Selective-Kernel-Network/tools/yolov8/yolov8n-obb.pt') # build from YAML and transfer weights

Train the model with 2 GPUs

results = model.train(data='/xiaying_ms/bp/Large-Selective-Kernel-Network/tools/yolov8/dotav1.yaml',
epochs=100, imgsz=1024, device=[0, 1],
save=True
)

[pderrenger]

Hey there!

Achieving a lower mAP (49%) compared to the official results (78% for YOLOv8n-obb on DOTAv1.0) could indeed be influenced by the single-scale training approach. Here are some suggestions:

• Multi-scale Training: It appears you're training the model using images of a single size (1024). The official results usually benefit from multi-scale training, where the input image size varies during training. This technique typically enhances the model's robustness and generalization across different object sizes. Consider incorporating it into your training process.
• Epochs and Learning Rate: While you've trained for 100 epochs, the learning journey of the model might benefit from either more epochs or adjusting the learning rate. Sometimes, further fine-tuning or even learning rate schedules can help the model converge to a higher accuracy.
• Model Selection: Ensure you're using a model architecture suited to your task's complexity. If your dataset is significantly different or more challenging than DOTAv1.0, experimenting with other OBB-pretrained models like YOLOv8s-obb, YOLOv8m-obb, or above might yield better results.
• Review Data and Annotations: Double-check your dataset and annotations, especially since you're working with single-scale images. Ensure they align well with DOTA's format and that there are no issues affecting model learning.

As for the code snippet you provided, it looks like you're on the right track. Perhaps try adapting it to use variable image sizes for training:

from ultralytics import YOLO

# Load the model
model = YOLO('yolov8n-obb.yaml').load('yolov8n-obb.pt')

# Train with varied image sizes
results = model.train(data='dotav1.yaml', epochs=100, imgsz=[640, 1024], device=[0, 1])

Note: [640, 1024] allows the model to see images of different sizes during training, potentially boosting its ability to generalize.

Keep experimenting, and good luck! 🍀

[hencai]

But currently, my images only have 1024 sized single scale images that have been cut, and I am using them for comparative experiments. Is the official results (78% for YOLOv8n obb on DOTAv1.0) you just mentioned the official results for single scale? I couldn't find it on the official website. How many epochs are 78% of this website trained under what image size?

[pderrenger]

Hey there! 😄 It looks like you're diving deep into using the YOLOv8n-obb model for oriented bounding box detection on the DOTA dataset. You've noticed a significant point regarding single-scale versus multi-scale training which can indeed have a big impact on your model's performance.

The official 78% mAP for YOLOv8n-obb mentioned on our website is achieved under multi-scale training conditions, typically with image sizes around 1024 pixels. This diversity in image sizes during training plays a crucial role in making the model more resilient and adaptable to various object sizes, which is likely why you're seeing a difference in accuracy with single-scale training.

If you're sticking to 1024-sized single-scale images for your comparison experiments, it's worth considering incorporating multi-scale training to better match the conditions under which the official results were obtained. As for the epochs, the official results are generally achieved after extensive hyperparameter tuning and potentially more than 100 epochs of training, depending on various factors like the complexity of the dataset, learning rate schedules, etc.

Here’s a little adjustment to your training code that enables multi-scale training:

from ultralytics import YOLO

# Load the model with pre-trained weights
model = YOLO('yolov8n-obb.yaml').load('yolov8n-obb.pt')

# Train the model with multi-scale
results = model.train(data='dotav1.yaml', epochs=100, imgsz=[640, 1024], device=[0, 1])

Remember, achieving top-notch results often requires experimenting with not just epochs and image sizes but also with learning rates, batch sizes, and augmentation strategies. Keep exploring, and best of luck! 🚀 If you have any more questions or need further assistance, feel free to ask.

[ccsadsxz]

@hencai Hi I notice that you can train yolov8_obb models on muti-GPUs, how can you achieve this? Did you enconunter this error?

File "/tmp/pycharm_project_538/ultralytics-main/ultralytics/utils/loss.py", line 626, in call
feats, pred_angle = preds if isinstance(preds[0], list) else preds[1]
ValueError: too many values to unpack (expected 2)

[hencai]

how can i test DOTA1.0 datasets using YOLOV8-obb ? online submit for results? somebody help me? emergency

[pderrenger]

@hencai hey there! 🌟 For testing DOTA1.0 datasets using YOLOv8-obb, you can follow these steps:

1. If you haven't already, download and set up the DOTA1.0 dataset as per the Ultralytics documentation.
2. Load the pretrained YOLOv8-obb model, for example, use model = YOLO('yolov8n-obb.pt') to load the YOLOv8n-obb model which is pretrained on DOTAv1.
3. You can run validation on the dataset using the command:

   results = model.val(data='path/to/your/DOTA1.0_yaml_file.yaml')

   Replace 'path/to/your/DOTA1.0_yaml_file.yaml' with the actual path to your DOTA1.0 dataset YAML file.
4. To submit results online, you'll need to convert the results into the format required by the DOTA evaluation server and follow their submission guidelines. Typically, this involves creating a text file for each image, listing detected objects and their oriented bounding box coordinates.

If this is an emergency, I'd recommend diving into the predict and val sections of the documentation for detailed code examples and further instructions. The key here is to ensure your dataset is correctly formatted as per the Dataset Guide and utilize the pretrained models effectively.

For submitting your results, please check the specific instructions provided by DOTA1.0 on their evaluation server. Every competition or dataset may have a slightly different submission procedure.

Hope this helps, and good luck with your work!

[Intellectus-Rheejeongjin]

Hi, I saw yolov8 obb with tracking from yolov8-v2
Where can I see that docs?

[pderrenger]

Hey there! 🚀 It looks like you're interested in the YOLOv8 Oriented Bounding Boxes (OBB) model with tracking. For comprehensive documentation on YOLOv8 OBB, including details on training, validating, making predictions with, and exporting these models, you can check out our dedicated Oriented Bounding Boxes Object Detection page.

You'll find everything from an introduction to oriented object detection, tips on using the YOLOv8 OBB models (which are pretrained on DOTAv1 and use the -obb suffix like yolov8n-obb.pt), to examples of training commands and more. Here’s a quick example to get you started with training a YOLOv8n-obb model:

from ultralytics import YOLO

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

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

And for validation:

# Validate the model
metrics = model.val(data='dota8.yaml')

Feel free to explore the page for more details on other tasks like exporting models to different formats! If you have any further questions, just let me know. Happy detecting!

[cabral0413]

Subject: Cropping Images from YOLOv8 Detections (Python)

Hi everyone,

I'm working on a Python project that utilizes a YOLOv8 model for object detection. I'd like to achieve the following functionality:

Perform object detection on input images using my trained YOLOv8 model.
Extract the bounding boxes of the detected objects from the model's output.
Crop the input image based on each detected object's bounding box and save the cropped images to a separate folder.
I'm currently using the ultralytics library for YOLOv8 integration in Python. However, I'm unsure how to access and utilize the bounding box information from the model's output for cropping purposes.

could you share an example code snippet demonstrating how to achieve this cropping functionality using the bounding box data?

[pderrenger]

Hey there! 👋

For cropping images using bounding box information from YOLOv8 detections, you can follow this straightforward example. Once you've got the detection results, you can simply loop through them, access the bounding box coordinates, and use them to crop the original image. Here's how:

from PIL import Image
from ultralytics import YOLO

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

# Run detection
results = model('path/to/input/image.jpg')

# For each detection, crop and save the image
for i, det in enumerate(results[0].boxes.xyxy):
    # Convert detections to integer coordinates
    xmin, ymin, xmax, ymax = map(int, det[:4])
    
    # Open the original image
    img = Image.open('path/to/input/image.jpg')
    
    # Crop the image based on detection bounding box
    cropped_img = img.crop((xmin, ymin, xmax, ymax))
    
    # Save the cropped image
    cropped_img.save(f'cropped_image_{i}.jpg')

This script will save each detected object as a separate cropped image. Make sure to replace 'path/to/your_model.pt' and 'path/to/input/image.jpg' with the actual paths to your YOLOv8 model and input image.

Happy coding! 🚀

[sana-18]

Hello,

I'm currently working with YOLOOBB (You Only Look Once Oriented Bounding Boxes), and I've annotated my data using the YOLOOBB format. My concern now is how to apply augmentations for oriented bounding boxes, particularly for transformations like rotation, horizontal flipping, and vertical flipping. Each augmented image will need its annotation file adjusted accordingly.

I'm using the albumentations library in Python for data augmentation. Here's the transformation pipeline I've defined:

import albumentations as A

transform_pipeline= A.Compose([
A.Rotate(limit=(-90, 90)),
A.VerticalFlip(p=1),
A.HorizontalFlip(p=0.5),
A.ToTensor()
], bbox_params=A.BboxParams(
format="yolo",
label_fields=["class_labels"],
))

However, the YOLOOBB format is different from the default YOLO format. How should I process the annotations in this case to ensure they match the augmented images?

Any insights or suggestions on how to handle this scenario would be greatly appreciated!

Thank you.

[glenn-jocher]

Hey there! It looks like you're taking on the challenge of data augmentation for YOLOOBB, which is super interesting. 🚀 When dealing with rotations and flips, especially with oriented bounding boxes (OBBs), the key lies in adjusting the angle of orientation alongside the bounding box coordinates during augmentation.

For albumentations, you're on the right track with defining transformations. However, for YOLOOBB which includes angles in annotations, you'll need to handle the angle adjustments manually post-augmentation, as albumentations currently doesn't directly support the YOLOOBB format with angle orientation.

After applying the transformations, you can adjust the angle as follows:

• Rotation: For a rotation transformation, you will need to add the rotation angle to your OBB orientation angle. Make sure to modulate by 360 to keep the angle within bounds.
• Flipping: For flipping transformations, the handling will depend on the flip type. For a horizontal flip, you'll invert the orientation angle with respect to the y-axis, and similarly for a vertical flip with respect to the x-axis.

Since these are post-processing steps after albumentations' transformations, you would iterate through each transformed bounding box and apply the corresponding angle adjustments according to the transformation applied.

Given the complexity, you might consider writing or modifying a custom function in your dataset processing pipeline that applies these post-augmentation corrections to ensure the augmented annotations remain consistent with their respective images.

Keep in mind, this approach requires careful implementation to make sure angles are adjusted correctly, taking into account the periodic nature of angles (e.g., handling cases where angle exceeds 360 degrees or goes below 0).

def adjust_obb_annotations(boxes, transformation_type, transformation_value):
    # Your code here to adjust the angles and bounding boxes
    pass

This isn't a one-size-fits-all solution, and experimentation may be necessary to tailor the adjustments to your specific dataset and augmentation needs.

I hope this helps give you a direction on handling OBBs with your augmentations! Feel free to reach out if you have more questions or need further assistance. Happy coding! 🚀

[ccsadsxz]

HI, when I am training yolov8_obb models on muti-GPUs I meet an error

File "/tmp/pycharm_project_538/ultralytics-main/ultralytics/utils/loss.py", line 626, in call
feats, pred_angle = preds if isinstance(preds[0], list) else preds[1]
ValueError: too many values to unpack (expected 2)

It seems that the error is related to the calculation of the OBB loss. It expects two elements but got three. This error occurs when training on multiple GPUs, but it works fine on single GPU. How can I solve this problem?Thank you.

[glenn-jocher]

@ccsadsxz hey! 👋 It looks like you're diving into YOLOv8 OBB (Oriented Bounding Boxes) models, which is great for detecting objects with more accuracy by considering their orientation. You're already on the right track by exploring our docs and examples.

For your quick reference, here are a few points that might help you further:

• To train on OBB datasets, ensure your dataset is properly formatted. For OBB, you'll need five values [x_center, y_center, width, height, angle] for each bounding box.
• When moving to multi-GPU training or validation, double-check your dataset paths and batch sizes to ensure smooth operation across GPUs.
• Exporting models trained on OBB data: Choose the format that best suits your deployment scenario. For faster inference, consider using format='onnx' for CPU deployments or format='engine' for GPU-accelerated deployments.

Here's a snippet to get you started with model export after training:

model = YOLO('yolov8n-obb.pt')  # Assuming yolov8n-obb.pt is your trained model
model.export(format='onnx')  # Export to ONNX format

If you run into any further issues or have questions about OBB specific details, feel free to reach out. Happy coding! 🚀

[SilverStarCoder]

@ccsadsxz I am getting a similar RuntimeError to you, were you able to correctly resolve this?

[SilverStarCoder]

@glenn-jocher , I am confused, why did you say "To train on OBB datasets, ensure your dataset is properly formatted. For OBB, you'll need five values [x_center, y_center, width, height, angle] for each bounding box.". I thought the expected format is "class_index, x1, y1, x2, y2, x3, y3, x4, y4" ?

[glenn-jocher]

Hey! 👋 You brought up a great point regarding the format for OBB datasets. The essential distinction here is between the handling of conventional bounding boxes and the oriented bounding boxes (OBB).

For conventional YOLO models, the dataset format usually includes class_index, x_center, y_center, width, height. However, for Oriented Bounding Boxes (OBB) which include an angle to address the object orientation, you might indeed encounter datasets indicating bounding box coordinates like class_index, x1, y1, x2, y2, x3, y3, x4, y4, especially for complex applications or specific datasets like DOTAv1 that involve rotated objects.

In the context of Ultralytics YOLO, for OBB, a typical input might also include an angle along with the center coordinates and dimensions (i.e., [x_center, y_center, width, height, angle]). This format helps in specifying the rotation of the bounding box around its center. Always ensure you're aligning with the specific format expectation of your YOLO model version and the dataset you're using.

If there's any specific documentation or part of the dataset you're following, it's a good practice to stick closely to those format guidelines. Always open to discussing this further if you have more insights or queries! 🚀

[ccsadsxz]

@SilverStarCoder Sorry, I still haven't solved this problem.

[Violet-R4iN]

i am curious, doest it uses the same approach as yolov5-obb which use CSL for its OBB function?

[pderrenger]

@Violet-R4iN hey there! 😊 The YOLOv8 Oriented Bounding Boxes (OBB) models, identified by the -obb suffix like yolov8n-obb.pt, do not employ the CSL (Centerline Segmentation Loss) method used by some other versions of YOLO OBB implementations. Instead, our models are pre-trained on the DOTAv1 dataset, focusing on offering precise object detection by outputting rotated bounding boxes that accurately encapsulate objects at an angle. This approach is more about precision in rotation and alignment with the objects being detected.

For example, to use one of these models for detection, you'd load and predict like so:

from ultralytics import YOLO

# Load the OBB model
model = YOLO('yolov8n-obb.pt') 

# Predict!
results = model('https://ultralytics.com/images/bus.jpg')

Feel free to explore this feature for tasks requiring more detailed object localization. 🚀

[SFSimDev]

[pderrenger]

@SFSimDev hey there!

To save your OBB results as GeoJSON after running a YOLOv8 model against a GeoTIFF and preserve the coordinates, you might consider using Python libraries like rasterio (to handle GeoTIFF files) and geojson (to create and manage GeoJSON objects) 🌍. Here's a brief conceptual approach:

1. Use rasterio to open and read the GeoTIFF file, extracting georeferencing info.
2. Run your YOLOv8 OBB model to get the detection results.
3. Convert the detection results (oriented bounding boxes) into GeoJSON format. This involves translating pixel coordinates back to geographic coordinates using the GeoTIFF's affine transform.
4. Save the GeoJSON objects to a file.

Here's a small code snippet to illustrate parts of this process:

import rasterio
from geojson import Feature, Point, FeatureCollection
import json

# Load GeoTIFF and model results (pseudo-code)
with rasterio.open('path/to/your/geotiff.tif') as src:
    affine = src.transform
    # Assume 'results' is your model's output in pixel coords

# Convert results to GeoJSON (pseudo-code, simplify as needed)
features = []
for res in results:
    geo_point = affine * (res.x, res.y)  # Convert pixel coords to geo coords
    point = Point((geo_point[0], geo_point[1]))
    features.append(Feature(geometry=point, properties={"class": res.class, "confidence": res.confidence}))

# Save to GeoJSON
feature_collection = FeatureCollection(features)
with open('detections.geojson', 'w') as f:
    json.dump(feature_collection, f)

Keep in mind this is a high-level approach, and you'd need to adjust and extend it based on your exact requirements and the structure of your detection results. Also, make sure to manage the conversion between the coordinate systems accurately to retain the geographical accuracy of your results.

Hope this helps you on your geospatial adventure! 🚀

[SFSimDev]

Hi @pderrenger - Thanks this seems to be pretty much what I'm after but for some reason I'm getting the following error:

AttributeError: 'Results' object has no attribute 'x'.

Do you know why this might be happening? I've tried running it with my own model and the pretrained yolov8x-obb.pt plus a couple of different geotiff images on separate runs. I appreciate any help you can provide.

[pderrenger]

Hi @SFSimDev,

It looks like the error AttributeError: 'Results' object has no attribute 'x' is due to trying to access an attribute x that doesn't exist directly on the Results object returned by the model prediction. Instead, you should access the bounding box coordinates from the boxes attribute of the Results object.

Here's how you can modify your code to correctly access the bounding box coordinates:

from ultralytics import YOLO

# Load your model
model = YOLO('yolov8x-obb.pt')

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

# Access bounding box coordinates
for result in results:
    for box in result.boxes:
        x_center, y_center, width, height, angle = box.xywha  # x_center, y_center, width, height, angle
        print(f'Center: ({x_center}, {y_center}), Width: {width}, Height: {height}, Angle: {angle}')

Make sure to replace 'path/to/your/image.jpg' with the path to your actual image file. This code snippet assumes you are using an OBB model which provides the angle of the bounding box as well.

Let me know if this helps or if you have any more questions! 😊

[GhanasyamX]

for yolov8n-obb , results[0].boxes are returning none. previously, it was working. i think ultralytics recent update got it removed?

[pderrenger]

Hey there! 🌟 It sounds like you're encountering an issue with the results[0].boxes returning None when using yolov8n-obb. It's definitely not our intention to remove any functionality with updates, rather to improve and add features.

Could you please ensure you're loading the model correctly with the latest version? Here's a quick snippet you can try:

from ultralytics import YOLO

# Load the YOLOv8n-obb model
model = YOLO('yolov8n-obb.pt')

# Run prediction and check boxes
results = model('path/to/image.jpg')
if results[0].boxes is not None:
    print("Boxes are detected!")
else:
    print("No boxes detected, please check your model or image.")

If the problem persists, kindly share a bit more detail on the steps you followed or any specific changes in your environment. 🛠 Our team is here to help get to the bottom of this!

[SFSimDev]

I'm not the OP but I'm seeing the same error. I have added to the code to show that there are results but that results[0].boxes isn't working as expected.

from ultralytics import YOLO

# Load the YOLOv8n-obb model
model = YOLO('yolov8n-obb.pt')

# Run prediction and check boxes
results = model('boats.tiff')

for r in results:
    print("Results")
    print(r)
    
if results[0].boxes is not None:
    print("Boxes are detected!")
else:
    print("No boxes detected, please check your model or image.")

Output:

image 1/1 D:\Seafront\Tools\AI TOOLS\MyBoatDetector\boats.tiff: 864x1024 94.2ms
Speed: 15.6ms preprocess, 94.2ms inference, 1019.6ms postprocess per image at shape (1, 3, 864, 1024)
Results
[ultralytics.engine.results.Results object with attributes:

boxes: None
keypoints: None
masks: None
names: {0: 'plane', 1: 'ship', 2: 'storage tank', 3: 'baseball diamond', 4: 'tennis court', 5: 'basketball court', 6: 'ground track field', 7: 'harbor', 8: 'bridge', 9: 'large vehicle', 10: 'small vehicle', 11: 'helicopter', 12: 'roundabout', 13: 'soccer ball field', 14: 'swimming pool'}
obb: ultralytics.engine.results.OBB object
orig_img: array([[[ 67, 105,  98],
        [ 68, 106, 100],
        [ 69, 107, 101],
        ...,
        [ 75, 105,  95],
        [ 78, 107,  97],
        [ 80, 109, 100]],

       [[ 66, 104,  98],
        [ 67, 105,  99],
        [ 69, 106, 101],
        ...,
        [ 77, 106,  96],
        [ 79, 108,  99],
        [ 81, 111, 101]],

       [[ 66, 103,  98],
        [ 67, 105,  99],
        [ 68, 106, 101],
        ...,
        [ 78, 107,  98],
        [ 80, 110, 100],
        [ 83, 113, 102]],

       ...,

       [[ 35,  55,  42],
        [ 35,  55,  42],
        [ 36,  56,  43],
        ...,
        [ 35,  57,  52],
        [ 35,  57,  52],
        [ 35,  57,  52]],

       [[ 34,  54,  41],
        [ 34,  54,  41],
        [ 34,  54,  41],
        ...,
        [ 35,  57,  52],
        [ 35,  57,  52],
        [ 35,  57,  52]],

       [[ 32,  52,  39],
        [ 32,  52,  39],
        [ 33,  53,  40],
        ...,
        [ 35,  57,  52],
        [ 35,  57,  52],
        [ 34,  56,  51]]], dtype=uint8)
orig_shape: (16294, 19303)
path: 'D:\\Seafront\\Tools\\AI TOOLS\\MyBoatDetector\\boats.tiff'
probs: None
save_dir: 'runs\\obb\\predict2'
speed: {'preprocess': 15.635251998901367, 'inference': 94.16699409484863, 'postprocess': 1019.5722579956055}]
No boxes detected, please check your model or image.

[pderrenger]

@SFSimDev hey there! It seems like there might be a slight misunderstanding related to the output of yolov8n-obb model predictions.

From the output you've shared, it's clear that the model is recognizing and processing the image correctly as it should. However, for oriented bounding boxes (OBB), the results are stored in the obb attribute rather than the standard boxes attribute you might be used to with the regular YOLO models. This is because OBB deals with rotated bounding boxes that include an angle for orientation, which requires a different data structure.

For accessing the oriented bounding boxes, simply replace results[0].boxes with results[0].obb. Here's how you could modify your code snippet:

from ultralytics import YOLO

# Load the YOLOv8n-obb model
model = YOLO('yolov8n-obb.pt')

# Run prediction and check boxes
results = model('boats.tiff')

if results[0].obb is not None:  # Access the .obb attribute instead of .boxes
    print("Oriented bounding boxes are detected!")
else:
    print("No oriented bounding boxes detected, please check your model or image.")

Give this a try, and it should access the detected oriented bounding boxes as expected. Keep up the great work! 🌟

[lamb412]

Hey,
My program is runned properly with detection model but when i changed to obb model this problems appear. I tried in many ways but it still have the same results...

0: 704x1024 191.9ms
Traceback (most recent call last):
File "D:\project\py\test.py", line 18, in
for box in boxes:
TypeError: 'NoneType' object is not iterable
Exception ignored in: <generator object BasePredictor.stream_inference at 0x0000029994549B30>
Traceback (most recent call last):

AttributeError: 'NoneType' object has no attribute '_jit_internal'

This is my code:
from ultralytics import YOLO
import cv2

cap = cv2.VideoCapture("video.mp4")
model = YOLO("obb0410.pt")

while True:
success, img = cap.read()
img = cv2.resize(img, (1080,720))
results = model.predict(img)
if not success:
break
for r in results:
boxes = r.boxes
for box in boxes:
x1,y1,x2,y2=box.xyxy[0]
x1,y1,x2,y2=int(x1), int(y1), int(x2), int(y2)
print(x1,y1,x2,y2)
cv2.rectangle(img, (x1,y1), (x2,y2), (255,0,255), 3)
conf=math.ceil((box.conf[0]*100))/100
cls = int(box.cls[0])
class_name = className[cls]
label = f'{class_name}{conf}'
t_size = cv2.getTextSize(label, 0, fontScale=1, thickness=2)[0]
print(t_size)
c2 = x1 + t_size[0], y1 - t_size[1] - 3
cv2.rectangle(img, (x1,y1), c2, [255,0,255], -1, cv2.LINE_AA)
cv2.putText(img, label, (x1,y1-2),0, 1,[255,255,255], thickness=1,lineType=cv2.LINE_AA)
cv2.imshow("Video", img)
if cv2.waitKey(1)&0xFF ==ord('q'):
break
cv2.destroyAllWindows()

[pderrenger]

@lamb412 hi there,

It looks like the error you're encountering is due to the r.boxes attribute returning None, which suggests that no detections were made on the frames where this occurs. This might happen if the model confidence threshold is set too high or if the OBB model isn't properly detecting objects under the given conditions.

First, ensure that the video content contains objects that the OBB model is trained to detect, and check the lighting or image quality.

As a quick fix, you can add a check to see if boxes is None before iterating over it:

for r in results:
    boxes = r.boxes
    if boxes is not None:  # Add this check
        for box in boxes:
            x1, y1, x2, y2 = box.xyxy[0]
            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
            # your remaining logic

This should prevent your program from crashing when no objects are detected. If the issue persists, consider tuning the model or revisiting the training dataset to ensure it aligns well with your video content.

Hope this helps! If you need further assistance, feel free to ask. 😊

[masharib77]

How to use webcam in yolov8 obb ?

[pderrenger]

Hey there! To use a webcam with the YOLOv8 OBB (Oriented Bounding Boxes) model, you can modify your predict function to capture frames from the webcam instead of a video file. Here's a concise example using Python:

from ultralytics import YOLO
import cv2

# Load OBB model
model = YOLO('yolov8n-obb.pt')  # Adjust path if needed

# Start webcam capture
cap = cv2.VideoCapture(0)  # '0' assumes the default webcam
while True: 
    ret, frame = cap.read()
    if not ret:
        break

    # Predict using the OBB model
    results = model.predict(frame)

    # Visualize results
    frame = results.render()[0]
    cv2.imshow('YOLOv8 OBB Webcam', frame)
    if cv2.waitKey(1) == ord('q'):  # Press 'q' to quit
        break

cap.release()
cv2.destroyAllWindows()

In this script, model.predict() processes the webcam frames, and results.render() helps visualize the tracking with oriented bounding boxes. Just make sure your model path and the model you load (yolov8n-obb.pt) are correctly referenced. Happy coding! 😊

[54HaoHao-hue]

@glenn-jocher Hi!The data enhancements in v8-obb are very effective，however the sample distribution of my data is unbalanced, and I have found that YOLOV7 and V9 have ensembles "labels_to_class_weights" and "labels_to_image_weights" in the general.py, and these two strategies are effective when dealing with sample imbalance. However I didn't find these two strategies in v8, v10, I guess the strategies might be beneficial to improve v8's performance when the sample is unbalanced and I want to integrate them into the project, but I don't know which files to add, can you give me a little advice? Thank you very much!

[glenn-jocher]

@54HaoHao-hue for integrating "labels_to_class_weights" and "labels_to_image_weights" into YOLOv8, you might consider modifying the training scripts to include these strategies. Check the data loading and augmentation sections in the training pipeline. For more details on oriented bounding boxes, visit https://docs.ultralytics.com/tasks/obb/.

[liu15509348793]

Hello, thank you very much for your work, I encountered a problem when training my dataset with the yolov8obb model, my data annotation is in the format prompted by the document, but when I debugged the code, I found that there are only four values for each real box in the labels bboxes I read, and I am not sure how to get these four values, and the segments are a 4*2 vector, the values are the values in my label file, I am performing a detection task instead of splitting, My tag file doesn't split tags either. But in the end, I was able to train normally and achieve good results, I hope you can answer my questions

[glenn-jocher]

@liu15509348793 thank you for your kind words and detailed explanation. It sounds like your dataset annotations might not be fully aligned with the expected format for YOLOv8 OBB models. Each bounding box should include an angle to form an oriented bounding box, which is different from the standard four-value bounding box. Please ensure your annotations include this angle. For more details on the dataset format, you can refer to the Dataset Guide. If the issue persists, try updating to the latest package version to see if it resolves the problem.

[liu15509348793]

0 0.282878 0.663086 0.0016276 0.664062 0.000976562 0.0986328 0.282227 0.0981445
1 0.307292 0.334961 0.388672 0.348145 0.367188 0.638672 0.285807 0.625488
1 0.775716 0.485352 0.70931 0.564453 0.597982 0.353027 0.664062 0.273926
1 0.564453 0.23584 0.754557 0.23584 0.754557 0.375488 0.564453 0.375488
1 0.798177 0.649414 0.66276 0.838867 0.601237 0.739746 0.736654 0.550293
1 0.605794 0.924805 0.688477 0.924805 0.688477 1 0.605794 1
1 0.847331 0.773438 0.999674 0.796387 0.990885 0.925781 0.838867 0.902832
1 0.908529 0.344727 0.999674 0.365723 0.972005 0.638672 0.880859 0.618164
0 0.722331 0 0.999674 0 0.999674 0.280273 0.722331 0.280273
Thank you for the recovery, my label file is prepared according to the requirements of the document, the above is the content of one of my label files, and my training can also be carried out normally, but in the process of debugging, I found that the bboxes of labels correspond to only four values instead of eight, but the segment corresponds to a 4*2 vector, that is, eight values. Could you please help me see what the problem is? Or is that how the model is implemented internally?

[glenn-jocher]

It seems like your label file is correctly formatted, but the discrepancy you're seeing might be due to how the model processes the annotations internally. YOLOv8 OBB models expect oriented bounding boxes, which include an angle for rotation. Ensure your annotations include this angle. If the issue persists, please verify with the latest version of the package. For more details, refer to the Dataset Guide.

[liu15509348793]

Hello, thank you for your work, I want to use yolov8obb to detect my dataset, my dataset is about industrial materials, it can be divided into several categories, but each category is divided into heads and tails, which is usually difficult to distinguish, and each material is divided into head and tail, that is to say, I not only need to detect the angle of the material, but also know where his head is or the angle relative to the head, how should I solve my problem, in terms of dataset preparation and model, Can someone help me, thank you very much

[glenn-jocher]

@liu15509348793 to address your dataset needs with YOLOv8 OBB, you'll need to prepare your data with oriented bounding boxes that distinguish between the head and tail of each material. You can use the YOLO11-OBB models, which are pretrained on DOTAv1, to detect angles and orientations. For more details on dataset preparation and model usage, please visit the Oriented Bounding Boxes documentation.

[dearMOMO]

Can object detection be used?

[glenn-jocher]

@dearMOMO yes, object detection can be used. For more precise localization, you might consider using Oriented Bounding Boxes (OBB) with YOLOv8-OBB models. These models provide rotated bounding boxes for better accuracy. For more details, please visit Oriented Bounding Boxes Object Detection.

[dearMOMO]

Is target tracking okay

[glenn-jocher]

Yes, target tracking is supported. You can use YOLOv8 models for tracking tasks. For more details on how to implement tracking, please refer to the Ultralytics documentation.

[dearMOMO]

Great! I would appreciate it.

[glenn-jocher]

Thank you for your interest! You can find detailed information on Oriented Bounding Boxes (OBB) and how to use YOLOv8-OBB models in the Ultralytics documentation. If you have any specific questions or need further assistance, feel free to ask!

[Rakib-Ul-Haque]

Dear Concern,

is there any ways I can keep the model architecture and parameters constant before and after training, just the weights and bias should be training, just like the conventional ML models. ?

For example consider the following code:

from ultralytics import YOLO

Load a model

model = YOLO("yolov8n-obb.yaml") # build a new model from YAML
model = YOLO("yolov8n-obb.pt") # load a pretrained model (recommended for training)
model = YOLO("yolov8n-obb.yaml").load("yolov8n.pt") # build from YAML and transfer weights

Train the model

results = model.train(data="dota8.yaml", epochs=100, imgsz=640)

Now, Here, is there any parameter, which can help me to keep the architecture and model parameters constant across the train and validation.

I know few ways but still I wanna know from experts how to initialize a YOLO("yolov8n-obb.yaml") with weights, which might not have the same architecture or nodes or layers

[Rakib-Ul-Haque]

let's consider, I have the weight w, which is loaded from the torch loader

[glenn-jocher]

@Rakib-Ul-Haque to ensure the model architecture and parameters remain constant while only training the weights and biases, you can use the freeze argument during training. This allows you to freeze specific layers of the model. Here's an example:

from ultralytics import YOLO

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

# Train the model with frozen layers
results = model.train(data="dota8.yaml", epochs=100, imgsz=640, freeze=[0, 1, 2, 3])

This will keep the architecture and specified layers constant. For more details, please refer to the Ultralytics documentation.

[Rakib-Ul-Haque]

@glenn-jocher Thanks a lot, Though I solved the problem in another way, this also helps a lot. thank you.

[glenn-jocher]

You're welcome! I'm glad the information was helpful. If you have any more questions or need further assistance, feel free to ask.

[windzu]

if you want draw predict results to img and save , you can ref below easy code :

# you predict code #

import cv2

image = cv2.imread(test_img_path)
for r in results:
    xyxyxyxy = r.obb.xyxyxyxy.cpu().numpy()

    for box in xyxyxyxy:
        points = box.reshape(4, 2).astype(int)
        cv2.polylines(image, [points], isClosed=True, color=(0, 255, 0), thickness=2)

cv2.imwrite("detected_image.jpg", image)

[glenn-jocher]

@windzu thank you for sharing the code example. For more details on using YOLOv8 Oriented Bounding Boxes, please refer to our documentation on training, validation, and exporting models. If you have further questions, feel free to ask here.

[dov84d]

I want to understand the range of the output rotation. According to the documentation for the function xyxyxyxy2xywhr, it states that "Rotation values are expected in degrees from 0 to 90." And the function cv2.minAreaRect that prepare the data also produces this range of rotation values.

Therefore, I would expect the network to output angles only between 0 and 90 degrees (converted to radians). However, I'm observing output values greater than 270 degrees. How does this discrepancy make sense?

[glenn-jocher]

@dov84d the discrepancy you're observing might be due to how angles are represented in the model's output. While the function expects angles between 0 and 90 degrees, the network might output angles in a different range due to transformations or rotations applied during processing. It's essential to normalize or adjust these angles according to your specific application needs. If further clarification is needed, please refer to the detailed documentation or the Dataset Guide for more insights.

[enescanerkan]

Hello, I have a problem. I want to convert my labels to OBB format for YOLOv8. While processing in Google Colab, even though my dataset is fine, I want to convert my labels from YOLO format (for example → 0 0.738636 0.124589 0.008264 0.048520) to OBB format. I'm using the following code:

from ultralytics.data.converter import convert_dota_to_yolo_obb

dota_labels_directory = "/content/drive/MyDrive/data"

convert_dota_to_yolo_obb(dota_labels_directory)

After that, the names of my label files for train and val are coming out correctly, but they don’t contain any coordinates in OBB format. My labels are in txt format, but they are completely empty inside. What could be the reason for this and what is the solution? Thank you.

(What I'm trying to do is to convert the labels to OBB format for YOLOv8 and train with the yolov8n-obb.pt weight file to see if it has a positive impact on my project)

[glenn-jocher]

@enescanerkan it seems like the conversion process might not be correctly identifying the labels. Please ensure your dataset follows the required OBB format. You can refer to the Dataset Guide for detailed format specifications. If the issue persists, double-check the directory paths and file permissions.

[enescanerkan]

from ultralytics.data.converter import convert_dota_to_yolo_obb

convert_dota_to_yolo_obb("path/to/DOTA")

This code only starts converting the DOTA format dataset to YOLO-OBB format. What I am looking for is to convert my YOLO format labels to YOLO-OBB format. In your documentation, you show that you converted the labels you gave in yolo format to yolo obb format, but this code does not help in any way.

For example, can't I convert my yolo format label from class_index x1 y1 x2 y2 to → class_index x1 y1 x2 y2 x3 y3 x4 y4? Isn't the process we call oriented bounding box converting from the format I wrote above to obb format?

[glenn-jocher]

@enescanerkan to convert YOLO format labels to YOLO-OBB format, you'll need to manually adjust the label format to include the additional coordinates for the oriented bounding boxes. Unfortunately, there's no direct function for this conversion in the current tools. You might need to write a custom script to transform your labels from class_index x1 y1 x2 y2 to class_index x1 y1 x2 y2 x3 y3 x4 y4. For more guidance, please refer to our documentation: https://docs.ultralytics.com/quickstart/.

[HarinathPapireddy]

Hi, I have trained a YOLO OBB model. While testing it, I am able to test on the images, but the main issue I am facing is that while converting the model into other formats (for example, TFLite), I am unable to test the image. It always gives the same error like this:

KeyError                                  Traceback (most recent call last)
<ipython-input-33-16bc2bd0ae9e> in <cell line: 7>()
      5 
      6 # Run inference on an image
----> 7 results = model("/content/WhatsApp Image 2024-10-16 at 16.52.15 (1).jpeg",save=True)  # results list
      8 # View results
      9 

6 frames
/usr/local/lib/python3.10/dist-packages/ultralytics/engine/results.py in verbose(self)
    661             for c in boxes.cls.unique():
    662                 n = (boxes.cls == c).sum()  # detections per class
--> 663                 log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, "
    664         return log_string
    665 

KeyError: 2

But I have only two classes, and I don’t know what is going wrong.

[glenn-jocher]

@HarinathPapireddy it seems like the issue might be related to class indexing during the conversion process. Ensure that your class names are correctly defined and match the indices in your dataset configuration. If the problem persists, consider checking the export documentation for potential format-specific requirements. For more details, visit the Ultralytics OBB documentation.

[HarinathPapireddy]

I have only two classes, can you tell me how to verify the export documentation.

[HarinathPapireddy]

description: Ultralytics YOLOv8n-obb model trained on /home/tekroi/akhil/rice_coin_detection1-7/data.yaml
author: Ultralytics
date: '2024-10-21T07:59:38.657486'
version: 8.3.18
license: AGPL-3.0 License (https://ultralytics.com/license)
docs: https://docs.ultralytics.com
stride: 32
task: obb
batch: 1
imgsz:

• 1024
• 1024
  names:
  0: coin
  1: rice

[HarinathPapireddy]

i am trying to convert the model into tflite

[glenn-jocher]

To convert your YOLO OBB model to TFLite, ensure your class indices and names are correctly aligned in your dataset configuration. If the issue persists, verify the export process by following the Ultralytics OBB export documentation. This should help resolve the KeyError you're encountering.

[mozeqiu123]

Why do I need to download yolo11n.pt when I am training an OBB model。
The training command is as follows. The model has been specified and I have downloaded it locally。
< yolo obb train data=OBB/DOTAv1.yaml model=yolo11m-obb.pt device=0 epochs=250 imgsz=640>
What model is trained in this way

[glenn-jocher]

@mozeqiu123 when training an OBB model with the command you provided, the specified model yolo11m-obb.pt is used. The download of yolo11n.pt might be related to a dependency or default setting in the environment. Ensure your setup only references the models you intend to use.

[CS-Guo]

For YOLO-OBB Is there any heat map drawing method, can you provide the reference code to draw the heat map of the feature layer?

[glenn-jocher]

@CS-Guo currently, we don't have a specific method for drawing heat maps of feature layers in YOLO-OBB models. For more details on oriented object detection, please visit our documentation at https://docs.ultralytics.com/tasks/obb/.

[Violet-R4iN]

hi, i am currently a student learning Yolov11 algorithm,

from what i can see the difference between standard detect yolov11 and yolov11-obb located in the head

what are the changes made to the head that allow yolov11 to detect object angle? does it use different loss function?

thank you

[glenn-jocher]

The YOLO11-OBB models incorporate an additional angle parameter in the head to detect object orientation, enhancing localization accuracy. They use a modified loss function to accommodate this angle detection.

[Violet-R4iN]

thanks for your answer, when training yolov11-obb it showed me box_loss, cls_loss, and dfl_loss, how to show what kind of loss function is used ?

[glenn-jocher]

The box_loss, cls_loss, and dfl_loss correspond to bounding box regression loss, classification loss, and distribution focal loss, respectively. To examine the exact loss function details, you may review the source code in the YOLO11 repository under training modules or refer to the loss function implementation in the model head. Let me know if you need guidance on locating this in the codebase!

[Violet-R4iN]

Yes pls help me do that, I am a beginner and would be great if you could help me explain it Pada Rab, 4 Des 2024, 11.47 AM, Glenn Jocher ***@***.***> menulis:

…

The box_loss, cls_loss, and dfl_loss correspond to bounding box regression loss, classification loss, and distribution focal loss, respectively. To examine the exact loss function details, you may review the source code in the YOLO11 repository under training modules or refer to the loss function implementation in the model head. Let me know if you need guidance on locating this in the codebase! — Reply to this email directly, view it on GitHub <#7974 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AWDBONZEKLRWHBTYQ4RPMWL2D2CNTAVCNFSM6AAAAABCWLPUJWVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTCNBVGY4TCNI> . You are receiving this because you commented.Message ID: ***@***.*** com>

[glenn-jocher]

Thank you for your comment! If you're a beginner and need help understanding the loss functions in YOLO11, you can refer to the specific training modules within the YOLO11 GitHub repository. These modules show how box_loss (bounding box regression), cls_loss (classification), and dfl_loss (distribution focal loss) are calculated in detail. If further clarification is needed, feel free to ask specific questions!

[kirilman]

Hello dear developers. I don't get correct forecast results for OBB models unlike BOX. I get forecasts from yolo model and pass them through nms. For the standard yolo8x.pt box model I have everything working fine, however for yolo8x-obb.pt all the forecasts are not correct. Sample forecasts below.

My code on colab colab
Thanks for your help

[glenn-jocher]

@kirilman it appears the issue might be with how post-processing, particularly NMS, is being applied to the OBB predictions. OBB models output additional parameters (e.g., rotation angle) that standard NMS implementations may not handle correctly. Ensure you're using NMS designed for OBBs or refer to the Ultralytics OBB guide for compatible processing methods. Let us know if you face further issues!

[kirilman]

I see what the problem is. I have to pass classes=[0] to ops.non_max_suppression. However, after non_max_suppression function in oriented boxes that I drew as tilt angle conf appears. After the nms function in the tensor in x[:,5] - the conf values are found, but not the angle. I need to find the values of angles for boxes obtained after nms. This is very strange.
`
r = model.model(torch_img)
out = ops.non_max_suppression( r, conf_thres=0.25, iou_thres=0.45, classes=[0], rotated=True, agnostic=False, max_det=300)

out[0][:5]

tensor([[286.2367, 338.7935, 56.0656, 61.4904, 0.9751, 0.0000],
[470.3996, 428.5539, 72.4891, 50.4747, 0.9516, 0.0000],
[396.7098, 301.0814, 51.3490, 42.1323, 0.9511, 0.0000],
[149.9862, 501.3095, 69.2072, 57.5442, 0.9470, 0.0000],
[562.6898, 271.3908, 44.8985, 39.5666, 0.9455, 0.0000]])
`

[glenn-jocher]

@kirilman the results you are observing suggest that the angles for the oriented bounding boxes are not being retained after NMS. In your case, the ops.non_max_suppression function may not output the angle parameter properly. Ensure you use the rotated=True argument, as you have done, and confirm your YOLO model outputs in the xywhr (center x, y, width, height, rotation) format for the OBB detections. The angle is typically located in x[:, 5] before NMS. After NMS, you may need to map back or custom-handle the angle retention. Review the Ultralytics OBB guide for more details. Let me know if you need further clarification!