Predicción de modelos con Ultralytics YOLO
Introducción#
En el aprendizaje automático y la visión artificial, el proceso de interpretar datos visuales con un modelo entrenado se denomina inferencia o predicción. El modo predict de Ultralytics YOLO26 realiza inferencias en tiempo real a gran velocidad a partir de una amplia variedad de fuentes de datos.
Consulta la vista previa de YOLO27 aún no publicada para ver ejemplos de inferencia previstos.
Mira: Extrae cajas delimitadoras, máscaras, puntos clave, OBB, profundidad y mucho más con Ultralytics YOLO26 en Python 🚀
Aplicaciones en el mundo real#
| Fabricación | Deportes | Seguridad |
|---|---|---|
| Detección de piezas de repuesto de vehículos | Detección de jugadores de fútbol | Detección de caídas de personas |
¿Por qué usar Ultralytics YOLO para la inferencia?#
Motivos principales para utilizar el modo predict de YOLO26:
- Versatilidad: Ejecuta inferencias con imágenes, vídeos y transmisiones en directo.
- Rendimiento: Diseñado para procesar datos a gran velocidad y en tiempo real sin sacrificar la precisión.
- Facilidad de uso: Interfaces intuitivas de Python y CLI para implementar y probar rápidamente.
- Altamente personalizable: Diversos ajustes y parámetros para adaptar el comportamiento de inferencia del modelo a tus requisitos específicos.
- Listo para producción: Implementa modelos como puntos de conexión de inferencia de Ultralytics Platform con escalado automático y supervisión, o ejecuta inferencias en local.
Características principales del modo de predicción#
El modo predict de YOLO26 incluye:
- Compatibilidad con varias fuentes de datos: El modo predict admite imágenes individuales, colecciones de imágenes, archivos de vídeo y transmisiones de vídeo en tiempo real.
- Modo de transmisión: Usa la función de transmisión para generar un generador de objetos
Resultsque ahorra memoria. Actívala estableciendostream=Trueen el método de llamada del predictor. A diferencia del comportamiento predeterminado (stream=False), que devuelve una lista con todos los resultados,stream=Trueproduce los resultados uno a uno, lo que resulta especialmente útil para vídeos largos y transmisiones en directo. - Procesamiento por lotes: Procesa varias imágenes o fotogramas de vídeo en un solo lote para reducir aún más el tiempo total de inferencia.
- Fácil integración: Intégralo con los flujos de datos existentes y otros componentes de software mediante una API flexible.
Los modelos Ultralytics YOLO devuelven una lista de objetos Results de Python o, si se pasa stream=True al modelo durante la inferencia, un generador de objetos Results que ahorra memoria:
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.pt") # modelo YOLO26n preentrenado
# Ejecuta la inferencia por lotes en una lista de imágenes
results = model(["image1.jpg", "image2.jpg"]) # devuelve una lista de objetos Results
# Procesa la lista de resultados
for result in results:
boxes = result.boxes # Objeto Boxes para las salidas de cuadros delimitadores
masks = result.masks # Objeto Masks para las salidas de máscaras de segmentación
keypoints = result.keypoints # Objeto Keypoints para las salidas de pose
probs = result.probs # Objeto Probs para las salidas de clasificación
obb = result.obb # Objeto Oriented boxes para las salidas OBB
result.show() # mostrar en pantalla
result.save(filename="result.jpg") # guardar en el discoFuentes de inferencia#
YOLO26 puede procesar distintos tipos de fuentes de entrada para realizar inferencias, como se muestra en la siguiente tabla. Entre las fuentes hay imágenes estáticas, transmisiones de vídeo y varios formatos de datos. La tabla también indica si se puede usar cada fuente en modo de transmisión con el argumento stream=True ✅. El modo de transmisión resulta útil para procesar vídeos o emisiones en directo, ya que crea un generador de resultados en lugar de cargar todos los fotogramas en memoria.
Usa stream=True para procesar vídeos largos o conjuntos de datos grandes y gestionar la memoria de forma eficiente. Cuando se usa stream=False, los resultados de todos los fotogramas o puntos de datos se almacenan en memoria, lo que puede acumularse rápidamente y provocar errores de falta de memoria con entradas grandes. En cambio, stream=True utiliza un generador que solo mantiene en memoria los resultados del fotograma o punto de datos actual, lo que reduce considerablemente el consumo de memoria y evita problemas de falta de memoria.
| Fuente | Ejemplo | Tipo | Notas |
|---|---|---|---|
| imagen | 'image.jpg' | str o Path | Archivo de imagen individual. |
| URL | 'https://ultralytics.com/images/bus.jpg' | str | URL de una imagen. |
| captura de pantalla ✅ | 'screen' | str | Captura la pantalla continuamente hasta que la detengas. |
| PIL | Image.open('image.jpg') | PIL.Image | Formato HWC con canales RGB. |
| OpenCV | cv2.imread('image.jpg') | np.ndarray | Formato HWC con canales BGR uint8 (0-255). |
| NumPy | np.zeros((640,1280,3)) | np.ndarray | Formato HWC con canales BGR uint8 (0-255). |
| torch | torch.zeros(16,3,320,640) | torch.Tensor | Formato BCHW con canales RGB float32 (0.0-1.0). |
| CSV | 'sources.csv' | str o Path | Archivo CSV con rutas a imágenes, vídeos o directorios. |
| vídeo ✅ | 'video.mp4' | str o Path | Archivo de vídeo en formatos como MP4, AVI, etc. |
| directorio ✅ | 'path/' | str o Path | Ruta a un directorio que contiene imágenes o vídeos. |
| glob ✅ | 'path/*.jpg' | str | Patrón glob para buscar varios archivos. Usa el carácter * como comodín. |
| YouTube ✅ | 'https://youtu.be/LNwODJXcvt4' | str | URL de un vídeo de YouTube. |
| transmisión ✅ | 'rtsp://example.com/media.mp4' | str | URL para protocolos de transmisión como RTSP, RTMP, TCP o una dirección IP. |
| varias transmisiones ✅ | 'list.streams' | str o Path | Archivo de texto *.streams con una URL de transmisión por fila; es decir, se ejecutarán 8 transmisiones con un tamaño de lote de 8. |
| cámara web ✅ | 0 | int | Índice del dispositivo de cámara conectado en el que se ejecutará la inferencia. |
A continuación se muestran ejemplos de código para usar cada tipo de fuente:
Ejecuta una inferencia en un archivo de imagen.
from ultralytics import YOLO
# Carga un modelo YOLO26n preentrenado
model = YOLO("yolo26n.pt")
# Define la ruta al archivo de imagen
source = "path/to/image.jpg"
# Ejecuta la inferencia sobre la fuente
results = model(source) # lista de objetos ResultsArgumentos de inferencia#
model.predict() acepta varios argumentos que puedes pasar en el momento de la inferencia para sustituir los valores predeterminados:
Tamaño fijo frente a rectángulo mínimo (rect)#
De forma predeterminada, predict usa rect=True, que aplica el relleno de rectángulo mínimo cuando es posible. La imagen se escala para caber dentro de imgsz y solo se rellena hasta el múltiplo de stride más cercano, por lo que el tensor final puede ser más pequeño que imgsz. El relleno de rectángulo mínimo solo se usa cuando todas las imágenes del lote tienen la misma forma y el backend lo admite (PyTorch .pt o una exportación con forma dinámica, como ONNX dinámico). De lo contrario, las imágenes se rellenan hasta el objetivo imgsz completo. Los modelos de profundidad y RT-DETR ignoran rect y estiran todas las imágenes hasta el imgsz completo sin relleno.
Usa rect=False para utilizar siempre el objetivo imgsz completo. Se recomienda hacerlo cuando necesites un tamaño de entrada fijo que coincida con los modelos exportados (ONNX, TensorRT, etc.).
imgsz entero frente a tupla
- Un
imgsz=640entero se convierte en un objetivo cuadrado(640, 640)tras el redondeo al stride. - Una tupla
imgsz=(384, 672)establece un objetivo rectangular. Conrect=True, el tensor real puede ser más pequeño que este objetivo.
Entrenamiento frente a predict/export
El entrenamiento solo acepta un imgsz entero (una lista [h, w] se convierte en el valor más alto). Predict y export aceptan un entero o una tupla (height, width).
from ultralytics import YOLO
# Carga un modelo YOLO26n preentrenado
model = YOLO("yolo26n.pt")
# Ejecuta inferencias en «bus.jpg» con argumentos
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)Argumentos de inferencia:
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
source | str o int o None | None | Especifica el origen de datos para la inferencia. Puede ser la ruta a una imagen, un archivo de vídeo, un directorio, una URL o el ID de un dispositivo para transmisiones en directo. Si se omite, se registra una advertencia y el modelo recurre a los recursos de demostración integrados (ultralytics/assets o una URL de demostración para OBB). Admite una amplia variedad de formatos y orígenes, lo que permite usarlo con flexibilidad en distintos tipos de entrada. |
conf | float | 0.25 | Establece el umbral mínimo de confianza para las detecciones. Se descartan los objetos detectados con un nivel de confianza inferior a este umbral. Ajustar este valor puede ayudar a reducir los falsos positivos. |
iou | float | 0.5 | Umbral de intersección sobre unión (IoU) para la supresión no máxima (NMS). Los valores más bajos producen menos detecciones al eliminar cuadros superpuestos, lo que resulta útil para reducir los duplicados. |
imgsz | int o tuple | 640 | Objetivo de Letterbox. Un entero define un N×N cuadrado; una tupla define (height, width). Con rect=True, el tensor real puede ser más pequeño que este objetivo debido al relleno mínimo en rectángulo. Usa rect=False para fijar el tamaño. Consulta Forma fija frente a rectángulo mínimo. |
rect | bool | True | Si True, usa el relleno de rectángulo mínimo cuando sea posible (lote con la misma forma y backend compatible). Si False, usa siempre el imgsz completo. Consulta Forma fija frente a rectángulo mínimo. Se ignora en los modelos depth y RT-DETR, que estiran las imágenes hasta el imgsz completo sin relleno. |
quantize | int o str | None | Precisión de inferencia: 16/"fp16" y 32/"fp32"/unset seleccionan el cálculo FP16 o FP32 para los modelos PyTorch y TorchScript (FP32 en CPU); los demás formatos usan la precisión que seleccionen el artefacto y el entorno de ejecución. En 16, OpenVINO sigue redondeando la entrada a FP16 en el cliente y volviéndola a ampliar a FP32, sin cambiar la precisión del entorno de ejecución. La cuantización INT8/PTQ se configura durante la exportación y se utiliza después al cargar el modelo exportado. Sustituye a la marca obsoleta half. |
device | str | None | Especifica el dispositivo para la inferencia (p. ej., cpu, cuda:0, 0, npu o npu:0). Permite seleccionar entre la CPU, una GPU específica, la NPU Huawei Ascend u otros dispositivos de cálculo para ejecutar el modelo. Los modelos OpenVINO y LiteRT se ejecutan xpu y npu en la GPU y la NPU Intel; consulta dispositivos de inferencia para ver cada formato. |
dnn | bool | False | Si True, usa el módulo DNN de OpenCV en lugar de ONNX Runtime para la inferencia de modelos ONNX. |
data | str | None | Ruta a un YAML del conjunto de datos (p. ej., coco8.yaml) que se lee solo para obtener su names, y únicamente cuando el modelo cargado no incluye nombres de clase propios: una exportación de terceros o una exportación de Ultralytics separada de los metadatos que la acompañan. De lo contrario, el modelo indica class0, class1, etc. |
batch | int | 1 | Especifica el tamaño del lote para la inferencia (solo funciona cuando el origen es un directorio, un archivo de vídeo o un archivo .txt). Un tamaño de lote mayor puede aumentar el rendimiento y reducir el tiempo total necesario para la inferencia. |
tile | bool o int | False | Ejecuta inferencia con teselas fijas y devuelve resultados en las coordenadas de la imagen original. True usa imgsz; un entero positivo establece el tamaño de las teselas. Consulta Teselado de alta resolución. |
max_det | int | 300 | Número máximo de detecciones permitido por imagen. Limita el número total de objetos que el modelo puede detectar en una sola inferencia para evitar resultados excesivos en escenas densas. |
vid_stride | int | 1 | Salto de fotogramas para entradas de vídeo. Permite omitir fotogramas para acelerar el procesamiento a costa de la resolución temporal. El valor 1 procesa todos los fotogramas; los valores superiores los omiten. |
stream_buffer | bool | False | Determina si se ponen en cola los fotogramas entrantes de las secuencias de vídeo. Si False, se descartan los fotogramas antiguos para dejar sitio a los nuevos (optimizado para aplicaciones en tiempo real). Si True, los fotogramas nuevos se guardan en un búfer para garantizar que no se omita ninguno, pero se introduce latencia si los FPS de inferencia son inferiores a los FPS de la secuencia. |
visualize | bool | False | Guarda un mapa de calor de activación de clases junto a cada predicción, que muestra qué píxeles han elevado las puntuaciones de la clase predicha. Respeta conf y classes, por lo que classes=[0] solo asigna esa clase. Solo está disponible para modelos PyTorch de Ultralytics. |
augment | bool | False | Activa el aumento en tiempo de prueba (TTA) para las predicciones, lo que puede mejorar la robustez de la detección a costa de la velocidad de inferencia. Solo está disponible para modelos PyTorch de Ultralytics. |
agnostic_nms | bool | False | Activa la supresión no máxima (NMS) independiente de la clase, que suprime los cuadros solapados con puntuaciones más bajas entre clases distintas, en lugar de hacerlo solo dentro de la misma clase. Es útil en escenarios de detección multiclase donde los solapamientos entre clases son frecuentes. Con la inferencia sin NMS (nms=False en YOLO26 o YOLOv10), solo impide que la misma detección aparezca con varias etiquetas de clase (duplicados con IoU=1.0); no suprime cuadros distintos según el umbral de IoU. |
classes | list[int] | None | Filtra las predicciones para limitarse a un conjunto de ID de clase. Solo se devuelven las detecciones pertenecientes a las clases especificadas. Es útil para centrarse en los objetos relevantes en tareas de detección multiclase. |
retina_masks | bool | False | Devuelve máscaras de segmentación de alta resolución. Si se activa, las máscaras devueltas (masks.data) coinciden con el tamaño de la imagen original. Si se desactiva, tienen el tamaño de imagen utilizado durante la inferencia. |
embed | list[int] | None | Especifica las capas de las que se extraen vectores de características o embeddings. Usa model.embed(source) para obtener embeddings de la penúltima capa o model.predict(source, embed=[layer]) para seleccionar capas concretas. Es útil para tareas posteriores, como la agrupación en clústeres o la búsqueda por similitud. Solo está disponible para modelos PyTorch de Ultralytics. |
project | str | None | Nombre del directorio del proyecto donde se guardan los resultados de las predicciones si save está habilitado. Una ruta relativa se coloca dentro de runs_dir/<task>, mientras que una ruta absoluta se usa tal cual. |
name | str | None | Nombre de la ejecución de predicción. Se usa para crear un subdirectorio dentro de la carpeta del proyecto, donde se guardan los resultados de las predicciones si se activa save. |
stream | bool | False | Permite procesar de forma eficiente en cuanto a memoria vídeos largos o numerosas imágenes, ya que devuelve un generador de objetos Results en lugar de cargar todos los fotogramas en memoria a la vez. |
verbose | bool | True | Controla si se muestran registros detallados de inferencia en el terminal para ofrecer información en tiempo real sobre el proceso de predicción. |
compile | bool o str | False | Activa la compilación de grafos torch.compile de PyTorch 2.x con backend='inductor'. Acepta True → "default" para activarla, False → para desactivarla o un modo de cadena como "default", "reduce-overhead", "max-autotune-no-cudagraphs". Si no es compatible, vuelve al modo eager y muestra una advertencia. |
channels_last | bool | None | Usa el formato de memoria channels_last (NHWC) para la inferencia nativa de PyTorch. None lo activa automáticamente en CPU x86 con Linux y Windows, compatible con oneDNN y PyTorch 1.13 o posterior; False lo desactiva y True lo solicita en dispositivos CPU x86 o CUDA compatibles. ARM64, MPS, las versiones anteriores de PyTorch, las CPU sin oneDNN y los formatos exportados como TensorRT y ONNX no cambian. |
nms | bool, opcional | None | Por defecto, ejecuta inferencia uno a varios con NMS (None o True). Configura False para usar el cabezal uno a uno sin NMS cuando esté disponible. Consulta la guía de detección de extremo a extremo para obtener más información. |
Argumentos de visualización:
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
show | bool | False | Si True, muestra las imágenes o los vídeos anotados en una ventana. Es útil para obtener información visual inmediata durante el desarrollo o las pruebas. |
save | bool | False or True | Activa el guardado de las imágenes o los vídeos anotados en archivos. Es útil para documentar, analizar más adelante o compartir resultados. De forma predeterminada, es True al usar la CLI y False al usar Python. |
save_frames | bool | False | Al procesar vídeos, guarda fotogramas individuales como imágenes. Es útil para extraer fotogramas concretos o analizarlos detalladamente uno por uno. |
save_txt | bool | False | Guarda los resultados de detección en un archivo de texto con el formato [class] [x_center] [y_center] [width] [height] [confidence]. Es útil para integrarlos con otras herramientas de análisis. |
save_conf | bool | False | Incluye puntuaciones de confianza en los archivos de texto guardados. Ofrece más detalles para el posprocesamiento y el análisis. |
save_crop | bool | False | Guarda imágenes recortadas de las detecciones. Es útil para aumentar conjuntos de datos, realizar análisis o crear conjuntos de datos centrados en objetos concretos. |
show_labels | bool | True | Muestra etiquetas para cada detección en la salida visual. Facilita la identificación inmediata de los objetos detectados. |
show_conf | bool | True | Muestra la puntuación de confianza de cada detección junto a su etiqueta. Permite conocer el grado de certeza del modelo para cada detección. |
show_boxes | bool | True | Dibuja cuadros delimitadores alrededor de los objetos detectados. Es esencial para identificar visualmente y localizar objetos en imágenes o fotogramas de vídeo. |
line_width | int or None | None | Especifica el grosor de línea de los cuadros delimitadores. Si None, el grosor de línea se ajusta automáticamente al tamaño de la imagen. Permite personalizar la visualización para mejorar la claridad. |
Dispositivos de inferencia#
device acepta nombres de dispositivos PyTorch para todos los formatos de modelo, por lo que el mismo valor selecciona el mismo hardware tanto si ejecutas un punto de control .pt como un modelo exportado. Déjalo sin configurar para usar el mejor dispositivo disponible. Cada entorno de ejecución asigna el nombre a su propio hardware, y la validación y la evaluación comparativa aceptan los mismos valores:
| Formato | sin configurar | cpu | 0 o cuda:0 | mps | xpu | npu |
|---|---|---|---|---|---|---|
PyTorch .pt, TorchScript | GPU CUDA; si no, CPU | CPU | GPU NVIDIA | GPU de Apple | GPU Intel | NPU Huawei Ascend |
| ONNX | GPU CUDA; si no, CPU | CPU | GPU NVIDIA (CUDA), GPU AMD (MIGraphX) | Core ML | - | - |
| TensorRT | GPU NVIDIA | GPU NVIDIA | GPU NVIDIA | - | - | - |
| OpenVINO | OpenVINO AUTO | CPU Intel | - | - | GPU Intel (xpu:1 es OpenVINO GPU.1) | NPU Intel |
| LiteRT | CPU | CPU | - | - | GPU Intel mediante el complemento OpenVINO | NPU Intel mediante el complemento OpenVINO |
| PaddlePaddle | GPU CUDA; si no, CPU | CPU | GPU NVIDIA | - | - | - |
- significa que el entorno de ejecución no tiene un backend para ese dispositivo. ONNX, TensorRT y PaddlePaddle comprueban primero el nombre con PyTorch, así que rechazan los dispositivos que PyTorch no puede detectar y, en caso contrario, se ejecutan en su hardware predeterminado. OpenVINO muestra una advertencia y recurre a AUTO si falta un dispositivo Intel solicitado, y el complemento Intel LiteRT recurre a la CPU. Los demás formatos eligen su propio hardware: CoreML se ejecuta en Apple Neural Engine y la CPU, Edge TPU acepta tpu:0, NCNN acepta vulkan:0 para su ruta de GPU Vulkan, y los formatos restantes se ejecutan en la CPU o el acelerador del dispositivo de destino. Los nombres anteriores intel:cpu, intel:gpu y intel:npu siguen funcionando como alias obsoletos de cpu, xpu y npu.
from ultralytics import YOLO
model = YOLO("yolo26n_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg", device="npu") # Intel NPUFormatos de imagen y vídeo#
YOLO26 admite varios formatos de imagen y vídeo, como se especifica en ultralytics/data/utils.py. Consulta las tablas siguientes para ver las extensiones válidas y ejemplos de comandos predict.
Imágenes#
La tabla siguiente contiene los formatos de imagen válidos de Ultralytics.
Los formatos HEIC/HEIF requieren pi-heif, que se instala automáticamente la primera vez que se usa. Pillow admite AVIF de forma nativa.
| Extensiones de imagen | Ejemplo de comando predict | Referencia |
|---|---|---|
.avif | yolo predict source=image.avif | Formato de archivo de imagen AV1 |
.bmp | yolo predict source=image.bmp | Formato de archivo BMP de Microsoft |
.dng | yolo predict source=image.dng | DNG de Adobe |
.heic | yolo predict source=image.heic | Formato de imagen de alta eficiencia |
.heif | yolo predict source=image.heif | Formato de imagen de alta eficiencia |
.jp2 | yolo predict source=image.jp2 | JPEG 2000 |
.jpeg | yolo predict source=image.jpeg | JPEG |
.jpg | yolo predict source=image.jpg | JPEG |
.mpo | yolo predict source=image.mpo | Objeto de varias imágenes |
.png | yolo predict source=image.png | Gráficos de red portátiles |
.tif | yolo predict source=image.tif | Formato de archivo de imagen etiquetado |
.tiff | yolo predict source=image.tiff | Formato de archivo de imagen etiquetado |
.webp | yolo predict source=image.webp | WebP |
Vídeos#
La tabla siguiente contiene los formatos de vídeo válidos de Ultralytics.
| Extensiones de vídeo | Ejemplo de comando predict | Referencia |
|---|---|---|
.asf | yolo predict source=video.asf | Formato de sistemas avanzados |
.avi | yolo predict source=video.avi | Entrelazado de audio y vídeo |
.gif | yolo predict source=video.gif | Formato de intercambio de gráficos |
.m4v | yolo predict source=video.m4v | MPEG-4 Parte 14 |
.mkv | yolo predict source=video.mkv | Matroska |
.mov | yolo predict source=video.mov | Formato de archivo QuickTime |
.mp4 | yolo predict source=video.mp4 | MPEG-4 Parte 14 - Wikipedia |
.mpeg | yolo predict source=video.mpeg | MPEG-1 Parte 2 |
.mpg | yolo predict source=video.mpg | MPEG-1 Parte 2 |
.ts | yolo predict source=video.ts | Flujo de transporte MPEG |
.wmv | yolo predict source=video.wmv | Vídeo de Windows Media |
.webm | yolo predict source=video.webm | Proyecto WebM |
Trabajar con resultados#
Todas las llamadas de Ultralytics predict() devuelven una lista de objetos Results:
from ultralytics import YOLO
# Carga un modelo YOLO26n preentrenado
model = YOLO("yolo26n.pt")
# Ejecuta la inferencia en una imagen
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
[
"https://ultralytics.com/images/bus.jpg",
"https://ultralytics.com/images/zidane.jpg",
]
) # inferencias por lotesLos objetos Results tienen los siguientes atributos:
| Atributo | Tipo | Descripción |
|---|---|---|
orig_img | np.ndarray | La imagen original como matriz NumPy. |
orig_shape | tuple | La forma de la imagen original en formato (alto, ancho). |
boxes | Boxes, optional | Un objeto Boxes que contiene los cuadros delimitadores de las detecciones. |
masks | Masks, optional | Un objeto Masks que contiene las máscaras de las detecciones. |
probs | Probs, optional | Un objeto Probs que contiene las probabilidades de cada clase para la tarea de clasificación. |
keypoints | Keypoints, optional | Un objeto Keypoints que contiene los puntos clave detectados de cada objeto. |
obb | OBB, optional | Un objeto OBB que contiene cuadros delimitadores orientados. |
semantic_mask | SemanticMask, optional | Un objeto SemanticMask que contiene un mapa de clases denso por píxel. |
depth | DepthMap, optional | Un objeto DepthMap que contiene un mapa de profundidad denso por píxel. |
speed | dict | Un diccionario con las velocidades de preprocesamiento, inferencia y posprocesamiento, en milisegundos por imagen. |
names | dict | Un diccionario que asigna índices de clase a nombres de clase. |
path | str | La ruta al archivo de imagen. |
save_dir | str, optional | Directorio en el que guardar los resultados. |
Resultados por tarea#
Los campos que se rellenan a continuación dependen de la tarea del modelo: compara detección, segmentación, segmentación semántica, estimación de profundidad, clasificación, pose y OBB si aún no has elegido una. Cada predicción devuelve un objeto Results por imagen o fotograma. Los campos comunes anteriores siempre están disponibles, mientras que los datos de predicción específicos de cada tarea se almacenan en los campos siguientes. Los tensores de coordenadas y confianza de YOLO son torch.float32; los tensores de probabilidad son torch.float32, salvo que el modelo se ejecute en FP16 (quantize=16 con un modelo PyTorch o TorchScript fuera de la CPU, o un modelo ONNX con entradas FP16), en cuyo caso son torch.float16. Después de result.numpy(), los tensores se convierten en matrices NumPy con los tipos de datos NumPy correspondientes. Las máscaras de instancia son tensores binarios torch.uint8, mientras que las máscaras semánticas usan el tipo de entero práctico más pequeño para los ID de clase: torch.uint8, torch.int16 o torch.int32, según el número de clases.
| 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. |
Los objetos Results tienen los siguientes métodos:
| Método | Tipo de retorno | Descripción |
|---|---|---|
update() | None | Actualiza el objeto Results con datos nuevos, como cajas, máscaras, probs, obb, puntos clave, máscaras semánticas o profundidad. |
cpu() | Results | Devuelve una copia del objeto Results con todos los tensores trasladados a la memoria de la CPU. |
numpy() | Results | Devuelve una copia del objeto Results con todos los tensores convertidos en matrices NumPy. |
cuda() | Results | Devuelve una copia del objeto Results con todos los tensores trasladados a la memoria de la GPU. |
to() | Results | Devuelve una copia del objeto Results con los tensores trasladados al dispositivo y tipo de datos especificados. |
new() | Results | Crea un nuevo objeto Results con los mismos atributos de imagen, ruta, nombres y velocidad. |
plot() | np.ndarray | Representa los resultados de detección en una imagen BGR de entrada y devuelve la imagen anotada. |
show() | None | Muestra la imagen con los resultados de inferencia anotados. |
save() | str | Guarda en un archivo la imagen con los resultados de inferencia anotados y devuelve el nombre del archivo. |
verbose() | str | Devuelve una cadena de registro para cada tarea, con detalles de los resultados de detección y clasificación. |
save_txt() | str | Guarda los resultados de detección en un archivo de texto y devuelve la ruta del archivo guardado. |
save_crop() | None | Guarda las imágenes recortadas de detección en el directorio especificado. |
summary() | List[Dict[str, Any]] | Convierte los resultados de inferencia en un diccionario resumido, con normalización opcional. |
to_df() | DataFrame | Convierte los resultados de detección en un DataFrame de Polars. |
to_csv() | str | Convierte los resultados de detección al formato CSV. |
to_json() | str | Convierte los resultados de detección al formato JSON. |
Para obtener más información, consulta la documentación de la clase Results.
Cajas#
El objeto Boxes se puede usar para indexar y manipular cajas delimitadoras, y convertirlas a distintos formatos.
from ultralytics import YOLO
# Carga un modelo YOLO26n preentrenado
model = YOLO("yolo26n.pt")
# Ejecuta la inferencia en una imagen
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.boxes) # imprimir el objeto Boxes que contiene las cajas delimitadoras de detecciónAquí tienes una tabla con los métodos y propiedades de la clase Boxes, incluidos sus nombres, tipos y descripciones:
| Nombre | Tipo | Descripción |
|---|---|---|
cpu() | Método | Traslada el objeto a la memoria de la CPU. |
numpy() | Método | Convierte el objeto en una matriz NumPy. |
cuda() | Método | Traslada el objeto a la memoria de CUDA. |
to() | Método | Traslada el objeto al dispositivo especificado. |
xyxy | Propiedad (torch.Tensor) | Devuelve las cajas en formato xyxy. |
conf | Propiedad (torch.Tensor) | Devuelve los valores de confianza de las cajas. |
cls | Propiedad (torch.Tensor) | Devuelve los valores de clase de las cajas. |
id | Propiedad (torch.Tensor) | Devuelve los ID de seguimiento de las cajas (si están disponibles). |
xywh | Propiedad (torch.Tensor) | Devuelve las cajas en formato xywh. |
xyxyn | Propiedad (torch.Tensor) | Devuelve las cajas en formato xyxy, normalizadas según el tamaño original de la imagen. |
xywhn | Propiedad (torch.Tensor) | Devuelve las cajas en formato xywh, normalizadas según el tamaño original de la imagen. |
Para obtener más información, consulta la documentación de la clase Boxes.
Máscaras#
El objeto Masks se puede usar para indexar y manipular máscaras, y convertirlas en segmentos.
from ultralytics import YOLO
# Cargar un modelo de segmentación YOLO26n-seg preentrenado
model = YOLO("yolo26n-seg.pt")
# Ejecuta la inferencia en una imagen
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.masks) # imprimir el objeto Masks que contiene las máscaras de instancia detectadasAquí tienes una tabla con los métodos y propiedades de la clase Masks, incluidos sus nombres, tipos y descripciones:
| Nombre | Tipo | Descripción |
|---|---|---|
data | Propiedad (torch.Tensor) | Tensor de máscara binaria torch.uint8 con forma (N,H,W) y valores 0 o 1. |
cpu() | Método | Devuelve el tensor de máscaras en la memoria de la CPU. |
numpy() | Método | Devuelve el tensor de máscaras como una matriz NumPy. |
cuda() | Método | Devuelve el tensor de máscaras en la memoria de la GPU. |
to() | Método | Devuelve el tensor de máscaras con el dispositivo y el tipo de datos especificados. |
xyn | Propiedad (list[np.ndarray]) | Una lista de polígonos de máscara normalizados. |
xy | Propiedad (list[np.ndarray]) | Una lista de polígonos de máscara en coordenadas de píxeles. |
Para obtener más información, consulta la documentación de la clase Masks.
Máscara semántica#
SemanticMask almacena un mapa de clases denso para los resultados de segmentación semántica. A diferencia de Masks, no contiene una máscara binaria por objeto ni proporciona funciones auxiliares para polígonos.
from ultralytics import YOLO
# Cargar un modelo semántico YOLO26n-sem preentrenado
model = YOLO("yolo26n-sem.pt")
# Ejecuta la inferencia en una imagen
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.semantic_mask.data) # imprimir el mapa de ID de clase H x W| Nombre | Tipo | Descripción |
|---|---|---|
data | Propiedad (torch.Tensor) | Mapa de ID de clase con forma (H,W). El tipo de datos es torch.uint8, torch.int16 o torch.int32, según el número de clases. |
shape | Propiedad (tuple) | Forma del mapa de clases, que suele coincidir con result.orig_shape. |
cpu() | Método | Devuelve el tensor de máscara semántica en la memoria de la CPU. |
numpy() | Método | Devuelve el tensor de máscara semántica como una matriz NumPy. |
cuda() | Método | Devuelve el tensor de máscara semántica en la memoria de la GPU. |
to() | Método | Devuelve el tensor de máscara semántica con el dispositivo y el tipo de datos especificados. |
Puntos clave#
El objeto Keypoints se puede usar para indexar y manipular coordenadas, y normalizarlas.
from ultralytics import YOLO
# Cargar un modelo Pose YOLO26n-pose preentrenado
model = YOLO("yolo26n-pose.pt")
# Ejecuta la inferencia en una imagen
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.keypoints) # imprimir el objeto Keypoints que contiene los puntos clave detectadosAquí tienes una tabla con los métodos y propiedades de la clase Keypoints, incluidos sus nombres, tipos y descripciones:
| Nombre | Tipo | Descripción |
|---|---|---|
cpu() | Método | Devuelve el tensor de puntos clave en la memoria de la CPU. |
numpy() | Método | Devuelve el tensor de puntos clave como una matriz NumPy. |
cuda() | Método | Devuelve el tensor de puntos clave en la memoria de la GPU. |
to() | Método | Devuelve el tensor de puntos clave con el dispositivo y el tipo de datos especificados. |
xyn | Propiedad (torch.Tensor) | Coordenadas normalizadas de puntos clave con forma (N,K,2). |
xy | Propiedad (torch.Tensor) | Coordenadas de puntos clave en píxeles con forma (N,K,2). |
conf | Propiedad (torch.Tensor) | Devuelve los valores de confianza de los puntos clave si están disponibles; de lo contrario, devuelve None. |
Para obtener más información, consulta la documentación de la clase Keypoints.
Probabilidades#
El objeto Probs se puede usar para obtener los índices y las puntuaciones de clasificación top1 y top5.
from ultralytics import YOLO
# Cargar un modelo Classify YOLO26n-cls preentrenado
model = YOLO("yolo26n-cls.pt")
# Ejecuta la inferencia en una imagen
results = model("https://ultralytics.com/images/bus.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.probs) # imprimir el objeto Probs que contiene las probabilidades de clase detectadasAquí tienes una tabla que resume los métodos y las propiedades de la clase Probs:
| Nombre | Tipo | Descripción |
|---|---|---|
cpu() | Método | Devuelve una copia del tensor probs en la memoria de la CPU. |
numpy() | Método | Devuelve una copia del tensor probs como matriz NumPy. |
cuda() | Método | Devuelve una copia del tensor probs en la memoria de la GPU. |
to() | Método | Devuelve una copia del tensor probs con el dispositivo y el tipo de datos especificados. |
top1 | Propiedad (int) | Índice de la clase con mayor puntuación. |
top5 | Propiedad (list[int]) | Índices de las 5 clases con mayor puntuación. |
top1conf | Propiedad (torch.Tensor) | Confianza de la clase con mayor puntuación. |
top5conf | Propiedad (torch.Tensor) | Confianzas de las 5 clases con mayor puntuación. |
Para obtener más información, consulta la documentación de la clase Probs.
OBB#
El objeto OBB permite indexar, manipular y convertir cajas delimitadoras orientadas a distintos formatos.
from ultralytics import YOLO
# Carga un modelo YOLO26n preentrenado
model = YOLO("yolo26n-obb.pt")
# Ejecuta la inferencia en una imagen
results = model("https://ultralytics.com/images/boats.jpg") # lista de resultados
# Ver resultados
for r in results:
print(r.obb) # imprime el objeto OBB que contiene las cajas delimitadoras orientadas de las deteccionesAquí tienes una tabla con los métodos y propiedades de la clase OBB, incluidos sus nombres, tipos y descripciones:
| Nombre | Tipo | Descripción |
|---|---|---|
cpu() | Método | Traslada el objeto a la memoria de la CPU. |
numpy() | Método | Convierte el objeto en una matriz NumPy. |
cuda() | Método | Traslada el objeto a la memoria de CUDA. |
to() | Método | Traslada el objeto al dispositivo especificado. |
conf | Propiedad (torch.Tensor) | Devuelve los valores de confianza de las cajas. |
cls | Propiedad (torch.Tensor) | Devuelve los valores de clase de las cajas. |
id | Propiedad (torch.Tensor) | Devuelve los ID de seguimiento de las cajas (si están disponibles). |
xyxy | Propiedad (torch.Tensor) | Devuelve las cajas horizontales en formato xyxy. |
xywhr | Propiedad (torch.Tensor) | Devuelve las cajas giradas en formato xywhr. |
xyxyxyxy | Propiedad (torch.Tensor) | Devuelve las cajas giradas en formato xyxyxyxy. |
xyxyxyxyn | Propiedad (torch.Tensor) | Devuelve las cajas giradas en formato xyxyxyxy normalizadas según el tamaño de la imagen. |
Para obtener más información, consulta la documentación de la clase OBB.
Representación de resultados#
El método plot() de los objetos Results facilita la visualización de las predicciones al superponer los objetos detectados (como cajas delimitadoras, máscaras, puntos clave y probabilidades) sobre la imagen original. Este método devuelve la imagen anotada como una matriz NumPy, lo que permite mostrarla o guardarla fácilmente.
from PIL import Image
from ultralytics import YOLO
# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")
# Run inference on 'bus.jpg'
results = model(["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/zidane.jpg"]) # results list
# Visualize the results
for i, r in enumerate(results):
# Plot results image
im_bgr = r.plot() # BGR-order numpy array
im_rgb = Image.fromarray(im_bgr[..., ::-1]) # RGB-order PIL image
# Show results to screen (in supported environments)
r.show()
# Save results to disk
r.save(filename=f"results{i}.jpg")Parámetros del método plot()#
El método plot() admite varios argumentos para personalizar el resultado:
| Argumento | Tipo | Descripción | Predeterminado |
|---|---|---|---|
conf | bool | Incluye las puntuaciones de confianza de las detecciones. | True |
line_width | float | Grosor de línea de las cajas delimitadoras. Se escala con el tamaño de la imagen si None. | None |
font_size | float | Tamaño de fuente del texto. Se escala con el tamaño de la imagen si None. | None |
font | str | Nombre de la fuente para las anotaciones de texto. | 'Arial.ttf' |
pil | bool | Devuelve la imagen como un objeto PIL Image. | False |
img | np.ndarray | torch.Tensor | Imagen alternativa. Los tensores deben ser contiguos y tener el formato HWC BGR uint8. | None |
kpt_radius | int | Radio de los puntos clave dibujados. | 5 |
kpt_line | bool | Conecta los puntos clave con líneas. | True |
labels | bool | Incluye las etiquetas de clase en las anotaciones. | True |
boxes | bool | Superpone las cajas delimitadoras en la imagen. | True |
masks | bool | Superpone las máscaras en la imagen. | True |
probs | bool | Incluye las probabilidades de clasificación. | True |
show | bool | Muestra directamente la imagen anotada con el visor de imágenes predeterminado. | False |
save | bool | Guarda la imagen anotada en el archivo especificado por filename. | False |
filename | str | Ruta y nombre del archivo en el que se guardará la imagen anotada si save es True. | None |
color_mode | str | Especifica el modo de color, por ejemplo, 'instance' o 'class'. | 'class' |
txt_color | tuple[int, int, int] | Color de texto BGR para las etiquetas de clasificación. | (255, 255, 255) |
Inferencia segura para subprocesos#
Garantizar la seguridad entre hilos durante la inferencia es fundamental cuando se ejecutan varios modelos YOLO en paralelo en distintos hilos. La inferencia segura para hilos garantiza que las predicciones de cada hilo estén aisladas y no interfieran entre sí, lo que evita condiciones de carrera y asegura resultados coherentes y fiables.
Al usar modelos YOLO en una aplicación con varios subprocesos, es importante crear instancias de modelo separadas para cada subproceso o emplear almacenamiento local para cada subproceso a fin de evitar conflictos:
Crea una única instancia del modelo dentro de cada subproceso para realizar inferencias de forma segura:
from threading import Thread
from ultralytics import YOLO
def thread_safe_predict(model, image_path):
"""Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
model = YOLO(model)
results = model.predict(image_path)
# Procesa los resultados
# Inicia subprocesos, cada uno con su propia instancia del modelo
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()Bucle for para fuentes de transmisión#
Aquí tienes un script de Python que utiliza OpenCV (cv2) y YOLO para realizar inferencias en fotogramas de vídeo. Este script presupone que ya has instalado los paquetes necesarios (opencv-python y ultralytics).
import cv2
from ultralytics import YOLO
# Cargar el modelo YOLO
model = YOLO("yolo26n.pt")
# Abre el archivo de vídeo
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)
# Recorre los fotogramas del vídeo
while cap.isOpened():
# Lee un fotograma del vídeo
success, frame = cap.read()
if success:
# Realiza inferencias de YOLO en el fotograma
results = model(frame)
# Visualiza los resultados en el fotograma
annotated_frame = results[0].plot()
# Muestra el fotograma anotado
cv2.imshow("YOLO Inference", annotated_frame)
# Interrumpe el bucle si se pulsa 'q'
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Interrumpe el bucle si se llega al final del vídeo
break
# Libera el objeto de captura de vídeo y cierra la ventana de visualización
cap.release()
cv2.destroyAllWindows()Este script realizará predicciones en cada fotograma del vídeo, visualizará los resultados y los mostrará en una ventana. Puedes salir del bucle pulsando 'q'.
Qué hacer a continuación#
¿Listo para pasar de un modelo preentrenado? Confirma que tu tarea se ajusta a tu problema, da formato a tus propios datos con la guía de conjuntos de datos y, después, entrena con ellos.
Preguntas frecuentes#
Ultralytics YOLO es una familia de modelos de vanguardia 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 la detección de cajas delimitadoras orientadas (OBB) en tiempo real. Su modo de predicción ejecuta inferencias de alta velocidad en fuentes de datos como imágenes, vídeos y transmisiones en directo, con procesamiento por lotes y compatibilidad con la transmisión continua.
Ultralytics YOLO puede procesar una amplia variedad de fuentes de datos, como imágenes individuales, vídeos, directorios, URL y transmisiones. Puedes especificar la fuente de datos en la llamada
model.predict(). Por ejemplo, usa'image.jpg'para una imagen local o'https://ultralytics.com/images/bus.jpg'para una URL. Consulta los ejemplos detallados de distintas fuentes de inferencia en la documentación.Para optimizar la velocidad de inferencia y gestionar la memoria de forma eficiente, puedes usar el modo de transmisión estableciendo
stream=Trueen el método de llamada del predictor. El modo de transmisión genera un generador de objetosResultsque consume poca memoria, en lugar de cargar todos los fotogramas en memoria. Este modo es especialmente útil para procesar vídeos largos o conjuntos de datos grandes. Descubre más sobre el modo de transmisión.El método
model.predict()de YOLO admite varios argumentos, comoconf,iou,imgsz,device, entre otros. Estos argumentos permiten personalizar el proceso de inferencia y establecer parámetros como los umbrales de confianza, el tamaño de imagen y el dispositivo utilizado para los cálculos. Encontrarás descripciones detalladas de estos argumentos en la sección de argumentos de inferencia.Usa
model.embed(source)para extraer incrustaciones de características de la penúltima capa, o pasaembed=[layer_index]amodel.predict()para elegir capas específicas.from ultralytics import YOLO model = YOLO("yolo26n.pt") source = "https://ultralytics.com/images/bus.jpg" results = model.predict(source) # Objetos de resultados embeddings = model.embed(source) # lista de incrustaciones torch.TensorTras realizar inferencias con YOLO, los objetos
Resultscontienen métodos para mostrar y guardar imágenes anotadas. Puedes usar métodos comoresult.show()yresult.save(filename="result.jpg")para visualizar y guardar los resultados. Las carpetas principales que falten en la ruta del nombre de archivo se crean automáticamente (por ejemplo,result.save("path/to/result.jpg")). Para consultar una lista completa de estos métodos, ve a la sección trabajar con resultados.
Comentarios629
Haz una pregunta, comparte tus resultados o ayuda a otra persona.
Tigores
你好,我想问一下为什么我在推理相同的图像时,设置不同的imgsz参数,会有不同的结果。在一张图像上,有大船、小船、人。imgsz设置的值有640(默认)、1280、1980。640只能检测到大船;1280会检测到大船和小船,并且大船的置信度更高;1980还能检测到人。我很疑惑,模型的输入尺寸不是在训练的时候就已经固定了吗,这是否意味着推理的图像预处理阶段,不管我如何调整imgsz参数,模型都会将输入图像采样到640。但是现在出现的不同的结果,是为什么呢?下面是我的代码: from ultralytics import YOLO model = YOLO("/data/dxh/ultralytics/weight/yolov8s.pt")
results = model("/data/dxh/ultralytics/datasets/test/invade_ship_cls/invade_result", imgsz=1280, save=True)1
Glenn JocherUltralytics@Tigores 您好!YOLO模型在推理时会自动将输入图像缩放到您指定的imgsz参数值(而非固定为训练尺寸),更大的分辨率能保留更多细节从而提升小目标检测能力。具体原理可参考Predict模式文档中的图像尺寸与精度关系说明,这是预期行为而非异常现象。
LwpZoe
Hello, I would like to ask, my task is instance segmentation. At present, I get the predicted result is the original image superimposed label image, but the result I want is just the RGB label image, no need to superimpose the original image. Where do I need to make changes to make the result a segmented label image?
1
Glenn JocherUltralytics(editado)@LwpZoe to obtain only the RGB label image without the original image overlay, you can disable the overlay during visualization. Use the
plot()method withboxes=Falseandmasks=Trueto only display the segmentation masks. Alternatively, you can directly accessresult.masks.datafor raw mask data and process it as needed. Refer to the Results section for more details.LwpZoe
Found plot () in yolo-segment-main/ultralytics/engine/results.py, modified content: Def plot ( Self, Conf = True, line_width = None, font_size = None, Font = "Arial.ttf", Pil = False, Img = None, im_gpu = None, kpt_radius = 5, kpt_line = False, Labels = False, Boxes = False, Masks = True, Probs = True, Show = True, Save = True, Filename = 'result', color_mode = "class", ): Make predictions using the command line: Yolo segment predict model = runs/segment/train/weights/best.pt source=yolo-seg-main/datasets/test The result is still the original image overlay mask and box, why? Does changing plot () require retraining to get best.pt in order to predict?
Glenn JocherUltralyticsTo display only the segmentation mask without overlays, modify the
plot()function parameters by settingboxes=False,labels=False, and ensuringmasks=True. You don't need retraining to adjust visualization settings, as the weights remain unaffected. For further details, refer to the Results.plot() documentation.
UserHello, when I run the predict script, I predict a large amount of image data (about more than 20,000 test images). At this time, the model's predict will get stuck, and I don't generate the image of the prediction box. How can I solve this bug?
1
Paula DerrengerUltralytics@Stephen-Hao it sounds like you might be running into memory issues when processing a large number of images. To handle large datasets more efficiently, consider using the
stream=Trueargument in yourmodel.predict()call. This will create a memory-efficient generator of results, reducing the likelihood of your system getting stuck. Additionally, ensure you are using the latest version of the Ultralytics package to benefit from any recent optimizations and bug fixes. If the issue persists, please provide more details about your environment and any error messages you encounter.
UserYes, Thank you a lot.
Paula DerrengerUltralytics@Stephen-Hao you're welcome! If you're experiencing issues with the model getting stuck while predicting a large number of images, try using the
stream=Trueargument in yourmodel.predict()call. This will help manage memory more efficiently by processing images one at a time instead of loading all at once. Also, ensure you're using the latest version of the Ultralytics package. If the problem persists, please provide more details about your setup and any error messages you encounter.
Johanna-Jones
Hey, Is there a way to get the MAP precision, IOU and other metrics for the test images you might give the model?
I have images and the ground truth for the test images but not sure how to get the same metrics for the PREDICT mode
Thank you!
1Johanna-Jones
For clarification my pipeline is currently train> valid with
valparameter set to false. I then pass one image at a time to the Yolov8 model in the PREDICT mode
Paula DerrengerUltralyticsHey there!
For evaluating your model with metrics like mAP, precision, and IOU on your test images, you should use the
Valmode rather than thePredictmode. TheValmode allows you to validate your model on a dataset and provides comprehensive metrics, including the ones you're interested in. Here's an example on how to do it:from ultralytics import YOLO # Assuming 'coco128.yaml' is your dataset configuration file that includes your test data path # and that 'your_model.pt' is the trained model you want to evaluate model = YOLO('path/to/your_model.pt') # Validate the model, this will automatically calculate mAP, IOU, and other metrics results = model.val(data='path/to/your_dataset_config.yaml')Remember to adjust
'path/to/your_model.pt'and'path/to/your_dataset_config.yaml'to the actual paths of your model and dataset configuration file.In your YAML dataset configuration file, make sure to correctly specify the path to your test images and annotations. This way, YOLOv8 will know how to find your test data and corresponding ground truth for evaluation.
If you have any more questions, feel free to ask. Good luck with your model evaluation! 🚀
GUPABE10
how to ignore printing results after inference: 0: 384x640 10 persons, 1 sports ball, 4080.4ms Speed: 12.3ms preprocess, 4080.4ms inference, 1.7ms postprocess per image at shape (1, 3, 384, 640)
1
Glenn JocherUltralyticsTo disable printing inference results after running predictions, you can use the
verbose=Falseargument in yourpredict()function. This will prevent the printout of inference times and detected objects. Here's a quick example on how to do it:from ultralytics import YOLO # Load your YOLOv8 model model = YOLO('yolov8n.pt') # Run inference with verbose=False results = model.predict('path/to/your/image.jpg', verbose=False)This should keep your console output clean while still performing inference. 😊
GUPABE10
Is it the same if I use:
results = model('path/to/your/image.jpg')
just as mentioned in the example in this tutorial.
Glenn JocherUltralytics@GUPABE10 hi there!
Yes, using
results = model('path/to/your/image.jpg')is perfectly fine and aligns with the examples provided in the tutorial. This command will run inference on the specified image and return the results as a list ofResultsobjects.If you want to avoid printing the detailed inference results (like the number of detected objects and processing times), you can use the
verbose=Falseargument:from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference on an image without printing detailed results results = model.predict('path/to/your/image.jpg', verbose=False)This will keep your console output clean while still performing the inference. If you have any more questions or need further assistance, feel free to ask! 😊
GUPABE10
What is the difference between model.predict() and model()?
Glenn JocherUltralyticsHi there!
Great question! The difference between
model.predict()andmodel()lies in their usage and flexibility:-
model.predict():- This method is explicitly designed for running predictions and allows you to pass various arguments to customize the inference process.
- You can specify parameters like
save,imgsz,conf,device, and more to control the behavior of the prediction. - Example:
from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference with custom arguments results = model.predict("path/to/image.jpg", save=True, imgsz=320, conf=0.5)
-
model():- This is a shorthand method that calls the
predict()function internally with default settings. - It is useful for quick predictions without needing to specify additional parameters.
- Example:
from ultralytics import YOLO # Load a pretrained YOLOv8n model model = YOLO("yolov8n.pt") # Run inference with default settings results = model("path/to/image.jpg")
- This is a shorthand method that calls the
Both methods will return a list of
Resultsobjects, which you can then process as needed. If you need more control over the prediction process,model.predict()is the way to go. For quick and straightforward predictions,model()is convenient.Feel free to check out the Ultralytics documentation on prediction for more details and examples.
Happy coding! 😊
-
amani784
Hello @glenn-jocher, i have question, my inputs are videos, if i use vid-stride , can i use imgsz with it ?
Glenn JocherUltralyticsYes—
vid_stride(frame skipping) andimgsz(inference resize) are independent, so you can use them together on video sources;imgszwill be applied to the frames that are actually processed (see the Predict mode inference arguments).yolo predict model=yolo26n.pt source=video.mp4 vid_stride=2 imgsz=640from ultralytics import YOLO model = YOLO("yolo26n.pt") for r in model.predict("video.mp4", vid_stride=2, imgsz=640, stream=True): pass1amani784
Thank you for your help. I have another question: if I don’t define imgsz in predict, will it resize the image to 640 by default? I have multiple inputs with different resolutions, so I can’t specify a single value for imgsz in .predict or even during ONNX export, because sometimes the input resolution is larger than imgsz.
Glenn JocherUltralyticsYes—if you don’t pass
imgsztopredict(), it uses the defaultimgsz=640and will letterbox/resize each frame/image to that inference size (so larger inputs are downscaled, smaller are upscaled); for mixed-resolution sources you can either leave the default or set a largerimgszfor more detail (GPU memory permitting) as described in the predict settings defaults.If you need an ONNX that can accept varying input shapes at runtime, export with dynamic shapes enabled (then your runtime can feed different H×W sizes):
yolo export model=yolo26n.pt format=onnx dynamic=Truefrom ultralytics import YOLO model = YOLO("yolo26n.pt") model.export(format="onnx", dynamic=True)Feel free to drop the exact input resolutions (and whether this is video-only) here in the discussion and we can suggest a good
imgszstrategy for your case.1amani784
Thank you so much ,but for tensorRT export , the model can't accept varying input shapes and i was obliged to put imgsz or my videos have different resolutions and i can't put one imgsz value that can fit all the resolutions. Is there any other solution?
Glenn JocherUltralyticsYes—TensorRT doesn’t have to be fixed-shape: export your
.enginewithdynamic=Trueso the runtime can accept varying input shapes (you can then chooseimgszper run/video), see the Export mode docs and the TensorRT integration guide.yolo export model=yolo26n.pt format=engine dynamic=TrueIf you need peak throughput and your resolutions vary a lot, the usual workaround is exporting 2–3 fixed engines at common
imgszvalues and selecting the closest one at runtime.1
Asshok1
Hey @glenn-jocher, I’m trying to integrate a TensorRT-optimized YOLO model (.engine) with SAHI (Slicing Aided Hyper Inference) for efficient large-image inference, but I’m facing difficulties making them work together correctly as .engine is not accepted in sahi, can you help in providing the complete code for integrating tensorRT with sahi.
Glenn JocherUltralyticsSAHI’s built-in Ultralytics integration (
model_type="ultralytics") currently expects PyTorch weights like*.pt, so a TensorRT*.enginefile won’t load through SAHI as-is; the supported path is to use SAHI with*.ptper the SAHI tiled inference guide, or run the TensorRT engine directly with Ultralytics per the TensorRT export/inference guide. If you specifically need SAHI slicing + a*.engine, you’ll need a custom SAHIDetectionModeladapter around Ultralytics’ TensorRT predictor (best tracked upstream in the SAHI repository); please paste your Ultralytics/SAHI versions and a minimal repro here in the discussion so we can advise on the cleanest adapter approach.# SAHI (supported): Ultralytics *.pt + slicing from sahi import AutoDetectionModel from sahi.predict import get_sliced_prediction detection_model = AutoDetectionModel.from_pretrained( model_type="ultralytics", model_path="best.pt", confidence_threshold=0.25, device="cuda:0", ) result = get_sliced_prediction( "large.jpg", detection_model, slice_height=640, slice_width=640, overlap_height_ratio=0.2, overlap_width_ratio=0.2, )# TensorRT (supported): Ultralytics *.engine inference (no SAHI wrapper) from ultralytics import YOLO model = YOLO("best.engine") results = model.predict("large.jpg", device=0, imgsz=640)
hanchaoyuan
hello! I used the YOLO11-pose model to estimate the key points of people in the automotive production workshop. However, the model often identified vehicles, hoists and other equipment as humans and calculated the key points, resulting in a relatively high false alarm rate. My question is: How can we prevent the model from identifying other objects and reduce the false alarm rate?
Glenn JocherUltralyticsFor workshop false positives with pose models, the quickest lever is raising the prediction threshold (and optionally increasing
imgszfor better person discrimination), but the most reliable fix is fine-tuning on your own workshop data with “hard negative” images (frames with vehicles/hoists but no people) so the model learns your background; see the inference args in the predict mode docs.yolo pose predict model=yolo11n-pose.pt source=path/to/video.mp4 conf=0.6 imgsz=960If you paste your exact command, plus a couple representative frames (people + false positives) here in the discussion, we can suggest tighter settings or a training setup (and for new work, try a YOLO26 pose checkpoint as it’s generally stronger out of the box).
d5423197
Hi there,
If no boxes/masks detected by the model, what will be the output of model inference. (results = model(["image1.jpg", "image2.jpg"]) #)
I want to deal with the edge case.
max-dev-14
How to predict and show or save prediction YOLO (custom model) for video fragment?
