Phát hiện hộp giới hạn định hướng với Ultralytics YOLO
Phát hiện đối tượng định hướng vượt hơn phát hiện đối tượng tiêu chuẩn bằng cách thêm một góc để định vị đối tượng trong ảnh chính xác hơn.
Đầu ra của model phát hiện đối tượng định hướng là tập hợp các bounding box xoay bao quanh chính xác đối tượng trong ảnh, cùng với nhãn lớp và điểm confidence cho từng box. Bounding box định hướng đặc biệt hữu ích khi đối tượng xuất hiện ở nhiều góc độ, chẳng hạn trong ảnh hàng không, nơi bounding box căn theo trục truyền thống có thể chứa phần nền không cần thiết. Các ứng dụng phổ biến gồm phát hiện tàu và phương tiện từ vệ tinh và drone, phân tích tòa nhà và cơ sở hạ tầng phục vụ quy hoạch đô thị, giám sát cây trồng và kiểm tra tấm pin mặt trời hoặc tua-bin gió.
Xem: Cách phát hiện và theo dõi đối tượng bằng bounding box định hướng (OBB) của Ultralytics YOLO26 | Theo dõi tàu 🚢
Model OBB YOLO26 sử dụng hậu tố -obb, ví dụ yolo26n-obb.pt, và được pretrained trên DOTAv1.
| Phát hiện tàu thuyền bằng OBB | Phát hiện phương tiện bằng OBB |
|---|---|
![]() | ![]() |
Models#
Các model YOLO26 OBB được pretrained trên dataset DOTAv1 được hiển thị bên dưới.
Model sẽ tự động tải xuống từ bản phát hành Ultralytics mới nhất trong lần sử dụng đầu tiên.
Hình ảnh và chú thích của DOTAv1 chỉ được phép sử dụng cho mục đích học thuật và không được sử dụng cho mục đích thương mại. Ultralytics hiểu rằng các hạn chế này áp dụng cho bộ dữ liệu nguồn, không áp dụng cho trọng số model đã được pretrained hoặc fine-tune. Hãy xem điều khoản DOTA để xác định mục đích sử dụng dự kiến của bạn.
| Model | kích thước (pixel) | mAPtest50-95 (e2e) | mAPtest50 (e2e) | Tốc độ CPU ONNX (ms) | Tốc độ T4 TensorRT10 (ms) | params (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n-obb | 1024 | 52.4 | 78.9 | 97.7 ± 0.9 | 2.8 ± 0.0 | 2.4 | 14.8 |
| YOLO26s-obb | 1024 | 54.8 | 80.9 | 218.0 ± 1.4 | 4.9 ± 0.1 | 9.8 | 56.7 |
| YOLO26m-obb | 1024 | 55.3 | 81.0 | 579.2 ± 3.8 | 10.2 ± 0.3 | 21.2 | 184.9 |
| YOLO26l-obb | 1024 | 56.2 | 81.6 | 735.6 ± 3.1 | 13.0 ± 0.2 | 25.6 | 232.4 |
| YOLO26x-obb | 1024 | 56.7 | 81.7 | 1485.7 ± 11.5 | 30.5 ± 0.9 | 57.6 | 520.1 |
- Các giá trị mAPtest được đo với một model, đa scale trên dataset DOTAv1.
Tái lập kết quả bằngyolo obb val data=DOTAv1.yaml device=0 split=test nms=False save_json=Truevà gửi kết quả đã gộp đến đánh giá DOTA. - Tốc độ được tính trung bình trên các ảnh val của DOTAv1 bằng ONNX trên CPU và TensorRT10 trên GPU NVIDIA T4.
Tái lập kết quả bằngyolo obb val data=DOTAv1.yaml batch=1 device=0|cpu nms=False - Các giá trị Params và FLOPs được tính cho model đã hợp nhất sau khi gộp Conv/BatchNorm và loại bỏ nhánh phát hiện không sử dụng. Checkpoint được huấn luyện trước vẫn giữ nguyên kiến trúc huấn luyện đầy đủ nên có thể hiển thị số liệu cao hơn.
Xem bản preview YOLO27 chưa phát hành để biết kết quả sơ bộ trên DOTAv1.
Huấn luyện#
Huấn luyện model YOLO26n-obb trên dataset DOTA8 trong 100 epoch với kích thước ảnh 640.
Một OBB và phép xoay 180° của nó là giống hệt nhau, vì vậy góc xoay được xác định theo modulo 180° và hộp không có hướng. Nhãn training được chuẩn hóa theo dạng cạnh dài: chiều rộng hộp w là cạnh dài hơn, góc được đo theo chiều kim đồng hồ từ trục x dương đến hướng của cạnh w, và được lưu bằng radian trong [-π/4, 3π/4) ([-45°, 135°)). Dự đoán không được chuẩn hóa, vì vậy hộp được dự đoán có thể báo cạnh ngắn là w; xem Đầu ra kết quả. Dạng [0°, 90°) là quy ước kiểu DOTA đã chuẩn hóa và không được áp dụng trong quá trình training hoặc inference.
from ultralytics import YOLO
# Tải model
model = YOLO("yolo26n-obb.yaml") # tạo model mới từ YAML
model = YOLO("yolo26n-obb.pt") # tải model đã huấn luyện trước (được khuyến nghị khi huấn luyện)
model = YOLO("yolo26n-obb.yaml").load("yolo26n-obb.pt") # tạo từ YAML và chuyển trọng số
# Huấn luyện model
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)Xem: Cách huấn luyện model Ultralytics YOLO-OBB (bounding box định hướng) trên dataset DOTA bằng Ultralytics Platform
Xem chi tiết đầy đủ về chế độ train trên trang Train. Bạn cũng có thể train model OBB bằng dịch vụ training đám mây của Ultralytics Platform.
Định dạng dataset#
Bạn có thể xem chi tiết định dạng dataset OBB trong Hướng dẫn về dataset. Định dạng YOLO OBB biểu diễn hộp giới hạn bằng bốn điểm góc có tọa độ chuẩn hóa trong khoảng từ 0 đến 1, theo cấu trúc sau. Tính năng gán nhãn của Ultralytics Platform hỗ trợ nhãn OBB với công cụ vẽ hộp giới hạn định hướng chuyên dụng:
class_index x1 y1 x2 y2 x3 y3 x4 y4Bên trong, YOLO xử lý loss và đầu ra theo định dạng xywhr, biểu diễn tâm (xy), chiều rộng, chiều cao và góc xoay của bounding box.
Đánh giá#
Validation độ chính xác của model YOLO26n-obb đã huấn luyện trên bộ dữ liệu DOTA8, đo bằng độ chính xác trung bình (mAP). Truyền rõ ràng data để validation sử dụng đúng YAML của bộ dữ liệu.
from ultralytics import YOLO
# Tải model
model = YOLO("yolo26n-obb.pt") # tải model chính thức
model = YOLO("path/to/best.pt") # tải model tùy chỉnh
# Xác thực model
metrics = model.val(data="dota8.yaml") # validate trên dataset DOTA8
metrics.box.map # map50-95(B)
metrics.box.map50 # map50(B)
metrics.box.map75 # map75(B)
metrics.box.maps # mAP50-95(B) theo từng lớp; các lớp không có trong tập val nhận giá trị mAP(B) tổng thể
metrics.box.ap_class_index # chỉ số lớp thực sự được đánh giá
metrics.box.image_metrics # dictionary metric theo từng ảnh, gồm precision, recall, F1, TP, FP và FNDự đoán#
Sử dụng model YOLO26n-obb đã train để chạy dự đoán trên ảnh.
from ultralytics import YOLO
# Tải model
model = YOLO("yolo26n-obb.pt") # tải model chính thức
model = YOLO("path/to/best.pt") # tải model tùy chỉnh
# Dự đoán bằng model
results = model("https://ultralytics.com/images/boats.jpg") # dự đoán trên một ảnh
# Truy cập kết quả
for result in results:
xywhr = result.obb.xywhr # tâm-x, tâm-y, chiều rộng, chiều cao, góc (radian)
xyxyxyxy = result.obb.xyxyxyxy # định dạng đa giác với 4 điểm
names = [result.names[cls.item()] for cls in result.obb.cls.int()] # tên lớp của từng hộp
confs = result.obb.conf # điểm tin cậy của từng hộpXem chi tiết đầy đủ về chế độ predict trên trang Dự đoán.
Truyền save_crop=True để lưu ảnh cắt của mỗi OBB đã căn chỉnh theo góc xoay với kích thước bằng kích thước box, giống như ObjectCropper.
Đầu ra kết quả#
Phát hiện hộp giới hạn định hướng trả về một đối tượng Results cho mỗi ảnh. Trường dự đoán chính là result.obb, chứa các hộp xoay, ID lớp và điểm tin cậy cho từng đối tượng được phát hiện.
| Thuộc tính | Kiểu | Hình dạng | Mô tả |
|---|---|---|---|
result.obb | OBB | (N) | BBox định hướng. |
result.obb.data | torch.float32 | (N,7/8) | BBox xoay thô kèm độ tin cậy/lớp. |
result.obb.xywhr | torch.float32 | (N,5) | BBox xoay xywhr. |
result.obb.xyxyxyxy | torch.float32 | (N,4,2) | Bốn điểm góc. |
result.obb.conf | torch.float32 | (N,) | Điểm độ tin cậy. |
Nhãn được chuẩn hóa theo quy ước cạnh dài, nhưng các dự đoán thì không, vì vậy result.obb.xywhr có thể báo w nhỏ hơn h khi góc được đo từ cạnh ngắn. Cả hai dạng đều mô tả cùng một hình chữ nhật, vì vậy result.obb.xyxyxyxy đều đúng trong cả hai trường hợp. Khi theo dõi, mỗi track giữ dạng nửa vòng (θ hoặc θ ± π) gần với góc trước đó nhất, vì vậy góc của track không bị lật π giữa các frame và có thể vượt ra ngoài [-π/4, 3π/4). Hãy chuyển đổi các đỉnh trở lại khi code ở bước sau cần dạng cạnh dài, đồng thời lưu ý rằng việc viết lại các tham số của bounding box có thể làm thứ tự các đỉnh dịch chuyển theo chu kỳ:
from ultralytics.utils.ops import xyxyxyxy2xywhr
xywhr = xyxyxyxy2xywhr(result.obb.xyxyxyxy) # w >= h, rotation in [-pi/4, 3pi/4)Để xem các trường Results dành riêng cho từng tác vụ trên tất cả tác vụ, hãy tham khảo mục Kết quả dự đoán theo tác vụ.
Export#
Xuất model YOLO26n-obb sang định dạng khác như ONNX, CoreML, v.v.
from ultralytics import YOLO
# Tải model
model = YOLO("yolo26n-obb.pt") # tải model chính thức
model = YOLO("path/to/best.pt") # tải model tùy chỉnh
# # Xuất model
model.export(format="onnx")Các định dạng export YOLO26-obb hiện có được liệt kê trong bảng bên dưới. Bạn có thể export sang bất kỳ định dạng nào bằng tham số format, ví dụ format='onnx' hoặc format='engine'. Bạn có thể predict hoặc validation trực tiếp trên model đã export, ví dụ yolo predict model=yolo26n-obb.onnx. Sau khi hoàn tất export, các ví dụ sử dụng model sẽ được hiển thị.
| Định dạng | Đối số format | Model | Metadata | Đối số |
|---|---|---|---|---|
| PyTorch | - | yolo26n-obb.pt | ✅ | - |
| TorchScript | torchscript | yolo26n-obb.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n-obb.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n-obb_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n-obb.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n-obb.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| Apple Core AI | coreai | yolo26n-obb.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n-obb_saved_model/ | ✅ | imgsz, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n-obb.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n-obb_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| LiteRT | litert | yolo26n-obb.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n-obb_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n-obb.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n-obb_ncnn_model/ | ✅ | imgsz, quantize, device |
| IMX500 | imx | yolo11n_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n-obb_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n-obb_executorch_model/ | ✅ | imgsz, quantize, batch, data, fraction, device |
| Axelera | axelera | yolo26n-obb_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n-obb_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n-obb_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| Hailo | hailo | yolo26n-obb_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n-obb_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n-obb_xilinx_model/ | ✅ | imgsz, name, quantize, data, fraction, opset, simplify, device |
| NXP | nxp | yolo26n-obb_nxp.tflite | ✅ | imgsz, quantize, data, fraction, device |
| ST Edge AI | stedgeai | yolo26n-obb_stedgeai.onnx | ✅ | imgsz, quantize, data, fraction, opset, simplify, device |
nms=None mặc định xuất dữ liệu thô để thực hiện NMS bên ngoài (YOLO26 vẫn giữ head không cần NMS trên Axelera). Đặt nms=False để chọn head không cần NMS hiện có; các định dạng không được hỗ trợ sẽ chuyển về đường dẫn xuất dữ liệu gốc của định dạng đó. Các mục nms ở trên xác định những định dạng có thể tích hợp NMS bằng nms=True.
Xem chi tiết đầy đủ về export trên trang Export.
Câu hỏi thường gặp#
Bounding box định hướng (OBB) có thêm một góc để nâng cao độ chính xác định vị đối tượng trong ảnh. Không giống bounding box thông thường là các hình chữ nhật song song với trục, OBB có thể xoay để khớp hơn với hướng của đối tượng. Điều này đặc biệt hữu ích cho các ứng dụng đòi hỏi định vị đối tượng chính xác, chẳng hạn như ảnh chụp từ trên không hoặc ảnh vệ tinh (Hướng dẫn về dataset).
Để huấn luyện model YOLO26n-obb bằng dataset tùy chỉnh, hãy làm theo ví dụ bên dưới bằng Python hoặc CLI:
Ví dụfrom ultralytics import YOLO # Tải model pretrained model = YOLO("yolo26n-obb.pt") # Huấn luyện model results = model.train(data="path/to/custom_dataset.yaml", epochs=100, imgsz=640)Để biết thêm các đối số huấn luyện, hãy xem mục Cấu hình.
Model YOLO26-OBB được huấn luyện trước trên các dataset như DOTAv1, nhưng bạn có thể dùng bất kỳ dataset nào được định dạng cho OBB. Thông tin chi tiết về định dạng dataset OBB có trong Hướng dẫn về dataset.
Để đánh giá model YOLO26n-obb, bạn có thể dùng các lệnh Python hoặc CLI như minh họa bên dưới:
Ví dụfrom ultralytics import YOLO # Tải model model = YOLO("yolo26n-obb.pt") # Xác thực model metrics = model.val(data="dota8.yaml")Xem thông tin chi tiết về quy trình đánh giá trong mục Val.
Có thể dễ dàng xuất model YOLO26-OBB sang định dạng ONNX bằng Python hoặc CLI:
Ví dụfrom ultralytics import YOLO # Tải model model = YOLO("yolo26n-obb.pt") # # Xuất model model.export(format="onnx")Để biết thêm định dạng xuất và thông tin chi tiết, hãy tham khảo trang Export.
Bình luận252
Đặt câu hỏi, chia sẻ kết quả hoặc giúp đỡ người khác.
zhouyizhuo
how to do Model Ensembling on yolov8-obb models?
2
Paula DerrengerUltralytics(đã chỉnh sửa)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[0].obb) # Extracting OBB predictions (xywhr, conf, cls) # 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! 😊
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)1
Glenn JocherUltralytics@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.
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.🙂
1RizwanMunawar
@krialm In the case of OBB, you can get bounding box data, using the mentioned code below.
model = YOLO("yolov8n-obb.pt") results = model.predict(im0) pred_boxes = results[0].obbI hope this helps! Let me know if you have any additional questions.
Thanks and Regards Ultralytics Team!
1kedardg
Is there a way for me to train OBB models from scratch let's say the P2 or RTDETR models which are not available pre-trained?
Paula DerrengerUltralytics@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=640Just replace
your_dataset.yamlwith your dataset configuration file andyour_model.yamlwith 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
Paula DerrengerUltralytics@RumaisaIlyas hey there! 😊 To draw bounding boxes on your test image and return it, you can use the
plot()method available in theResultsobject. 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_imageIn this updated function, after making predictions with
model.predict(image), we useresults[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
Paula DerrengerUltralytics(đã chỉnh sửa)Hey there! 😊 It sounds like you're doing everything right, but if the
runsfolder isn't being created, it might be due to a small oversight. Here's a quick checklist:- Ensure you're using the latest version of the Ultralytics YOLO library. Sometimes, updates fix these kinds of issues.
- 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 # save=True writes the annotated image to the 'runs' folder results = model.predict('path/to/your/image.jpg', save=True)- If you're still not seeing the
runsfolder, try specifying the output directory explicitly in your code:
results = model.predict('path/to/your/image.jpg', save=True, project='runs/detect') # Adjust the path as needed- 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!
Ci-ne
I also face the same problem. I tried using the code provided but it still says NoneType
ncnn_model = YOLO("./my_ncnn_model", task='detect') results = ncnn_model.predict(image_path)
if results[0] is not None: # Ensure results is not None obb_boxes = results[0].obb # For OBB models print(f"OBB Box: {obb_boxes}") else: print("No detections.")
This is what I get
Speed: 4.1ms preprocess, 93.1ms inference, 1.2ms postprocess per image at shape (1, 3, 640, 640) OBB Box: None
Any help?
1chengz
The document notes that 'OBB angles are constrained to the range 0–90 degrees (exclusive of 90). Angles of 90 degrees or greater are not supported.' So what is the normal radian range for an OBB, [-π/4, 3π/4) or something else?
Murat Raimbekovthe radian range is
[-π/4, 3π/4), i.e.[-45°, 135°), not[0°, 90°). that docs note was inaccurate and is fixed in #24534.ground-truth angles are normalized in
xyxyxyxy2xywhr(ultralytics/utils/ops.py) by two loops,while theta >= 3*pi/4: theta -= piandwhile theta < -pi/4: theta += pi, withwswapped to the longer side. sweeping a rectangle through physical 0->180°:0° -> 0.0000 45° -> 0.7854 (π/4) 90° -> 1.5708 (π/2) 120° -> 2.0944 135° -> -0.7854 (-π/4) 165° -> -0.2618so the span is exactly π wide, half-open at
3π/4.the heads match this:
OBB(yolov8/yolo11):angle = (sigmoid(raw) - 0.25) * π, hard-bounded to[-π/4, 3π/4].OBB26(yolo26): raw output, no sigmoid, trained on targets already in[-π/4, 3π/4).
[0, π/2)is the regularized DOTA-style form produced byregularize_rboxesinops.py. that function is defined but has no callers anywhere inultralytics/, so it is not applied at training or inference. predicted boxes reach you unregularized:result.obb.xywhrreturns the angle in[-π/4, 3π/4)(verified by feeding angles like-0.70and2.30through the predict path and reading them back unchanged).one consequence, which is what the original note was really about: an OBB and its 180° rotation encode to the same
xywhr, so rotation is defined only modulo 180° and the box has no direction. θ and θ+180° are indistinguishable, so you cannot recover a fixed corner ordering from the predicted angle.
UsermAPtest values are for single-model multiscale on DOTAv1 dataset. Reproduce by yolo val obb data=DOTAv1.yaml device=0 split=test and submit merged results to DOTA evaluation. This mentions that the test results are submitted to the DOTAv1 server through a multiscale approach. I would like to ask, what does this "multiscale" mean? How is it specifically implemented? Is it trained at scales like 512512 and 10241024, and then tested on the test dataset? How are the final results obtained? I am not quite clear on what this multiscale refers to. Please help me with this.
Glenn JocherUltralyticsHere, “multiscale” means evaluating the same trained model on multiple resized/split versions of each DOTA image tile, then merging those detections back into the original image for final submission; in Ultralytics this is tied to the DOTA split pipeline with scales like
rates=[0.5, 1.0, 1.5]in the DOTA dataset guide and the merged-result export inOBBValidator.eval_json(), so it is usually multi-scale test-time inference with one model rather than separately training 512 and 1024 models.
Murat Raimbekovit is one model, trained once. there is no separate 512 and 1024 model, and no separate training runs per scale. the "multiscale" lives entirely in the dota tiling step, not inside
yolo val.where it comes from. dota images are huge (800x800 up to ~20000x20000), so they are cut into overlapping tiles before training/val using
split_trainval/split_testfromultralytics/data/split_dota.py. the multiscale variant passesrates=[0.5, 1.0, 1.5](this is exactly what the dota dataset guide shows). for each raterthe code usescrop_size / randgap / r, so with the defaultscrop_size=1024, gap=200you get tiles of:rate 0.5 -> 2048 px tiles (gap 400) rate 1.0 -> 1024 px tiles (gap 200) rate 1.5 -> 682 px tiles (gap 133)every original image is therefore cut into overlapping windows at all three crop sizes. each window is later resized to
imgszat inference, so the same content is effectively seen at three resolutions. concretely, a single 4000x4000 image produces ~98 tiles spread across those three sizes.training. the model is trained once on the multiscale-split trainval tiles (same
rates=[0.5, 1.0, 1.5]). it is not "trained at 512 then at 1024" as separate models.test / how the final number is obtained.
yolo val obb data=DOTAv1.yaml split=testruns that single model over every test tile. each tile filename encodes the source image id and crop offset (name__cropsize__xstart___ystart).OBBValidator.eval_json()parses that, shifts each tile's rotated boxes back into the original full-image coordinates, concatenates detections from all tiles and all scales, then runs a rotated probiou NMS (fast_nms, iou 0.3) to remove the overlap introduced by tiling. the merged per-image results are written as dotaTask1_*.txt, which is what you submit to the dota evaluation server.one practical caveat.
yolo val ... split=testdoes not create the multiscale tiles for you. you have to runsplit_test(rates=[0.5, 1.0, 1.5])first (andsplit_trainvalwith the same rates for training). running val on the raw full dota images is single-scale and will not reproduce themAPtestnumber in the table.so in short: multiscale = offline multi-scale tiling + per-tile single-scale inference + merge-back-and-NMS, all with one model. it is test-time multi-scale through the tiling, not test-time augmentation inside
val.
kssion
WARNING ⚠️ CoreML: 'nms=True' is only available for Detect models like 'yolo11n.pt'.
yolo export model=best.pt format=coreml nms=True conf=0.25 iou=0.45Ultralytics 8.3.232 🚀 Python-3.11.11 torch-2.9.1 CPU (Apple M1) YOLO11n-obb summary (fused): 109 layers, 2,653,918 parameters, 0 gradients, 6.6 GFLOPs
PyTorch: starting from 'best.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 6, 8400) (5.5 MB) Torch version 2.9.1 has not been tested with coremltools. You may run into unexpected errors. Torch 2.7.0 is the most recent version that has been tested.
CoreML: starting export with coremltools 9.0... WARNING ⚠️ CoreML: 'nms=True' is only available for Detect models like 'yolo11n.pt'. Converting PyTorch Frontend ==> MIL Ops: 100%|██████████████▉| 867/868 [00:00<00:00, 8975.73 ops/s] Running MIL frontend_pytorch pipeline: 100%|███████████████████| 5/5 [00:00<00:00, 166.58 passes/s] Running MIL default pipeline: 100%|███████████████████████████| 95/95 [00:00<00:00, 99.61 passes/s] Running MIL backend_mlprogram pipeline: 100%|████████████████| 12/12 [00:00<00:00, 176.60 passes/s] CoreML: export success ✅ 4.8s, saved as 'best.mlpackage' (5.3 MB)
Export complete (5.0s)
Glenn JocherUltralyticsThat warning is expected for OBB models: CoreML
nms=Trueis only supported for axis-aligned Detect heads, so export your*-obbmodel without NMS and do confidence/IoU (rotated NMS) post-processing on the app side (export success ✅ means you’re fine). See the Ultralytics YOLO OBB task docs for the OBB output formats.yolo export model=best.pt format=coreml
wang18382140151-hub
你好,请问你们未来的工作计划中是否有将rtdetr用于obb检测呢,最近我正在基于贵司源码做改进
AbhisekRao
I'm currently working with the YOLOv11 Oriented Bounding Box (OBB) model exported in TensorRT format, and deploying it on an NVIDIA Jetson device (AGX Orin). While the model works in standard inference pipelines (.pt) , I’m facing challenges integrating it into a DeepStream-based application to process live RTSP video streams.
There seems to be no existing reference implementation or sample Python code that demonstrates how to use the OBB variant of the model with DeepStream. Specifically, I'm looking for guidance on:
1- Integrating the YOLOv11 OBB TensorRT model with DeepStream (preferably using Python bindings). 2- Proper parsing and visualization of oriented bounding boxes from the model output. 3- Any custom parser or config file changes required in the DeepStream pipeline.
Any support, documentation, or examples from the team or community would be greatly appreciated.
cripsgreen
Hello, could you please share some insights on how to train the hyperparameters for YOLOv11-OBB, as well as the pre-trained weights? Thank you.
ziishuo
May I ask if the OBB model can be used to detect subjects in a normal perspective (such as a level shot)? I noticed that most of the examples are from a top-down angle. Thank you!



