Inizia

Previsione con Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Introduzione#

Nel machine learning e nella visione artificiale, usare un modello addestrato per interpretare i dati visivi si chiama inferenza o previsione. La modalità Predict di Ultralytics YOLO26 esegue inferenze in tempo reale ad alta velocità su un'ampia gamma di sorgenti dati.

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



Guarda: Estrai riquadri di delimitazione, maschere, punti chiave, OBB, profondità e altro con Ultralytics YOLO26 in Python 🚀

Applicazioni nel mondo reale#

ProduzioneSportSicurezza
Rilevamento di ricambi per veicoliRilevamento dei calciatoriRilevamento delle cadute delle persone

Perché usare Ultralytics YOLO per l'inferenza?#

Motivi principali per usare la modalità Predict di YOLO26:

  • Versatilità: esegui inferenze su immagini, video e 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à Predict di YOLO26 include:

  • Compatibilità con più sorgenti dati: la modalità Predict accetta singole immagini, raccolte di immagini, file video e flussi video in tempo reale.
  • 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.
  • Facilità di integrazione: integra i modelli con le pipeline di dati esistenti e altri componenti software tramite un'API flessibile.

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:

Predici
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.

Suggerimento

Usa stream=True per elaborare video lunghi o set di dati di grandi dimensioni e gestire la memoria in modo efficiente. Quando usi stream=False, i risultati di tutti i fotogrammi o punti dati vengono archiviati in memoria, che può riempirsi rapidamente e causare errori di memoria esaurita con input di grandi dimensioni. Al contrario, stream=True usa un generatore, che mantiene in memoria solo i risultati del fotogramma o punto dati corrente, riducendo notevolmente il consumo di memoria e prevenendo problemi di memoria esaurita.

OrigineEsempioTipoNote
immagine'image.jpg'str o PathFile immagine singolo.
URL'https://ultralytics.com/images/bus.jpg'strURL di un'immagine.
Schermata ✅'screen'strAcquisisci continuamente lo schermo finché non interrompi l'acquisizione.
PILImage.open('image.jpg')PIL.ImageFormato HWC con canali RGB.
OpenCVcv2.imread('image.jpg')np.ndarrayFormato HWC con canali BGR uint8 (0-255).
NumPynp.zeros((640,1280,3))np.ndarrayFormato HWC con canali BGR uint8 (0-255).
torchtorch.zeros(16,3,320,640)torch.TensorFormato BCHW con canali RGB float32 (0.0-1.0).
CSV'sources.csv'str o PathFile CSV contenente i percorsi di immagini, video o directory.
video ✅'video.mp4'str o PathFile video in formati come MP4, AVI ecc.
directory ✅'path/'str o PathPercorso di una directory contenente immagini o video.
glob ✅'path/*.jpg'strModello glob per trovare più file. Usa il carattere * come carattere jolly.
YouTube ✅'https://youtu.be/LNwODJXcvt4'strURL di un video YouTube.
flusso ✅'rtsp://example.com/media.mp4'strURL per protocolli di streaming come RTSP, RTMP, TCP o un indirizzo IP.
flusso multiplo ✅'list.streams'str o PathFile di testo *.streams con un URL di flusso per riga; ad esempio, 8 flussi verranno eseguiti con una dimensione del batch pari a 8.
webcam ✅0intIndice del dispositivo della fotocamera collegata su cui eseguire l'inferenza.

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

Origini delle predizioni

Esegui l'inferenza su un file immagine.

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 quando possibile il padding a rettangolo minimo. L'immagine viene ridimensionata per rientrare in imgsz e riceve padding solo fino al multiplo di stride più vicino, quindi il tensore finale può essere più piccolo di imgsz. Il padding a rettangolo minimo viene usato solo quando tutte le immagini nel batch hanno la stessa forma e il backend lo supporta (PyTorch .pt o un'esportazione con forma dinamica, come ONNX dinamico). Altrimenti, alle immagini viene applicato il padding fino all'intera dimensione imgsz prevista. I modelli Depth e RT-DETR ignorano rect e ridimensionano ogni immagine adattandola all'intero imgsz senza padding.

Usa rect=False per usare sempre l'intera dimensione imgsz prevista. È consigliato quando ti serve una dimensione di input fissa che corrisponda 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).

Esempio
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:

ArgomentoTipoPredefinitoDescrizione
sourcestr o int o NoneNoneSpecifica la sorgente dei dati per l'inferenza. Può essere il percorso di un'immagine, un file video, una directory, un URL o l'ID di un dispositivo per i flussi in diretta. Se omessa, viene registrato un avviso e il modello usa le risorse demo integrate (ultralytics/assets oppure un URL demo per OBB). Supporta un'ampia gamma di formati e sorgenti, consentendo applicazioni flessibili con diversi tipi di input.
conffloat0.25Imposta la soglia minima di confidenza per i rilevamenti. Gli oggetti rilevati con una confidenza inferiore a questa soglia vengono ignorati. Regolare questo valore può aiutare a ridurre i falsi positivi.
ioufloat0.5Soglia di intersezione sull'unione (IoU) per la soppressione non massima (NMS). Valori più bassi producono meno rilevamenti eliminando i riquadri sovrapposti; utile per ridurre i duplicati.
imgszint o tuple640Dimensione di destinazione del letterbox. Un numero intero indica un N×N quadrato; una tupla indica (height, width). Con rect=True, il tensore effettivo può essere più piccolo di questa dimensione a causa del padding a rettangolo minimo. Usa rect=False per una dimensione fissa. Consulta Forma fissa e rettangolo minimo.
rectboolTrueSe True, usa quando possibile il padding a rettangolo minimo (batch con forme uguali e backend supportato). Se False, usa sempre l'intero imgsz. Vedi Forma fissa e rettangolo minimo. Ignorato per depth e i modelli RT-DETR, che ridimensionano le immagini adattandole all'intero imgsz senza padding.
quantizeint o strNonePrecisione dell’inferenza: 16/"fp16" e 32/"fp32"/unset selezionano il calcolo FP16 o FP32 per i modelli PyTorch e TorchScript (FP32 su CPU); gli altri formati usano la precisione selezionata dal rispettivo artefatto e ambiente di esecuzione. In 16, OpenVINO continua ad arrotondare l’input a FP16 sul client e a riconvertirlo in FP32, senza modificare la precisione dell’ambiente di esecuzione. La quantizzazione INT8/PTQ viene configurata durante l’esportazione, quindi viene usata caricando il modello esportato. Sostituisce il flag deprecato half.
devicestrNoneSpecifica il dispositivo per l'inferenza (ad es. cpu, cuda:0, 0, npu o npu:0). Consente di scegliere tra CPU, una GPU specifica, NPU Huawei Ascend o altri dispositivi di calcolo per l'esecuzione del modello. I modelli OpenVINO e LiteRT eseguono xpu e npu sulla GPU e sulla NPU Intel; consulta i dispositivi di inferenza per tutti i formati.
dnnboolFalseSe True, usa il modulo DNN di OpenCV invece di ONNX Runtime per l'inferenza dei modelli ONNX.
datastrNonePercorso a un file YAML del dataset (ad es. coco8.yaml), letto solo per il suo names e solo quando il modello caricato non contiene nomi di classe propri: un'esportazione di terze parti oppure un'esportazione Ultralytics separata dai metadati inclusi. In caso contrario, il modello segnala class0, class1 e così via.
batchint1Specifica la dimensione del batch per l'inferenza (funziona solo se la sorgente è una directory, un file video o un file .txt). Una dimensione del batch maggiore può aumentare la produttività, riducendo il tempo totale necessario per l'inferenza.
tilebool o intFalseEsegue l'inferenza su riquadri di dimensioni fisse e restituisce i risultati nelle coordinate dell'immagine originale. True usa imgsz; un intero positivo imposta la dimensione del riquadro. Vedi Suddivisione in riquadri ad alta risoluzione.
max_detint300Numero massimo di rilevamenti consentiti per immagine. Limita il numero totale di oggetti che il modello può rilevare in una singola inferenza, evitando risultati eccessivi nelle scene dense.
vid_strideint1Intervallo tra i frame per gli input video. Consente di saltare dei frame nei video per velocizzare l'elaborazione, a scapito della risoluzione temporale. Il valore 1 elabora ogni frame; valori maggiori saltano dei frame.
stream_bufferboolFalseDetermina se accodare i frame in arrivo per gli stream video. Se False, i frame meno recenti vengono scartati per fare spazio a quelli nuovi (ottimizzato per le applicazioni in tempo reale). Se True, i nuovi frame vengono accodati in un buffer, evitando che ne venga saltato qualcuno, ma causando latenza se gli FPS dell'inferenza sono inferiori a quelli dello stream.
visualizeboolFalseSalva una mappa di attivazione delle classi accanto a ogni predizione, mostrando quali pixel hanno aumentato i punteggi della classe predetta. Rispetta conf e classes, quindi classes=[0] mappa solo quella classe. Disponibile solo per i modelli Ultralytics PyTorch.
augmentboolFalseAbilita l'aumento dei dati al test (TTA) per le predizioni, migliorando potenzialmente la robustezza del rilevamento a scapito della velocità di inferenza. Disponibile solo per i modelli Ultralytics PyTorch.
agnostic_nmsboolFalseAbilita la soppressione non massima (NMS) indipendente dalla classe, sopprimendo i riquadri sovrapposti con punteggi inferiori tra classi diverse, anziché solo all'interno della stessa classe. Utile negli scenari di rilevamento multi-classe in cui la sovrapposizione tra classi è comune. Con l'inferenza senza NMS (nms=False su YOLO26 o YOLOv10), questa opzione impedisce solo che lo stesso rilevamento compaia con più etichette di classe (duplicati con IoU=1.0) e non applica la soppressione basata sulla soglia IoU tra riquadri distinti.
classeslist[int]NoneFiltra le predizioni in base a un insieme di ID di classe. Vengono restituiti solo i rilevamenti appartenenti alle classi specificate. Utile per concentrarsi sugli oggetti pertinenti nelle attività di rilevamento multi-classe.
retina_masksboolFalseRestituisce maschere di segmentazione ad alta risoluzione. Se abilitata, le maschere restituite (masks.data) avranno le stesse dimensioni dell'immagine originale. Se disabilitata, avranno le dimensioni dell'immagine usate durante l'inferenza.
embedlist[int]NoneSpecifica i layer da cui estrarre vettori di caratteristiche o embedding. Usa model.embed(source) per gli embedding del penultimo layer oppure model.predict(source, embed=[layer]) per selezionare layer specifici. Utile per attività successive come il clustering o la ricerca per similarità. Disponibile solo per i modelli Ultralytics PyTorch.
projectstrNoneNome della directory del progetto in cui vengono salvati gli output delle previsioni se save è abilitato. Un percorso relativo viene inserito in runs_dir/<task>, mentre un percorso assoluto viene utilizzato così com'è.
namestrNoneNome dell'esecuzione delle predizioni. Usato per creare una sottodirectory nella cartella del progetto, in cui vengono salvati i risultati delle predizioni se save è abilitato.
streamboolFalseAbilita un'elaborazione efficiente in termini di memoria per video lunghi o numerose immagini, restituendo un generatore di oggetti Results invece di caricare tutti i frame in memoria contemporaneamente.
verboseboolTrueControlla se visualizzare nel terminale i log dettagliati dell'inferenza, fornendo un riscontro in tempo reale sul processo di predizione.
compilebool o strFalseAbilita la compilazione del grafo torch.compile di PyTorch 2.x con backend='inductor'. Accetta True → "default", False → disattivazione oppure una modalità stringa come "default", "reduce-overhead", "max-autotune-no-cudagraphs". Se non è supportata, ripiega sulla modalità eager con un avviso.
channels_lastboolNoneUsa il formato di memoria channels_last (NHWC) per l'inferenza PyTorch nativa. None lo abilita automaticamente su CPU x86 Linux e Windows con oneDNN e PyTorch 1.13 o versioni successive; False lo disabilita e True ne richiede l'uso sui dispositivi CPU x86 o CUDA supportati. ARM64, MPS, le versioni precedenti di PyTorch, le CPU senza oneDNN e i formati esportati come TensorRT e ONNX restano invariati.
nmsbool, facoltativoNoneEsegue per impostazione predefinita un'inferenza one-to-many con NMS (None o True). Imposta False per usare la testa one-to-one senza NMS, se disponibile. Per i dettagli, consulta la guida al rilevamento end-to-end.

Argomenti di visualizzazione:

ArgomentoTipoPredefinitoDescrizione
showboolFalseSe True, mostra le immagini o i video annotati in una finestra. Utile per ottenere un riscontro visivo immediato durante lo sviluppo o i test.
saveboolFalse or TrueAbilita il salvataggio su file delle immagini o dei video annotati. Utile per documentare, analizzare ulteriormente o condividere i risultati. Per impostazione predefinita è True quando si usa la CLI e False quando si usa Python.
save_framesboolFalseDurante l'elaborazione dei video, salva i singoli frame come immagini. Utile per estrarre frame specifici o eseguire un'analisi dettagliata frame per frame.
save_txtboolFalseSalva i risultati del rilevamento in un file di testo, seguendo il formato [class] [x_center] [y_center] [width] [height] [confidence]. Utile per l'integrazione con altri strumenti di analisi.
save_confboolFalseInclude i punteggi di confidenza nei file di testo salvati. Aumenta il livello di dettaglio disponibile per la post-elaborazione e l'analisi.
save_cropboolFalseSalva immagini ritagliate dei rilevamenti. Utile per l'aumento dei dati del dataset, l'analisi o la creazione di dataset mirati a oggetti specifici.
show_labelsboolTrueMostra le etichette di ogni rilevamento nell'output visivo. Permette di identificare immediatamente gli oggetti rilevati.
show_confboolTrueMostra il punteggio di confidenza di ogni rilevamento accanto all'etichetta. Fornisce indicazioni sul grado di certezza del modello per ciascun rilevamento.
show_boxesboolTrueDisegna riquadri di delimitazione attorno agli oggetti rilevati. Essenziale per identificarli visivamente e localizzarli nelle immagini o nei frame video.
line_widthint or NoneNoneSpecifica lo spessore della linea dei riquadri di delimitazione. Se None, lo spessore della linea viene regolato automaticamente in base alle dimensioni dell'immagine. Consente di personalizzare la visualizzazione per una maggiore chiarezza.

Dispositivi di inferenza#

device accetta i nomi dei dispositivi PyTorch per tutti i formati di modello, quindi lo stesso valore seleziona lo stesso hardware sia che tu esegua un checkpoint .pt sia un modello esportato. Lascialo non impostato per usare il miglior dispositivo disponibile. Ogni runtime associa il nome al proprio hardware e la convalida e il benchmarking accettano gli stessi valori:

Formatonon impostatocpu0 o cuda:0mpsxpunpu
PyTorch .pt, TorchScriptGPU CUDA, altrimenti CPUCPUGPU NVIDIAGPU AppleGPU IntelNPU Huawei Ascend
ONNXGPU CUDA, altrimenti CPUCPUGPU NVIDIA (CUDA), GPU AMD (MIGraphX)Core ML--
TensorRTGPU NVIDIAGPU NVIDIAGPU NVIDIA---
OpenVINOOpenVINO AUTOCPU Intel--GPU Intel (xpu:1 è il GPU.1 di OpenVINO)NPU Intel
LiteRTCPUCPU--GPU Intel tramite il plugin OpenVINONPU Intel tramite il plugin OpenVINO
PaddlePaddleGPU CUDA, altrimenti CPUCPUGPU NVIDIA---

- significa che il runtime non dispone di un backend per quel dispositivo. ONNX, TensorRT e PaddlePaddle verificano prima il nome con PyTorch, quindi rifiutano un dispositivo che PyTorch non rileva e, in caso contrario, usano l'hardware predefinito. OpenVINO avvisa e ripiega su AUTO quando il dispositivo Intel richiesto non è disponibile, mentre il plugin Intel LiteRT ripiega sulla CPU. Gli altri formati scelgono il proprio hardware: CoreML viene eseguito su Apple Neural Engine e CPU, Edge TPU accetta tpu:0, NCNN accetta vulkan:0 per il percorso GPU Vulkan e i formati rimanenti vengono eseguiti sulla CPU o sull'acceleratore della piattaforma di destinazione. I nomi precedenti intel:cpu, intel:gpu e intel:npu funzionano ancora come alias deprecati di cpu, xpu e npu.

Esempio
from ultralytics import YOLO

model = YOLO("yolo26n_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg", device="npu")  # NPU Intel

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.

Nota

I formati HEIC/HEIF richiedono pi-heif, che viene installato automaticamente al primo utilizzo. Pillow supporta AVIF in modo nativo.

Suffissi delle immaginiComando predict di esempioRiferimento
.avifyolo predict source=image.avifFormato file di immagini AV1
.bmpyolo predict source=image.bmpFormato file BMP di Microsoft
.dngyolo predict source=image.dngAdobe DNG
.heicyolo predict source=image.heicFormato immagine ad alta efficienza
.heifyolo predict source=image.heifFormato immagine ad alta efficienza
.jp2yolo predict source=image.jp2JPEG 2000
.jpegyolo predict source=image.jpegJPEG
.jpgyolo predict source=image.jpgJPEG
.mpoyolo predict source=image.mpoOggetto multi-immagine
.pngyolo predict source=image.pngGrafica di rete portatile
.tifyolo predict source=image.tifFormato file immagine con tag
.tiffyolo predict source=image.tiffFormato file immagine con tag
.webpyolo predict source=image.webpWebP

Video#

La tabella seguente contiene i formati video Ultralytics validi.

Suffissi dei videoComando predict di esempioRiferimento
.asfyolo predict source=video.asfFormato Advanced Systems
.aviyolo predict source=video.aviAudio Video Interleave
.gifyolo predict source=video.gifFormato di interscambio grafico
.m4vyolo predict source=video.m4vMPEG-4 Parte 14
.mkvyolo predict source=video.mkvMatroska
.movyolo predict source=video.movFormato file QuickTime
.mp4yolo predict source=video.mp4MPEG-4 Parte 14 - Wikipedia
.mpegyolo predict source=video.mpegMPEG-1 Parte 2
.mpgyolo predict source=video.mpgMPEG-1 Parte 2
.tsyolo predict source=video.tsFlusso di trasporto MPEG
.wmvyolo predict source=video.wmvWindows Media Video
.webmyolo predict source=video.webmProgetto WebM

Uso dei risultati#

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

Risultati
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:

AttributoTipoDescrizione
orig_imgnp.ndarrayL'immagine originale come array NumPy.
orig_shapetupleLa forma dell'immagine originale nel formato (altezza, larghezza).
boxesBoxes, optionalUn oggetto Boxes contenente i riquadri di delimitazione rilevati.
masksMasks, optionalUn oggetto Masks contenente le maschere rilevate.
probsProbs, optionalUn oggetto Probs contenente le probabilità di ogni classe per l'attività di classificazione.
keypointsKeypoints, optionalUn oggetto Keypoints contenente i punti chiave rilevati per ogni oggetto.
obbOBB, optionalUn oggetto OBB contenente riquadri di delimitazione orientati.
semantic_maskSemanticMask, optionalUn oggetto SemanticMask contenente una mappa delle classi densa per pixel.
depthDepthMap, optionalUn oggetto DepthMap contenente una mappa di profondità densa per pixel.
speeddictUn dizionario delle velocità di preelaborazione, inferenza e postelaborazione in millisecondi per immagine.
namesdictUn dizionario che associa gli indici delle classi ai nomi delle classi.
pathstrIl percorso del file immagine.
save_dirstr, optionalDirectory in cui salvare i risultati.

Risultati per attività#

I campi popolati di seguito dipendono dal task del modello: se non ne hai ancora scelto uno, confronta rilevamento, segmentazione, segmentazione semantica, stima della profondità, classificazione, posa e OBB. Ogni predizione restituisce un oggetto Results per immagine o frame. I campi comuni riportati sopra sono sempre disponibili, mentre i dati di predizione specifici del task sono memorizzati nei campi riportati di seguito. I tensori di coordinate e confidenza YOLO sono torch.float32; i tensori di probabilità sono torch.float32, a meno che il modello non venga eseguito in FP16 (quantize=16 con un modello PyTorch o TorchScript non eseguito su CPU, oppure con un modello ONNX con input FP16), nel qual caso sono torch.float16. Dopo result.numpy(), i tensori diventano array NumPy con i corrispondenti tipi di dati NumPy. Le maschere delle istanze sono tensori binari torch.uint8, mentre le maschere semantiche usano il tipo di dato intero più piccolo praticabile per gli ID di classe: torch.uint8, torch.int16 o torch.int32, a seconda del numero di classi.

AttributoTipoFormaDescrizione
result.boxesBoxes(N)Riquadri di rilevamento.
result.boxes.datatorch.float32(N,6/7)[x1,y1,x2,y2,conf,cls] grezzi, più l'ID di tracciamento opzionale.
result.boxes.xyxytorch.float32(N,4)Riquadri in pixel xyxy.
result.boxes.conftorch.float32(N,)Punteggi di confidenza.
result.boxes.clstorch.float32(N,)ID delle classi; converti in int per ottenere i nomi.

Gli oggetti Results dispongono dei seguenti metodi:

MetodoTipo restituitoDescrizione
update()NoneAggiorna l'oggetto Results con nuovi dati, come riquadri, maschere, probabilità, OBB, punti chiave, maschere semantiche o profondità.
cpu()ResultsRestituisce una copia dell'oggetto Results con tutti i tensori spostati nella memoria CPU.
numpy()ResultsRestituisce una copia dell'oggetto Results con tutti i tensori convertiti in array NumPy.
cuda()ResultsRestituisce una copia dell'oggetto Results con tutti i tensori spostati nella memoria GPU.
to()ResultsRestituisce una copia dell'oggetto Results con i tensori spostati sul dispositivo e convertiti nel tipo di dati specificati.
new()ResultsCrea un nuovo oggetto Results con gli stessi attributi image, path, names e speed.
plot()np.ndarrayTraccia i risultati del rilevamento su un'immagine BGR di input e restituisce l'immagine annotata.
show()NoneVisualizza l'immagine con i risultati dell'inferenza annotati.
save()strSalva su file l'immagine con i risultati dell'inferenza annotati e restituisce il nome del file.
verbose()strRestituisce una stringa di log per ogni attività, con i dettagli dei risultati del rilevamento e della classificazione.
save_txt()strSalva i risultati del rilevamento in un file di testo e restituisce il percorso del file salvato.
save_crop()NoneSalva le immagini ritagliate del rilevamento nella directory specificata.
summary()List[Dict[str, Any]]Converte i risultati dell'inferenza in un dizionario riepilogativo, con normalizzazione facoltativa.
to_df()DataFrameConverte i risultati del rilevamento in un DataFrame Polars.
to_csv()strConverte i risultati del rilevamento in formato CSV.
to_json()strConverte i risultati del rilevamento in formato JSON.

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.

Riquadri
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:

NomeTipoDescrizione
cpu()MetodoSposta l'oggetto nella memoria CPU.
numpy()MetodoConverte l'oggetto in un array NumPy.
cuda()MetodoSposta l'oggetto nella memoria CUDA.
to()MetodoSposta l'oggetto sul dispositivo specificato.
xyxyProprietà (torch.Tensor)Restituisce i riquadri in formato xyxy.
confProprietà (torch.Tensor)Restituisce i valori di confidenza dei riquadri.
clsProprietà (torch.Tensor)Restituisce i valori di classe dei riquadri.
idProprietà (torch.Tensor)Restituisce gli ID di tracciamento dei riquadri, se disponibili.
xywhProprietà (torch.Tensor)Restituisce i riquadri in formato xywh.
xyxynProprietà (torch.Tensor)Restituisce i riquadri in formato xyxy, normalizzati rispetto alle dimensioni dell'immagine originale.
xywhnProprietà (torch.Tensor)Restituisce i riquadri in formato xywh, normalizzati rispetto alle dimensioni dell'immagine originale.

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.

Maschere
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:

NomeTipoDescrizione
dataProprietà (torch.Tensor)Tensore di maschere binarie torch.uint8 con forma (N,H,W) e valori 0 o 1.
cpu()MetodoRestituisce il tensore delle maschere nella memoria CPU.
numpy()MetodoRestituisce il tensore delle maschere come array NumPy.
cuda()MetodoRestituisce il tensore delle maschere nella memoria GPU.
to()MetodoRestituisce il tensore delle maschere con il dispositivo e il tipo di dati specificati.
xynProprietà (list[np.ndarray])Un elenco di poligoni delle maschere normalizzati.
xyProprietà (list[np.ndarray])Un elenco di poligoni delle maschere in coordinate pixel.

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.

SemanticMask
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
NomeTipoDescrizione
dataProprietà (torch.Tensor)Mappa degli ID di classe con forma (H,W). Il tipo di dati è torch.uint8, torch.int16 o torch.int32, selezionato in base al numero di classi.
shapeProprietà (tuple)Forma della mappa delle classi, generalmente corrispondente a result.orig_shape.
cpu()MetodoRestituisce il tensore della maschera semantica nella memoria CPU.
numpy()MetodoRestituisce il tensore della maschera semantica come array NumPy.
cuda()MetodoRestituisce il tensore della maschera semantica nella memoria GPU.
to()MetodoRestituisce il tensore della maschera semantica con il dispositivo e il tipo di dati specificati.

Punti chiave#

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

Punti chiave
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:

NomeTipoDescrizione
cpu()MetodoRestituisce il tensore dei punti chiave nella memoria CPU.
numpy()MetodoRestituisce il tensore dei punti chiave come array NumPy.
cuda()MetodoRestituisce il tensore dei punti chiave nella memoria GPU.
to()MetodoRestituisce il tensore dei punti chiave con il dispositivo e il tipo di dati specificati.
xynProprietà (torch.Tensor)Coordinate normalizzate dei punti chiave con forma (N,K,2).
xyProprietà (torch.Tensor)Coordinate dei punti chiave in pixel con forma (N,K,2).
confProprietà (torch.Tensor)Restituisce i valori di confidenza dei punti chiave, se disponibili; altrimenti restituisce None.

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.

Probabilità
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:

NomeTipoDescrizione
cpu()MetodoRestituisce una copia del tensore probs nella memoria della CPU.
numpy()MetodoRestituisce una copia del tensore probs come array NumPy.
cuda()MetodoRestituisce una copia del tensore probs nella memoria della GPU.
to()MetodoRestituisce una copia del tensore probs con il dispositivo e il dtype specificati.
top1Proprietà (int)Indice della classe al primo posto.
top5Proprietà (list[int])Indici delle prime 5 classi.
top1confProprietà (torch.Tensor)Confidenza della classe al primo posto.
top5confProprietà (torch.Tensor)Confidenze delle prime 5 classi.

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.

OBB
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:

NomeTipoDescrizione
cpu()MetodoSposta l'oggetto nella memoria CPU.
numpy()MetodoConverte l'oggetto in un array NumPy.
cuda()MetodoSposta l'oggetto nella memoria CUDA.
to()MetodoSposta l'oggetto sul dispositivo specificato.
confProprietà (torch.Tensor)Restituisce i valori di confidenza dei riquadri.
clsProprietà (torch.Tensor)Restituisce i valori di classe dei riquadri.
idProprietà (torch.Tensor)Restituisce gli ID di tracciamento dei riquadri, se disponibili.
xyxyProprietà (torch.Tensor)Restituisce le bounding box orizzontali nel formato xyxy.
xywhrProprietà (torch.Tensor)Restituisce le bounding box ruotate nel formato xywhr.
xyxyxyxyProprietà (torch.Tensor)Restituisce le bounding box ruotate nel formato xyxyxyxy.
xyxyxyxynProprietà (torch.Tensor)Restituisce le bounding box ruotate nel formato xyxyxyxy, normalizzate in base alle dimensioni dell'immagine.

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.

Visualizzazione
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:

ArgomentoTipoDescrizionePredefinito
confboolIncludi i punteggi di confidenza delle rilevazioni.True
line_widthfloatSpessore delle linee delle bounding box. Si adatta alle dimensioni dell'immagine se None.None
font_sizefloatDimensione del carattere del testo. Si adatta alle dimensioni dell'immagine se None.None
fontstrNome del carattere per le annotazioni testuali.'Arial.ttf'
pilboolRestituisce l'immagine come oggetto PIL Image.False
imgnp.ndarray | torch.TensorImmagine alternativa. I tensori devono essere contigui, nel formato HWC BGR uint8.None
kpt_radiusintRaggio dei keypoint disegnati.5
kpt_lineboolCollega i keypoint con delle linee.True
labelsboolIncludi le etichette delle classi nelle annotazioni.True
boxesboolSovrapponi le bounding box all'immagine.True
masksboolSovrapponi le maschere all'immagine.True
probsboolIncludi le probabilità di classificazione.True
showboolVisualizza direttamente l'immagine annotata con il visualizzatore di immagini predefinito.False
saveboolSalva l'immagine annotata nel file specificato da filename.False
filenamestrPercorso e nome del file in cui salvare l'immagine annotata se save è True.None
color_modestrSpecifica la modalità del colore, ad esempio 'instance' o 'class'.'class'
txt_colortuple[int, int, int]Colore del testo BGR per le etichette di classificazione.(255, 255, 255)

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 race condition e assicurando risultati 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:

Inferenza thread-safe

Istanzia un singolo modello all'interno di ogni thread per eseguire inferenze thread-safe:

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

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

Ciclo for sullo streaming
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#

  • Ultralytics YOLO è una famiglia di modelli all'avanguardia per il rilevamento degli oggetti in tempo reale, la segmentazione delle istanze, la segmentazione semantica, la stima della profondità, la classificazione, la stima della posa e il rilevamento di riquadri delimitatori orientati (OBB). La modalità di previsione esegue inferenze ad alta velocità su fonti di dati quali immagini, video e flussi in tempo reale, con supporto per l'elaborazione in batch e lo streaming.

  • Ultralytics YOLO può elaborare un'ampia gamma di sorgenti di dati, tra cui singole immagini, video, directory, URL e flussi. Puoi specificare la sorgente di dati nella chiamata model.predict(). Ad esempio, usa 'image.jpg' per un'immagine locale oppure 'https://ultralytics.com/images/bus.jpg' per un URL. Consulta gli esempi dettagliati delle diverse sorgenti di inferenza nella documentazione.

  • Per ottimizzare la velocità di inferenza e gestire la memoria in modo efficiente, puoi usare la modalità streaming impostando stream=True nel metodo di chiamata del predictor. La modalità streaming genera un generatore di oggetti Results a basso consumo di memoria, invece di caricare tutti i fotogrammi in memoria. È particolarmente utile per elaborare video lunghi o dataset di grandi dimensioni. Scopri di più sulla modalità streaming.

  • Il metodo model.predict() di YOLO supporta diversi argomenti, come conf, iou, imgsz, device e altri. Questi argomenti consentono di personalizzare il processo di inferenza impostando parametri come le soglie di confidenza, le dimensioni delle immagini e il dispositivo usato per il calcolo. Le descrizioni dettagliate di questi argomenti sono disponibili nella sezione argomenti di inferenza.

  • Usa model.embed(source) per estrarre gli embedding delle caratteristiche dal penultimo livello oppure passa embed=[layer_index] a model.predict() per scegliere livelli specifici.

    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    source = "https://ultralytics.com/images/bus.jpg"
    
    results = model.predict(source)  # Oggetti Results
    embeddings = model.embed(source)  # elenco di embedding torch.Tensor
  • Dopo aver eseguito l'inferenza con YOLO, gli oggetti Results contengono metodi per visualizzare e salvare le immagini annotate. Puoi usare metodi come result.show() e result.save(filename="result.jpg") per visualizzare e salvare i risultati. Le directory principali mancanti nel percorso del nome file vengono create automaticamente (ad esempio, result.save("path/to/result.jpg")). Per un elenco completo di questi metodi, consulta la sezione utilizzo dei risultati.

Commenti629

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  1. TigoresGitHub

    你好,我想问一下为什么我在推理相同的图像时,设置不同的imgsz参数,会有不同的结果。在一张图像上,有大船、小船、人。imgsz设置的值有640(默认)、1280、1980。640只能检测到大船;1280会检测到大船和小船,并且大船的置信度更高;1980还能检测到人。我很疑惑,模型的输入尺寸不是在训练的时候就已经固定了吗,这是否意味着推理的图像预处理阶段,不管我如何调整imgsz参数,模型都会将输入图像采样到640。但是现在出现的不同的结果,是为什么呢?下面是我的代码: from ultralytics import YOLO model = YOLO("/data/dxh/ultralytics/weight/yolov8s.pt")
    results = model("/data/dxh/ultralytics/datasets/test/invade_ship_cls/invade_result", imgsz=1280, save=True)

    1
    1. Glenn JocherUltralytics

      @Tigores 您好!YOLO模型在推理时会自动将输入图像缩放到您指定的imgsz参数值(而非固定为训练尺寸),更大的分辨率能保留更多细节从而提升小目标检测能力。具体原理可参考Predict模式文档中的图像尺寸与精度关系说明,这是预期行为而非异常现象。

  2. LwpZoeGitHub

    Hello, I would like to ask, my task is instance segmentation. At present, I get the predicted result is the original image superimposed label image, but the result I want is just the RGB label image, no need to superimpose the original image. Where do I need to make changes to make the result a segmented label image?

    1
    1. Glenn JocherUltralytics(modificato)

      @LwpZoe to obtain only the RGB label image without the original image overlay, you can disable the overlay during visualization. Use the plot() method with boxes=False and masks=True to only display the segmentation masks. Alternatively, you can directly access result.masks.data for raw mask data and process it as needed. Refer to the Results section for more details.

    2. LwpZoeGitHub

      Found plot () in yolo-segment-main/ultralytics/engine/results.py, modified content: Def plot ( Self, Conf = True, line_width = None, font_size = None, Font = "Arial.ttf", Pil = False, Img = None, im_gpu = None, kpt_radius = 5, kpt_line = False, Labels = False, Boxes = False, Masks = True, Probs = True, Show = True, Save = True, Filename = 'result', color_mode = "class", ): Make predictions using the command line: Yolo segment predict model = runs/segment/train/weights/best.pt source=yolo-seg-main/datasets/test The result is still the original image overlay mask and box, why? Does changing plot () require retraining to get best.pt in order to predict?

    3. Glenn JocherUltralytics

      To display only the segmentation mask without overlays, modify the plot() function parameters by setting boxes=False, labels=False, and ensuring masks=True. You don't need retraining to adjust visualization settings, as the weights remain unaffected. For further details, refer to the Results.plot() documentation.

  3. User

    Hello, when I run the predict script, I predict a large amount of image data (about more than 20,000 test images). At this time, the model's predict will get stuck, and I don't generate the image of the prediction box. How can I solve this bug?

    1
    1. Paula DerrengerUltralytics

      @Stephen-Hao it sounds like you might be running into memory issues when processing a large number of images. To handle large datasets more efficiently, consider using the stream=True argument in your model.predict() call. This will create a memory-efficient generator of results, reducing the likelihood of your system getting stuck. Additionally, ensure you are using the latest version of the Ultralytics package to benefit from any recent optimizations and bug fixes. If the issue persists, please provide more details about your environment and any error messages you encounter.

    2. Paula DerrengerUltralytics

      @Stephen-Hao you're welcome! If you're experiencing issues with the model getting stuck while predicting a large number of images, try using the stream=True argument in your model.predict() call. This will help manage memory more efficiently by processing images one at a time instead of loading all at once. Also, ensure you're using the latest version of the Ultralytics package. If the problem persists, please provide more details about your setup and any error messages you encounter.

  4. Johanna-JonesGitHub

    Hey, Is there a way to get the MAP precision, IOU and other metrics for the test images you might give the model?

    I have images and the ground truth for the test images but not sure how to get the same metrics for the PREDICT mode

    Thank you!

    1
    1. Johanna-JonesGitHub

      For clarification my pipeline is currently train> valid with val parameter set to false. I then pass one image at a time to the Yolov8 model in the PREDICT mode

    2. Paula DerrengerUltralytics

      Hey there!

      For evaluating your model with metrics like mAP, precision, and IOU on your test images, you should use the Val mode rather than the Predict mode. The Val mode allows you to validate your model on a dataset and provides comprehensive metrics, including the ones you're interested in. Here's an example on how to do it:

      from ultralytics import YOLO
      
      # Assuming 'coco128.yaml' is your dataset configuration file that includes your test data path
      # and that 'your_model.pt' is the trained model you want to evaluate
      model = YOLO('path/to/your_model.pt')
      
      # Validate the model, this will automatically calculate mAP, IOU, and other metrics
      results = model.val(data='path/to/your_dataset_config.yaml')

      Remember to adjust 'path/to/your_model.pt' and 'path/to/your_dataset_config.yaml' to the actual paths of your model and dataset configuration file.

      In your YAML dataset configuration file, make sure to correctly specify the path to your test images and annotations. This way, YOLOv8 will know how to find your test data and corresponding ground truth for evaluation.

      If you have any more questions, feel free to ask. Good luck with your model evaluation! 🚀

  5. GUPABE10GitHub

    how to ignore printing results after inference: 0: 384x640 10 persons, 1 sports ball, 4080.4ms Speed: 12.3ms preprocess, 4080.4ms inference, 1.7ms postprocess per image at shape (1, 3, 384, 640)

    1
    1. Glenn JocherUltralytics

      To disable printing inference results after running predictions, you can use the verbose=False argument in your predict() function. This will prevent the printout of inference times and detected objects. Here's a quick example on how to do it:

      from ultralytics import YOLO
      
      # Load your YOLOv8 model
      model = YOLO('yolov8n.pt')  
      
      # Run inference with verbose=False
      results = model.predict('path/to/your/image.jpg', verbose=False)

      This should keep your console output clean while still performing inference. 😊

    2. GUPABE10GitHub

      Is it the same if I use:

      results = model('path/to/your/image.jpg')

      just as mentioned in the example in this tutorial.

    3. Glenn JocherUltralytics

      @GUPABE10 hi there!

      Yes, using results = model('path/to/your/image.jpg') is perfectly fine and aligns with the examples provided in the tutorial. This command will run inference on the specified image and return the results as a list of Results objects.

      If you want to avoid printing the detailed inference results (like the number of detected objects and processing times), you can use the verbose=False argument:

      from ultralytics import YOLO
      
      # Load a pretrained YOLOv8n model
      model = YOLO("yolov8n.pt")
      
      # Run inference on an image without printing detailed results
      results = model.predict('path/to/your/image.jpg', verbose=False)

      This will keep your console output clean while still performing the inference. If you have any more questions or need further assistance, feel free to ask! 😊

    4. Glenn JocherUltralytics

      Hi there!

      Great question! The difference between model.predict() and model() lies in their usage and flexibility:

      1. model.predict():

        • This method is explicitly designed for running predictions and allows you to pass various arguments to customize the inference process.
        • You can specify parameters like save, imgsz, conf, device, and more to control the behavior of the prediction.
        • Example:
          from ultralytics import YOLO
          
          # Load a pretrained YOLOv8n model
          model = YOLO("yolov8n.pt")
          
          # Run inference with custom arguments
          results = model.predict("path/to/image.jpg", save=True, imgsz=320, conf=0.5)
      2. model():

        • This is a shorthand method that calls the predict() function internally with default settings.
        • It is useful for quick predictions without needing to specify additional parameters.
        • Example:
          from ultralytics import YOLO
          
          # Load a pretrained YOLOv8n model
          model = YOLO("yolov8n.pt")
          
          # Run inference with default settings
          results = model("path/to/image.jpg")

      Both methods will return a list of Results objects, which you can then process as needed. If you need more control over the prediction process, model.predict() is the way to go. For quick and straightforward predictions, model() is convenient.

      Feel free to check out the Ultralytics documentation on prediction for more details and examples.

      Happy coding! 😊

    1. Glenn JocherUltralytics

      Yes—vid_stride (frame skipping) and imgsz (inference resize) are independent, so you can use them together on video sources; imgsz will be applied to the frames that are actually processed (see the Predict mode inference arguments).

      yolo predict model=yolo26n.pt source=video.mp4 vid_stride=2 imgsz=640
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      for r in model.predict("video.mp4", vid_stride=2, imgsz=640, stream=True):
          pass
      1
    2. amani784GitHub

      Thank you for your help. I have another question: if I don’t define imgsz in predict, will it resize the image to 640 by default? I have multiple inputs with different resolutions, so I can’t specify a single value for imgsz in .predict or even during ONNX export, because sometimes the input resolution is larger than imgsz.

    3. Glenn JocherUltralytics

      Yes—if you don’t pass imgsz to predict(), it uses the default imgsz=640 and will letterbox/resize each frame/image to that inference size (so larger inputs are downscaled, smaller are upscaled); for mixed-resolution sources you can either leave the default or set a larger imgsz for more detail (GPU memory permitting) as described in the predict settings defaults.

      If you need an ONNX that can accept varying input shapes at runtime, export with dynamic shapes enabled (then your runtime can feed different H×W sizes):

      yolo export model=yolo26n.pt format=onnx dynamic=True
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      model.export(format="onnx", dynamic=True)

      Feel free to drop the exact input resolutions (and whether this is video-only) here in the discussion and we can suggest a good imgsz strategy for your case.

      1
    4. amani784GitHub

      Thank you so much ,but for tensorRT export , the model can't accept varying input shapes and i was obliged to put imgsz or my videos have different resolutions and i can't put one imgsz value that can fit all the resolutions. Is there any other solution?

    5. Glenn JocherUltralytics

      Yes—TensorRT doesn’t have to be fixed-shape: export your .engine with dynamic=True so the runtime can accept varying input shapes (you can then choose imgsz per run/video), see the Export mode docs and the TensorRT integration guide.

      yolo export model=yolo26n.pt format=engine dynamic=True

      If you need peak throughput and your resolutions vary a lot, the usual workaround is exporting 2–3 fixed engines at common imgsz values and selecting the closest one at runtime.

      1
  6. Asshok1GitHub

    Hey @glenn-jocher, I’m trying to integrate a TensorRT-optimized YOLO model (.engine) with SAHI (Slicing Aided Hyper Inference) for efficient large-image inference, but I’m facing difficulties making them work together correctly as .engine is not accepted in sahi, can you help in providing the complete code for integrating tensorRT with sahi.

    1. Glenn JocherUltralytics

      SAHI’s built-in Ultralytics integration (model_type="ultralytics") currently expects PyTorch weights like *.pt, so a TensorRT *.engine file won’t load through SAHI as-is; the supported path is to use SAHI with *.pt per the SAHI tiled inference guide, or run the TensorRT engine directly with Ultralytics per the TensorRT export/inference guide. If you specifically need SAHI slicing + a *.engine, you’ll need a custom SAHI DetectionModel adapter around Ultralytics’ TensorRT predictor (best tracked upstream in the SAHI repository); please paste your Ultralytics/SAHI versions and a minimal repro here in the discussion so we can advise on the cleanest adapter approach.

      # SAHI (supported): Ultralytics *.pt + slicing
      from sahi import AutoDetectionModel
      from sahi.predict import get_sliced_prediction
      
      detection_model = AutoDetectionModel.from_pretrained(
          model_type="ultralytics",
          model_path="best.pt",
          confidence_threshold=0.25,
          device="cuda:0",
      )
      
      result = get_sliced_prediction(
          "large.jpg",
          detection_model,
          slice_height=640,
          slice_width=640,
          overlap_height_ratio=0.2,
          overlap_width_ratio=0.2,
      )
      # TensorRT (supported): Ultralytics *.engine inference (no SAHI wrapper)
      from ultralytics import YOLO
      
      model = YOLO("best.engine")
      results = model.predict("large.jpg", device=0, imgsz=640)
  7. hanchaoyuanGitHub

    hello! I used the YOLO11-pose model to estimate the key points of people in the automotive production workshop. However, the model often identified vehicles, hoists and other equipment as humans and calculated the key points, resulting in a relatively high false alarm rate. My question is: How can we prevent the model from identifying other objects and reduce the false alarm rate?

    1. Glenn JocherUltralytics

      For workshop false positives with pose models, the quickest lever is raising the prediction threshold (and optionally increasing imgsz for better person discrimination), but the most reliable fix is fine-tuning on your own workshop data with “hard negative” images (frames with vehicles/hoists but no people) so the model learns your background; see the inference args in the predict mode docs.

      yolo pose predict model=yolo11n-pose.pt source=path/to/video.mp4 conf=0.6 imgsz=960

      If you paste your exact command, plus a couple representative frames (people + false positives) here in the discussion, we can suggest tighter settings or a training setup (and for new work, try a YOLO26 pose checkpoint as it’s generally stronger out of the box).

  8. d5423197GitHub

    Hi there,

    If no boxes/masks detected by the model, what will be the output of model inference. (results = model(["image1.jpg", "image2.jpg"]) #)

    I want to deal with the edge case.

  9. max-dev-14GitHub

    How to predict and show or save prediction YOLO (custom model) for video fragment?