Commencer

Prédiction avec Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Introduction#

En apprentissage automatique et en vision par ordinateur, le fait d’interpréter des données visuelles avec un modèle entraîné s’appelle inférence ou prédiction. Le mode Predict d’Ultralytics YOLO26 permet une inférence en temps réel rapide sur un large éventail de sources de données.

Consulte l’aperçu non publié de YOLO27 pour découvrir les exemples d’inférence prévus.



Regarde : Extrais des boîtes englobantes, des masques, des points clés, des OBB, la profondeur et plus encore avec Ultralytics YOLO26 en Python 🚀

Applications concrètes#

Industrie manufacturièreSportsSécurité
Détection de pièces détachées de véhiculesDétection de joueurs de footballDétection des chutes de personnes

Pourquoi utiliser Ultralytics YOLO pour l’inférence ?#

Principales raisons d’utiliser le mode Predict de YOLO26 :

  • Polyvalence : effectue l’inférence sur des images, des vidéos et des flux en direct.
  • Performances : conçu pour un traitement rapide en temps réel sans sacrifier la précision.
  • Facilité d’utilisation : des interfaces Python et CLI intuitives pour un déploiement et des tests rapides.
  • Personnalisation avancée : divers paramètres permettent d’ajuster le comportement d’inférence du modèle selon tes besoins spécifiques.
  • Prêt pour la production : déploie des modèles sous forme de points de terminaison d’inférence de l’Ultralytics Platform avec mise à l’échelle automatique et surveillance, ou exécute l’inférence localement.

Principales fonctionnalités du mode predict#

Le mode Predict de YOLO26 comprend :

  • Compatibilité avec plusieurs sources de données : le mode Predict accepte des images individuelles, des collections d’images, des fichiers vidéo et des flux vidéo en temps réel.
  • Mode de diffusion en continu : utilise cette fonctionnalité pour générer un générateur économe en mémoire d’objets Results. Active-la en définissant stream=True dans la méthode d’appel du prédicteur. Contrairement au comportement par défaut (stream=False), qui renvoie une liste contenant tous les résultats, stream=True fournit les résultats un par un, ce qui est particulièrement utile pour les longues vidéos et les flux en direct.
  • Traitement par lots : traite plusieurs images ou images vidéo dans un même lot, ce qui réduit encore le temps total d’inférence.
  • Facilité d’intégration : intègre le modèle à tes pipelines de données existants et à d’autres composants logiciels grâce à une API flexible.

Les modèles Ultralytics YOLO renvoient soit une liste Python d’objets Results, soit un générateur économe en mémoire d’objets Results lorsque stream=True est transmis au modèle pendant l’inférence :

Prédiction
from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")  # modèle YOLO26n préentraîné

# Exécuter l’inférence par lots sur une liste d’images
results = model(["image1.jpg", "image2.jpg"])  # renvoyer une liste d’objets Results

# Traiter la liste de résultats
for result in results:
    boxes = result.boxes  # Objet Boxes pour les sorties de boîtes englobantes
    masks = result.masks  # Objet Masks pour les sorties de masques de segmentation
    keypoints = result.keypoints  # Objet Keypoints pour les sorties de pose
    probs = result.probs  # Objet Probs pour les sorties de classification
    obb = result.obb  # Objet Oriented boxes pour les sorties OBB
    result.show()  # afficher à l’écran
    result.save(filename="result.jpg")  # enregistrer sur le disque

Sources d’inférence#

YOLO26 peut traiter différents types de sources d’entrée pour l’inférence, comme indiqué dans le tableau ci-dessous. Ces sources comprennent des images fixes, des flux vidéo et divers formats de données. Le tableau indique également si chaque source peut être utilisée en mode de diffusion en continu avec l’argument stream=True ✅. Ce mode est utile pour traiter des vidéos ou des flux en direct, car il crée un générateur de résultats au lieu de charger toutes les images en mémoire.

Conseil

Utilise stream=True pour traiter de longues vidéos ou de grands jeux de données et gérer efficacement la mémoire. Lorsque stream=False, les résultats de toutes les images ou de tous les points de données sont stockés en mémoire, ce qui peut rapidement occuper beaucoup d’espace et provoquer des erreurs de mémoire insuffisante avec les entrées volumineuses. En revanche, stream=True utilise un générateur qui ne conserve en mémoire que les résultats de l’image ou du point de données actuel, réduisant considérablement la consommation de mémoire et évitant les problèmes de mémoire insuffisante.

SourceExempleTypeRemarques
image'image.jpg'str ou PathFichier image unique.
URL'https://ultralytics.com/images/bus.jpg'strURL d’une image.
capture d’écran ✅'screen'strCapture l’écran en continu jusqu’à l’arrêt.
PILImage.open('image.jpg')PIL.ImageFormat HWC avec des canaux RGB.
OpenCVcv2.imread('image.jpg')np.ndarrayFormat HWC avec des canaux BGR uint8 (0-255).
NumPynp.zeros((640,1280,3))np.ndarrayFormat HWC avec des canaux BGR uint8 (0-255).
torchtorch.zeros(16,3,320,640)torch.TensorFormat BCHW avec des canaux RGB float32 (0.0-1.0).
CSV'sources.csv'str ou PathFichier CSV contenant les chemins d’accès aux images, vidéos ou répertoires.
video ✅'video.mp4'str ou PathFichier vidéo dans des formats tels que MP4, AVI, etc.
directory ✅'path/'str ou PathChemin d’accès à un répertoire contenant des images ou des vidéos.
glob ✅'path/*.jpg'strMotif glob pour faire correspondre plusieurs fichiers. Utilise le caractère * comme joker.
YouTube ✅'https://youtu.be/LNwODJXcvt4'strURL d’une vidéo YouTube.
stream ✅'rtsp://example.com/media.mp4'strURL de protocoles de diffusion en continu tels que RTSP, RTMP, TCP, ou adresse IP.
multi-stream ✅'list.streams'str ou PathFichier texte *.streams contenant une URL de flux par ligne ; par exemple, 8 flux s’exécuteront avec une taille de lot de 8.
webcam ✅0intIndex de la caméra connectée utilisée pour exécuter l’inférence.

Voici des exemples de code pour utiliser chaque type de source :

Sources de prédiction

Effectue une inférence sur un fichier image.

from ultralytics import YOLO

# Charger un modèle YOLO26n préentraîné
model = YOLO("yolo26n.pt")

# Définir le chemin d’accès au fichier image
source = "path/to/image.jpg"

# Exécuter l’inférence sur la source
results = model(source)  # liste d’objets Results

Arguments d’inférence#

model.predict() accepte plusieurs arguments qui peuvent être transmis au moment de l’inférence pour remplacer les valeurs par défaut :

Forme fixe ou rectangle minimal (rect)#

Par défaut, predict utilise rect=True, qui active le remplissage par rectangle minimal lorsque c'est possible. L'image est redimensionnée pour tenir dans imgsz et n'est complétée que jusqu'au multiple de pas le plus proche ; le tenseur final peut donc être plus petit que imgsz. Le remplissage par rectangle minimal n'est utilisé que si toutes les images du lot ont la même forme et si le backend le prend en charge (PyTorch .pt ou export à formes dynamiques, comme ONNX dynamique). Sinon, les images sont complétées jusqu'à la cible complète imgsz. Les modèles de profondeur et RT-DETR ignorent rect et étirent chaque image jusqu'à la cible complète imgsz sans remplissage.

Utilise rect=False pour toujours utiliser la cible complète imgsz. Cette option est recommandée si tu as besoin d'une taille d'entrée fixe correspondant aux modèles exportés (ONNX, TensorRT, etc.).

Entier ou tuple imgsz

  • Un imgsz=640 entier devient une cible (640, 640) carrée après l’arrondi au stride supérieur.
  • Un imgsz=(384, 672) tuple définit une cible rectangulaire. Avec rect=True, le tenseur réel peut être plus petit que cette cible.

Entraînement ou prédiction/export

L’entraînement accepte uniquement un imgsz entier (une liste [h, w] est convertie à sa valeur maximale). Predict et export acceptent un entier ou un tuple (height, width).

Exemple
from ultralytics import YOLO

# Charger un modèle YOLO26n préentraîné
model = YOLO("yolo26n.pt")

# Lancer l’inférence sur « bus.jpg » avec des arguments
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)

Arguments d’inférence :

ArgumentTypeValeur par défautDescription
sourcestr ou int ou NoneNoneSpécifie la source de données pour l’inférence. Il peut s’agir du chemin d’accès à une image, d’un fichier vidéo, d’un répertoire, d’une URL ou de l’identifiant d’un périphérique pour les flux en direct. Si cette valeur est omise, un avertissement est consigné et le modèle utilise les ressources de démonstration intégrées (ultralytics/assets ou une URL de démonstration pour OBB). De nombreux formats et sources sont pris en charge, ce qui permet une utilisation flexible avec différents types d’entrées.
conffloat0.25Définit le seuil de confiance minimal pour les détections. Les objets détectés avec un niveau de confiance inférieur à ce seuil sont ignorés. Modifier cette valeur peut aider à réduire les faux positifs.
ioufloat0.5Seuil d’intersection sur union (IoU) pour la suppression non maximale (NMS). Des valeurs plus faibles produisent moins de détections en éliminant les boîtes qui se chevauchent, ce qui est utile pour réduire les doublons.
imgszint ou tuple640Taille cible du letterboxing. Un entier définit un N×N carré ; un tuple définit (height, width). Avec rect=True, le tenseur réel peut être plus petit que cette taille cible grâce au remplissage en rectangle minimal. Utilise rect=False pour une taille fixe. Consulte Forme fixe ou rectangle minimal.
rectboolTrueSi True, utilise si possible le remplissage par rectangle minimal (même forme de lot et backend compatible). Si False, utilise toujours la cible complète imgsz. Voir Forme fixe ou rectangle minimal. Ignoré pour depth et les modèles RT-DETR, qui étirent les images jusqu'à la cible complète imgsz sans remplissage.
quantizeint ou strNonePrécision d’inférence : 16/"fp16" et 32/"fp32"/unset sélectionnent le calcul en FP16 ou en FP32 pour les modèles PyTorch et TorchScript (FP32 sur CPU) ; les autres formats utilisent la précision définie par leur artefact et leur environnement d’exécution. Avec 16, OpenVINO arrondit toujours l’entrée en FP16 côté client, puis la reconvertit en FP32, sans modifier la précision d’exécution. La quantification INT8/PTQ est configurée lors de l’exportation, puis utilisée lors du chargement du modèle exporté. Remplace l’indicateur half obsolète.
devicestrNoneIndique l'appareil utilisé pour l'inférence (par exemple, cpu, cuda:0, 0, npu ou npu:0). Permet aux utilisateurs de choisir le matériel d'exécution du modèle : CPU, GPU spécifique, NPU Huawei Ascend ou autre appareil de calcul. Les modèles OpenVINO et LiteRT s'exécutent sur le GPU et le NPU Intel avec xpu et npu ; consulte les appareils d'inférence pour chaque format.
dnnboolFalseSi True, utilise le module DNN d'OpenCV au lieu d'ONNX Runtime pour l'inférence des modèles ONNX.
datastrNoneChemin vers un fichier YAML de jeu de données (p. ex. coco8.yaml), lu uniquement pour son names, et seulement si le modèle chargé ne possède pas ses propres noms de classes : un export tiers, ou un export Ultralytics séparé des métadonnées qui l'accompagnent. Sinon, un tel modèle indique class0, class1, et ainsi de suite.
batchint1Définit la taille du lot pour l'inférence (fonctionne uniquement lorsque la source est un répertoire, un fichier vidéo ou un fichier .txt). Une taille de lot plus élevée peut augmenter le débit et réduire le temps total nécessaire à l'inférence.
tilebool ou intFalseEffectue une inférence avec des tuiles fixes et renvoie les résultats dans les coordonnées de l'image d'origine. True utilise imgsz ; un entier positif définit la taille des tuiles. Consulte le découpage en tuiles haute résolution.
max_detint300Nombre maximal de détections autorisées par image. Limite le nombre total d'objets que le modèle peut détecter lors d'une seule inférence, afin d'éviter des sorties excessives dans les scènes denses.
vid_strideint1Pas entre les images pour les entrées vidéo. Permet d'ignorer des images dans les vidéos afin d'accélérer le traitement, au prix d'une résolution temporelle réduite. La valeur 1 traite chaque image ; les valeurs supérieures ignorent des images.
stream_bufferboolFalseDétermine s'il faut mettre en file d'attente les images entrantes des flux vidéo. Si False, les anciennes images sont supprimées pour laisser place aux nouvelles (optimisé pour les applications en temps réel). Si True, les nouvelles images sont placées dans une mémoire tampon, ce qui garantit qu'aucune image n'est ignorée, mais entraîne une latence si le nombre d'images par seconde de l'inférence est inférieur à celui du flux.
visualizeboolFalseEnregistre une carte thermique d'activation des classes à côté de chaque prédiction, indiquant les pixels qui ont augmenté les scores des classes prédites. Respecte conf et classes, de sorte que classes=[0] ne représente que cette classe. Disponible uniquement pour les modèles PyTorch Ultralytics.
augmentboolFalseActive l'augmentation au moment du test (TTA) pour les prédictions, ce qui peut améliorer la robustesse de la détection au prix d'une inférence plus lente. Disponible uniquement pour les modèles PyTorch Ultralytics.
agnostic_nmsboolFalseActive la suppression non maximale (NMS) indépendante des classes : les boîtes qui se chevauchent et dont le score est inférieur sont supprimées même si elles appartiennent à des classes différentes, plutôt qu'uniquement au sein d'une même classe. Utile pour les tâches de détection multiclasse où les classes se chevauchent souvent. Avec l'inférence sans NMS (nms=False sur YOLO26 ou YOLOv10), cette option empêche uniquement la même détection d'apparaître avec plusieurs étiquettes de classe (doublons IoU=1.0) et n'effectue pas de suppression fondée sur un seuil IoU entre des boîtes distinctes.
classeslist[int]NoneFiltre les prédictions selon un ensemble d'identifiants de classe. Seules les détections appartenant aux classes indiquées sont renvoyées. Utile pour se concentrer sur les objets pertinents dans les tâches de détection multiclasse.
retina_masksboolFalseRenvoie des masques de segmentation haute résolution. Si cette option est activée, les masques renvoyés (masks.data) ont la taille de l'image d'origine. Sinon, ils ont la taille de l'image utilisée pour l'inférence.
embedlist[int]NoneIndique les couches à partir desquelles extraire des vecteurs de caractéristiques ou des représentations vectorielles. Utilise model.embed(source) pour les représentations de l'avant-dernière couche, ou model.predict(source, embed=[layer]) pour sélectionner des couches précises. Utile pour les tâches en aval, comme le regroupement ou la recherche par similarité. Disponible uniquement pour les modèles PyTorch Ultralytics.
projectstrNoneNom du répertoire du projet où sont enregistrées les sorties de prédiction si save est activé. Un chemin relatif est placé sous runs_dir/<task>, tandis qu'un chemin absolu est utilisé tel quel.
namestrNoneNom de l'exécution de prédiction. Sert à créer un sous-répertoire dans le dossier du projet, où sont stockées les sorties de prédiction si save est activé.
streamboolFalsePermet de traiter efficacement en mémoire les longues vidéos ou un grand nombre d'images en renvoyant un générateur d'objets Results, au lieu de charger toutes les images en mémoire en une seule fois.
verboseboolTrueDétermine si les journaux détaillés d'inférence sont affichés dans le terminal, pour fournir un retour en temps réel sur le processus de prédiction.
compilebool ou strFalseActive la compilation de graphes torch.compile de PyTorch 2.x avec backend='inductor'. Accepte True → "default", False → désactivation, ou un mode sous forme de chaîne tel que "default", "reduce-overhead", "max-autotune-no-cudagraphs". En cas d’incompatibilité, revient au mode eager avec un avertissement.
channels_lastboolNoneUtilise le format mémoire channels_last (NHWC) pour l'inférence PyTorch native. None l'active automatiquement sur les processeurs x86 sous Linux et Windows compatibles avec oneDNN, avec PyTorch 1.13 ou version ultérieure ; False le désactive et True le demande sur les processeurs x86 ou les appareils CUDA pris en charge. Les appareils ARM64, MPS, les versions antérieures de PyTorch, les processeurs sans oneDNN et les formats exportés tels que TensorRT et ONNX ne sont pas concernés.
nmsbool, facultatifNoneExécute par défaut une inférence un-vers-plusieurs avec NMS (None ou True). Définis False pour utiliser la tête un-vers-un sans NMS lorsqu'elle est disponible. Consulte le guide sur la détection de bout en bout pour en savoir plus.

Arguments de visualisation :

ArgumentTypeValeur par défautDescription
showboolFalseSi True, affiche les images ou vidéos annotées dans une fenêtre. Utile pour obtenir un retour visuel immédiat pendant le développement ou les tests.
saveboolFalse or TrueActive l'enregistrement des images ou vidéos annotées dans des fichiers. Utile pour la documentation, les analyses ultérieures ou le partage des résultats. Valeur par défaut : True avec la CLI et False avec Python.
save_framesboolFalseLors du traitement de vidéos, enregistre chaque image comme fichier image. Utile pour extraire des images spécifiques ou effectuer une analyse détaillée image par image.
save_txtboolFalseEnregistre les résultats de détection dans un fichier texte, au format [class] [x_center] [y_center] [width] [height] [confidence]. Utile pour intégrer les résultats à d'autres outils d'analyse.
save_confboolFalseInclut les scores de confiance dans les fichiers texte enregistrés. Fournit davantage de détails pour le post-traitement et l'analyse.
save_cropboolFalseEnregistre des images recadrées des détections. Utile pour l'augmentation de données, l'analyse ou la création de jeux de données ciblés sur des objets précis.
show_labelsboolTrueAffiche les étiquettes de chaque détection dans le résultat visuel. Permet d'identifier immédiatement les objets détectés.
show_confboolTrueAffiche le score de confiance de chaque détection à côté de son étiquette. Donne une indication du degré de certitude du modèle pour chaque détection.
show_boxesboolTrueDessine des boîtes englobantes autour des objets détectés. Indispensable pour visualiser et localiser les objets dans les images ou les images vidéo.
line_widthint or NoneNoneDéfinit l'épaisseur du trait des boîtes englobantes. Si None, l'épaisseur est ajustée automatiquement en fonction de la taille de l'image. Permet d'adapter l'affichage pour une meilleure lisibilité.

Appareils d'inférence#

device accepte les noms d'appareils PyTorch pour tous les formats de modèle, de sorte que la même valeur sélectionne le même matériel, que tu exécutes un point de contrôle .pt ou un modèle exporté. Laisse ce paramètre non défini pour utiliser le meilleur appareil disponible. Chaque moteur d'exécution associe le nom à son propre matériel, et la validation ainsi que l'évaluation des performances acceptent les mêmes valeurs :

Formatnon définicpu0 ou cuda:0mpsxpunpu
PyTorch .pt, TorchScriptGPU CUDA, sinon CPUCPUGPU NVIDIAGPU AppleGPU IntelNPU Huawei Ascend
ONNXGPU CUDA, sinon CPUCPUGPU NVIDIA (CUDA), GPU AMD (MIGraphX)Core ML--
TensorRTGPU NVIDIAGPU NVIDIAGPU NVIDIA---
OpenVINOOpenVINO AUTOCPU Intel--GPU Intel (xpu:1 correspond à OpenVINO GPU.1)NPU Intel
LiteRTCPUCPU--GPU Intel via le plug-in OpenVINONPU Intel via le plug-in OpenVINO
PaddlePaddleGPU CUDA, sinon CPUCPUGPU NVIDIA---

- signifie que le moteur d'exécution ne dispose d'aucun moteur de calcul pour cet appareil. ONNX, TensorRT et PaddlePaddle vérifient d'abord le nom auprès de PyTorch : ils rejettent donc un appareil que PyTorch ne détecte pas, et s'exécutent sinon sur leur matériel par défaut. OpenVINO émet un avertissement et utilise AUTO si l'appareil Intel demandé est indisponible, tandis que le plug-in Intel LiteRT bascule sur le CPU. Les autres formats choisissent leur propre matériel : CoreML s'exécute sur l'Apple Neural Engine et le CPU, Edge TPU accepte tpu:0, NCNN accepte vulkan:0 pour son chemin GPU Vulkan, et les autres formats s'exécutent sur le CPU ou l'accélérateur de leur cible. Les anciens noms intel:cpu, intel:gpu et intel:npu restent utilisables comme alias obsolètes pour cpu, xpu et npu.

Exemple
from ultralytics import YOLO

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

Formats d’image et de vidéo#

YOLO26 prend en charge différents formats d’image et de vidéo, comme indiqué dans ultralytics/data/utils.py. Consulte les tableaux ci-dessous pour connaître les suffixes valides et voir des exemples de commandes predict.

Images#

Le tableau ci-dessous répertorie les formats d’image Ultralytics valides.

Remarque

Les formats HEIC/HEIF nécessitent pi-heif, qui est installé automatiquement lors de la première utilisation. Pillow prend en charge AVIF nativement.

Suffixes d’imageExemple de commande predictRéférence
.avifyolo predict source=image.avifFormat de fichier image AV1
.bmpyolo predict source=image.bmpFormat de fichier BMP de Microsoft
.dngyolo predict source=image.dngAdobe DNG
.heicyolo predict source=image.heicFormat d’image à haute efficacité
.heifyolo predict source=image.heifFormat d’image à haute efficacité
.jp2yolo predict source=image.jp2JPEG 2000
.jpegyolo predict source=image.jpegJPEG
.jpgyolo predict source=image.jpgJPEG
.mpoyolo predict source=image.mpoObjet image multi-image
.pngyolo predict source=image.pngGraphiques réseau transportables
.tifyolo predict source=image.tifFormat de fichier image balisé
.tiffyolo predict source=image.tiffFormat de fichier image balisé
.webpyolo predict source=image.webpWebP

Vidéos#

Le tableau ci-dessous répertorie les formats vidéo Ultralytics valides.

Suffixes vidéoExemple de commande predictRéférence
.asfyolo predict source=video.asfFormat de systèmes avancés
.aviyolo predict source=video.aviEntrelacement audio-vidéo
.gifyolo predict source=video.gifFormat d’échange de graphiques
.m4vyolo predict source=video.m4vMPEG-4 partie 14
.mkvyolo predict source=video.mkvMatroska
.movyolo predict source=video.movFormat de fichier QuickTime
.mp4yolo predict source=video.mp4MPEG-4 partie 14 - Wikipédia
.mpegyolo predict source=video.mpegMPEG-1 partie 2
.mpgyolo predict source=video.mpgMPEG-1 partie 2
.tsyolo predict source=video.tsFlux de transport MPEG
.wmvyolo predict source=video.wmvVidéo Windows Media
.webmyolo predict source=video.webmProjet WebM

Utiliser les résultats#

Tous les appels Ultralytics predict() renvoient une liste d’objets Results :

Résultats
from ultralytics import YOLO

# Charger un modèle YOLO26n préentraîné
model = YOLO("yolo26n.pt")

# Effectuer une inférence sur une image
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # inférence par lots

Les objets Results possèdent les attributs suivants :

AttributTypeDescription
orig_imgnp.ndarrayL’image d’origine sous forme de tableau NumPy.
orig_shapetupleLa forme de l’image d’origine au format (hauteur, largeur).
boxesBoxes, optionalUn objet Boxes contenant les boîtes englobantes des détections.
masksMasks, optionalUn objet Masks contenant les masques des détections.
probsProbs, optionalUn objet Probs contenant les probabilités de chaque classe pour la tâche de classification.
keypointsKeypoints, optionalUn objet Keypoints contenant les points clés détectés pour chaque objet.
obbOBB, optionalUn objet OBB contenant les boîtes englobantes orientées.
semantic_maskSemanticMask, optionalUn objet SemanticMask contenant une carte de classes dense par pixel.
depthDepthMap, optionalUn objet DepthMap contenant une carte de profondeur dense par pixel.
speeddictUn dictionnaire des vitesses de prétraitement, d’inférence et de post-traitement en millisecondes par image.
namesdictUn dictionnaire associant les indices de classe aux noms des classes.
pathstrLe chemin d’accès au fichier image.
save_dirstr, optionalRépertoire dans lequel enregistrer les résultats.

Résultats par tâche#

Les champs renseignés ci-dessous dépendent de la tâche de ton modèle — compare la détection, la segmentation, la segmentation sémantique, l'estimation de profondeur, la classification, la pose et l'OBB si tu n'as pas encore choisi. Chaque prédiction renvoie un objet Results par image ou trame. Les champs communs ci-dessus sont toujours disponibles, tandis que les données de prédiction propres à la tâche sont stockées dans les champs ci-dessous. Les tenseurs de coordonnées et de confiance YOLO sont de type torch.float32 ; les tenseurs de probabilités sont de type torch.float32, sauf si le modèle s'exécute en FP16 (quantize=16 avec un modèle PyTorch ou TorchScript hors CPU, ou un modèle ONNX avec des entrées FP16), auquel cas ils sont de type torch.float16. Après result.numpy(), les tenseurs deviennent des tableaux NumPy avec les types de données NumPy correspondants. Les masques d'instance sont des tenseurs binaires torch.uint8, tandis que les masques sémantiques utilisent le type d'entier le plus petit possible pour les identifiants de classe : torch.uint8, torch.int16 ou torch.int32, selon le nombre de classes.

AttributTypeFormeDescription
result.boxesBoxes(N)Boîtes de détection.
result.boxes.datatorch.float32(N,6/7)[x1,y1,x2,y2,conf,cls] bruts, avec ID de suivi facultatif.
result.boxes.xyxytorch.float32(N,4)Boîtes de pixels xyxy.
result.boxes.conftorch.float32(N,)Scores de confiance.
result.boxes.clstorch.float32(N,)ID de classe ; convertis-les en int pour obtenir les noms.

Les objets Results disposent des méthodes suivantes :

MéthodeType de retourDescription
update()NoneMet à jour l’objet Results avec de nouvelles données telles que les boîtes, les masques, les probabilités, les OBB, les points clés, les masques sémantiques ou la profondeur.
cpu()ResultsRenvoie une copie de l’objet Results dont tous les tenseurs ont été transférés dans la mémoire CPU.
numpy()ResultsRenvoie une copie de l’objet Results dont tous les tenseurs ont été convertis en tableaux NumPy.
cuda()ResultsRenvoie une copie de l’objet Results dont tous les tenseurs ont été transférés dans la mémoire GPU.
to()ResultsRenvoie une copie de l’objet Results dont les tenseurs ont été transférés vers le périphérique et le type de données spécifiés.
new()ResultsCrée un nouvel objet Results avec les mêmes attributs image, chemin, noms et vitesse.
plot()np.ndarrayTrace les résultats de détection sur une image BGR d’entrée et renvoie l’image annotée.
show()NoneAffiche l’image avec les résultats d’inférence annotés.
save()strEnregistre les résultats d’inférence annotés dans un fichier et renvoie le nom du fichier.
verbose()strRenvoie une chaîne de journal pour chaque tâche, détaillant les résultats de détection et de classification.
save_txt()strEnregistre les résultats de détection dans un fichier texte et renvoie le chemin du fichier enregistré.
save_crop()NoneEnregistre les images de détection recadrées dans le répertoire spécifié.
summary()List[Dict[str, Any]]Convertit les résultats d’inférence en un dictionnaire récapitulatif, avec normalisation facultative.
to_df()DataFrameConvertit les résultats de détection en DataFrame Polars.
to_csv()strConvertit les résultats de détection au format CSV.
to_json()strConvertit les résultats de détection au format JSON.

Pour plus de détails, consulte la documentation de la classe Results.

Boîtes#

L’objet Boxes peut servir à indexer, manipuler et convertir les boîtes englobantes dans différents formats.

Boîtes
from ultralytics import YOLO

# Charger un modèle YOLO26n préentraîné
model = YOLO("yolo26n.pt")

# Effectuer une inférence sur une image
results = model("https://ultralytics.com/images/bus.jpg")  # liste des résultats

# Afficher les résultats
for r in results:
    print(r.boxes)  # afficher l’objet Boxes contenant les boîtes englobantes des détections

Voici un tableau des méthodes et propriétés de la classe Boxes, avec leur nom, leur type et leur description :

NomTypeDescription
cpu()MéthodeTransfère l’objet dans la mémoire CPU.
numpy()MéthodeConvertit l’objet en tableau NumPy.
cuda()MéthodeTransfère l’objet dans la mémoire CUDA.
to()MéthodeTransfère l’objet vers le périphérique spécifié.
xyxyPropriété (torch.Tensor)Renvoie les boîtes au format xyxy.
confPropriété (torch.Tensor)Renvoie les valeurs de confiance des boîtes.
clsPropriété (torch.Tensor)Renvoie les valeurs de classe des boîtes.
idPropriété (torch.Tensor)Renvoie les ID de suivi des boîtes (si disponibles).
xywhPropriété (torch.Tensor)Renvoie les boîtes au format xywh.
xyxynPropriété (torch.Tensor)Renvoie les boîtes au format xyxy, normalisées par rapport à la taille de l’image d’origine.
xywhnPropriété (torch.Tensor)Renvoie les boîtes au format xywh, normalisées par rapport à la taille de l’image d’origine.

Pour plus de détails, consulte la documentation de la classe Boxes.

Masques#

L’objet Masks peut servir à indexer, manipuler et convertir les masques en segments.

Masques
from ultralytics import YOLO

# Charger un modèle YOLO26n-seg Segment préentraîné
model = YOLO("yolo26n-seg.pt")

# Effectuer une inférence sur une image
results = model("https://ultralytics.com/images/bus.jpg")  # liste des résultats

# Afficher les résultats
for r in results:
    print(r.masks)  # afficher l’objet Masks contenant les masques d’instance détectés

Voici un tableau des méthodes et propriétés de la classe Masks, avec leur nom, leur type et leur description :

NomTypeDescription
dataPropriété (torch.Tensor)Tenseur de masque binaire torch.uint8 de forme (N,H,W) et dont les valeurs sont 0 ou 1.
cpu()MéthodeRenvoie le tenseur des masques dans la mémoire CPU.
numpy()MéthodeRenvoie le tenseur des masques sous forme de tableau NumPy.
cuda()MéthodeRenvoie le tenseur des masques dans la mémoire GPU.
to()MéthodeRenvoie le tenseur des masques avec le périphérique et le type de données spécifiés.
xynPropriété (list[np.ndarray])Une liste de polygones de masque normalisés.
xyPropriété (list[np.ndarray])Une liste de polygones de masque en coordonnées de pixels.

Pour plus de détails, consulte la documentation de la classe Masks.

SemanticMask#

SemanticMask stocke une carte de classes dense pour les résultats de segmentation sémantique. Contrairement à Masks, il ne contient pas un masque binaire par objet et ne fournit pas d’outils de manipulation de polygones.

SemanticMask
from ultralytics import YOLO

# Charger un modèle YOLO26n-sem Semantic préentraîné
model = YOLO("yolo26n-sem.pt")

# Effectuer une inférence sur une image
results = model("https://ultralytics.com/images/bus.jpg")  # liste des résultats

# Afficher les résultats
for r in results:
    print(r.semantic_mask.data)  # afficher la carte des ID de classe H x W
NomTypeDescription
dataPropriété (torch.Tensor)Carte des ID de classe de forme (H,W). Le type de données est torch.uint8, torch.int16 ou torch.int32, selon le nombre de classes.
shapePropriété (tuple)Forme de la carte des classes, généralement identique à result.orig_shape.
cpu()MéthodeRenvoie le tenseur du masque sémantique dans la mémoire CPU.
numpy()MéthodeRenvoie le tenseur du masque sémantique sous forme de tableau NumPy.
cuda()MéthodeRenvoie le tenseur du masque sémantique dans la mémoire GPU.
to()MéthodeRenvoie le tenseur du masque sémantique avec le périphérique et le type de données spécifiés.

Points clés#

L’objet Keypoints peut servir à indexer, manipuler et normaliser des coordonnées.

Points clés
from ultralytics import YOLO

# Charger un modèle YOLO26n-pose Pose préentraîné
model = YOLO("yolo26n-pose.pt")

# Effectuer une inférence sur une image
results = model("https://ultralytics.com/images/bus.jpg")  # liste des résultats

# Afficher les résultats
for r in results:
    print(r.keypoints)  # afficher l’objet Keypoints contenant les points clés détectés

Voici un tableau des méthodes et propriétés de la classe Keypoints, avec leur nom, leur type et leur description :

NomTypeDescription
cpu()MéthodeRenvoie le tenseur des points clés dans la mémoire CPU.
numpy()MéthodeRenvoie le tenseur des points clés sous forme de tableau NumPy.
cuda()MéthodeRenvoie le tenseur des points clés dans la mémoire GPU.
to()MéthodeRenvoie le tenseur des points clés avec le périphérique et le type de données spécifiés.
xynPropriété (torch.Tensor)Coordonnées normalisées des points clés de forme (N,K,2).
xyPropriété (torch.Tensor)Coordonnées des points clés en pixels, de forme (N,K,2).
confPropriété (torch.Tensor)Renvoie les valeurs de confiance des points clés si elles sont disponibles, sinon None.

Pour plus de détails, consulte la documentation de la classe Keypoints.

Probabilités#

L’objet Probs permet d’obtenir les indices et les scores de classification top1 et top5.

Probabilités
from ultralytics import YOLO

# Charger un modèle YOLO26n-cls Classify préentraîné
model = YOLO("yolo26n-cls.pt")

# Effectuer une inférence sur une image
results = model("https://ultralytics.com/images/bus.jpg")  # liste des résultats

# Afficher les résultats
for r in results:
    print(r.probs)  # afficher l’objet Probs contenant les probabilités des classes détectées

Voici un tableau récapitulatif des méthodes et propriétés de la classe Probs :

NomTypeDescription
cpu()MéthodeRenvoie une copie du tenseur probs dans la mémoire CPU.
numpy()MéthodeRenvoie une copie du tenseur probs sous forme de tableau NumPy.
cuda()MéthodeRenvoie une copie du tenseur probs dans la mémoire GPU.
to()MéthodeRenvoie une copie du tenseur probs avec le périphérique et le type de données spécifiés.
top1Propriété (int)Indice de la classe la mieux classée.
top5Propriété (list[int])Indices des 5 classes les mieux classées.
top1confPropriété (torch.Tensor)Confiance de la classe la mieux classée.
top5confPropriété (torch.Tensor)Scores de confiance des 5 classes les mieux classées.

Pour plus de détails, consulte la documentation de la classe Probs.

OBB#

L’objet OBB permet d’indexer, de manipuler et de convertir des boîtes englobantes orientées dans différents formats.

OBB
from ultralytics import YOLO

# Charger un modèle YOLO26n préentraîné
model = YOLO("yolo26n-obb.pt")

# Effectuer une inférence sur une image
results = model("https://ultralytics.com/images/boats.jpg")  # liste des résultats

# Afficher les résultats
for r in results:
    print(r.obb)  # afficher l’objet OBB contenant les boîtes englobantes des détections orientées

Voici un tableau des méthodes et propriétés de la classe OBB, avec leur nom, leur type et leur description :

NomTypeDescription
cpu()MéthodeTransfère l’objet dans la mémoire CPU.
numpy()MéthodeConvertit l’objet en tableau NumPy.
cuda()MéthodeTransfère l’objet dans la mémoire CUDA.
to()MéthodeTransfère l’objet vers le périphérique spécifié.
confPropriété (torch.Tensor)Renvoie les valeurs de confiance des boîtes.
clsPropriété (torch.Tensor)Renvoie les valeurs de classe des boîtes.
idPropriété (torch.Tensor)Renvoie les ID de suivi des boîtes (si disponibles).
xyxyPropriété (torch.Tensor)Renvoie les boîtes horizontales au format xyxy.
xywhrPropriété (torch.Tensor)Renvoie les boîtes pivotées au format xywhr.
xyxyxyxyPropriété (torch.Tensor)Renvoie les boîtes pivotées au format xyxyxyxy.
xyxyxyxynPropriété (torch.Tensor)Renvoie les boîtes pivotées au format xyxyxyxy normalisé par la taille de l’image.

Pour plus de détails, consulte la documentation de la classe OBB.

Affichage des résultats#

La méthode plot() des objets Results facilite la visualisation des prédictions en superposant les objets détectés (tels que les boîtes englobantes, les masques, les points clés et les probabilités) sur l’image d’origine. Cette méthode renvoie l’image annotée sous forme de tableau NumPy, ce qui permet de l’afficher ou de l’enregistrer facilement.

Affichage
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")

Paramètres de la méthode plot()#

La méthode plot() accepte différents arguments pour personnaliser la sortie :

ArgumentTypeDescriptionValeur par défaut
confboolInclure les scores de confiance des détections.True
line_widthfloatÉpaisseur des lignes des boîtes englobantes. S’adapte à la taille de l’image si None.None
font_sizefloatTaille de la police du texte. S’adapte à la taille de l’image si None.None
fontstrNom de la police des annotations textuelles.'Arial.ttf'
pilboolRenvoie l’image sous forme d’objet PIL Image.False
imgnp.ndarray | torch.TensorImage de remplacement. Les tenseurs doivent être contigus, au format HWC, en BGR et de type uint8.None
kpt_radiusintRayon des points clés dessinés.5
kpt_lineboolRelier les points clés par des lignes.True
labelsboolInclure les étiquettes de classe dans les annotations.True
boxesboolSuperposer les boîtes englobantes sur l’image.True
masksboolSuperposer les masques sur l’image.True
probsboolInclure les probabilités de classification.True
showboolAfficher directement l’image annotée avec la visionneuse d’images par défaut.False
saveboolEnregistrer l’image annotée dans le fichier spécifié par filename.False
filenamestrChemin et nom du fichier dans lequel enregistrer l’image annotée si save est True.None
color_modestrSpécifier le mode couleur, par exemple « instance » ou « class ».'class'
txt_colortuple[int, int, int]Couleur du texte BGR pour les étiquettes de classification.(255, 255, 255)

Inférence thread-safe#

Garantir la sécurité des threads pendant l’inférence est essentiel lorsque tu exécutes plusieurs modèles YOLO en parallèle dans différents threads. Une inférence thread-safe garantit que les prédictions de chaque thread restent isolées et n’interfèrent pas entre elles, ce qui évite les conditions de concurrence et assure des résultats cohérents et fiables.

Lorsque tu utilises des modèles YOLO dans une application multithread, il est important d’instancier des objets de modèle distincts pour chaque thread ou d’utiliser un stockage local aux threads afin d’éviter les conflits :

Inférence thread-safe

Instancie un modèle unique dans chaque thread pour obtenir une inférence 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)
    # Traiter les résultats

# Démarrer des threads ayant chacun leur propre instance de modèle
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()

Boucle for sur une source en continu#

Voici un script Python utilisant OpenCV (cv2) et YOLO pour effectuer l’inférence sur des images vidéo. Ce script suppose que tu as déjà installé les packages nécessaires (opencv-python et ultralytics).

Boucle for sur un flux
import cv2

from ultralytics import YOLO

# Charger le modèle YOLO
model = YOLO("yolo26n.pt")

# Ouvrir le fichier vidéo
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Parcourir les images vidéo
while cap.isOpened():
    # Lire une image de la vidéo
    success, frame = cap.read()

    if success:
        # Effectuer l’inférence YOLO sur l’image
        results = model(frame)

        # Visualiser les résultats sur l’image
        annotated_frame = results[0].plot()

        # Afficher l’image annotée
        cv2.imshow("YOLO Inference", annotated_frame)

        # Interrompre la boucle si « q » est pressé
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrompre la boucle si la fin de la vidéo est atteinte
        break

# Libérer l’objet de capture vidéo et fermer la fenêtre d’affichage
cap.release()
cv2.destroyAllWindows()

Ce script effectue des prédictions sur chaque image de la vidéo, visualise les résultats et les affiche dans une fenêtre. Tu peux quitter la boucle en appuyant sur « q ».

Et ensuite ?#

Prêt à passer à autre chose qu’un modèle préentraîné ? Vérifie que ta tâche correspond à ton problème, formate tes données avec le guide des jeux de données, puis entraîne ton modèle.

FAQ#

  • Ultralytics YOLO est une famille de modèles de pointe pour la détection d’objets en temps réel, la segmentation d’instances, la segmentation sémantique, l’estimation de profondeur, la classification, l’estimation de pose et la détection de boîtes englobantes orientées (OBB). Son mode de prédiction exécute une inférence à grande vitesse sur des sources de données telles que des images, des vidéos et des flux en direct, avec prise en charge du traitement par lots et du streaming.

  • Ultralytics YOLO peut traiter un large éventail de sources de données, notamment des images individuelles, des vidéos, des répertoires, des URL et des flux. Tu peux spécifier la source de données dans l’appel model.predict(). Par exemple, utilise 'image.jpg' pour une image locale ou 'https://ultralytics.com/images/bus.jpg' pour une URL. Consulte les exemples détaillés de différentes sources d’inférence dans la documentation.

  • Pour optimiser la vitesse d’inférence et gérer efficacement la mémoire, tu peux utiliser le mode de diffusion en continu en définissant stream=True dans la méthode d’appel du prédicteur. Ce mode génère un générateur de Results peu gourmand en mémoire au lieu de charger toutes les images en mémoire. Le mode de diffusion en continu est particulièrement utile pour traiter de longues vidéos ou de grands jeux de données. Pour en savoir plus, consulte la section sur le mode de diffusion en continu.

  • La méthode model.predict() de YOLO prend en charge différents arguments, tels que conf, iou, imgsz, device et d’autres. Ces arguments te permettent de personnaliser le processus d’inférence en définissant des paramètres tels que les seuils de confiance, la taille de l’image et le périphérique utilisé pour les calculs. Tu trouveras des descriptions détaillées de ces arguments dans la section arguments d’inférence.

  • Utilise model.embed(source) pour extraire des embeddings de caractéristiques de l’avant-dernière couche, ou passe embed=[layer_index] à model.predict() pour choisir des couches spécifiques.

    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    source = "https://ultralytics.com/images/bus.jpg"
    
    results = model.predict(source)  # Objets Results
    embeddings = model.embed(source)  # liste d’embeddings torch.Tensor
  • Après une inférence avec YOLO, les objets Results contiennent des méthodes permettant d’afficher et d’enregistrer les images annotées. Tu peux utiliser des méthodes comme result.show() et result.save(filename="result.jpg") pour visualiser et enregistrer les résultats. Tous les répertoires parents manquants dans le chemin du nom de fichier sont créés automatiquement (par exemple, result.save("path/to/result.jpg")). Pour obtenir la liste complète de ces méthodes, consulte la section utilisation des résultats.

Commentaires629

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

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

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