Predicción de modelos con Ultralytics YOLO#

Introducción#

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

Consulta la vista previa de YOLO27 aún no publicada para ver ejemplos de inferencia previstos.

Aplicaciones en el mundo real#

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

Estas son algunas razones para considerar el modo de predicción de YOLO26 para tus distintas necesidades de inferencia:

• Versatilidad: Puede ejecutar inferencias sobre imágenes, vídeos e incluso 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 de predicción de YOLO26 está diseñado para ser robusto y versátil, e incluye:

• Compatibilidad con varios tipos de fuentes de datos: Tanto si tus datos son imágenes individuales, un conjunto de imágenes, archivos de vídeo o transmisiones de vídeo en tiempo real, el modo de predicción te ofrece todo lo que necesitas.
• 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: Gracias a su API flexible, se integra fácilmente con las canalizaciones de datos existentes y otros componentes de software.

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

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

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 un 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). En caso contrario, las imágenes se rellenan hasta el objetivo imgsz completo.

Usa rect=False para rellenar siempre hasta el objetivo imgsz completo. Se recomienda esta opción cuando necesitas un tamaño de entrada fijo que coincida con el de 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).

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:

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 las extensiones válidas y ejemplos de comandos predict.

Imágenes#

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

Vídeos#

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

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 lotes

Los objetos Results tienen los siguientes atributos:

Resultados por tarea#

Los campos que se rellenan a continuación dependen de la tarea del modelo: compara la detección, la segmentación, la segmentación semántica, la estimación de profundidad, la clasificación, la 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 se use inferencia FP16 (quantize=16), en cuyo caso son torch.float16. Después de result.numpy(), los tensores se convierten en matrices NumPy con tipos de datos NumPy equivalentes. Las máscaras de instancia son tensores binarios torch.uint8, mientras que las máscaras semánticas usan el tipo de dato entero más pequeño que resulte práctico para los ID de clase: torch.uint8, torch.int16 o torch.int32, según el número de clases.

Los objetos Results tienen los siguientes métodos:

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

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

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 detectadas

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

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

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 detectados

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

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 detectadas

Aquí tienes 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 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 detecciones

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

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:

Inferencia segura para subprocesos#

Garantizar la seguridad de los subprocesos durante la inferencia es fundamental cuando ejecutas varios modelos YOLO en paralelo en distintos subprocesos. La inferencia segura para subprocesos garantiza que las predicciones de cada subproceso estén aisladas y no interfieran entre sí, evita las 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:

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

Para profundizar en la inferencia segura para subprocesos con modelos YOLO y consultar instrucciones paso a paso, visita nuestra guía de inferencia segura para subprocesos con YOLO. Esta guía te proporcionará toda la información necesaria para evitar errores habituales y garantizar que la inferencia con varios subprocesos se ejecute sin problemas.

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#