Previsione con Ultralytics YOLO#

Introduzione#

Nel mondo del machine learning e della visione artificiale, il processo di interpretazione dei dati visivi è spesso chiamato inferenza o previsione. Ultralytics YOLO26 offre una potente funzionalità chiamata modalità predict, progettata per eseguire inferenze in tempo reale ad alte prestazioni su un'ampia varietà di origini dati.

Consulta l'anteprima non ancora rilasciata di YOLO27 per gli esempi di inferenza previsti.

Applicazioni nel mondo reale#

Perché usare Ultralytics YOLO per l'inferenza?#

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

• Versatilità: consente di eseguire inferenze su immagini, video e persino flussi in diretta.
• Prestazioni: progettato per l'elaborazione in tempo reale ad alta velocità senza sacrificare la precisione.
• Facilità d'uso: interfacce intuitive per Python e CLI, per distribuire e testare rapidamente.
• Altamente personalizzabile: diverse impostazioni e parametri ti consentono di adattare il comportamento dell'inferenza del modello alle tue esigenze specifiche.
• Pronto per la produzione: distribuisci i modelli come endpoint di inferenza di Ultralytics Platform con scalabilità automatica e monitoraggio, oppure esegui l'inferenza in locale.

Funzionalità principali della modalità di predizione#

La modalità di predizione 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 flussi video in tempo reale, la modalità di predizione è la soluzione che fa per te.
• Modalità streaming: usa la funzionalità di streaming per generare un generatore efficiente in termini di memoria di oggetti Results. Per attivarla, imposta 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 flussi in diretta.
• Elaborazione in batch: elabora più immagini o fotogrammi video in un singolo batch, riducendo ulteriormente il tempo totale di inferenza.
• Facile da integrare: grazie alla sua API flessibile, si integra facilmente con le pipeline di dati esistenti e con altri componenti software.

Durante l'inferenza, i modelli Ultralytics YOLO restituiscono un elenco Python di oggetti Results oppure, se al modello viene passato stream=True, un generatore di oggetti Results efficiente in termini di memoria:

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")  # modello YOLO26n preaddestrato

# Esegui l'inferenza in batch su un elenco di immagini
results = model(["image1.jpg", "image2.jpg"])  # restituisce un elenco di oggetti Results

# Elabora l'elenco dei risultati
for result in results:
    boxes = result.boxes  # Oggetto Boxes per i risultati dei riquadri di delimitazione
    masks = result.masks  # Oggetto Masks per i risultati delle maschere di segmentazione
    keypoints = result.keypoints  # Oggetto Keypoints per i risultati della stima della posa
    probs = result.probs  # Oggetto Probs per i risultati della classificazione
    obb = result.obb  # Oggetto Oriented boxes per i risultati OBB
    result.show()  # visualizza sullo schermo
    result.save(filename="result.jpg")  # salva su disco

Origini di inferenza#

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

Di seguito trovi esempi di codice per usare ciascun tipo di origine:

from ultralytics import YOLO

# Carica un modello YOLO26n preaddestrato
model = YOLO("yolo26n.pt")

# Definisci il percorso del file immagine
source = "path/to/image.jpg"

# Esegui l'inferenza sull'origine
results = model(source)  # elenco di oggetti Results

Argomenti di inferenza#

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

Dimensione fissa vs rettangolo minimo (rect)#

Per impostazione predefinita, predict usa rect=True, che applica il padding con rettangolo minimo quando possibile. L'immagine viene ridimensionata per adattarsi a imgsz e riempita con padding solo fino al multiplo dello stride più vicino, quindi il tensore finale può essere più piccolo di imgsz. Il padding con rettangolo minimo viene usato solo quando tutte le immagini del batch hanno la stessa forma e il backend lo supporta (PyTorch .pt o un'esportazione con forma dinamica, come ONNX dinamico). In caso contrario, le immagini vengono riempite con padding fino alla dimensione completa imgsz.

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

imgsz intero vs tupla

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

Training vs predict/export

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

from ultralytics import YOLO

# Carica un modello YOLO26n preaddestrato
model = YOLO("yolo26n.pt")

# Esegui l'inferenza su 'bus.jpg' con gli argomenti
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 diversi formati di immagini e video, come specificato in ultralytics/data/utils.py. Consulta le tabelle seguenti per i suffissi validi e i comandi predict di esempio.

Immagini#

La tabella seguente contiene i formati di immagine Ultralytics validi.

Video#

La tabella seguente contiene i formati video Ultralytics validi.

Uso dei risultati#

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

from ultralytics import YOLO

# Carica un modello YOLO26n preaddestrato
model = YOLO("yolo26n.pt")

# Esegui l'inferenza su un'immagine
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # inferenza in batch

Gli oggetti Results hanno i seguenti attributi:

Risultati per attività#

I campi seguenti vengono popolati in base all'attività del modello: confronta rilevamento, segmentazione, segmentazione semantica, stima della profondità, classificazione, posa e OBB se non hai ancora scelto. Ogni predizione restituisce un oggetto Results per immagine o fotogramma. I campi comuni elencati sopra sono sempre disponibili, mentre i dati di predizione specifici dell'attività sono memorizzati nei campi seguenti. I tensori di coordinate e confidenza YOLO sono torch.float32; i tensori di probabilità sono torch.float32, a meno che non venga usata l'inferenza FP16 (quantize=16), nel qual caso sono torch.float16. Dopo result.numpy(), i tensori diventano array NumPy con tipi di dati NumPy corrispondenti. Le maschere di istanza sono tensori binari torch.uint8, mentre le maschere semantiche usano il tipo di dato intero più piccolo adatto agli ID di classe: torch.uint8, torch.int16 o torch.int32, a seconda del numero di classi.

Gli oggetti Results dispongono dei seguenti metodi:

Per maggiori dettagli, consulta la documentazione della classe Results.

Riquadri#

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

from ultralytics import YOLO

# Carica un modello YOLO26n preaddestrato
model = YOLO("yolo26n.pt")

# Esegui l'inferenza su un'immagine
results = model("https://ultralytics.com/images/bus.jpg")  # elenco dei risultati

# Visualizza i risultati
for r in results:
    print(r.boxes)  # stampa l'oggetto Boxes contenente i riquadri di delimitazione rilevati

Ecco una tabella dei metodi e delle proprietà della classe Boxes, con nome, tipo e descrizione:

Per maggiori dettagli, consulta la documentazione della classe Boxes.

Maschere#

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

from ultralytics import YOLO

# Carica un modello Segment YOLO26n-seg preaddestrato
model = YOLO("yolo26n-seg.pt")

# Esegui l'inferenza su un'immagine
results = model("https://ultralytics.com/images/bus.jpg")  # elenco dei risultati

# Visualizza i risultati
for r in results:
    print(r.masks)  # stampa l'oggetto Masks contenente le maschere di istanza rilevate

Ecco una tabella dei metodi e delle proprietà della classe Masks, con 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 oggetto e non fornisce funzioni per i poligoni.

from ultralytics import YOLO

# Carica un modello Semantic YOLO26n-sem preaddestrato
model = YOLO("yolo26n-sem.pt")

# Esegui l'inferenza su un'immagine
results = model("https://ultralytics.com/images/bus.jpg")  # elenco dei risultati

# Visualizza i risultati
for r in results:
    print(r.semantic_mask.data)  # stampa la mappa degli ID di classe H x W

Punti chiave#

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

from ultralytics import YOLO

# Carica un modello Pose YOLO26n-pose preaddestrato
model = YOLO("yolo26n-pose.pt")

# Esegui l'inferenza su un'immagine
results = model("https://ultralytics.com/images/bus.jpg")  # elenco dei risultati

# Visualizza i risultati
for r in results:
    print(r.keypoints)  # stampa l'oggetto Keypoints contenente i punti chiave rilevati

Ecco una tabella dei metodi e delle proprietà della classe Keypoints, con nome, tipo e descrizione:

Per maggiori dettagli, consulta la documentazione della classe Keypoints.

Probabilità#

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

from ultralytics import YOLO

# Carica un modello Classify YOLO26n-cls preaddestrato
model = YOLO("yolo26n-cls.pt")

# Esegui l'inferenza su un'immagine
results = model("https://ultralytics.com/images/bus.jpg")  # elenco dei risultati

# Visualizza i risultati
for r in results:
    print(r.probs)  # stampa l'oggetto Probs contenente le probabilità delle classi rilevate

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 usato per indicizzare, manipolare e convertire le bounding box orientate in diversi formati.

from ultralytics import YOLO

# Carica un modello YOLO26n preaddestrato
model = YOLO("yolo26n-obb.pt")

# Esegui l'inferenza su un'immagine
results = model("https://ultralytics.com/images/boats.jpg")  # elenco dei risultati

# Visualizza i risultati
for r in results:
    print(r.obb)  # stampa l'oggetto OBB contenente le bounding box orientate delle rilevazioni

Ecco una tabella dei metodi e delle proprietà della classe OBB, con nome, tipo e descrizione:

Per maggiori dettagli, consulta la documentazione della classe OBB.

Visualizzazione dei risultati#

Il metodo plot() degli oggetti Results facilita la visualizzazione delle previsioni sovrapponendo gli oggetti rilevati (come bounding box, maschere, keypoint e probabilità) all'immagine originale. Questo metodo restituisce l'immagine annotata come array NumPy, consentendo di visualizzarla o salvarla facilmente.

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 vari 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 previsioni di ciascun thread siano isolate e non interferiscano tra loro, evitando le condizioni di race e assicurando output coerenti e affidabili.

Quando usi modelli YOLO in un'applicazione multithread, è importante istanziare oggetti modello separati per ogni thread o usare uno spazio di 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)
    # Elabora i risultati

# Avvia thread, ciascuno con la propria istanza del modello
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()

Per un approfondimento sull'inferenza thread-safe con i modelli YOLO e istruzioni dettagliate, consulta la nostra guida all'inferenza thread-safe con YOLO. La guida fornisce tutte le informazioni necessarie per evitare gli errori più comuni e assicurarti che l'inferenza multithread venga eseguita senza problemi.

Ciclo for sulla sorgente di streaming for#

Ecco uno script Python che usa OpenCV (cv2) e YOLO per eseguire l'inferenza sui fotogrammi di un video. Lo script presuppone che tu abbia già installato i pacchetti necessari (opencv-python e ultralytics).

import cv2

from ultralytics import YOLO

# Carica il modello YOLO
model = YOLO("yolo26n.pt")

# Apri il file video
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Scorri i fotogrammi del video
while cap.isOpened():
    # Leggi un fotogramma dal video
    success, frame = cap.read()

    if success:
        # Esegui l'inferenza YOLO sul fotogramma
        results = model(frame)

        # Visualizza i risultati sul fotogramma
        annotated_frame = results[0].plot()

        # Mostra il fotogramma annotato
        cv2.imshow("YOLO Inference", annotated_frame)

        # Interrompi il ciclo se viene premuto 'q'
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrompi il ciclo se il video è terminato
        break

# Rilascia l'oggetto di acquisizione video e chiudi la finestra di visualizzazione
cap.release()
cv2.destroyAllWindows()

Questo script esegue le previsioni su ogni fotogramma del video, visualizza i risultati e li mostra in una finestra. Puoi uscire dal ciclo premendo 'q'.

E adesso?#

Pronto a passare oltre un modello preaddestrato? Verifica che il tuo task sia adatto al tuo problema, formatta i tuoi dati seguendo la guida ai dataset, quindi esegui l'addestramento.

Domande frequenti#