Predizione del modello con Ultralytics YOLO

Introduzione

Nel mondo del machine learning e della computer vision, il processo di dare un senso ai dati visivi è chiamato 'inferenza' o 'predizione'. Ultralytics YOLO11 offre una potente funzionalità nota come modalità predict che è pensata per l'inferenza in tempo reale ad alte prestazioni su una vasta gamma di sorgenti di dati.

Guarda: Come estrarre i risultati dalleYOLO11 Ultralytics YOLO11 per progetti personalizzati 🚀

Applicazioni nel mondo reale

Produzione	Sport	Sicurezza
Rilevamento di pezzi di ricambio per veicoli	Rilevamento di giocatori di football americano	Rilevamento di cadute di persone

Perché utilizzare Ultralytics YOLO per l'inferenza?

Ecco perché dovresti considerare la modalità predict di YOLO11 per le tue diverse esigenze di inferenza:

• Versatilità: In grado di eseguire l'inferenza su immagini, video e persino live stream.
• Prestazioni: Progettato per l'elaborazione in tempo reale ad alta velocità senza sacrificare la precisione.
• Facilità d'uso: Interfacce intuitive Python e CLI per implementazione e test rapidi.
• Altamente personalizzabile: Diverse impostazioni e parametri per ottimizzare il comportamento di inferenza del modello in base alle tue esigenze specifiche.

Caratteristiche principali della modalità Predict

La modalità predict di YOLO11 è progettata per essere robusta e versatile, e offre:

• Compatibilità con molteplici sorgenti dati: Che i tuoi dati siano sotto forma di singole immagini, raccolte di immagini, file video o flussi video in tempo reale, la modalità predict ti supporta.
• Modalità Streaming: Utilizza la funzionalità di streaming per generare un generatore di oggetti efficiente in termini di memoria Results oggetti. Abilita questa opzione impostando stream=True nel metodo call del predittore.
• Elaborazione batch: Elabora più immagini o fotogrammi video in un singolo batch, riducendo ulteriormente il tempo totale di inferenza.
• Facilità di integrazione: Facile integrazione con pipeline di dati esistenti e altri componenti software, grazie alla sua API flessibile.

I modelli Ultralytics YOLO restituiscono un elenco Python di Results objects o un generatore di memoria efficiente di Results oggetti efficiente in termini di memoria quando stream=True viene passato al modello durante l'inferenza:

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

Sorgenti di inferenza

YOLO11 può elaborare diversi tipi di sorgenti di input per l'inferenza, come mostrato nella tabella seguente. Le sorgenti includono immagini statiche, flussi video e vari formati di dati. La tabella indica anche se ciascuna sorgente può essere utilizzata in modalità streaming con l'argomento stream=True ✅. La modalità streaming è utile 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 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

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

# Run inference on 'bus.jpg'
yolo predict model=yolo11n.pt source='https://ultralytics.com/images/bus.jpg'

Argomenti di inferenza:

Argomenti di visualizzazione:

Formati di immagine e video

YOLO11 supporta vari formati di immagine e video, come specificato in ultralytics/data/utils.py. Consultare le tabelle seguenti per i suffissi validi e gli esempi di comandi predict.

Immagini

La tabella seguente contiene i formati immagine Ultralytics validi.

Video

La tabella seguente contiene i formati video Ultralytics validi.

Lavorare con i risultati

Tutte le chiamate Ultralytics predict() restituiranno un elenco di Results oggetti:

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

Results Gli oggetti hanno i seguenti metodi:

Per maggiori dettagli, consultare la Results documentazione della classe.

Box

Boxes L'oggetto può essere utilizzato per indicizzare, manipolare e convertire i riquadri di delimitazione in diversi formati.

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

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

Per maggiori dettagli, consultare la Boxes documentazione della classe.

Maschere

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

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

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

Per maggiori dettagli, consultare la Masks documentazione della classe.

Punti chiave

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

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

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

Per maggiori dettagli, consultare la Keypoints documentazione della classe.

Probabilità

Probs L'oggetto può essere utilizzato per indicizzare, ottenere top1 e top5 indici e punteggi della classificazione.

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

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

Per maggiori dettagli, consultare la Probs documentazione della classe.

OBB

OBB L'oggetto può essere utilizzato per indicizzare, manipolare e convertire i bounding box orientati in diversi formati.

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

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

Per maggiori dettagli, consultare la OBB documentazione della classe.

Tracciamento dei risultati

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

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

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

Inferenza thread-safe

Garantire la thread safety durante l'inferenza è fondamentale quando si eseguono più modelli YOLO in parallelo su diversi thread. L'inferenza thread-safe garantisce che le predizioni di ciascun thread siano isolate e non interferiscano tra loro, evitando race condition e garantendo output coerenti e affidabili.

Quando si utilizzano modelli YOLO in un'applicazione multi-thread, è importante istanziare oggetti modello separati per ciascun thread o impiegare lo storage thread-local per prevenire conflitti:

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

Per un'analisi approfondita dell'inferenza thread-safe con i modelli YOLO e istruzioni dettagliate, consulta la nostra Guida all'inferenza thread-safe di YOLO. Questa guida ti fornirà tutte le informazioni necessarie per evitare insidie comuni e garantire che la tua inferenza multi-thread funzioni senza problemi.

Sorgente di streaming for-loop

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

Questo script eseguirà predizioni su ciascun frame del video, visualizzerà i risultati e li mostrerà in una finestra. È possibile uscire dal loop premendo 'q'.

FAQ

Cos'è Ultralytics YOLO e la sua modalità predict per l'inferenza in tempo reale?

Ultralytics YOLO è un modello all'avanguardia per il rilevamento di oggetti, la segmentazione e la classificazione in tempo reale. La sua modalità predict consente agli utenti di eseguire inferenze ad alta velocità su varie sorgenti di dati come immagini, video e streaming live. Progettato per prestazioni e versatilità, offre anche modalità di elaborazione batch e streaming. Per maggiori dettagli sulle sue funzionalità, consulta la modalità predict di Ultralytics YOLO.

Come posso eseguire l'inferenza utilizzando Ultralytics YOLO su diverse sorgenti di dati?

Ultralytics YOLO è in grado di elaborare un'ampia gamma di sorgenti dati, tra cui singole immagini, video, directory, URL e stream. È possibile specificare la sorgente dati nel model.predict() comando. Ad esempio, utilizzare 'image.jpg' per un'immagine locale o 'https://ultralytics.com/images/bus.jpg' per un URL. Consultare gli esempi dettagliati per le varie sorgenti di inferenza nella documentazione.

Come posso ottimizzare la velocità di inferenza e l'utilizzo della memoria di YOLO?

Per ottimizzare la velocità di inferenza e gestire la memoria in modo efficiente, è possibile utilizzare la modalità streaming impostando stream=True nel metodo call del predittore. La modalità streaming genera un generatore di oggetti a basso consumo di memoria Results invece di caricare tutti i frame in memoria. Per l'elaborazione di video lunghi o set di dati di grandi dimensioni, la modalità streaming è particolarmente utile. Ulteriori informazioni sul modalità streaming.

Quali argomenti di inferenza supporta Ultralytics YOLO?

Il model.predict() il metodo in YOLO supporta vari argomenti come conf, iou, imgsz, devicee altro ancora. Questi argomenti consentono di personalizzare il processo di inferenza, impostando parametri come le soglie di confidenza, le dimensioni dell'immagine e il dispositivo utilizzato per il calcolo. Descrizioni dettagliate di questi argomenti sono disponibili nella sezione argomenti di inferenza sezione.

Come posso visualizzare e salvare i risultati delle predizioni di YOLO?

Dopo aver eseguito l'inferenza con YOLO, gli Results oggetti contengono metodi per visualizzare e salvare le immagini annotate. È possibile utilizzare metodi come result.show() e result.save(filename="result.jpg") per visualizzare e salvare i risultati. Per un elenco completo di questi metodi, consultare la sezione lavorare con i risultati sezione.

📅 Creato 2 anni fa ✏️ Aggiornato 2 giorni fa

Commenti