Empezar

Predicción de modelos con Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

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ónDeportesSeguridad
Detección de piezas de repuesto de vehículosDetección de jugadores de fútbolDetecció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 Results que ahorra memoria. Actívala estableciendo stream=True en el método de llamada del predictor. A diferencia del comportamiento predeterminado (stream=False), que devuelve una lista con todos los resultados, stream=True produce 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:

Predecir
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 disco

Fuentes 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.

Consejo

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.

FuenteEjemploTipoNotas
imagen'image.jpg'str o PathArchivo de imagen individual.
URL'https://ultralytics.com/images/bus.jpg'strURL de una imagen.
captura de pantalla ✅'screen'strCaptura la pantalla continuamente hasta que la detengas.
PILImage.open('image.jpg')PIL.ImageFormato HWC con canales RGB.
OpenCVcv2.imread('image.jpg')np.ndarrayFormato HWC con canales BGR uint8 (0-255).
NumPynp.zeros((640,1280,3))np.ndarrayFormato HWC con canales BGR uint8 (0-255).
torchtorch.zeros(16,3,320,640)torch.TensorFormato BCHW con canales RGB float32 (0.0-1.0).
CSV'sources.csv'str o PathArchivo CSV con rutas a imágenes, vídeos o directorios.
vídeo ✅'video.mp4'str o PathArchivo de vídeo en formatos como MP4, AVI, etc.
directorio ✅'path/'str o PathRuta a un directorio que contiene imágenes o vídeos.
glob ✅'path/*.jpg'strPatrón glob para buscar varios archivos. Usa el carácter * como comodín.
YouTube ✅'https://youtu.be/LNwODJXcvt4'strURL de un vídeo de YouTube.
transmisión ✅'rtsp://example.com/media.mp4'strURL para protocolos de transmisión como RTSP, RTMP, TCP o una dirección IP.
varias transmisiones ✅'list.streams'str o PathArchivo 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 ✅0intÍ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:

Fuentes de predicción

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 Results

Argumentos 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=640 entero se convierte en un objetivo cuadrado (640, 640) tras el redondeo al stride.
  • Una tupla imgsz=(384, 672) establece un objetivo rectangular. Con rect=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).

Ejemplo
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:

ArgumentoTipoPredeterminadoDescripción
sourcestr o int o NoneNoneEspecifica 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.
conffloat0.25Establece 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.
ioufloat0.5Umbral 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.
imgszint o tuple640Objetivo 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.
rectboolTrueSi 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.
quantizeint o strNonePrecisió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.
devicestrNoneEspecifica 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.
dnnboolFalseSi True, usa el módulo DNN de OpenCV en lugar de ONNX Runtime para la inferencia de modelos ONNX.
datastrNoneRuta 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.
batchint1Especifica 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.
tilebool o intFalseEjecuta 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_detint300Nú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_strideint1Salto 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_bufferboolFalseDetermina 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.
visualizeboolFalseGuarda 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.
augmentboolFalseActiva 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_nmsboolFalseActiva 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.
classeslist[int]NoneFiltra 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_masksboolFalseDevuelve 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.
embedlist[int]NoneEspecifica 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.
projectstrNoneNombre 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.
namestrNoneNombre 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.
streamboolFalsePermite 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.
verboseboolTrueControla si se muestran registros detallados de inferencia en el terminal para ofrecer información en tiempo real sobre el proceso de predicción.
compilebool o strFalseActiva 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_lastboolNoneUsa 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.
nmsbool, opcionalNonePor 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:

ArgumentoTipoPredeterminadoDescripción
showboolFalseSi 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.
saveboolFalse or TrueActiva 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_framesboolFalseAl procesar vídeos, guarda fotogramas individuales como imágenes. Es útil para extraer fotogramas concretos o analizarlos detalladamente uno por uno.
save_txtboolFalseGuarda 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_confboolFalseIncluye puntuaciones de confianza en los archivos de texto guardados. Ofrece más detalles para el posprocesamiento y el análisis.
save_cropboolFalseGuarda 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_labelsboolTrueMuestra etiquetas para cada detección en la salida visual. Facilita la identificación inmediata de los objetos detectados.
show_confboolTrueMuestra 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_boxesboolTrueDibuja cuadros delimitadores alrededor de los objetos detectados. Es esencial para identificar visualmente y localizar objetos en imágenes o fotogramas de vídeo.
line_widthint or NoneNoneEspecifica 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:

Formatosin configurarcpu0 o cuda:0mpsxpunpu
PyTorch .pt, TorchScriptGPU CUDA; si no, CPUCPUGPU NVIDIAGPU de AppleGPU IntelNPU Huawei Ascend
ONNXGPU CUDA; si no, CPUCPUGPU NVIDIA (CUDA), GPU AMD (MIGraphX)Core ML--
TensorRTGPU NVIDIAGPU NVIDIAGPU NVIDIA---
OpenVINOOpenVINO AUTOCPU Intel--GPU Intel (xpu:1 es OpenVINO GPU.1)NPU Intel
LiteRTCPUCPU--GPU Intel mediante el complemento OpenVINONPU Intel mediante el complemento OpenVINO
PaddlePaddleGPU CUDA; si no, CPUCPUGPU 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.

Ejemplo
from ultralytics import YOLO

model = YOLO("yolo26n_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg", device="npu")  # Intel NPU

Formatos 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.

Nota

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 imagenEjemplo de comando predictReferencia
.avifyolo predict source=image.avifFormato de archivo de imagen AV1
.bmpyolo predict source=image.bmpFormato de archivo BMP de Microsoft
.dngyolo predict source=image.dngDNG de Adobe
.heicyolo predict source=image.heicFormato de imagen de alta eficiencia
.heifyolo predict source=image.heifFormato de imagen de alta eficiencia
.jp2yolo predict source=image.jp2JPEG 2000
.jpegyolo predict source=image.jpegJPEG
.jpgyolo predict source=image.jpgJPEG
.mpoyolo predict source=image.mpoObjeto de varias imágenes
.pngyolo predict source=image.pngGráficos de red portátiles
.tifyolo predict source=image.tifFormato de archivo de imagen etiquetado
.tiffyolo predict source=image.tiffFormato de archivo de imagen etiquetado
.webpyolo predict source=image.webpWebP

Vídeos#

La tabla siguiente contiene los formatos de vídeo válidos de Ultralytics.

Extensiones de vídeoEjemplo de comando predictReferencia
.asfyolo predict source=video.asfFormato de sistemas avanzados
.aviyolo predict source=video.aviEntrelazado de audio y vídeo
.gifyolo predict source=video.gifFormato de intercambio de gráficos
.m4vyolo predict source=video.m4vMPEG-4 Parte 14
.mkvyolo predict source=video.mkvMatroska
.movyolo predict source=video.movFormato de archivo QuickTime
.mp4yolo predict source=video.mp4MPEG-4 Parte 14 - Wikipedia
.mpegyolo predict source=video.mpegMPEG-1 Parte 2
.mpgyolo predict source=video.mpgMPEG-1 Parte 2
.tsyolo predict source=video.tsFlujo de transporte MPEG
.wmvyolo predict source=video.wmvVídeo de Windows Media
.webmyolo predict source=video.webmProyecto WebM

Trabajar con resultados#

Todas las llamadas de Ultralytics predict() devuelven una lista de objetos Results:

Resultados
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 lotes

Los objetos Results tienen los siguientes atributos:

AtributoTipoDescripción
orig_imgnp.ndarrayLa imagen original como matriz NumPy.
orig_shapetupleLa forma de la imagen original en formato (alto, ancho).
boxesBoxes, optionalUn objeto Boxes que contiene los cuadros delimitadores de las detecciones.
masksMasks, optionalUn objeto Masks que contiene las máscaras de las detecciones.
probsProbs, optionalUn objeto Probs que contiene las probabilidades de cada clase para la tarea de clasificación.
keypointsKeypoints, optionalUn objeto Keypoints que contiene los puntos clave detectados de cada objeto.
obbOBB, optionalUn objeto OBB que contiene cuadros delimitadores orientados.
semantic_maskSemanticMask, optionalUn objeto SemanticMask que contiene un mapa de clases denso por píxel.
depthDepthMap, optionalUn objeto DepthMap que contiene un mapa de profundidad denso por píxel.
speeddictUn diccionario con las velocidades de preprocesamiento, inferencia y posprocesamiento, en milisegundos por imagen.
namesdictUn diccionario que asigna índices de clase a nombres de clase.
pathstrLa ruta al archivo de imagen.
save_dirstr, optionalDirectorio 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.

AtributoTipoFormaDescripción
result.boxesBoxes(N)Cuadros de detección.
result.boxes.datatorch.float32(N,6/7)[x1,y1,x2,y2,conf,cls] sin procesar, más un ID de seguimiento opcional.
result.boxes.xyxytorch.float32(N,4)Cuadros de píxeles xyxy.
result.boxes.conftorch.float32(N,)Puntuaciones de confianza.
result.boxes.clstorch.float32(N,)ID de clase; conviértelos a int para obtener los nombres.

Los objetos Results tienen los siguientes métodos:

MétodoTipo de retornoDescripción
update()NoneActualiza el objeto Results con datos nuevos, como cajas, máscaras, probs, obb, puntos clave, máscaras semánticas o profundidad.
cpu()ResultsDevuelve una copia del objeto Results con todos los tensores trasladados a la memoria de la CPU.
numpy()ResultsDevuelve una copia del objeto Results con todos los tensores convertidos en matrices NumPy.
cuda()ResultsDevuelve una copia del objeto Results con todos los tensores trasladados a la memoria de la GPU.
to()ResultsDevuelve una copia del objeto Results con los tensores trasladados al dispositivo y tipo de datos especificados.
new()ResultsCrea un nuevo objeto Results con los mismos atributos de imagen, ruta, nombres y velocidad.
plot()np.ndarrayRepresenta los resultados de detección en una imagen BGR de entrada y devuelve la imagen anotada.
show()NoneMuestra la imagen con los resultados de inferencia anotados.
save()strGuarda en un archivo la imagen con los resultados de inferencia anotados y devuelve el nombre del archivo.
verbose()strDevuelve una cadena de registro para cada tarea, con detalles de los resultados de detección y clasificación.
save_txt()strGuarda los resultados de detección en un archivo de texto y devuelve la ruta del archivo guardado.
save_crop()NoneGuarda 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()DataFrameConvierte los resultados de detección en un DataFrame de Polars.
to_csv()strConvierte los resultados de detección al formato CSV.
to_json()strConvierte 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.

Cajas
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ón

Aquí tienes una tabla con los métodos y propiedades de la clase Boxes, incluidos sus nombres, tipos y descripciones:

NombreTipoDescripción
cpu()MétodoTraslada el objeto a la memoria de la CPU.
numpy()MétodoConvierte el objeto en una matriz NumPy.
cuda()MétodoTraslada el objeto a la memoria de CUDA.
to()MétodoTraslada el objeto al dispositivo especificado.
xyxyPropiedad (torch.Tensor)Devuelve las cajas en formato xyxy.
confPropiedad (torch.Tensor)Devuelve los valores de confianza de las cajas.
clsPropiedad (torch.Tensor)Devuelve los valores de clase de las cajas.
idPropiedad (torch.Tensor)Devuelve los ID de seguimiento de las cajas (si están disponibles).
xywhPropiedad (torch.Tensor)Devuelve las cajas en formato xywh.
xyxynPropiedad (torch.Tensor)Devuelve las cajas en formato xyxy, normalizadas según el tamaño original de la imagen.
xywhnPropiedad (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.

Máscaras
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 detectadas

Aquí tienes una tabla con los métodos y propiedades de la clase Masks, incluidos sus nombres, tipos y descripciones:

NombreTipoDescripción
dataPropiedad (torch.Tensor)Tensor de máscara binaria torch.uint8 con forma (N,H,W) y valores 0 o 1.
cpu()MétodoDevuelve el tensor de máscaras en la memoria de la CPU.
numpy()MétodoDevuelve el tensor de máscaras como una matriz NumPy.
cuda()MétodoDevuelve el tensor de máscaras en la memoria de la GPU.
to()MétodoDevuelve el tensor de máscaras con el dispositivo y el tipo de datos especificados.
xynPropiedad (list[np.ndarray])Una lista de polígonos de máscara normalizados.
xyPropiedad (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.

Máscara semántica
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
NombreTipoDescripción
dataPropiedad (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.
shapePropiedad (tuple)Forma del mapa de clases, que suele coincidir con result.orig_shape.
cpu()MétodoDevuelve el tensor de máscara semántica en la memoria de la CPU.
numpy()MétodoDevuelve el tensor de máscara semántica como una matriz NumPy.
cuda()MétodoDevuelve el tensor de máscara semántica en la memoria de la GPU.
to()MétodoDevuelve 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.

Puntos clave
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 detectados

Aquí tienes una tabla con los métodos y propiedades de la clase Keypoints, incluidos sus nombres, tipos y descripciones:

NombreTipoDescripción
cpu()MétodoDevuelve el tensor de puntos clave en la memoria de la CPU.
numpy()MétodoDevuelve el tensor de puntos clave como una matriz NumPy.
cuda()MétodoDevuelve el tensor de puntos clave en la memoria de la GPU.
to()MétodoDevuelve el tensor de puntos clave con el dispositivo y el tipo de datos especificados.
xynPropiedad (torch.Tensor)Coordenadas normalizadas de puntos clave con forma (N,K,2).
xyPropiedad (torch.Tensor)Coordenadas de puntos clave en píxeles con forma (N,K,2).
confPropiedad (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.

Probabilidades
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 detectadas

Aquí tienes una tabla que resume los métodos y las propiedades de la clase Probs:

NombreTipoDescripción
cpu()MétodoDevuelve una copia del tensor probs en la memoria de la CPU.
numpy()MétodoDevuelve una copia del tensor probs como matriz NumPy.
cuda()MétodoDevuelve una copia del tensor probs en la memoria de la GPU.
to()MétodoDevuelve una copia del tensor probs con el dispositivo y el tipo de datos especificados.
top1Propiedad (int)Índice de la clase con mayor puntuación.
top5Propiedad (list[int])Índices de las 5 clases con mayor puntuación.
top1confPropiedad (torch.Tensor)Confianza de la clase con mayor puntuación.
top5confPropiedad (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.

OBB
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 detecciones

Aquí tienes una tabla con los métodos y propiedades de la clase OBB, incluidos sus nombres, tipos y descripciones:

NombreTipoDescripción
cpu()MétodoTraslada el objeto a la memoria de la CPU.
numpy()MétodoConvierte el objeto en una matriz NumPy.
cuda()MétodoTraslada el objeto a la memoria de CUDA.
to()MétodoTraslada el objeto al dispositivo especificado.
confPropiedad (torch.Tensor)Devuelve los valores de confianza de las cajas.
clsPropiedad (torch.Tensor)Devuelve los valores de clase de las cajas.
idPropiedad (torch.Tensor)Devuelve los ID de seguimiento de las cajas (si están disponibles).
xyxyPropiedad (torch.Tensor)Devuelve las cajas horizontales en formato xyxy.
xywhrPropiedad (torch.Tensor)Devuelve las cajas giradas en formato xywhr.
xyxyxyxyPropiedad (torch.Tensor)Devuelve las cajas giradas en formato xyxyxyxy.
xyxyxyxynPropiedad (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.

Representación
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:

ArgumentoTipoDescripciónPredeterminado
confboolIncluye las puntuaciones de confianza de las detecciones.True
line_widthfloatGrosor de línea de las cajas delimitadoras. Se escala con el tamaño de la imagen si None.None
font_sizefloatTamaño de fuente del texto. Se escala con el tamaño de la imagen si None.None
fontstrNombre de la fuente para las anotaciones de texto.'Arial.ttf'
pilboolDevuelve la imagen como un objeto PIL Image.False
imgnp.ndarray | torch.TensorImagen alternativa. Los tensores deben ser contiguos y tener el formato HWC BGR uint8.None
kpt_radiusintRadio de los puntos clave dibujados.5
kpt_lineboolConecta los puntos clave con líneas.True
labelsboolIncluye las etiquetas de clase en las anotaciones.True
boxesboolSuperpone las cajas delimitadoras en la imagen.True
masksboolSuperpone las máscaras en la imagen.True
probsboolIncluye las probabilidades de clasificación.True
showboolMuestra directamente la imagen anotada con el visor de imágenes predeterminado.False
saveboolGuarda la imagen anotada en el archivo especificado por filename.False
filenamestrRuta y nombre del archivo en el que se guardará la imagen anotada si save es True.None
color_modestrEspecifica el modo de color, por ejemplo, 'instance' o 'class'.'class'
txt_colortuple[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:

Inferencia segura para subprocesos

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).

Bucle for de transmisión
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=True en el método de llamada del predictor. El modo de transmisión genera un generador de objetos Results que 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, como conf, 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 pasa embed=[layer_index] a model.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.Tensor
  • Tras realizar inferencias con YOLO, los objetos Results contienen métodos para mostrar y guardar imágenes anotadas. Puedes usar métodos como result.show() y result.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.

  1. TigoresGitHub

    你好,我想问一下为什么我在推理相同的图像时,设置不同的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
    1. Glenn JocherUltralytics

      @Tigores 您好!YOLO模型在推理时会自动将输入图像缩放到您指定的imgsz参数值(而非固定为训练尺寸),更大的分辨率能保留更多细节从而提升小目标检测能力。具体原理可参考Predict模式文档中的图像尺寸与精度关系说明,这是预期行为而非异常现象。

  2. LwpZoeGitHub

    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
    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 with boxes=False and masks=True to only display the segmentation masks. Alternatively, you can directly access result.masks.data for raw mask data and process it as needed. Refer to the Results section for more details.

    2. LwpZoeGitHub

      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?

    3. Glenn JocherUltralytics

      To display only the segmentation mask without overlays, modify the plot() function parameters by setting boxes=False, labels=False, and ensuring masks=True. You don't need retraining to adjust visualization settings, as the weights remain unaffected. For further details, refer to the Results.plot() documentation.

  3. User

    Hello, 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
    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=True argument in your model.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.

    2. 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=True argument in your model.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.

  4. Johanna-JonesGitHub

    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!

    1
    1. Johanna-JonesGitHub

      For clarification my pipeline is currently train> valid with val parameter set to false. I then pass one image at a time to the Yolov8 model in the PREDICT mode

    2. Paula DerrengerUltralytics

      Hey there!

      For evaluating your model with metrics like mAP, precision, and IOU on your test images, you should use the Val mode rather than the Predict mode. The Val mode 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! 🚀

  5. GUPABE10GitHub

    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
    1. Glenn JocherUltralytics

      To disable printing inference results after running predictions, you can use the verbose=False argument in your predict() 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. 😊

    2. GUPABE10GitHub

      Is it the same if I use:

      results = model('path/to/your/image.jpg')

      just as mentioned in the example in this tutorial.

    3. 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 of Results objects.

      If you want to avoid printing the detailed inference results (like the number of detected objects and processing times), you can use the verbose=False argument:

      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! 😊

    4. Glenn JocherUltralytics

      Hi there!

      Great question! The difference between model.predict() and model() lies in their usage and flexibility:

      1. 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)
      2. 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")

      Both methods will return a list of Results objects, 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! 😊

    1. Glenn JocherUltralytics

      Yes—vid_stride (frame skipping) and imgsz (inference resize) are independent, so you can use them together on video sources; imgsz will 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=640
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      for r in model.predict("video.mp4", vid_stride=2, imgsz=640, stream=True):
          pass
      1
    2. amani784GitHub

      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.

    3. Glenn JocherUltralytics

      Yes—if you don’t pass imgsz to predict(), it uses the default imgsz=640 and 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 larger imgsz for 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=True
      from 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 imgsz strategy for your case.

      1
    4. amani784GitHub

      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?

    5. Glenn JocherUltralytics

      Yes—TensorRT doesn’t have to be fixed-shape: export your .engine with dynamic=True so the runtime can accept varying input shapes (you can then choose imgsz per run/video), see the Export mode docs and the TensorRT integration guide.

      yolo export model=yolo26n.pt format=engine dynamic=True

      If you need peak throughput and your resolutions vary a lot, the usual workaround is exporting 2–3 fixed engines at common imgsz values and selecting the closest one at runtime.

      1
  6. Asshok1GitHub

    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.

    1. Glenn JocherUltralytics

      SAHI’s built-in Ultralytics integration (model_type="ultralytics") currently expects PyTorch weights like *.pt, so a TensorRT *.engine file won’t load through SAHI as-is; the supported path is to use SAHI with *.pt per 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 SAHI DetectionModel adapter 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)
  7. hanchaoyuanGitHub

    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?

    1. Glenn JocherUltralytics

      For workshop false positives with pose models, the quickest lever is raising the prediction threshold (and optionally increasing imgsz for 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=960

      If 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).

  8. d5423197GitHub

    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.

  9. max-dev-14GitHub

    How to predict and show or save prediction YOLO (custom model) for video fragment?