Predicción de modelos con Ultralytics YOLO

Introducción

En el mundo del aprendizaje automático y la visión artificial, el proceso de dar sentido a los datos visuales se denomina 'inferencia' o 'predicción'. Ultralytics YOLO11 ofrece una potente función conocida como modo predict que está diseñada para la inferencia en tiempo real y de alto rendimiento en una amplia gama de fuentes de datos.

Ver: Cómo extraer las salidas del modelo Ultralytics YOLO para proyectos personalizados.

Aplicaciones en el mundo real

Fabricación	Deportes	Seguridad
Detección de repuestos de vehículos	Detección de jugadores de fútbol	Detección de caídas de personas

¿Por qué utilizar Ultralytics YOLO para la inferencia?

He aquí por qué debería considerar el modo predict de YOLO11 para sus diversas necesidades de inferencia:

• Versatilidad: Capaz de realizar inferencias sobre imágenes, vídeos e incluso transmisiones en directo.
• Rendimiento: Diseñado para el procesamiento en tiempo real y de alta velocidad sin sacrificar la precisión.
• Facilidad de uso: Interfaces intuitivas de python y CLI para una rápida implementación y pruebas.
• Altamente personalizable: Varios ajustes y parámetros para optimizar el comportamiento de la inferencia del modelo según sus requisitos específicos.

Características principales del modo Predict

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

• Compatibilidad con múltiples fuentes de datos: Ya sea que sus datos estén en forma de imágenes individuales, una colección de imágenes, archivos de video o transmisiones de video en tiempo real, el modo de predicción lo tiene cubierto.
• Modo de transmisión: Utilice la función de transmisión para generar un generador de objetos eficiente en cuanto a la memoria Results objetos. Habilite esto configurando stream=True en el método de llamada del predictor.
• Procesamiento por lotes: La capacidad de procesar múltiples imágenes o fotogramas de video en un solo lote, lo que acelera aún más el tiempo de inferencia.
• Fácil de integrar: Se integra fácilmente con los flujos de datos existentes y otros componentes de software, gracias a su API flexible.

Los modelos YOLO de Ultralytics devuelven una lista de python de Results objetos, o un generador de python de bajo consumo de memoria de Results objetos cuando stream=True se pasa al modelo durante la inferencia:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # pretrained YOLO11n 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

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # pretrained YOLO11n model

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

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

YOLO11 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, transmisiones de video y varios formatos de datos. La tabla también indica si cada fuente se puede utilizar en el modo de transmisión con el argumento stream=True ✅. El modo de transmisión es beneficioso para procesar videos o transmisiones en vivo, ya que crea un generador de resultados en lugar de cargar todos los fotogramas en la memoria.

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

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

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define current screenshot as source
source = "screen"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define remote image or video URL
source = "https://ultralytics.com/images/bus.jpg"

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

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Open an image using PIL
source = Image.open("path/to/image.jpg")

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

import cv2

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Read an image using OpenCV
source = cv2.imread("path/to/image.jpg")

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

import numpy as np

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random numpy array of HWC shape (640, 640, 3) with values in range [0, 255] and type uint8
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype="uint8")

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

import torch

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a path to a CSV file with images, URLs, videos and directories
source = "path/to/file.csv"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to video file
source = "path/to/video.mp4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to directory containing images and videos for inference
source = "path/to/dir"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a glob search for all JPG files in a directory
source = "path/to/dir/*.jpg"

# OR define a recursive glob search for all JPG files including subdirectories
source = "path/to/dir/**/*.jpg"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define source as YouTube video URL
source = "https://youtu.be/LNwODJXcvt4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Single stream with batch-size 1 inference
source = "rtsp://example.com/media.mp4"  # RTSP, RTMP, TCP, or IP streaming address

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Multiple streams with batched inference (e.g., batch-size 8 for 8 streams)
source = "path/to/list.streams"  # *.streams text file with one streaming address per line

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

rtsp://example.com/media1.mp4
rtsp://example.com/media2.mp4
rtmp://example2.com/live
tcp://192.168.1.100:554
...

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on the source
results = model(source=0, stream=True)  # generator of Results objects

Argumentos de inferencia

model.predict() acepta múltiples argumentos que se pueden pasar en tiempo de inferencia para anular los valores predeterminados:

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

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

Argumentos de inferencia:

Argumentos de visualización:

Formatos de imagen y vídeo

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

Imágenes

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

Vídeos

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

Trabajar con resultados

Todos los Ultralytics predict() las llamadas devolverán una lista de Results objetos:

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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

Results los objetos tienen los siguientes atributos:

Results Los objetos tienen los siguientes métodos:

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

Cajas delimitadoras

Boxes El objeto puede utilizarse para indexar, manipular y convertir bounding boxes a diferentes formatos.

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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í hay una tabla para los Boxes métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

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

Máscaras

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

from ultralytics import YOLO

# Load a pretrained YOLO11n-seg Segment model
model = YOLO("yolo11n-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í hay una tabla para los Masks métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

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

Puntos clave

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

from ultralytics import YOLO

# Load a pretrained YOLO11n-pose Pose model
model = YOLO("yolo11n-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í hay una tabla para los Keypoints métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

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

Probabilidades

Probs El objeto se puede utilizar para indexar, obtener top1 y top5 índices y puntuaciones de clasificación.

from ultralytics import YOLO

# Load a pretrained YOLO11n-cls Classify model
model = YOLO("yolo11n-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

Aquí tienes una tabla que resume los métodos y propiedades para el Probs clase:

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

OBB

OBB El objeto se puede utilizar para indexar, manipular y convertir cajas delimitadoras orientadas a diferentes formatos.

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n-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í hay una tabla para los OBB métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

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

Graficar resultados

El plot() método en Results objetos 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 un array de NumPy, lo que permite mostrarla o guardarla fácilmente.

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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")

plot() Parámetros del método

El plot() El método admite varios argumentos para personalizar la salida:

Inferencia segura para subprocesos

Garantizar la seguridad de los hilos durante la inferencia es crucial cuando se ejecutan 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 salidas consistentes y confiables.

Cuando se utilizan modelos YOLO en una aplicación multi-hilo, es importante instanciar objetos de modelo separados para cada hilo o emplear almacenamiento local de hilos para prevenir 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=("yolo11n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo11n.pt", "image2.jpg")).start()

Para una visión en profundidad de la inferencia segura para hilos con modelos YOLO e instrucciones paso a paso, por favor, consulte nuestra Guía de Inferencia Segura para Hilos YOLO. Esta guía le proporcionará toda la información necesaria para evitar errores comunes y asegurar que su inferencia multi-hilo se ejecute sin problemas.

Fuente de Streaming for-loop

Aquí hay un script de python usando OpenCV (cv2) y YOLO para ejecutar la inferencia en los fotogramas de vídeo. Este script asume que ya ha instalado los paquetes necesarios (opencv-python y ultralytics).

import cv2

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo11n.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. Se puede salir del bucle pulsando 'q'.

Preguntas frecuentes

¿Qué es Ultralytics YOLO y su modo predict para la inferencia en tiempo real?

Ultralytics YOLO es un modelo de última generación para la detección de objetos, la segmentación y la clasificación en tiempo real. Su modo predict permite a los usuarios realizar inferencias de alta velocidad en varias fuentes de datos, como imágenes, vídeos y transmisiones en vivo. Diseñado para el rendimiento y la versatilidad, también ofrece procesamiento por lotes y modos de transmisión. Para obtener más detalles sobre sus características, consulte el modo predict de Ultralytics YOLO.

¿Cómo puedo ejecutar la inferencia usando Ultralytics YOLO en diferentes fuentes de datos?

Ultralytics YOLO puede procesar una amplia gama de fuentes de datos, incluyendo imágenes individuales, vídeos, directorios, URLs y streams. Puede especificar la fuente de datos en la model.predict() llamada. Por ejemplo, use 'image.jpg' para una imagen local o 'https://ultralytics.com/images/bus.jpg' para una URL. Consulte los ejemplos detallados para varios fuentes de inferencia en la documentación.

¿Cómo optimizo la velocidad de inferencia y el uso de memoria de YOLO?

Para optimizar la velocidad de inferencia y gestionar la memoria de manera eficiente, puede utilizar el modo de transmisión configurando stream=True en el método de llamada del predictor. El modo de transmisión genera un generador de objetos con uso eficiente de la memoria en lugar de cargar todos los fotogramas en la memoria. Para procesar videos largos o grandes conjuntos de datos, el modo de transmisión es particularmente útil. Obtenga más información sobre el Results objetos en lugar de cargar todos los fotogramas en la memoria. Para procesar videos largos o grandes conjuntos de datos, el modo de transmisión es particularmente útil. Obtenga más información sobre el modo de transmisión.

¿Qué argumentos de inferencia admite Ultralytics YOLO?

El model.predict() método en YOLO admite varios argumentos como conf, iou, imgsz, device, y más. Estos argumentos le permiten personalizar el proceso de inferencia, estableciendo parámetros como los umbrales de confianza, el tamaño de la imagen y el dispositivo utilizado para el cálculo. Puede encontrar descripciones detalladas de estos argumentos en los argumentos de inferencia sección.

¿Cómo puedo visualizar y guardar los resultados de las predicciones de YOLO?

Después de ejecutar la inferencia con YOLO, los Results objetos contienen métodos para mostrar y guardar imágenes anotadas. Puede utilizar métodos como result.show() y result.save(filename="result.jpg") para visualizar y guardar los resultados. Para obtener una lista completa de estos métodos, consulte la sección de trabajar con resultados sección.

📅 Creado hace 1 año ✏️ Actualizado hace 6 días

Comentarios