Detección de objetos con Ultralytics YOLO#
La detección de objetos es una tarea que consiste en identificar la ubicación y la clase de los objetos en una imagen o una transmisión de vídeo.
El resultado de un detector de objetos es un conjunto de cajas delimitadoras que rodean los objetos de la imagen, junto con etiquetas de clase y puntuaciones de confianza para cada caja. La detección de objetos es una buena opción cuando necesitas identificar los objetos de interés de una escena, pero no conocer su forma exacta.
Ver: Detección de objetos con un modelo Ultralytics YOLO preentrenado.
Los modelos YOLO26 Detect son los modelos YOLO26 predeterminados, es decir, yolo26n.pt, y están preentrenados con COCO.
Modelos#
A continuación se muestran los modelos YOLO26 Detect preentrenados con el conjunto de datos COCO.
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) | mAPval 50-95 | mAPvalidación 50-95(integral) | Velocidad CPU ONNX (ms) | Velocidad T4 TensorRT10 (ms) | parámetros (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.5 |
| YOLO26s | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.9 |
| YOLO26m | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.4 |
| YOLO26l | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.8 |
| YOLO26x | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 194.4 |
- Los valores de mAPval corresponden a un único modelo y una única escala en el conjunto de datos COCO val2017.
Reprodúcelos conyolo detect val data=coco.yaml device=0. Añadenms=Falsepara reproducir la columna e2e. - La velocidad es el promedio calculado con imágenes de COCO val usando ONNX en CPU y TensorRT10 en una GPU NVIDIA T4.
Reprodúcela conyolo detect val data=coco.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 de YOLO27 aún no publicada para ver resultados preliminares de detección en COCO.
Entrenar#
Entrena YOLO26n con el conjunto de datos COCO8 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.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.yaml") # Crea un modelo nuevo a partir de YAML
model = YOLO("yolo26n.pt") # Carga un modelo preentrenado (recomendado para el entrenamiento)
model = YOLO("yolo26n.yaml").load("yolo26n.pt") # Crea el modelo a partir de YAML y transfiere los pesos
# Entrenar el modelo
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Consulta todos los detalles del modo train en la página de entrenamiento. También puedes entrenar modelos de detección con el entrenamiento en la nube de Ultralytics Platform.
Formato del conjunto de datos#
Encontrarás información detallada sobre el formato de los conjuntos de datos de detección YOLO en la guía de conjuntos de datos. Para convertir un conjunto de datos COCO JSON existente al formato YOLO, usa la función integrada convert_coco, descrita en la guía de conversión de COCO a YOLO. También puedes anotar y gestionar conjuntos de datos de detección con las herramientas de anotación asistidas por IA de Ultralytics Platform.
Validar#
Valida la precisión del modelo YOLO26n entrenado. No necesitas argumentos, ya que model conserva los valores de entrenamiento de data y los argumentos como atributos del modelo: path/to/best.pt del ejemplo de entrenamiento valida el modelo con COCO8. Los pesos oficiales registran una ruta al conjunto de datos de entrenamiento que no existe en tu equipo, por lo que recurren al valor predeterminado de la tarea coco8.yaml y muestran una advertencia. Pasa data para validar el modelo con otro conjunto de datos.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.pt") # carga un modelo oficial
model = YOLO("path/to/best.pt") # cargar un modelo personalizado
# Valida el modelo
metrics = model.val() # no hacen falta argumentos; se recuerdan el conjunto de datos y los ajustes
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # una lista que contiene mAP50-95 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 entrenado para hacer predicciones sobre imágenes.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.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/bus.jpg") # haz una predicción sobre una imagen
# Accede a los resultados
for result in results:
xywh = result.boxes.xywh # centro-x, centro-y, ancho, alto
xywhn = result.boxes.xywhn # normalized
xyxy = result.boxes.xyxy # arriba-izquierda-x, arriba-izquierda-y, abajo-derecha-x, abajo-derecha-y
xyxyn = result.boxes.xyxyn # normalized
names = [result.names[cls.item()] for cls in result.boxes.cls.int()] # nombre de clase de cada caja
confs = result.boxes.conf # puntuación de confianza de cada cajaConsulta todos los detalles del modo predict en la página de predicción.
Resultados de salida#
La detección de objetos devuelve un objeto Results por imagen. El campo principal de predicción es result.boxes, que contiene las coordenadas de las cajas, los ID de clase y las puntuaciones de confianza de cada objeto detectado.
| Atributo | Tipo | Forma | Descripción |
|---|---|---|---|
result.boxes | Boxes | (N) | Cuadros de detección. |
result.boxes.data | torch.float32 | (N,6/7) | [x1,y1,x2,y2,conf,cls] sin procesar, más un ID de seguimiento opcional. |
result.boxes.xyxy | torch.float32 | (N,4) | Cuadros de píxeles xyxy. |
result.boxes.conf | torch.float32 | (N,) | Puntuaciones de confianza. |
result.boxes.cls | torch.float32 | (N,) | ID de clase; conviértelos a int para obtener los nombres. |
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 a otro formato, como ONNX, CoreML, etc.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.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 aparecen en la tabla siguiente. Puedes exportar a cualquier formato con el argumento format, por ejemplo, format='onnx' o format='engine'. Puedes hacer predicciones o validar directamente con modelos exportados, por ejemplo, yolo predict model=yolo26n.onnx. Cuando termine la exportación, se mostrarán ejemplos de uso para tu modelo.
| Formato | Argumento format | Modelo | Metadatos | Argumentos |
|---|---|---|---|---|
| PyTorch | - | yolo26n.pt | ✅ | - |
| TorchScript | torchscript | yolo26n.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| Apple Core AI | coreai | yolo26n.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n_saved_model/ | ✅ | imgsz, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| LiteRT | litert | yolo26n.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n_ncnn_model/ | ✅ | imgsz, quantize, batch, device |
| IMX500 | imx | yolo26n_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| Hailo | hailo | yolo26n_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n_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#
Sí. La guía de inicio rápido de Ultralytics Platform explica un flujo de trabajo en el navegador para anotar conjuntos de datos, entrenar modelos de detección en GPU en la nube y desplegarlos en endpoints de inferencia.
Entrenar un modelo YOLO26 con un conjunto de datos personalizado requiere seguir unos pocos pasos:
- Prepara el conjunto de datos: Asegúrate de que tu conjunto de datos esté en formato YOLO. Consulta nuestra guía de conjuntos de datos para obtener indicaciones.
- Carga el modelo: Usa la biblioteca Ultralytics YOLO para cargar un modelo preentrenado o crear uno nuevo a partir de un archivo YAML.
- Entrena el modelo: Ejecuta el método
trainen Python o el comandoyolo detect trainen CLI.
Ejemplofrom ultralytics import YOLO # Cargar un modelo preentrenado model = YOLO("yolo26n.pt") # Entrena el modelo con tu conjunto de datos personalizado model.train(data="my_custom_dataset.yaml", epochs=100, imgsz=640)Visita la página de configuración para consultar las opciones de configuración detalladas.
Ultralytics YOLO26 ofrece varios modelos preentrenados para la detección de objetos, la segmentación de instancias, la segmentación semántica, la estimación de profundidad, la clasificación, la estimación de pose y las cajas delimitadoras orientadas. Estos modelos están preentrenados con el conjunto de datos COCO, Cityscapes para segmentación semántica, una combinación de varios conjuntos de datos para estimación de profundidad, ImageNet para clasificación o DOTAv1 para OBB. Estos son algunos de los modelos disponibles:
Consulta la sección modelos para ver la lista detallada y las métricas de rendimiento.
Para validar la precisión de tu modelo YOLO26 entrenado, puedes usar el método
.val()en Python o el comandoyolo detect valen CLI. Así obtendrás métricas como mAP50-95, mAP50 y otras.Ejemplofrom ultralytics import YOLO # Carga el modelo model = YOLO("path/to/best.pt") # Valida el modelo metrics = model.val() print(metrics.box.map) # mAP50-95Visita la página de validación para obtener más información sobre la validación.
Ultralytics YOLO26 permite exportar modelos a varios formatos, como ONNX, TensorRT, CoreML y otros, para garantizar la compatibilidad con distintas plataformas y dispositivos.
Ejemplofrom ultralytics import YOLO # Carga el modelo model = YOLO("yolo26n.pt") # Exporta el modelo al formato ONNX model.export(format="onnx")Consulta la lista completa de formatos compatibles y las instrucciones en la página de exportación.
Ultralytics YOLO26 está diseñado para ofrecer un rendimiento de vanguardia en detección de objetos, segmentación de instancias, segmentación semántica y estimación de pose. Estas son algunas de sus principales ventajas:
- Modelos preentrenados: Aprovecha modelos preentrenados con conjuntos de datos populares como COCO e ImageNet para acelerar el desarrollo.
- Gran precisión: Consigue puntuaciones mAP excelentes que garantizan una detección de objetos fiable.
- Velocidad: Optimizado para la inferencia en tiempo real, es ideal para aplicaciones que requieren un procesamiento rápido.
- Flexibilidad: Exporta modelos a varios formatos, como ONNX y TensorRT, para desplegarlos en distintas plataformas.
Descubre en nuestro blog casos de uso e historias de éxito que muestran YOLO26 en acción.