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 YOLOv8 ofrece una potente función conocida como modo de predicción, que está 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 YOLOv8 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 YOLOv8 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

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

• 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('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.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('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.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

YOLOv8 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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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

import torch
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.pt')

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

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

# Run inference on the source
results = model(source, 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 YOLOv8n model
model = YOLO('yolov8n.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

YOLOv8 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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n-seg Segment model
model = YOLO('yolov8n-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 YOLOv8n-pose Pose model
model = YOLO('yolov8n-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 YOLOv8n-cls Classify model
model = YOLO('yolov8n-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 YOLOv8n model
model = YOLO('yolov8n-obb.pt')

# Run inference on an image
results = model('bus.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 YOLOv8n model
model = YOLO('yolov8n.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 ultralytics import YOLO
from threading import Thread

def thread_safe_predict(image_path):
    """Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results


# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("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 YOLOv8 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 YOLOv8 model
model = YOLO('yolov8n.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 YOLOv8 inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 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".

Comentarios