Predicción de modelos con Ultralytics YOLO#

Introducción#

En el mundo del aprendizaje automático y la visión por computador, el proceso de interpretar datos visuales suele denominarse inferencia o predicción. Ultralytics YOLO26 ofrece una potente función conocida como modo predict, diseñada para realizar inferencias de alto rendimiento y en tiempo real en una amplia variedad de fuentes de datos.

Consulta la vista previa no publicada de YOLO27 para ver ejemplos de inferencia planeados.

Aplicaciones del mundo real#

¿Por qué usar Ultralytics YOLO para la inferencia?#

Estas son las razones por las que deberías considerar el modo predict de YOLO26 para tus distintas necesidades de inferencia:

• Versatilidad: Capaz de realizar inferencias en imágenes, vídeos e incluso retransmisiones en directo.
• Rendimiento: Diseñado para un procesamiento de alta velocidad en tiempo real sin sacrificar la precisión.
• Facilidad de uso: Interfaces intuitivas de Python y CLI para una implementación y unas pruebas rápidas.
• 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 endpoints de inferencia de Ultralytics Platform con escalado automático y supervisión, o ejecuta la inferencia localmente.

Funciones clave del modo predict#

El modo predict de YOLO26 está diseñado para ser robusto y versátil, e incluye:

• Compatibilidad con múltiples fuentes de datos: Tanto si tus datos tienen la forma de imágenes individuales, una colección de imágenes, archivos de vídeo o retransmisiones de vídeo en tiempo real, el modo predict se adapta a tus necesidades.
• Modo de streaming: Usa la función de streaming para generar un generador eficiente en memoria de objetos Results. 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 de uno en uno, lo que resulta especialmente útil para vídeos largos y retransmisiones en directo.
• Procesamiento por lotes: Procesa varias imágenes o fotogramas de vídeo en un solo lote, reduciendo aún más el tiempo total de inferencia.
• Fácil integración: Intégralo fácilmente con canalizaciones de datos existentes y otros componentes de software gracias a su API flexible.

Los modelos Ultralytics YOLO devuelven una lista de Python de objetos Results o un generador eficiente en memoria de objetos Results cuando se pasa stream=True al modelo durante la inferencia:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # pretrained YOLO26n model

# Run batched inference on a list of images
results = model(["image1.jpg", "image2.jpg"])  # return a list of Results objects

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

Fuentes de inferencia#

YOLO26 puede procesar distintos tipos de fuentes de entrada para la inferencia, como se muestra en la tabla siguiente. Las fuentes incluyen imágenes estáticas, retransmisiones de vídeo y varios formatos de datos. La tabla también indica si cada fuente puede utilizarse en modo de streaming con el argumento stream=True ✅. El modo de streaming resulta útil para procesar vídeos o retransmisiones en directo, ya que crea un generador de resultados en lugar de cargar todos los fotogramas en memoria.

A continuación se muestran ejemplos de código para utilizar cada tipo de fuente:

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Define path to the image file
source = "path/to/image.jpg"

# Run inference on the source
results = model(source)  # list of Results objects

Argumentos de inferencia#

model.predict() acepta varios argumentos que pueden pasarse durante la inferencia para anular los valores predeterminados:

Forma fija frente a rectángulo mínimo (rect)#

De forma predeterminada, predict usa rect=True, que activa el relleno de rectángulo mínimo cuando es posible. La imagen se escala para ajustarse 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 utiliza cuando todas las imágenes del lote tienen la misma forma y el backend lo admite (PyTorch .pt, u ONNX / Triton dinámico). De lo contrario, las imágenes se rellenan hasta el objetivo completo imgsz.

Usa rect=False para rellenar siempre hasta el objetivo imgsz completo. Se recomienda cuando necesitas un tamaño de entrada fijo que coincida con los modelos exportados (ONNX, TensorRT, etc.).

Entero frente a tupla imgsz

• Un entero imgsz=640 se convierte en un objetivo cuadrado (640, 640) después del redondeo al stride.
• Una tupla imgsz=(384, 672) establece un objetivo rectangular. Con rect=True y auto=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 al valor más grande). Predict y export aceptan un entero o una tupla (height, width).

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on 'bus.jpg' with arguments
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)

Argumentos de inferencia:

Argumentos de visualización:

Formatos de imagen y vídeo#

YOLO26 admite varios formatos de imagen y vídeo, tal como se especifica en ultralytics/data/utils.py. Consulta las tablas siguientes para ver los sufijos válidos y ejemplos de comandos de predicción.

Imágenes#

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

Vídeos#

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

Trabajo con resultados#

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

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # batch inference

Los objetos Results tienen los siguientes atributos:

Resultados por tarea#

Qué campos de los siguientes se rellenan depende de la tarea de tu 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 están siempre disponibles, mientras que los datos de predicción específicos de la 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 a menos que se use media precisión, en cuyo caso son torch.float16. Después de result.numpy(), los tensores se convierten en matrices de NumPy con los tipos de datos de NumPy correspondientes. Las máscaras de instancia son tensores binarios torch.uint8, mientras que las máscaras semánticas utilizan el tipo de datos entero más pequeño posible para los ID de clase: torch.uint8, torch.int16 o torch.int32, según el recuento de clases.

Los objetos Results tienen los siguientes métodos:

Para obtener más información, consulta la documentación de la clase Results.

Cuadros#

El objeto Boxes se puede usar para indexar, manipular y convertir BBox a distintos formatos.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.boxes)  # print the Boxes object containing the detection bounding boxes

Esta es una tabla con los métodos y las propiedades de la clase Boxes, incluidos su nombre, tipo y descripción:

Para obtener más información, consulta la documentación de la clase Boxes.

Máscaras#

El objeto Masks se puede usar para indexar, manipular y convertir máscaras en segmentos.

from ultralytics import YOLO

# Load a pretrained YOLO26n-seg Segment model
model = YOLO("yolo26n-seg.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.masks)  # print the Masks object containing the detected instance masks

Esta es una tabla con los métodos y las propiedades de la clase Masks, incluidos su nombre, tipo y descripción:

Para obtener más información, consulta la documentación de la clase Masks.

SemanticMask#

SemanticMask almacena un único 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 utilidades para polígonos.

from ultralytics import YOLO

# Load a pretrained YOLO26n-sem Semantic model
model = YOLO("yolo26n-sem.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.semantic_mask.data)  # print the H x W class-ID map

Puntos clave#

El objeto Keypoints se puede usar para indexar, manipular y normalizar coordenadas.

from ultralytics import YOLO

# Load a pretrained YOLO26n-pose Pose model
model = YOLO("yolo26n-pose.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.keypoints)  # print the Keypoints object containing the detected keypoints

Esta es una tabla con los métodos y las propiedades de la clase Keypoints, incluidos su nombre, tipo y descripción:

Para obtener más información, consulta la documentación de la clase Keypoints.

Probs#

El objeto Probs se puede usar para obtener los índices y las puntuaciones de clasificación top1 y top5.

from ultralytics import YOLO

# Load a pretrained YOLO26n-cls Classify model
model = YOLO("yolo26n-cls.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.probs)  # print the Probs object containing the detected class probabilities

Esta es una tabla que resume los métodos y las propiedades de la clase Probs:

Para obtener más información, consulta la documentación de la clase Probs.

OBB#

El objeto OBB se puede usar para indexar, manipular y convertir BBox orientados a distintos formatos.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n-obb.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/boats.jpg")  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

Esta es una tabla con los métodos y las propiedades de la clase OBB, incluidos su nombre, tipo y descripción:

Para obtener más información, consulta la documentación de la clase OBB.

Resultados de trazado#

El método plot() de los objetos Results facilita la visualización de las predicciones al superponer los objetos detectados (como BBox, máscaras, puntos clave y probabilidades) sobre la imagen original. Este método devuelve la imagen anotada como una matriz de NumPy, lo que facilita su visualización o guardado.

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 la salida:

Inferencia segura para subprocesos#

Garantizar la seguridad de los hilos durante la inferencia es crucial cuando ejecutas 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 multihilo, es importante instanciar objetos de modelo independientes para cada hilo o utilizar almacenamiento local de hilos para evitar conflictos:

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)
    # Process results

# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()

Para consultar en profundidad la inferencia segura para hilos con modelos YOLO y obtener instrucciones paso a paso, consulta nuestra Guía de inferencia segura para hilos con YOLO. Esta guía te proporcionará toda la información necesaria para evitar errores habituales y garantizar que la inferencia multihilo se ejecute sin problemas.

Bucle for de la fuente de streaming#

Este es un script de Python que utiliza OpenCV (cv2) y YOLO para ejecutar 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

# Load the YOLO model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO Inference", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Este script ejecutará predicciones en cada fotograma del vídeo, visualizará los resultados y los mostrará en una ventana. Puedes salir del bucle pulsando «q».

¿Y ahora qué?#

¿Listo para ir más allá 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#