Detecção de caixas delimitadoras orientadas com Ultralytics YOLO#
A detecção de objetos orientados vai além da detecção de objetos padrão ao introduzir um ângulo adicional para localizar objetos com mais precisão em uma imagem.
A saída de um detector de objetos orientados é um conjunto de caixas delimitadoras rotacionadas que envolvem com precisão os objetos na imagem, junto com os rótulos de classe e as pontuações de confiança de cada caixa. As caixas delimitadoras orientadas são especialmente úteis quando os objetos aparecem em vários ângulos, como em imagens aéreas, nas quais caixas delimitadoras tradicionais alinhadas aos eixos podem incluir fundo desnecessário. Entre os usos comuns estão a detecção de navios e veículos por satélites e drones, a análise de edifícios e infraestrutura para planejamento urbano, o monitoramento de culturas e a inspeção de painéis solares ou turbinas eólicas.
Assista: Como detectar e rastrear objetos com caixas delimitadoras orientadas (OBB) do Ultralytics YOLO26 | Rastreamento de navios 🚢
Os modelos YOLO26 OBB usam o sufixo -obb, ou seja, yolo26n-obb.pt, e são pré-treinados no DOTAv1.
| Detecção de navios usando OBB | Detecção de veículos usando OBB |
|---|---|
![]() | ![]() |
Modelos#
Abaixo estão os modelos YOLO26 OBB pré-treinados no conjunto de dados DOTAv1.
Os modelos são transferidos automaticamente da versão mais recente do Ultralytics na primeira utilização.
| Modelo | tamanho (pixels) | mAPteste 50-95(e2e) | mAPteste 50(e2e) | Velocidade CPU ONNX (ms) | Velocidade 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 |
- Os valores de mAPtest são para um único modelo em várias escalas no conjunto de dados DOTAv1.
Reproduza comyolo obb val data=DOTAv1.yaml device=0 split=test nms=Falsee envie os resultados combinados para a avaliação DOTA. - Velocidade calculada como a média em imagens de validação do DOTAv1 com ONNX na CPU e TensorRT10 em uma GPU NVIDIA T4.
Reproduza comyolo obb val data=DOTAv1.yaml batch=1 device=0|cpu nms=False - Os valores de Params e FLOPs referem-se a modelos fundidos após a fusão de Conv/BatchNorm e a remoção do ramo de deteção não utilizado. Os pontos de controlo pré-treinados mantêm a arquitetura de treino completa e podem apresentar contagens superiores.
Consulte a prévia não lançada do YOLO27 para ver resultados preliminares do DOTAv1.
Treinar#
Treine YOLO26n-obb no conjunto de dados DOTA8 por 100 épocas, com tamanho de imagem 640. Para ver a lista completa de argumentos disponíveis, consulte a página Configuração.
Uma OBB e sua rotação de 180° são idênticas; por isso, a rotação é definida módulo 180° e a caixa não tem direção. Os rótulos de treinamento são normalizados para o formato de lado maior: a largura da caixa w corresponde ao lado mais longo, o ângulo é medido no sentido horário a partir do eixo x positivo até a orientação da aresta w e é armazenado em radianos em [-π/4, 3π/4) ([-45°, 135°)). As previsões não são normalizadas; portanto, uma caixa prevista pode informar a aresta curta como w; consulte Saída dos resultados. O formato [0°, 90°) é a convenção regularizada no estilo DOTA e não é aplicado durante o treinamento nem a inferência.
from ultralytics import YOLO
# Carregar um modelo
model = YOLO("yolo26n-obb.yaml") # crie um novo modelo a partir de YAML
model = YOLO("yolo26n-obb.pt") # carregue um modelo pré-treinado (recomendado para treinamento)
model = YOLO("yolo26n-obb.yaml").load("yolo26n-obb.pt") # crie a partir de YAML e transfira os pesos
# Treinar o modelo
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)Assista: Como treinar modelos Ultralytics YOLO-OBB (caixas delimitadoras orientadas) no conjunto de dados DOTA usando a plataforma Ultralytics
Consulte a página Treinar para ver todos os detalhes do modo train. Os modelos OBB também podem ser treinados com o treinamento na nuvem da Ultralytics Platform.
Formato do conjunto de dados#
Você encontra detalhes sobre o formato do conjunto de dados OBB no Guia do conjunto de dados. O formato YOLO OBB representa as caixas delimitadoras pelos quatro pontos dos cantos, com coordenadas normalizadas entre 0 e 1, seguindo esta estrutura. A anotação da Ultralytics Platform oferece suporte a rótulos OBB com uma ferramenta dedicada para desenhar caixas delimitadoras orientadas:
class_index x1 y1 x2 y2 x3 y3 x4 y4Internamente, o YOLO processa perdas e saídas no formato xywhr, que representa o ponto central (xy), a largura, a altura e a rotação da caixa delimitadora.
Validar#
Valide a precisão de um modelo YOLO26n-obb treinado no conjunto de dados DOTA8. Passe data explicitamente para que a validação use o YAML do conjunto de dados desejado.
from ultralytics import YOLO
# Carregar um modelo
model = YOLO("yolo26n-obb.pt") # carrega um modelo oficial
model = YOLO("path/to/best.pt") # carregar um modelo personalizado
# Valida o modelo
metrics = model.val(data="dota8.yaml") # valida no conjunto de dados DOTA8
metrics.box.map # map50-95(B)
metrics.box.map50 # map50(B)
metrics.box.map75 # map75(B)
metrics.box.maps # uma lista que contém mAP50-95(B) para cada categoria
metrics.box.image_metrics # dicionário de métricas por imagem com precisão, revocação, F1, TP, FP e FNPrever#
Use um modelo YOLO26n-obb treinado para fazer previsões em imagens.
from ultralytics import YOLO
# Carregar um modelo
model = YOLO("yolo26n-obb.pt") # carrega um modelo oficial
model = YOLO("path/to/best.pt") # carregar um modelo personalizado
# Faz previsões com o modelo
results = model("https://ultralytics.com/images/boats.jpg") # faz uma previsão numa imagem
# Acede aos resultados
for result in results:
xywhr = result.obb.xywhr # centro-x, centro-y, largura, altura, ângulo (radianos)
xyxyxyxy = result.obb.xyxyxyxy # formato de polígono com 4 pontos
names = [result.names[cls.item()] for cls in result.obb.cls.int()] # nome da classe de cada caixa
confs = result.obb.conf # pontuação de confiança de cada caixaConsulta os detalhes completos do modo predict na página Previsão.
Passe save_crop=True para salvar um recorte alinhado à rotação de cada OBB no tamanho da caixa, como ObjectCropper também faz.
Saída dos resultados#
A detecção de caixas delimitadoras orientadas retorna um objeto Results por imagem. O principal campo de previsão é result.obb, que contém caixas rotacionadas, IDs de classe e pontuações de confiança para cada objeto detectado.
| Atributo | Tipo | Formato | Descrição |
|---|---|---|---|
result.obb | OBB | (N) | Caixas orientadas. |
result.obb.data | torch.float32 | (N,7/8) | Caixas rotacionadas brutas com confiança/classe. |
result.obb.xywhr | torch.float32 | (N,5) | Caixas rotacionadas xywhr. |
result.obb.xyxyxyxy | torch.float32 | (N,4,2) | Pontos dos quatro cantos. |
result.obb.conf | torch.float32 | (N,) | Pontuações de confiança. |
Os rótulos são normalizados de acordo com a convenção do lado maior, mas as previsões não; portanto, result.obb.xywhr pode informar w menor que h, com a rotação medida a partir do lado curto. As duas formas descrevem o mesmo retângulo; assim, result.obb.xyxyxyxy está correto em ambos os casos. Converta os cantos de volta quando o código subsequente precisar do formato de lado maior, lembrando que reescrever os parâmetros da caixa pode deslocar ciclicamente a ordem dos cantos:
from ultralytics.utils.ops import xyxyxyxy2xywhr
xywhr = xyxyxyxy2xywhr(result.obb.xyxyxyxy) # w >= h, rotação em [-pi/4, 3pi/4)Para ver os campos Results específicos de cada tarefa, consulta a secção Resultados da previsão por tarefa.
Exportar#
Exporte um modelo YOLO26n-obb para outro formato, como ONNX, CoreML etc.
from ultralytics import YOLO
# Carregar um modelo
model = YOLO("yolo26n-obb.pt") # carrega um modelo oficial
model = YOLO("path/to/best.pt") # carregar um modelo personalizado
# Exporta o modelo
model.export(format="onnx")Os formatos de exportação disponíveis para YOLO26-obb estão na tabela abaixo. Você pode exportar para qualquer formato usando o argumento format, ou seja, format='onnx' ou format='engine'. Você pode fazer previsões ou validar diretamente em modelos exportados, ou seja, yolo predict model=yolo26n-obb.onnx. Os exemplos de uso do seu modelo são exibidos após a conclusão da exportação.
| Formato | Argumento format | Modelo | Metadados | 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 por predefinição saídas brutas para NMS externo. Define nms=False para selecionar uma cabeça sem NMS disponível; os formatos não suportados recorrem ao respetivo caminho de saída nativo. As entradas nms acima identificam os formatos que podem incorporar NMS com nms=True.
Consulte os detalhes completos de export na página Exportação.
Perguntas frequentes#
As caixas delimitadoras orientadas (OBB) incluem um ângulo adicional para aumentar a precisão da localização de objetos em imagens. Ao contrário das caixas delimitadoras comuns, que são retângulos alinhados aos eixos, as OBB podem girar para se ajustar melhor à orientação do objeto. Isso é especialmente útil em aplicações que exigem o posicionamento preciso de objetos, como imagens aéreas ou de satélite (Guia de conjuntos de dados).
Para treinar um modelo YOLO26n-obb com um conjunto de dados personalizado, siga o exemplo abaixo usando Python ou a CLI:
Exemplofrom ultralytics import YOLO # Carregar um modelo pré-treinado model = YOLO("yolo26n-obb.pt") # Treinar o modelo results = model.train(data="path/to/custom_dataset.yaml", epochs=100, imgsz=640)Para ver mais argumentos de treinamento, consulte a seção Configuração.
Os modelos YOLO26-OBB são pré-treinados em conjuntos de dados como DOTAv1, mas você pode usar qualquer conjunto de dados formatado para OBB. Você encontra informações detalhadas sobre os formatos de conjuntos de dados OBB no Guia de conjuntos de dados.
Para validar um modelo YOLO26n-obb, você pode usar comandos Python ou da CLI, como mostrado abaixo:
Exemplofrom ultralytics import YOLO # Carregar um modelo model = YOLO("yolo26n-obb.pt") # Valida o modelo metrics = model.val(data="dota8.yaml")Consulte todos os detalhes da validação na seção Val.
É simples exportar um modelo YOLO26-OBB para o formato ONNX usando Python ou a CLI:
Exemplofrom ultralytics import YOLO # Carregar um modelo model = YOLO("yolo26n-obb.pt") # Exporta o modelo model.export(format="onnx")Para ver mais formatos de exportação e detalhes, consulte a página Export.

