Modelo de predicción con Ultralytics YOLO

Introducción

En el mundo del aprendizaje automático y la visión por ordenador, 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 de predicción, diseñada para realizar inferencias de alto rendimiento en tiempo real sobre una amplia gama de fuentes de datos.

Observa: Cómo extraer los resultados del modelo Ultralytics YOLO para proyectos personalizados.

Aplicaciones reales

Fabricación	Deportes	Seguridad
Detección de piezas de recambio 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 de predicción de YOLO11 para sus diversas necesidades de inferencia:

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

Características principales del modo Predecir

YOLO11está diseñado para ser robusto y versátil:

• Compatibilidad con múltiples fuentes de datos: Si sus datos están en forma de imágenes individuales, una colección de imágenes, archivos de vídeo o secuencias de vídeo en tiempo real, el modo predictivo lo tiene cubierto.
• Modo streaming: Utilice la función de streaming para generar un generador de memoria eficiente de Results objetos. Habilítelo configurando stream=True en el método de llamada del predictor.
• Procesamiento por lotes: Capacidad para procesar varias imágenes o fotogramas de vídeo en un solo lote, lo que acelera aún más el tiempo de inferencia.
• Fácil integración: se integra fácilmente con los canales de datos existentes y otros componentes de software, gracias a su flexible API.

Ultralytics YOLO devuelven una lista Python de Results o un generador de objetos Python de memoria eficiente. 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 distintos tipos de fuentes de entrada para la inferencia, como se muestra en la tabla siguiente. Las fuentes incluyen imágenes estáticas, secuencias de vídeo y diversos formatos de datos. La tabla también indica si cada fuente puede utilizarse en modo streaming con el argumento stream=True ✅. El modo Streaming 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 se muestran ejemplos de código para utilizar 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 pueden pasarse en el momento de la 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("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 predict de ejemplo.

Imágenes

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

Vídeos

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

Trabajar con resultados

Todos Ultralytics predict() devolverá 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("bus.jpg")  # list of 1 Results object
results = model(["bus.jpg", "zidane.jpg"])  # list of 2 Results objects

Results tienen los siguientes atributos:

Results tienen los siguientes métodos:

Para más información, consulte el Results documentación de clase.

Cajas

Boxes puede utilizarse para indexar, manipular y convertir cuadros delimitadores a diferentes formatos.

from ultralytics import YOLO

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

# Run inference on an image
results = model("bus.jpg")  # results list

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

He aquí una tabla para el Boxes métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

Para más información, consulte el Boxes documentación de clase.

Máscaras

Masks 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("bus.jpg")  # results list

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

He aquí una tabla para el Masks métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

Para más información, consulte el Masks documentación de clase.

Puntos clave

Keypoints 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("bus.jpg")  # results list

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

He aquí una tabla para el Keypoints métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

Para más información, consulte el Keypoints documentación de clase.

Probs

Probs se puede utilizar 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("bus.jpg")  # results list

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

A continuación se muestra una tabla que resume los métodos y propiedades de la función Probs clase:

Para más información, consulte el Probs documentación de clase.

OBB

OBB puede utilizarse para indexar, manipular y convertir cuadros delimitadores orientados a diferentes formatos.

from ultralytics import YOLO

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

# Run inference on an image
results = model("boats.jpg")  # results list

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

He aquí una tabla para el OBB métodos y propiedades de la clase, incluyendo su nombre, tipo y descripción:

Para más información, consulte el OBB documentación de clase.

Trazado de resultados

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

En plot() admite varios argumentos para personalizar la salida:

Inferencia segura de subprocesos

Garantizar la seguridad de los subprocesos durante la inferencia es crucial cuando se ejecutan varios modelos de YOLO en paralelo en distintos subprocesos. La inferencia segura de subprocesos garantiza que las predicciones de cada subproceso estén aisladas y no interfieran entre sí, evitando condiciones de carrera y asegurando resultados coherentes y fiables.

Cuando se utilizan 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=("yolo11n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo11n.pt", "image2.jpg")).start()

Para obtener información detallada sobre la inferencia segura con hilos con los modelos de YOLO e instrucciones paso a paso, consulte nuestra Guía de inferencia segura con hilosYOLO . Esta guía le proporcionará toda la información necesaria para evitar errores comunes y asegurarse de que su inferencia multihilo se ejecuta sin problemas.

Fuente de streaming for-bucle

He aquí un script Python que utiliza OpenCV (cv2) y YOLO para ejecutar la inferencia sobre fotogramas de vídeo. Este script asume que usted 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 de predicción para la inferencia en tiempo real?

Ultralytics YOLO es un modelo de vanguardia para la detección, segmentación y clasificación de objetos en tiempo real. Su modo de predicción permite a los usuarios realizar inferencias a alta velocidad en diversas fuentes de datos, como imágenes, vídeos y secuencias en directo. Diseñado para ofrecer rendimiento y versatilidad, también ofrece modos de procesamiento por lotes y streaming. Para obtener más información sobre sus funciones, consulte Ultralytics YOLO predict mode.

¿Cómo puedo realizar inferencias utilizando 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 el campo model.predict() llamada. Por ejemplo, utilice 'image.jpg' para una imagen local o 'https://ultralytics.com/images/bus.jpg' para una URL. Consulte los ejemplos detallados de varios fuentes de inferencia en la documentación.

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

Para optimizar la velocidad de inferencia y gestionar la memoria de forma eficiente, puede utilizar el modo streaming configurando stream=True en el método de llamada del predictor. El modo streaming genera un generador de Results en lugar de cargar todos los fotogramas en la memoria. Para procesar vídeos largos o grandes conjuntos de datos, el modo streaming resulta especialmente útil. Más información modo streaming.

¿Qué argumentos de inferencia apoya Ultralytics YOLO ?

En model.predict() de YOLO admite varios argumentos, como conf, iou, imgsz, deviceetc. 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. Encontrará descripciones detalladas de estos argumentos en la sección argumentos de inferencia sección.

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

Tras realizar la inferencia con YOLO, el Results 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 página trabajar con resultados sección.

Creado hace 1 año ✏️ Actualizado hace 1 mes

Comentarios