Previsione del modello con Ultralytics YOLO

Introduzione

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

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

Applicazioni nel 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é dovreste considerare la modalità di predizione di YOLO11 per le vostre esigenze di inferenza:

• Versatilità: È in grado di fare inferenze su immagini, video e persino flussi in diretta.
• Prestazioni: Progettato per l'elaborazione in tempo reale e ad alta velocità senza sacrificare la precisione.
• Facilità d'uso: interfacce intuitive 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 vostre esigenze specifiche.

Caratteristiche principali della modalità Predict

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

• Compatibilità con più fonti di dati: Che si tratti di singole immagini, di una raccolta di immagini, di file video o di flussi video in tempo reale, la modalità di previsione è la soluzione ideale.
• Modalità di streaming: Utilizzate la funzione di streaming per generare un generatore efficiente di memoria di Results oggetti. Attivare 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, accelerando ulteriormente i tempi di inferenza.
• Integrazione facile: si integra facilmente con le pipeline di dati esistenti e con altri componenti software, grazie alla sua API flessibile.

Ultralytics YOLO restituiscono un elenco Python di Results o un generatore Python efficiente in termini di memoria di oggetti Results oggetti 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

Fonti 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 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, poiché 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("bus.jpg", save=True, imgsz=320, conf=0.5)

Argomenti di inferenza:

Argomenti di visualizzazione:

Formati immagine e video

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

Immagini

La tabella seguente contiene i formati di immagine Ultralytics validi.

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

Results hanno i seguenti metodi:

Per maggiori dettagli, consultare la sezione Results documentazione della classe.

Scatole

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

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

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

Per maggiori dettagli, consultare la sezione Boxes documentazione della classe.

Maschere

Masks può essere usato 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("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 nome, tipo e descrizione:

Per maggiori dettagli, consultare la sezione Masks documentazione della classe.

Punti chiave

Keypoints può essere usato 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("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 nome, tipo e descrizione:

Per maggiori dettagli, consultare la sezione Keypoints documentazione della classe.

Probi

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

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

Ecco una tabella che riassume i metodi e le proprietà dell'oggetto Probs classe:

Per maggiori dettagli, consultare la sezione Probs documentazione della classe.

OBB

OBB può essere usato per indicizzare, manipolare e convertire i rettangoli di selezione 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("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 il OBB metodi e proprietà della classe, compresi nome, tipo e descrizione:

Per maggiori dettagli, consultare 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, per facilitarne la visualizzazione o il 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(["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 vari argomenti per personalizzare l'output:

Inferenza sicura per i thread

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 YOLO in un'applicazione multi-thread, è importante istanziare oggetti modello separati per ogni thread o utilizzare la memorizzazione locale dei thread per evitare 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 uno sguardo approfondito sull'inferenza thread-safe con i modelli di YOLO e per le istruzioni passo-passo, consultare la nostra Guida all'inferenza thread-safeYOLO . Questa guida fornisce tutte le informazioni necessarie per evitare le insidie più comuni e garantire che l'inferenza multi-thread funzioni senza problemi.

Fonte di streaming for-Anello

Ecco uno script Python che utilizza OpenCV (cv2) e YOLO per eseguire l'inferenza sui fotogrammi video. Questo script presuppone che siano già stati installati 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 esegue le previsioni su ogni fotogramma del video, visualizza i risultati e li mostra in una finestra. Il ciclo può essere interrotto premendo 'q'.

FAQ

Che cos'è Ultralytics YOLO e la sua modalità di predizione per l'inferenza in tempo reale?

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

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

Ultralytics YOLO può elaborare un'ampia gamma di sorgenti di dati, tra cui singole immagini, video, directory, URL e flussi. È possibile specificare l'origine dei dati nel campo model.predict() chiamata. Ad esempio, utilizzare 'image.jpg' per un'immagine locale o 'https://ultralytics.com/images/bus.jpg' per un URL. Consultate gli esempi dettagliati per i vari fonti di inferenza nella documentazione.

Come si ottimizza la velocità di inferenza di YOLO e l'utilizzo della memoria?

Per ottimizzare la velocità di inferenza e gestire la memoria in modo efficiente, è possibile utilizzare la modalità di streaming impostando stream=True nel metodo di chiamata del predittore. La modalità di streaming genera un generatore efficiente in termini di memoria di Results invece di caricare tutti i fotogrammi in memoria. Per l'elaborazione di video lunghi o di grandi insiemi di dati, la modalità streaming è particolarmente utile. Per saperne di più modalità streaming.

Quali argomenti di inferenza sostiene Ultralytics YOLO ?

Il model.predict() 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. Le descrizioni dettagliate di questi argomenti si trovano nella sezione argomenti di inferenza sezione.

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

Dopo aver eseguito l'inferenza con YOLO, il Results 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 il documento lavorare con i risultati sezione.

📅C reato 1 anno fa ✏️ Aggiornato 1 mese fa

Commenti