Previsione del modello con Ultralytics YOLO

Introduzione

Nel mondo dell'apprendimento automatico e della visione computerizzata, il processo di creazione di un senso dai dati visivi è chiamato "inferenza" o "predizione". Ultralytics YOLOv8 offre una potente funzione nota come modalità di predizione che è stata pensata per un'inferenza ad alte prestazioni e in tempo reale su un'ampia gamma di fonti di dati.

Guarda: Come estrarre gli output dal modello Ultralytics YOLOv8 per i progetti personalizzati.

Applicazioni del mondo reale

Produzione	Sport	Sicurezza
Rilevamento dei ricambi per veicoli	Rilevamento dei giocatori di calcio	Rilevamento delle cadute di persone

Perché utilizzare Ultralytics YOLO per l'inferenza?

Ecco perché dovresti prendere in considerazione la modalità di predizione di YOLOv8 per le tue esigenze di inferenza:

• Versatilità: È in grado di fare inferenze su immagini, video e persino flussi in diretta.
• Prestazioni: Progettato per un'elaborazione in tempo reale e ad alta velocità senza sacrificare la precisione.
• Facilità d'uso: interfacce intuitive di Python e CLI per un'implementazione e un test rapidi.
• Altamente personalizzabile: Diverse impostazioni e parametri per regolare il comportamento del modello di inferenza in base alle tue esigenze specifiche.

Caratteristiche principali della modalità Predict

YOLOv8La modalità di previsione è stata progettata per essere robusta e versatile:

• Compatibilità con più fonti di dati: Sia che i tuoi dati siano sotto forma di singole immagini, di una raccolta di immagini, di file video o di flussi video in tempo reale, la modalità di previsione ti soddisfa.
• Modalità di streaming: Utilizza la funzione di streaming per generare un generatore efficiente di memoria di Results oggetti. Abilita questa funzione impostando stream=True nel metodo di chiamata del predittore.
• Elaborazione batch: La possibilità di elaborare più immagini o fotogrammi video in un unico lotto, velocizzando ulteriormente i tempi di inferenza.
• Facile da integrare: si integra facilmente con le pipeline di dati esistenti e con altri componenti software, grazie alla sua API flessibile.

Ultralytics YOLO i modelli restituiscono un elenco Python di Results o un generatore di Python efficiente dal punto di vista della memoria di Results oggetti quando stream=True viene passato al modello durante l'inferenza:

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

Fonti di inferenza

YOLOv8 può elaborare diversi tipi di sorgenti di input per l'inferenza, come mostrato nella tabella seguente. Le fonti includono immagini statiche, flussi video e vari formati di dati. La tabella indica anche se ogni sorgente può essere utilizzata in modalità streaming con l'argomento stream=True ✅. La modalità Streaming è vantaggiosa per l'elaborazione di video o flussi live, in quanto crea un generatore di risultati invece di caricare tutti i fotogrammi in memoria.

Di seguito sono riportati esempi di codice per l'utilizzo di ciascun tipo di sorgente:

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

Argomenti di inferenza

model.predict() accetta più argomenti che possono essere passati al momento dell'inferenza per sovrascrivere i valori predefiniti:

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)

Argomenti di inferenza:

Argomenti di visualizzazione:

Formati immagine e video

YOLOv8 supporta diversi formati di immagini e video, come specificato in ultralytics/data/utils .py. Vedi le tabelle seguenti per i suffissi validi e gli esempi di comandi di previsione.

Immagini

La tabella seguente contiene i formati di immagine validi di Ultralytics .

Video

La tabella seguente contiene i formati video validi di Ultralytics .

Lavorare con i risultati

Tutti Ultralytics predict() restituirà un elenco di Results oggetti:

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 gli oggetti hanno i seguenti attributi:

Results gli oggetti hanno i seguenti metodi:

Per maggiori dettagli consulta la sezione Results documentazione della classe.

Scatole

Boxes può essere utilizzato per indicizzare, manipolare e convertire i rettangoli di selezione in diversi formati.

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

Ecco una tabella per il Boxes metodi e proprietà della classe, compresi il nome, il tipo e la descrizione:

Per maggiori dettagli consulta la sezione Boxes documentazione della classe.

Maschere

Masks può essere utilizzato per indicizzare, manipolare e convertire le maschere in segmenti.

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

Ecco una tabella per il Masks metodi e proprietà della classe, compresi il nome, il tipo e la descrizione:

Per maggiori dettagli consulta la sezione Masks documentazione della classe.

Punti chiave

Keypoints può essere utilizzato per indicizzare, manipolare e normalizzare le coordinate.

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

Ecco una tabella per il Keypoints metodi e proprietà della classe, compresi il nome, il tipo e la descrizione:

Per maggiori dettagli consulta la sezione Keypoints documentazione della classe.

Probi

Probs può essere utilizzato per indicizzare, ottenere top1 e top5 indici e punteggi di classificazione.

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

Ecco una tabella che riassume i metodi e le proprietà della classe Probs classe:

Per maggiori dettagli consulta la sezione Probs documentazione della classe.

OBB

OBB può essere utilizzato per indicizzare, manipolare e convertire i rettangoli di selezione orientati in diversi formati.

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

Ecco una tabella per il OBB metodi e proprietà della classe, compresi il nome, il tipo e la descrizione:

Per maggiori dettagli consulta la sezione OBB documentazione della classe.

Tracciare i risultati

Il plot() metodo in Results facilita la visualizzazione delle previsioni sovrapponendo gli oggetti rilevati (come bounding box, maschere, punti chiave e probabilità) all'immagine originale. Questo metodo restituisce l'immagine annotata come array NumPy, consentendo una facile visualizzazione o salvataggio.

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() Parametri del metodo

Il plot() supporta diversi argomenti per personalizzare l'output:

Inferenza thread-safe

Garantire la sicurezza dei thread durante l'inferenza è fondamentale quando si eseguono più modelli YOLO in parallelo su diversi thread. L'inferenza thread-safe garantisce che le previsioni di ciascun thread siano isolate e non interferiscano l'una con l'altra, evitando condizioni di gara e assicurando risultati coerenti e affidabili.

Quando si utilizzano i modelli di YOLO in un'applicazione multi-thread, è importante istanziare oggetti modello separati per ogni thread o utilizzare l'archiviazione thread-local per evitare conflitti:

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

Per un approfondimento sull'inferenza thread-safe con i modelli di YOLO e per le istruzioni passo-passo, consulta la nostra Guida all'inferenza thread-safe diYOLO . Questa guida ti fornirà tutte le informazioni necessarie per evitare le insidie più comuni e assicurarti che l'inferenza multi-thread funzioni senza problemi.

Fonte di streaming for-loop

Ecco uno script di Python che utilizza OpenCV (cv2) e YOLOv8 per eseguire l'inferenza sui fotogrammi video. Questo script presuppone che tu abbia già installato i pacchetti necessari (opencv-python e 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()

Questo script esegue previsioni su ogni fotogramma del video, visualizza i risultati e li mostra in una finestra. Il ciclo può essere interrotto premendo "q".

Commenti