Detección de cajas delimitadoras orientadas con Ultralytics YOLO#
La detección de objetos orientados va más allá de la detección de objetos estándar: añade un ángulo para localizar los objetos con mayor precisión en una imagen.
La salida de un detector de objetos orientados es un conjunto de cajas delimitadoras rotadas que rodean con precisión los objetos de la imagen, junto con las etiquetas de clase y las puntuaciones de confianza de cada caja. Las cajas delimitadoras orientadas son especialmente útiles cuando los objetos aparecen en distintos ángulos, por ejemplo, en imágenes aéreas, donde las cajas delimitadoras tradicionales alineadas con los ejes pueden incluir fondo innecesario. Entre sus usos habituales se encuentran la detección de barcos y vehículos mediante satélites y drones, el análisis de edificios e infraestructuras para la planificación urbana, la vigilancia de cultivos y la inspección de paneles solares o turbinas eólicas.
Ver: Cómo detectar y seguir objetos con cajas delimitadoras orientadas (OBB) de Ultralytics YOLO26 | Seguimiento de barcos 🚢
Los modelos YOLO26 OBB usan el sufijo -obb, es decir, yolo26n-obb.pt, y se preentrenan con DOTAv1.
| Detección de barcos con OBB | Detección de vehículos con OBB |
|---|---|
![]() | ![]() |
Modelos#
A continuación se muestran los modelos YOLO26 OBB preentrenados con el conjunto de datos DOTAv1.
Los modelos se descargan automáticamente desde la versión más reciente de Ultralytics al usarlos por primera vez.
| Modelo | tamaño (píxeles) | mAPtest 50-95(e2e) | mAPtest 50(e2e) | Velocidad CPU ONNX (ms) | Velocidad T4 TensorRT10 (ms) | parámetros (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 |
- Los valores mAPtest corresponden a un solo modelo con varias escalas en el conjunto de datos DOTAv1.
Reprodúcelos conyolo obb val data=DOTAv1.yaml device=0 split=test nms=Falsey envía los resultados fusionados a la evaluación de DOTA. - Velocidad media en las imágenes de validación de DOTAv1 con ONNX en CPU y TensorRT10 en una GPU NVIDIA T4.
Reprodúcela conyolo obb val data=DOTAv1.yaml batch=1 device=0|cpu nms=False - Los valores de Params y FLOPs corresponden a modelos fusionados tras plegar Conv/BatchNorm y eliminar la rama de detección no utilizada. Los checkpoints preentrenados conservan toda la arquitectura de entrenamiento y pueden mostrar valores más altos.
Consulta la versión preliminar no publicada de YOLO27 para ver los resultados preliminares de DOTAv1.
Entrenar#
Entrena YOLO26n-obb con el conjunto de datos DOTA8 durante 100 épocas con un tamaño de imagen de 640. Consulta la página de Configuración para ver la lista completa de argumentos disponibles.
Un OBB y su rotación de 180° son idénticos, por lo que la rotación se define módulo 180° y la caja no tiene dirección. Las etiquetas de entrenamiento se normalizan según la convención del lado largo: el ancho de la caja w es el lado más largo, el ángulo se mide en sentido horario desde el eje x positivo hasta la orientación del borde w y se almacena en radianes en [-π/4, 3π/4) ([-45°, 135°)). Las predicciones no se normalizan, por lo que una caja predicha puede indicar el lado corto como w; consulta Salida de resultados. El formato [0°, 90°) corresponde a la convención regularizada de estilo DOTA y no se aplica durante el entrenamiento ni la inferencia.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n-obb.yaml") # Crea un modelo nuevo a partir de YAML
model = YOLO("yolo26n-obb.pt") # Carga un modelo preentrenado (recomendado para el entrenamiento)
model = YOLO("yolo26n-obb.yaml").load("yolo26n-obb.pt") # Crea el modelo a partir de YAML y transfiere los pesos
# Entrenar el modelo
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)Ver: Cómo entrenar modelos Ultralytics YOLO-OBB (cajas delimitadoras orientadas) con el conjunto de datos DOTA mediante Ultralytics Platform
Consulta todos los detalles del modo train en la página Entrenar. También puedes entrenar modelos OBB con el entrenamiento en la nube de Ultralytics Platform.
Formato del conjunto de datos#
Encontrarás todos los detalles sobre el formato de los conjuntos de datos OBB en la Guía de conjuntos de datos. El formato OBB de YOLO define las cajas delimitadoras mediante las coordenadas de sus cuatro esquinas, normalizadas entre 0 y 1, según la estructura siguiente. La anotación de Ultralytics Platform admite etiquetas OBB e incluye una herramienta específica para dibujar cajas delimitadoras orientadas:
class_index x1 y1 x2 y2 x3 y3 x4 y4Internamente, YOLO procesa las pérdidas y las salidas en el formato xywhr, que representa el punto central (xy), el ancho, la altura y la rotación de la caja delimitadora.
Validar#
Valida la precisión del modelo YOLO26n-obb entrenado con el conjunto de datos DOTA8. Pasa data explícitamente para que la validación use el archivo YAML del conjunto de datos previsto.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n-obb.pt") # carga un modelo oficial
model = YOLO("path/to/best.pt") # cargar un modelo personalizado
# Valida el modelo
metrics = model.val(data="dota8.yaml") # valida con el conjunto de datos DOTA8
metrics.box.map # map50-95(B)
metrics.box.map50 # map50(B)
metrics.box.map75 # map75(B)
metrics.box.maps # una lista que contiene mAP50-95(B) para cada categoría
metrics.box.image_metrics # diccionario de métricas por imagen con precisión, exhaustividad, F1, TP, FP y FNPredecir#
Usa un modelo YOLO26n-obb entrenado para hacer predicciones en imágenes.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n-obb.pt") # carga un modelo oficial
model = YOLO("path/to/best.pt") # cargar un modelo personalizado
# Haz predicciones con el modelo
results = model("https://ultralytics.com/images/boats.jpg") # haz una predicción sobre una imagen
# Accede a los resultados
for result in results:
xywhr = result.obb.xywhr # centro-x, centro-y, ancho, alto, ángulo (radianes)
xyxyxyxy = result.obb.xyxyxyxy # formato de polígono con 4 puntos
names = [result.names[cls.item()] for cls in result.obb.cls.int()] # nombre de clase de cada caja
confs = result.obb.conf # puntuación de confianza de cada cajaConsulta todos los detalles del modo predict en la página de predicción.
Pasa save_crop=True para guardar un recorte alineado con la rotación de cada OBB al tamaño de su caja, como también hace ObjectCropper.
Resultados de salida#
La detección de cajas delimitadoras orientadas devuelve un objeto Results por imagen. El campo de predicción principal es result.obb, que contiene las cajas rotadas, los ID de clase y las puntuaciones de confianza de cada objeto detectado.
| Atributo | Tipo | Forma | Descripción |
|---|---|---|---|
result.obb | OBB | (N) | Cajas orientadas. |
result.obb.data | torch.float32 | (N,7/8) | Cajas giradas sin procesar con nivel de confianza/clase. |
result.obb.xywhr | torch.float32 | (N,5) | Cajas giradas xywhr. |
result.obb.xyxyxyxy | torch.float32 | (N,4,2) | Cuatro puntos de las esquinas. |
result.obb.conf | torch.float32 | (N,) | Puntuaciones de confianza. |
Las etiquetas se normalizan según la convención del lado largo, pero las predicciones no. Por eso, result.obb.xywhr puede indicar que w es menor que h y que la rotación se mide desde el lado corto. Ambas formas describen el mismo rectángulo, por lo que result.obb.xyxyxyxy es correcto en cualquier caso. Convierte de nuevo las esquinas si el código posterior necesita el formato del lado largo, teniendo en cuenta que reescribir los parámetros de la caja puede desplazar cíclicamente el orden de las esquinas:
from ultralytics.utils.ops import xyxyxyxy2xywhr
xywhr = xyxyxyxy2xywhr(result.obb.xyxyxyxy) # w >= h, rotation in [-pi/4, 3pi/4)Para consultar los campos Results específicos de cada tarea, visita la sección resultados de predicción por tarea.
Exportar#
Exporta un modelo YOLO26n-obb a otro formato, como ONNX, CoreML, etc.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n-obb.pt") # carga un modelo oficial
model = YOLO("path/to/best.pt") # cargar un modelo personalizado
# Exporta el modelo
model.export(format="onnx")Los formatos de exportación disponibles para YOLO26-obb se muestran en la tabla siguiente. Puedes exportar a cualquier formato usando el argumento format, es decir, format='onnx' o format='engine'. Puedes hacer predicciones o validar directamente con los modelos exportados, es decir, yolo predict model=yolo26n-obb.onnx. Cuando termine la exportación, se mostrarán ejemplos de uso para tu modelo.
| Formato | Argumento format | Modelo | Metadatos | Argumentos |
|---|---|---|---|---|
| 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, batch, device |
| IMX500 | imx | yolo26n-obb_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, batch, 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 |
nms=None usa de forma predeterminada salidas sin procesar para NMS externa. Establece nms=False para seleccionar una cabeza sin NMS disponible; los formatos no compatibles recurren a su ruta de salida nativa. Las entradas nms anteriores identifican los formatos que pueden integrar NMS con nms=True.
Consulta todos los detalles de export en la página Exportar.
Preguntas frecuentes#
Las cajas delimitadoras orientadas (OBB) incluyen un ángulo adicional para mejorar la precisión de la localización de objetos en las imágenes. A diferencia de las cajas delimitadoras normales, que son rectángulos alineados con los ejes, las OBB pueden girar para ajustarse mejor a la orientación del objeto. Esto resulta especialmente útil en aplicaciones que requieren una ubicación precisa de los objetos, como las imágenes aéreas o por satélite (Guía de conjuntos de datos).
Para entrenar un modelo YOLO26n-obb con un conjunto de datos personalizado, sigue el ejemplo siguiente con Python o la CLI:
Ejemplofrom ultralytics import YOLO # Cargar un modelo preentrenado model = YOLO("yolo26n-obb.pt") # Entrenar el modelo results = model.train(data="path/to/custom_dataset.yaml", epochs=100, imgsz=640)Para consultar más argumentos de entrenamiento, echa un vistazo a la sección Configuración.
Los modelos YOLO26-OBB se preentrenan con conjuntos de datos como DOTAv1, pero puedes usar cualquier conjunto de datos con formato OBB. Encontrarás información detallada sobre los formatos de conjuntos de datos OBB en la Guía de conjuntos de datos.
Para validar un modelo YOLO26n-obb, puedes usar Python o los comandos de la CLI que se muestran a continuación:
Ejemplofrom ultralytics import YOLO # Cargar un modelo model = YOLO("yolo26n-obb.pt") # Valida el modelo metrics = model.val(data="dota8.yaml")Consulta todos los detalles de validación en la sección Val.
Exportar un modelo YOLO26-OBB al formato ONNX es muy sencillo, tanto con Python como con la CLI:
Ejemplofrom ultralytics import YOLO # Cargar un modelo model = YOLO("yolo26n-obb.pt") # Exporta el modelo model.export(format="onnx")Para consultar más formatos y detalles de exportación, visita la página Export.

