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! 😊 Accessing the results from a YOLOv8-OBB model to extract bounding box information is straightforward. After running predictions with your model, you can access the bounding boxes, class labels, and confidence scores directly from the results object. Here's a quick example using Python:

from ultralytics import YOLO

# Load your YOLOv8-OBB model
model = YOLO('yolov8n-obb.pt')  # For an official model
# model = YOLO('path/to/your/custom-model.pt')  # Or load your custom trained model

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

# Accessing bounding box information
for result in results:
    boxes = result.boxes.xyxy  # Bounding boxes in xyxy format
    confs = result.boxes.conf  # Confidence scores
    classes = result.boxes.cls  # Class labels

    # Example: print bounding box info
    for box, conf, cls in zip(boxes, confs, classes):
        print(f"Box: {box}, Confidence: {conf}, Class: {cls}")

This will print the bounding box coordinates, confidence scores, and class labels for each detection in your image. The bounding boxes are in the format [x1, y1, x2, y2], where (x1, y1) and (x2, y2) are the coordinates of the top-left and bottom-right corners, respectively.

Hope this helps! Let us know if you have any more questions. 🚀

[SFSimDev]

Ok so I've tried this and I'm getting the following error:

boxes = result.boxes.xyxy # Bounding boxes in xyxy format
AttributeError: 'NoneType' object has no attribute 'xyxy'

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

[nguyenvandang1998]

Hi, I am trying to obtain the angle of an object using angle = float(box.xywhr[0][4]), but it does not seem to be what I expected. I usually get an angle value between 0 and 3, even when I rotate the image by 90 or 180 degrees, the model still predicts and returns the correct object coordinates. It seems like I made a mistake somewhere while attempting to obtain the angle of an object.
What should I do to get the angle of the object? Thank you!!!

[glenn-jocher]

Hi there! It sounds like you're making great progress with using Oriented Bounding Boxes (OBB) for object detection. 🚀 If the angle values are not as expected, it could be due to the representation or range of the angle output by the model. In YOLOv8-OBB models, the angle is usually in radians and might be normalized or have a specific range.

For YOLOv8 OBB models, angles are typically represented within a specific range to ensure efficient learning. You might want to check the angle's range or format expected by the model or post-processing code. Converting radians to degrees (if needed) could also offer more intuitive angle values: angle_degrees = angle_radians * (180.0 / np.pi).

Could you please share a bit more about how you're processing or visualizing the angle? Sometimes, a small adjustment in the post-processing steps can make a big difference. Let's figure this out together! 🛠️

[ivanstepanovftw]

@glenn-jocher, hello!

Can you check what you are feeding into ChatGPT or at least verify the answer?

User is clearly asking about output format for oriented bounding boxes. What is the output shape for OBB models? How to get angle of the predicted box? Which indices for bounding box, angle and classes?

[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! 😊

[tjsgn]

I tried to follow the above instructions to use OBB in a webcam environment, but I'm encountering the following error.
AttributeError: 'list' object has no attribute 'render'
How can I fix it?

[glenn-jocher]

Hi there!

The error you're encountering, AttributeError: 'list' object has no attribute 'render', typically occurs when trying to call a method on a list that doesn't exist. In this case, it seems like you're trying to render the results directly from a list of results.

To fix this, you should iterate over the list of results and call the render method on each individual result. Here's a quick example:

from ultralytics import YOLO
import cv2

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

# Capture video from the webcam
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Run prediction
    results = model(frame)

    # Iterate over the results and render each one
    for result in results:
        rendered_frame = result.render()
        cv2.imshow("YOLOv8-OBB", rendered_frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

This should resolve the issue and allow you to render the predictions correctly. If you need more details, feel free to check out the Oriented Bounding Boxes Object Detection documentation.

Happy coding! 😊

[tjsgn]

Thank you for your response. I'm sorry to bother you, but could you please tell me if it's possible to display the angle of the bounding box as a label?

[glenn-jocher]

Hi there,

No bother at all! Yes, you can display the angle of the bounding box as a label. You can extract the angle from the results and include it in the rendering process. Here's an example of how you can do this:

from ultralytics import YOLO
import cv2

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

# Capture video from the webcam
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Run prediction
    results = model(frame)

    # Iterate over the results and render each one
    for result in results:
        for box in result.boxes:
            angle = box.angle  # Extract the angle
            label = f"{box.cls} {angle:.2f}"  # Create label with angle
            rendered_frame = result.render(label=label)
            cv2.imshow("YOLOv8-OBB", rendered_frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

This code will display the angle of each bounding box as part of the label. If you need further assistance, feel free to ask! 😊

[lushanfu]

Hi, I would like to train a yolov8l-obb model, but I couldn't find the corresponding yolov8l-obb.yaml configuration file. Also, I want to set my image size to 512x1024, but it seems it's not taking effect. Lastly, how can I set up random vertical flipping during training? Looking forward to your response, thank you.

[glenn-jocher]

Hello,

Thank you for reaching out with your questions!

1. Configuration File: If the yolov8l-obb.yaml is not available in your setup, you might need to create or modify an existing configuration file to suit the yolov8l-obb model. You can start by copying and adjusting parameters from a similar model's configuration file.

2. Image Size: To set your image size to 512x1024, ensure you're modifying the imgsz parameter correctly in your training script or command line. It should look like this in Python: imgsz=(512, 1024) or in CLI: imgsz=512,1024.

3. Random Vertical Flipping: To enable random vertical flipping during training, you'll need to add or modify the augmentation settings in your dataset configuration file. Add flipud=0.5 (or your desired probability) under the augment section.

If you need further assistance or examples, feel free to ask. Happy training!

[lushanfu]

Thank you for your response.

[glenn-jocher]

Hello,

Thank you for your feedback!

For the yolov8l-obb.yaml configuration, you might need to create a custom YAML file based on another OBB model's configuration, adjusting parameters to fit the yolov8l-obb specifications. If you need assistance with this, I'm here to help!

Regarding setting the image size to 512x1024, ensure you're using the correct format in your training command or script, like imgsz=[512, 1024]. This should correctly set the dimensions for training.

To enable random vertical flipping during training, you can add flipud=0.5 (or your desired probability) to the augmentation settings in your dataset configuration file.

If there's anything more you need, feel free to ask. Happy training! 😊