Prédiction avec Ultralytics YOLO#

Introduction#

Dans le domaine de l’apprentissage automatique et de la vision par ordinateur, le processus d’interprétation des données visuelles est souvent appelé inférence ou prédiction. Ultralytics YOLO26 propose une fonctionnalité puissante appelée mode predict, conçue pour l’inférence en temps réel et hautes performances à partir d’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.

Applications concrètes#

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

Voici pourquoi tu devrais envisager le mode predict de YOLO26 pour tes différents besoins en inférence :

• Polyvalence : permet d’effectuer des inférences sur des images, des vidéos et même 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 est conçu pour être robuste et polyvalent, avec notamment :

• Compatibilité avec plusieurs sources de données : que tes données se présentent sous forme d’images individuelles, d’une collection d’images, de fichiers vidéo ou de flux vidéo en temps réel, le mode predict répond à tes besoins.
• 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 seul lot afin de réduire davantage le temps total d’inférence.
• Facilité d’intégration : grâce à son API flexible, intègre facilement le modèle à tes pipelines de données existants et à d’autres composants logiciels.

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 :

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.

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

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 cela est possible. L’image est redimensionnée pour tenir dans imgsz et complétée uniquement jusqu’au multiple de stride le plus proche ; le tenseur final peut donc être plus petit que imgsz. Le remplissage par rectangle minimal n’est utilisé que lorsque toutes les images du lot ont la même forme et que le backend le prend en charge (PyTorch .pt ou un export à forme dynamique, comme ONNX dynamique). Sinon, les images sont complétées jusqu’à la cible imgsz complète.

Utilise rect=False pour toujours compléter jusqu’à la cible imgsz complète. Cette option est recommandée lorsque tu as besoin d’une taille d’entrée fixe correspondant à celle des 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).

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 :

Arguments de visualisation :

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.

Vidéos#

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

Utiliser les résultats#

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

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 :

Résultats par tâche#

Les champs renseignés ci-dessous dépendent de la tâche de ton modèle — compare les tâches de détection, de segmentation, de segmentation sémantique, d’estimation de profondeur, de classification, de pose et OBB si tu n’as pas encore choisi. Chaque prédiction renvoie un objet Results par image ou par image vidéo. 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 torch.float32 ; les tenseurs de probabilité sont torch.float32, sauf en cas d’inférence FP16 (quantize=16), où ils sont alors 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 entier le plus petit possible pour les identifiants de classe : torch.uint8, torch.int16 ou torch.int32, selon le nombre de classes.

Les objets Results disposent des méthodes suivantes :

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.

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 :

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.

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 :

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.

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

Points clés#

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

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 :

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.

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 :

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.

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 :

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.

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 :

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 sur différents threads. Une inférence thread-safe garantit que les prédictions de chaque thread restent isolées et n’interfèrent pas les unes avec les autres, évitant ainsi les conditions de concurrence et assurant 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 :

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

Pour découvrir en détail l’inférence thread-safe avec les modèles YOLO et suivre des instructions étape par étape, consulte notre guide sur l’inférence thread-safe avec YOLO. Ce guide te fournira toutes les informations nécessaires pour éviter les pièges courants et assurer le bon déroulement de ton inférence multithread.

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

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#