Predicción de modelos con Ultralytics YOLO#

Introducción#

En el mundo del machine learning y la computer vision, el proceso de dar sentido a los datos visuales suele denominarse inferencia o predicción. Ultralytics YOLO26 ofrece una potente función conocida como predict mode, adaptada para ofrecer inferencia en tiempo real y de alto rendimiento en una amplia gama de fuentes de datos.

Aplicaciones en el mundo real#

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

Aquí tienes por qué deberías considerar el modo de predicción de YOLO26 para tus diversas necesidades de inferencia:

• Versatilidad: Capaz de realizar inferencias en imágenes, vídeos e incluso transmisiones en vivo.
• Performance: Diseñado para un procesamiento a alta velocidad y en tiempo real sin sacrificar la accuracy.
• Facilidad de uso: Interfaces intuitivas de Python y CLI para un despliegue y pruebas rápidas.
• Altamente personalizable: Diversos ajustes y parámetros para adaptar el comportamiento de inferencia del modelo según tus requisitos específicos.
• Production Ready: Despliega modelos como Ultralytics Platform inference endpoints con autoescalado y monitorización, o ejecuta la inferencia localmente.

Características clave del modo de predicción#

El modo de predicción de YOLO26 está diseñado para ser robusto y versátil, incluyendo:

• Compatibilidad con múltiples fuentes de datos: Ya sea que tus datos tengan forma de imágenes individuales, una colección de imágenes, archivos de vídeo o transmisiones de vídeo en tiempo real, el modo de predicción te cubre.
• Streaming Mode: Utiliza la función de transmisión para generar un generador eficiente en memoria de objetos Results. Habilita esta opción configurando 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 múltiples imágenes o fotogramas de vídeo en un solo lote, lo que reduce aún más el tiempo total de inferencia.
• Fácil integración: Integra fácilmente con pipelines de datos existentes y otros componentes de software, gracias a su API flexible.

Los modelos de 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 diferentes tipos de fuentes de entrada para la inferencia, como se muestra en la siguiente tabla. Las fuentes incluyen imágenes estáticas, secuencias de vídeo y varios formatos de datos. La tabla también indica si cada fuente se puede utilizar en streaming mode con el argumento stream=True ✅. El streaming mode es beneficioso para procesar vídeos o transmisiones en directo, ya que crea un generador de resultados en lugar de cargar todos los fotogramas en la memoria.

A continuación, tienes 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 múltiples argumentos que se pueden pasar en el momento de la inferencia para anular los valores predeterminados:

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

Por defecto, predict utiliza rect=True, lo que habilita el relleno de rectángulo mínimo cuando es posible. La imagen se escala para encajar dentro de imgsz y se rellena solo hasta el múltiplo de paso (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, o un ONNX / Triton dinámico). De lo contrario, las imágenes se rellenan hasta el destino completo de imgsz.

Usa rect=False para rellenar siempre hasta el destino completo de imgsz. Esto se recomienda cuando necesitas un tamaño de entrada fijo para 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 del paso (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/exportación

El entrenamiento solo acepta un único entero imgsz (una lista [h, w] se fuerza al valor más grande). La predicción y la exportación aceptan tanto un entero como 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, 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 formatos de imagen Ultralytics válidos.

Vídeos#

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

Trabajar con resultados#

Todas las llamadas a predict() de Ultralytics devolverán 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#

Los campos que se rellenan a continuación dependen 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, confianza y 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 (dtypes) 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 y práctico para los ID de clase: torch.uint8, torch.int16 o torch.int32, dependiendo del recuento de clases.

Los objetos Results tienen los siguientes métodos:

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

Cajas (Boxes)#

El objeto Boxes se puede utilizar para indexar, manipular y convertir cajas delimitadoras a diferentes 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

Aquí tienes una tabla con los métodos y propiedades de la clase Boxes, incluyendo su nombre, tipo y descripción:

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

Máscaras#

El objeto Masks se puede utilizar 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

Aquí tienes una tabla con los métodos y propiedades de la clase Masks, incluyendo su nombre, tipo y descripción:

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

SemanticMask#

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 y no proporciona funciones auxiliares 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 utilizar 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

Aquí tienes una tabla con los métodos y propiedades de la clase Keypoints, incluyendo su nombre, tipo y descripción:

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

Probs#

El objeto Probs se puede utilizar para obtener índices y puntuaciones de clasificación de 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

He aquí una tabla que resume los métodos y propiedades de la clase Probs:

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

OBB#

El objeto OBB se puede utilizar para indexar, manipular y convertir cajas delimitadoras orientadas (OBB) a diferentes 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

Aquí tienes una tabla con los métodos y propiedades de la clase OBB, incluyendo su nombre, tipo y descripción:

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

Visualización de resultados#

El método plot() en los objetos Results facilita la visualización de las predicciones superponiendo los objetos detectados (como cajas delimitadoras, máscaras, puntos clave y probabilidades) en la imagen original. Este método devuelve la imagen anotada como una matriz de NumPy, lo que permite visualizarla 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:

Inferencia segura para subprocesos#

Garantizar la seguridad de los hilos durante la inferencia es crucial cuando ejecutas múltiples modelos YOLO en paralelo a través de diferentes hilos. La inferencia segura para hilos garantiza que las predicciones de cada hilo estén aisladas y no interfieran entre sí, evitando condiciones de carrera y asegurando resultados consistentes y fiables.

Al usar modelos YOLO en una aplicación multihilo, es importante instanciar objetos de modelo separados para cada hilo o emplear 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 obtener una visión detallada de la inferencia segura para subprocesos (thread-safe) con modelos YOLO e instrucciones paso a paso, consulta nuestra YOLO Thread-Safe Inference Guide. Esta guía te proporcionará toda la información necesaria para evitar errores comunes y garantizar que tu inferencia multihilo se ejecute sin problemas.

Bucle de origen de streaming for#

Aquí tienes un script de Python que utiliza OpenCV (cv2) y YOLO para ejecutar la inferencia en fotogramas de vídeo. Este script asume 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 frame del video, visualizará los resultados y los mostrará en una ventana. Puedes salir del bucle presionando 'q'.

Qué sigue#

¿Estás listo para dejar atrás un modelo preentrenado? Confirma que tu tarea se ajusta a tu problema, formatea tus propios datos con la Datasets guide y luego entrénate con ellos.

FAQ#