Predizione del modello con Ultralytics YOLO#

Introduzione#

Nel mondo del machine learning e della computer vision, il processo di interpretazione dei dati visivi viene spesso chiamato inferenza o predizione. Ultralytics YOLO26 offre una potente funzionalità nota come modalità predict, progettata per l'inferenza in tempo reale ad alte prestazioni su un'ampia gamma di origini dati.

Consulta la anteprima di YOLO27 non rilasciata per gli esempi di inferenza pianificati.

Applicazioni nel mondo reale#

Perché usare Ultralytics YOLO per l'inferenza?#

Ecco perché dovresti prendere in considerazione la modalità predict di YOLO26 per le tue diverse esigenze di inferenza:

• Versatilità: consente di eseguire l'inferenza su immagini, video e persino stream dal vivo.
• Prestazioni: progettato per l'elaborazione in tempo reale ad alta velocità senza sacrificare l'accuratezza.
• Facilità d'uso: interfacce Python e CLI intuitive per una rapida distribuzione e verifica.
• Altamente personalizzabile: diverse impostazioni e parametri consentono di regolare il comportamento di inferenza del modello in base ai tuoi requisiti specifici.
• Pronto per la produzione: distribuisci i modelli come endpoint di inferenza della Ultralytics Platform con autoscaling e monitoraggio, oppure esegui l'inferenza localmente.

Funzionalità principali della modalità predict#

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

• Compatibilità con più origini dati: che i tuoi dati siano costituiti da singole immagini, raccolte di immagini, file video o stream video in tempo reale, la modalità predict è adatta alle tue esigenze.
• Modalità streaming: usa la funzionalità di streaming per generare un generatore efficiente in termini di memoria di oggetti Results. Attivala impostando stream=True nel metodo di chiamata del predittore. A differenza del comportamento predefinito (stream=False), che restituisce un elenco contenente tutti i risultati, stream=True restituisce i risultati uno alla volta, risultando particolarmente utile per video lunghi e stream dal vivo.
• Elaborazione batch: elabora più immagini o fotogrammi video in un singolo batch, riducendo ulteriormente il tempo totale di inferenza.
• Facile integrazione: integra facilmente il modello con pipeline di dati esistenti e altri componenti software grazie alla sua API flessibile.

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

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # pretrained YOLO26n 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

Origini dell'inferenza#

YOLO26 può elaborare diversi tipi di origini di input per l'inferenza, come mostrato nella tabella seguente. Le origini includono immagini statiche, stream video e vari formati di dati. La tabella indica anche se ogni origine può essere usata in modalità streaming con l'argomento stream=True ✅. La modalità streaming è utile per elaborare video o stream dal vivo, perché crea un generatore di risultati invece di caricare tutti i fotogrammi in memoria.

Di seguito sono riportati esempi di codice per usare ogni tipo di origine:

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Define path to the image file
source = "path/to/image.jpg"

# Run inference on the source
results = model(source)  # list of Results objects

Argomenti dell'inferenza#

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

Forma fissa vs rettangolo minimo (rect)#

Per impostazione predefinita, predict usa rect=True, che abilita il padding a rettangolo minimo quando possibile. L'immagine viene ridimensionata per rientrare in imgsz e sottoposta a padding solo fino al multiplo di stride più vicino; pertanto, il tensore finale può essere più piccolo di imgsz. Il padding a rettangolo minimo viene usato solo quando tutte le immagini del batch hanno la stessa forma e il backend lo supporta (.pt PyTorch oppure ONNX / Triton dinamico). In caso contrario, le immagini vengono sottoposte a padding fino alla destinazione completa imgsz.

Usa rect=False per applicare sempre il padding fino alla destinazione imgsz completa. Questa opzione è consigliata quando ti serve una dimensione di input fissa corrispondente ai modelli esportati (ONNX, TensorRT, ecc.).

Intero vs tupla imgsz

• Un valore intero imgsz=640 diventa una destinazione quadrata (640, 640) dopo l'arrotondamento in base allo stride.
• Una tupla imgsz=(384, 672) imposta una destinazione rettangolare. Con rect=True e auto=True, il tensore effettivo può essere più piccolo di questa destinazione.

Training vs predict/export

Il training accetta solo un singolo valore intero imgsz (un elenco [h, w] viene convertito nel valore più grande). Predict ed export accettano un valore intero o una tupla (height, width).

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on 'bus.jpg' with arguments
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)

Argomenti di inferenza:

Argomenti di visualizzazione:

Formati di immagini e video#

YOLO26 supporta vari formati di immagini e video, come specificato in ultralytics/data/utils.py. Consulta le tabelle seguenti per le estensioni valide e i comandi di predizione di esempio.

Immagini#

La tabella seguente contiene i formati di immagine Ultralytics validi.

Video#

La tabella seguente contiene i formati video Ultralytics validi.

Utilizzo dei Results#

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

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.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

Gli oggetti Results hanno i seguenti attributi:

Risultati per attività#

I campi che si popolano qui sotto dipendono dal task del tuo modello — confronta detection, segmentation, semantic segmentation, depth estimation, classification, pose e OBB se non ne hai ancora scelto uno. Ciascuna prediction restituisce un oggetto Results per ogni immagine o frame. I campi comuni di cui sopra sono sempre disponibili, mentre i dati di prediction specifici del task sono memorizzati nei campi sottostanti. I tensori di coordinate e confidenza di YOLO sono torch.float32; i tensori di probabilità sono torch.float32 a meno che non venga utilizzata la mezza precisione, nel qual caso sono torch.float16. Dopo result.numpy(), i tensori diventano array NumPy con i corrispondenti dtypes di NumPy. Le maschere di istanza sono tensori binari torch.uint8, mentre le maschere semantiche utilizzano il tipo di dato intero più piccolo possibile per gli ID delle classi: torch.uint8, torch.int16 o torch.int32, a seconda del numero di classi.

Gli oggetti Results hanno i seguenti metodi:

Per maggiori dettagli, consulta la documentazione della classe Results.

Riquadri#

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

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.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 dei metodi e delle proprietà della classe Boxes, inclusi nome, tipo e descrizione:

Per maggiori dettagli, consulta la documentazione della classe Boxes.

Maschere#

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

from ultralytics import YOLO

# Load a pretrained YOLO26n-seg Segment model
model = YOLO("yolo26n-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 dei metodi e delle proprietà della classe Masks, inclusi nome, tipo e descrizione:

Per maggiori dettagli, consulta la documentazione della classe Masks.

SemanticMask#

SemanticMask memorizza una mappa densa delle classi per i risultati della segmentazione semantica. A differenza di Masks, non contiene una maschera binaria per ogni oggetto e non fornisce helper per i poligoni.

from ultralytics import YOLO

# Load a pretrained YOLO26n-sem Semantic model
model = YOLO("yolo26n-sem.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.semantic_mask.data)  # print the H x W class-ID map

Punti chiave#

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

from ultralytics import YOLO

# Load a pretrained YOLO26n-pose Pose model
model = YOLO("yolo26n-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 dei metodi e delle proprietà della classe Keypoints, inclusi nome, tipo e descrizione:

Per maggiori dettagli, consulta la documentazione della classe Keypoints.

Probs#

L'oggetto Probs può essere utilizzato per ottenere gli indici e i punteggi di classificazione top1 e top5.

from ultralytics import YOLO

# Load a pretrained YOLO26n-cls Classify model
model = YOLO("yolo26n-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 riepilogativa dei metodi e delle proprietà della classe Probs:

Per maggiori dettagli, consulta la documentazione della classe Probs.

OBB#

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

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n-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 dei metodi e delle proprietà della classe OBB, inclusi nome, tipo e descrizione:

Per maggiori dettagli, consulta la documentazione della classe OBB.

Risultati della visualizzazione#

Il metodo plot() negli oggetti Results facilita la visualizzazione delle predizioni sovrapponendo gli oggetti rilevati (come riquadri delimitatori, maschere, keypoint e probabilità) all'immagine originale. Questo metodo restituisce l'immagine annotata come array NumPy, consentendone facilmente la visualizzazione o il salvataggio.

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.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")

Parametri del metodo plot()#

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

Inferenza thread-safe#

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

Quando utilizzi modelli YOLO in un'applicazione multithread, è importante istanziare oggetti modello separati per ogni thread oppure utilizzare l'archiviazione locale al thread 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=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()

Per un'analisi approfondita dell'inferenza thread-safe con i modelli YOLO e istruzioni dettagliate passo passo, consulta la nostra Guida all'inferenza YOLO thread-safe. Questa guida ti fornirà tutte le informazioni necessarie per evitare le problematiche comuni e garantire che l'inferenza multithread venga eseguita senza problemi.

Ciclo for della sorgente in streaming#

Ecco uno script Python che utilizza OpenCV (cv2) e YOLO 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 YOLO model
model = YOLO("yolo26n.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à le predizioni su ogni fotogramma del video, visualizzerà i risultati e li mostrerà in una finestra. Puoi uscire dal ciclo premendo 'q'.

E adesso?#

Pronto a passare oltre un modello pretrained? Verifica che il tuo task sia adatto al tuo problema, formatta i tuoi dati con la guida ai dataset, quindi addestra il modello.

FAQ#