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 y 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 en el mundo real

Fabricación	Deportes	Seguridad
Detección de recambios 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ías considerar el modo de predicción de YOLO11 para tus 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 en tiempo real a alta velocidad sin sacrificar la precisión.
• Facilidad de uso: interfaces intuitivas Python y CLI para una rápida implantación y pruebas.
• Altamente personalizable: Varios ajustes y parámetros para ajustar el comportamiento de inferencia del modelo según tus requisitos específicos.

Características principales del modo Predecir

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

• Compatibilidad con múltiples fuentes de datos: Tanto si tus datos están en forma de imágenes individuales, una colección de imágenes, archivos de vídeo o flujos de vídeo en tiempo real, el modo Predecir te tiene cubierto.
• Modo Streaming: Utiliza la función de streaming para generar un generador de memoria eficiente de Results objetos. Actívalo configurando stream=True en el método de llamada del predictor.
• Procesamiento por lotes: La capacidad de 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 de integrar: se integra fácilmente con las canalizaciones 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 de memoria eficiente Python 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 encontrarás 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 por defecto:

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. Consulta 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 siguiente tabla contiene los formatos de vídeo válidos de Ultralytics .

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 detalles, consulta Results documentación de clase.

Cajas

Boxes puede utilizarse para indexar, manipular y convertir cuadros delimitadores a distintos 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

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

Para más detalles, consulta 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

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

Para más detalles, consulta 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

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

Para más detalles, consulta 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

Aquí tienes una tabla que resume los métodos y propiedades de la función Probs clase:

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

OBB

OBB puede utilizarse para indexar, manipular y convertir cuadros delimitadores orientados a distintos 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

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

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

Trazar 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 hilos

Garantizar la seguridad de los hilos durante la inferencia es crucial cuando ejecutas varios modelos YOLO en paralelo a través de distintos hilos. La inferencia a prueba de hilos garantiza que las predicciones de cada hilo estén aisladas y no interfieran entre sí, evitando condiciones de carrera y asegurando resultados coherentes y fiables.

Cuando utilices modelos YOLO en una aplicación multihilo, es importante instanciar objetos modelo distintos 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 conocer en profundidad la inferencia a prueba de hilos con los modelos YOLO y las instrucciones paso a paso, consulta nuestra Guía de inferencia a prueba de hilosYOLO . Esta guía te proporcionará toda la información necesaria para evitar errores comunes y garantizar que tu inferencia multihilo se ejecute sin problemas.

Fuente de streaming for-bucle

Aquí tienes un script Python que utiliza OpenCV (cv2) y YOLO para ejecutar la inferencia sobre fotogramas de vídeo. Este script supone que ya tienes instalados 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 más detalles sobre sus funciones, consulta Ultralytics YOLO modo predicción.

¿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 flujos. Puedes especificar la fuente de datos en el campo model.predict() llamada. Por ejemplo, utiliza 'image.jpg' para una imagen local o 'https://ultralytics.com/images/bus.jpg' para una URL. Consulta los ejemplos detallados de 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 forma eficiente, puedes utilizar el modo streaming configurando stream=True en el método de llamada del predictor. El modo streaming genera un generador de memoria eficiente de Results en lugar de cargar todos los fotogramas en memoria. Para procesar vídeos largos o grandes conjuntos de datos, el modo streaming es especialmente útil. Más información modo streaming.

¿Qué argumentos de inferencia apoya Ultralytics YOLO ?

En model.predict() en YOLO admite varios argumentos, como conf, iou, imgsz, devicey más. Estos argumentos te 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. Puedes encontrar descripciones detalladas de estos argumentos en la página argumentos de inferencia sección.

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

Tras realizar la inferencia con YOLO, la Results contienen métodos para mostrar y guardar imágenes anotadas. Puedes 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, consulta la página trabajar con resultados sección.

📅 C reado hace 1 año ✏️ Actualizado hace 26 días

Comentarios