Previsione con Ultralytics YOLO
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#
| Produzione | Sport | Sicurezza |
|---|---|---|
| Rilevamento di ricambi per veicoli | Rilevamento dei calciatori | Rilevamento 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, impostastream=Truenel metodo di chiamata del predittore. A differenza del comportamento predefinito (stream=False), che restituisce un elenco contenente tutti i risultati,stream=Truerestituisce 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:
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 discoOrigini 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.
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.
| Origine | Esempio | Tipo | Note |
|---|---|---|---|
| immagine | 'image.jpg' | str o Path | File immagine singolo. |
| URL | 'https://ultralytics.com/images/bus.jpg' | str | URL di un'immagine. |
| Schermata ✅ | 'screen' | str | Acquisisci continuamente lo schermo finché non interrompi l'acquisizione. |
| PIL | Image.open('image.jpg') | PIL.Image | Formato HWC con canali RGB. |
| OpenCV | cv2.imread('image.jpg') | np.ndarray | Formato HWC con canali BGR uint8 (0-255). |
| NumPy | np.zeros((640,1280,3)) | np.ndarray | Formato HWC con canali BGR uint8 (0-255). |
| torch | torch.zeros(16,3,320,640) | torch.Tensor | Formato BCHW con canali RGB float32 (0.0-1.0). |
| CSV | 'sources.csv' | str o Path | File CSV contenente i percorsi di immagini, video o directory. |
| video ✅ | 'video.mp4' | str o Path | File video in formati come MP4, AVI ecc. |
| directory ✅ | 'path/' | str o Path | Percorso di una directory contenente immagini o video. |
| glob ✅ | 'path/*.jpg' | str | Modello glob per trovare più file. Usa il carattere * come carattere jolly. |
| YouTube ✅ | 'https://youtu.be/LNwODJXcvt4' | str | URL di un video YouTube. |
| flusso ✅ | 'rtsp://example.com/media.mp4' | str | URL per protocolli di streaming come RTSP, RTMP, TCP o un indirizzo IP. |
| flusso multiplo ✅ | 'list.streams' | str o Path | File 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 ✅ | 0 | int | Indice del dispositivo della fotocamera collegata su cui eseguire l'inferenza. |
Di seguito trovi esempi di codice per usare ciascun tipo di origine:
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 ResultsArgomenti 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=640intero diventa una dimensione target quadrata(640, 640)dopo l'arrotondamento allo stride. - Una
imgsz=(384, 672)tupla imposta una dimensione target rettangolare. Conrect=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:
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
source | str o int o None | None | Specifica 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. |
conf | float | 0.25 | Imposta 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. |
iou | float | 0.5 | Soglia 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. |
imgsz | int o tuple | 640 | Dimensione 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. |
rect | bool | True | Se 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. |
quantize | int o str | None | Precisione 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. |
device | str | None | Specifica 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. |
dnn | bool | False | Se True, usa il modulo DNN di OpenCV invece di ONNX Runtime per l'inferenza dei modelli ONNX. |
data | str | None | Percorso 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. |
batch | int | 1 | Specifica 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. |
tile | bool o int | False | Esegue 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_det | int | 300 | Numero 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_stride | int | 1 | Intervallo 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_buffer | bool | False | Determina 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. |
visualize | bool | False | Salva 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. |
augment | bool | False | Abilita 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_nms | bool | False | Abilita 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. |
classes | list[int] | None | Filtra 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_masks | bool | False | Restituisce 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. |
embed | list[int] | None | Specifica 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. |
project | str | None | Nome 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'è. |
name | str | None | Nome dell'esecuzione delle predizioni. Usato per creare una sottodirectory nella cartella del progetto, in cui vengono salvati i risultati delle predizioni se save è abilitato. |
stream | bool | False | Abilita 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. |
verbose | bool | True | Controlla se visualizzare nel terminale i log dettagliati dell'inferenza, fornendo un riscontro in tempo reale sul processo di predizione. |
compile | bool o str | False | Abilita 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_last | bool | None | Usa 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. |
nms | bool, facoltativo | None | Esegue 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:
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
show | bool | False | Se True, mostra le immagini o i video annotati in una finestra. Utile per ottenere un riscontro visivo immediato durante lo sviluppo o i test. |
save | bool | False or True | Abilita 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_frames | bool | False | Durante l'elaborazione dei video, salva i singoli frame come immagini. Utile per estrarre frame specifici o eseguire un'analisi dettagliata frame per frame. |
save_txt | bool | False | Salva 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_conf | bool | False | Include i punteggi di confidenza nei file di testo salvati. Aumenta il livello di dettaglio disponibile per la post-elaborazione e l'analisi. |
save_crop | bool | False | Salva immagini ritagliate dei rilevamenti. Utile per l'aumento dei dati del dataset, l'analisi o la creazione di dataset mirati a oggetti specifici. |
show_labels | bool | True | Mostra le etichette di ogni rilevamento nell'output visivo. Permette di identificare immediatamente gli oggetti rilevati. |
show_conf | bool | True | Mostra il punteggio di confidenza di ogni rilevamento accanto all'etichetta. Fornisce indicazioni sul grado di certezza del modello per ciascun rilevamento. |
show_boxes | bool | True | Disegna riquadri di delimitazione attorno agli oggetti rilevati. Essenziale per identificarli visivamente e localizzarli nelle immagini o nei frame video. |
line_width | int or None | None | Specifica 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:
| Formato | non impostato | cpu | 0 o cuda:0 | mps | xpu | npu |
|---|---|---|---|---|---|---|
PyTorch .pt, TorchScript | GPU CUDA, altrimenti CPU | CPU | GPU NVIDIA | GPU Apple | GPU Intel | NPU Huawei Ascend |
| ONNX | GPU CUDA, altrimenti CPU | CPU | GPU NVIDIA (CUDA), GPU AMD (MIGraphX) | Core ML | - | - |
| TensorRT | GPU NVIDIA | GPU NVIDIA | GPU NVIDIA | - | - | - |
| OpenVINO | OpenVINO AUTO | CPU Intel | - | - | GPU Intel (xpu:1 è il GPU.1 di OpenVINO) | NPU Intel |
| LiteRT | CPU | CPU | - | - | GPU Intel tramite il plugin OpenVINO | NPU Intel tramite il plugin OpenVINO |
| PaddlePaddle | GPU CUDA, altrimenti CPU | CPU | GPU 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.
from ultralytics import YOLO
model = YOLO("yolo26n_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg", device="npu") # NPU IntelFormati 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.
I formati HEIC/HEIF richiedono pi-heif, che viene installato automaticamente al primo utilizzo. Pillow supporta AVIF in modo nativo.
| Suffissi delle immagini | Comando predict di esempio | Riferimento |
|---|---|---|
.avif | yolo predict source=image.avif | Formato file di immagini AV1 |
.bmp | yolo predict source=image.bmp | Formato file BMP di Microsoft |
.dng | yolo predict source=image.dng | Adobe DNG |
.heic | yolo predict source=image.heic | Formato immagine ad alta efficienza |
.heif | yolo predict source=image.heif | Formato immagine ad alta efficienza |
.jp2 | yolo predict source=image.jp2 | JPEG 2000 |
.jpeg | yolo predict source=image.jpeg | JPEG |
.jpg | yolo predict source=image.jpg | JPEG |
.mpo | yolo predict source=image.mpo | Oggetto multi-immagine |
.png | yolo predict source=image.png | Grafica di rete portatile |
.tif | yolo predict source=image.tif | Formato file immagine con tag |
.tiff | yolo predict source=image.tiff | Formato file immagine con tag |
.webp | yolo predict source=image.webp | WebP |
Video#
La tabella seguente contiene i formati video Ultralytics validi.
| Suffissi dei video | Comando predict di esempio | Riferimento |
|---|---|---|
.asf | yolo predict source=video.asf | Formato Advanced Systems |
.avi | yolo predict source=video.avi | Audio Video Interleave |
.gif | yolo predict source=video.gif | Formato di interscambio grafico |
.m4v | yolo predict source=video.m4v | MPEG-4 Parte 14 |
.mkv | yolo predict source=video.mkv | Matroska |
.mov | yolo predict source=video.mov | Formato file QuickTime |
.mp4 | yolo predict source=video.mp4 | MPEG-4 Parte 14 - Wikipedia |
.mpeg | yolo predict source=video.mpeg | MPEG-1 Parte 2 |
.mpg | yolo predict source=video.mpg | MPEG-1 Parte 2 |
.ts | yolo predict source=video.ts | Flusso di trasporto MPEG |
.wmv | yolo predict source=video.wmv | Windows Media Video |
.webm | yolo predict source=video.webm | Progetto WebM |
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 batchGli oggetti Results hanno i seguenti attributi:
| Attributo | Tipo | Descrizione |
|---|---|---|
orig_img | np.ndarray | L'immagine originale come array NumPy. |
orig_shape | tuple | La forma dell'immagine originale nel formato (altezza, larghezza). |
boxes | Boxes, optional | Un oggetto Boxes contenente i riquadri di delimitazione rilevati. |
masks | Masks, optional | Un oggetto Masks contenente le maschere rilevate. |
probs | Probs, optional | Un oggetto Probs contenente le probabilità di ogni classe per l'attività di classificazione. |
keypoints | Keypoints, optional | Un oggetto Keypoints contenente i punti chiave rilevati per ogni oggetto. |
obb | OBB, optional | Un oggetto OBB contenente riquadri di delimitazione orientati. |
semantic_mask | SemanticMask, optional | Un oggetto SemanticMask contenente una mappa delle classi densa per pixel. |
depth | DepthMap, optional | Un oggetto DepthMap contenente una mappa di profondità densa per pixel. |
speed | dict | Un dizionario delle velocità di preelaborazione, inferenza e postelaborazione in millisecondi per immagine. |
names | dict | Un dizionario che associa gli indici delle classi ai nomi delle classi. |
path | str | Il percorso del file immagine. |
save_dir | str, optional | Directory 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.
| Attributo | Tipo | Forma | Descrizione |
|---|---|---|---|
result.boxes | Boxes | (N) | Riquadri di rilevamento. |
result.boxes.data | torch.float32 | (N,6/7) | [x1,y1,x2,y2,conf,cls] grezzi, più l'ID di tracciamento opzionale. |
result.boxes.xyxy | torch.float32 | (N,4) | Riquadri in pixel xyxy. |
result.boxes.conf | torch.float32 | (N,) | Punteggi di confidenza. |
result.boxes.cls | torch.float32 | (N,) | ID delle classi; converti in int per ottenere i nomi. |
Gli oggetti Results dispongono dei seguenti metodi:
| Metodo | Tipo restituito | Descrizione |
|---|---|---|
update() | None | Aggiorna l'oggetto Results con nuovi dati, come riquadri, maschere, probabilità, OBB, punti chiave, maschere semantiche o profondità. |
cpu() | Results | Restituisce una copia dell'oggetto Results con tutti i tensori spostati nella memoria CPU. |
numpy() | Results | Restituisce una copia dell'oggetto Results con tutti i tensori convertiti in array NumPy. |
cuda() | Results | Restituisce una copia dell'oggetto Results con tutti i tensori spostati nella memoria GPU. |
to() | Results | Restituisce una copia dell'oggetto Results con i tensori spostati sul dispositivo e convertiti nel tipo di dati specificati. |
new() | Results | Crea un nuovo oggetto Results con gli stessi attributi image, path, names e speed. |
plot() | np.ndarray | Traccia i risultati del rilevamento su un'immagine BGR di input e restituisce l'immagine annotata. |
show() | None | Visualizza l'immagine con i risultati dell'inferenza annotati. |
save() | str | Salva su file l'immagine con i risultati dell'inferenza annotati e restituisce il nome del file. |
verbose() | str | Restituisce una stringa di log per ogni attività, con i dettagli dei risultati del rilevamento e della classificazione. |
save_txt() | str | Salva i risultati del rilevamento in un file di testo e restituisce il percorso del file salvato. |
save_crop() | None | Salva 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() | DataFrame | Converte i risultati del rilevamento in un DataFrame Polars. |
to_csv() | str | Converte i risultati del rilevamento in formato CSV. |
to_json() | str | Converte 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.
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 rilevatiEcco una tabella dei metodi e delle proprietà della classe Boxes, con nome, tipo e descrizione:
| Nome | Tipo | Descrizione |
|---|---|---|
cpu() | Metodo | Sposta l'oggetto nella memoria CPU. |
numpy() | Metodo | Converte l'oggetto in un array NumPy. |
cuda() | Metodo | Sposta l'oggetto nella memoria CUDA. |
to() | Metodo | Sposta l'oggetto sul dispositivo specificato. |
xyxy | Proprietà (torch.Tensor) | Restituisce i riquadri in formato xyxy. |
conf | Proprietà (torch.Tensor) | Restituisce i valori di confidenza dei riquadri. |
cls | Proprietà (torch.Tensor) | Restituisce i valori di classe dei riquadri. |
id | Proprietà (torch.Tensor) | Restituisce gli ID di tracciamento dei riquadri, se disponibili. |
xywh | Proprietà (torch.Tensor) | Restituisce i riquadri in formato xywh. |
xyxyn | Proprietà (torch.Tensor) | Restituisce i riquadri in formato xyxy, normalizzati rispetto alle dimensioni dell'immagine originale. |
xywhn | Proprietà (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.
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 rilevateEcco una tabella dei metodi e delle proprietà della classe Masks, con nome, tipo e descrizione:
| Nome | Tipo | Descrizione |
|---|---|---|
data | Proprietà (torch.Tensor) | Tensore di maschere binarie torch.uint8 con forma (N,H,W) e valori 0 o 1. |
cpu() | Metodo | Restituisce il tensore delle maschere nella memoria CPU. |
numpy() | Metodo | Restituisce il tensore delle maschere come array NumPy. |
cuda() | Metodo | Restituisce il tensore delle maschere nella memoria GPU. |
to() | Metodo | Restituisce il tensore delle maschere con il dispositivo e il tipo di dati specificati. |
xyn | Proprietà (list[np.ndarray]) | Un elenco di poligoni delle maschere normalizzati. |
xy | Proprietà (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.
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| Nome | Tipo | Descrizione |
|---|---|---|
data | Proprietà (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. |
shape | Proprietà (tuple) | Forma della mappa delle classi, generalmente corrispondente a result.orig_shape. |
cpu() | Metodo | Restituisce il tensore della maschera semantica nella memoria CPU. |
numpy() | Metodo | Restituisce il tensore della maschera semantica come array NumPy. |
cuda() | Metodo | Restituisce il tensore della maschera semantica nella memoria GPU. |
to() | Metodo | Restituisce 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.
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 rilevatiEcco una tabella dei metodi e delle proprietà della classe Keypoints, con nome, tipo e descrizione:
| Nome | Tipo | Descrizione |
|---|---|---|
cpu() | Metodo | Restituisce il tensore dei punti chiave nella memoria CPU. |
numpy() | Metodo | Restituisce il tensore dei punti chiave come array NumPy. |
cuda() | Metodo | Restituisce il tensore dei punti chiave nella memoria GPU. |
to() | Metodo | Restituisce il tensore dei punti chiave con il dispositivo e il tipo di dati specificati. |
xyn | Proprietà (torch.Tensor) | Coordinate normalizzate dei punti chiave con forma (N,K,2). |
xy | Proprietà (torch.Tensor) | Coordinate dei punti chiave in pixel con forma (N,K,2). |
conf | Proprietà (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.
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 rilevateEcco una tabella riepilogativa dei metodi e delle proprietà della classe Probs:
| Nome | Tipo | Descrizione |
|---|---|---|
cpu() | Metodo | Restituisce una copia del tensore probs nella memoria della CPU. |
numpy() | Metodo | Restituisce una copia del tensore probs come array NumPy. |
cuda() | Metodo | Restituisce una copia del tensore probs nella memoria della GPU. |
to() | Metodo | Restituisce una copia del tensore probs con il dispositivo e il dtype specificati. |
top1 | Proprietà (int) | Indice della classe al primo posto. |
top5 | Proprietà (list[int]) | Indici delle prime 5 classi. |
top1conf | Proprietà (torch.Tensor) | Confidenza della classe al primo posto. |
top5conf | Proprietà (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.
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 rilevazioniEcco una tabella dei metodi e delle proprietà della classe OBB, con nome, tipo e descrizione:
| Nome | Tipo | Descrizione |
|---|---|---|
cpu() | Metodo | Sposta l'oggetto nella memoria CPU. |
numpy() | Metodo | Converte l'oggetto in un array NumPy. |
cuda() | Metodo | Sposta l'oggetto nella memoria CUDA. |
to() | Metodo | Sposta l'oggetto sul dispositivo specificato. |
conf | Proprietà (torch.Tensor) | Restituisce i valori di confidenza dei riquadri. |
cls | Proprietà (torch.Tensor) | Restituisce i valori di classe dei riquadri. |
id | Proprietà (torch.Tensor) | Restituisce gli ID di tracciamento dei riquadri, se disponibili. |
xyxy | Proprietà (torch.Tensor) | Restituisce le bounding box orizzontali nel formato xyxy. |
xywhr | Proprietà (torch.Tensor) | Restituisce le bounding box ruotate nel formato xywhr. |
xyxyxyxy | Proprietà (torch.Tensor) | Restituisce le bounding box ruotate nel formato xyxyxyxy. |
xyxyxyxyn | Proprietà (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.
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:
| Argomento | Tipo | Descrizione | Predefinito |
|---|---|---|---|
conf | bool | Includi i punteggi di confidenza delle rilevazioni. | True |
line_width | float | Spessore delle linee delle bounding box. Si adatta alle dimensioni dell'immagine se None. | None |
font_size | float | Dimensione del carattere del testo. Si adatta alle dimensioni dell'immagine se None. | None |
font | str | Nome del carattere per le annotazioni testuali. | 'Arial.ttf' |
pil | bool | Restituisce l'immagine come oggetto PIL Image. | False |
img | np.ndarray | torch.Tensor | Immagine alternativa. I tensori devono essere contigui, nel formato HWC BGR uint8. | None |
kpt_radius | int | Raggio dei keypoint disegnati. | 5 |
kpt_line | bool | Collega i keypoint con delle linee. | True |
labels | bool | Includi le etichette delle classi nelle annotazioni. | True |
boxes | bool | Sovrapponi le bounding box all'immagine. | True |
masks | bool | Sovrapponi le maschere all'immagine. | True |
probs | bool | Includi le probabilità di classificazione. | True |
show | bool | Visualizza direttamente l'immagine annotata con il visualizzatore di immagini predefinito. | False |
save | bool | Salva l'immagine annotata nel file specificato da filename. | False |
filename | str | Percorso e nome del file in cui salvare l'immagine annotata se save è True. | None |
color_mode | str | Specifica la modalità del colore, ad esempio 'instance' o 'class'. | 'class' |
txt_color | tuple[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:
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).
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=Truenel metodo di chiamata del predictor. La modalità streaming genera un generatore di oggettiResultsa 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, comeconf,iou,imgsz,devicee 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 passaembed=[layer_index]amodel.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.TensorDopo aver eseguito l'inferenza con YOLO, gli oggetti
Resultscontengono metodi per visualizzare e salvare le immagini annotate. Puoi usare metodi comeresult.show()eresult.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.
Tigores
你好,我想问一下为什么我在推理相同的图像时,设置不同的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
Glenn JocherUltralytics@Tigores 您好!YOLO模型在推理时会自动将输入图像缩放到您指定的imgsz参数值(而非固定为训练尺寸),更大的分辨率能保留更多细节从而提升小目标检测能力。具体原理可参考Predict模式文档中的图像尺寸与精度关系说明,这是预期行为而非异常现象。
LwpZoe
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
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 withboxes=Falseandmasks=Trueto only display the segmentation masks. Alternatively, you can directly accessresult.masks.datafor raw mask data and process it as needed. Refer to the Results section for more details.LwpZoe
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?
Glenn JocherUltralyticsTo display only the segmentation mask without overlays, modify the
plot()function parameters by settingboxes=False,labels=False, and ensuringmasks=True. You don't need retraining to adjust visualization settings, as the weights remain unaffected. For further details, refer to the Results.plot() documentation.
UserHello, 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
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=Trueargument in yourmodel.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.
UserYes, Thank you a lot.
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=Trueargument in yourmodel.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.
Johanna-Jones
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!
1Johanna-Jones
For clarification my pipeline is currently train> valid with
valparameter set to false. I then pass one image at a time to the Yolov8 model in the PREDICT mode
Paula DerrengerUltralyticsHey there!
For evaluating your model with metrics like mAP, precision, and IOU on your test images, you should use the
Valmode rather than thePredictmode. TheValmode 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! 🚀
GUPABE10
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
Glenn JocherUltralyticsTo disable printing inference results after running predictions, you can use the
verbose=Falseargument in yourpredict()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. 😊
GUPABE10
Is it the same if I use:
results = model('path/to/your/image.jpg')
just as mentioned in the example in this tutorial.
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 ofResultsobjects.If you want to avoid printing the detailed inference results (like the number of detected objects and processing times), you can use the
verbose=Falseargument: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! 😊
GUPABE10
What is the difference between model.predict() and model()?
Glenn JocherUltralyticsHi there!
Great question! The difference between
model.predict()andmodel()lies in their usage and flexibility:-
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)
-
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")
- This is a shorthand method that calls the
Both methods will return a list of
Resultsobjects, 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! 😊
-
amani784
Hello @glenn-jocher, i have question, my inputs are videos, if i use vid-stride , can i use imgsz with it ?
Glenn JocherUltralyticsYes—
vid_stride(frame skipping) andimgsz(inference resize) are independent, so you can use them together on video sources;imgszwill 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=640from ultralytics import YOLO model = YOLO("yolo26n.pt") for r in model.predict("video.mp4", vid_stride=2, imgsz=640, stream=True): pass1amani784
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.
Glenn JocherUltralyticsYes—if you don’t pass
imgsztopredict(), it uses the defaultimgsz=640and 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 largerimgszfor 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=Truefrom 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
imgszstrategy for your case.1amani784
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?
Glenn JocherUltralyticsYes—TensorRT doesn’t have to be fixed-shape: export your
.enginewithdynamic=Trueso the runtime can accept varying input shapes (you can then chooseimgszper run/video), see the Export mode docs and the TensorRT integration guide.yolo export model=yolo26n.pt format=engine dynamic=TrueIf you need peak throughput and your resolutions vary a lot, the usual workaround is exporting 2–3 fixed engines at common
imgszvalues and selecting the closest one at runtime.1
Asshok1
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.
Glenn JocherUltralyticsSAHI’s built-in Ultralytics integration (
model_type="ultralytics") currently expects PyTorch weights like*.pt, so a TensorRT*.enginefile won’t load through SAHI as-is; the supported path is to use SAHI with*.ptper 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 SAHIDetectionModeladapter 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)
hanchaoyuan
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?
Glenn JocherUltralyticsFor workshop false positives with pose models, the quickest lever is raising the prediction threshold (and optionally increasing
imgszfor 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=960If 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).
d5423197
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.
max-dev-14
How to predict and show or save prediction YOLO (custom model) for video fragment?
