Prédiction de modèles avec Ultralytics YOLO#

Introduction#

Dans le domaine de l'apprentissage automatique et de la vision par ordinateur, le processus consistant à interpréter des données visuelles est souvent appelé inférence ou prédiction. Ultralytics YOLO26 propose une fonctionnalité puissante appelée mode prédiction, conçue pour l'inférence haute performance en temps réel sur un large éventail de sources de données.

Consulte l'aperçu non publié de YOLO27 pour des exemples d'inférence prévus.

Applications concrètes#

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

Voici pourquoi tu devrais envisager le mode prédiction de YOLO26 pour tes différents besoins d'inférence :

• Polyvalence : capable d'effectuer des inférences sur des images, des vidéos et même des flux en direct.
• Performances : conçu pour un traitement en temps réel et à haute vitesse, sans sacrifier la précision.
• Facilité d'utilisation : interfaces Python et CLI intuitives pour un déploiement et des tests rapides.
• Hautement personnalisable : différents paramètres et réglages pour ajuster le comportement d'inférence du modèle en fonction de tes besoins spécifiques.
• Prêt pour la production : déploie les modèles en tant qu'endpoints d'inférence de la plateforme Ultralytics avec mise à l'échelle automatique et supervision, ou exécute l'inférence localement.

Fonctionnalités clés du mode prédiction#

Le mode prédiction de YOLO26 est conçu pour être robuste et polyvalent, avec notamment :

• Compatibilité avec plusieurs sources de données : que tes données prennent la forme d'images individuelles, d'une collection d'images, de fichiers vidéo ou de flux vidéo en temps réel, le mode prédiction répond à tes besoins.
• Mode streaming : utilise la fonctionnalité de streaming pour générer un générateur économe en mémoire d'objets Results. Active cette fonctionnalité 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 renvoie les résultats un par un, ce qui est particulièrement utile pour les vidéos longues et les flux en direct.
• Traitement par lots : traite plusieurs images ou images vidéo dans un seul lot afin de réduire davantage la durée totale de l'inférence.
• Facilité d'intégration : s'intègre facilement aux pipelines de données existants et à d'autres composants logiciels grâce à son 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 :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # pretrained YOLO26n model

# Run batched inference on a list of images
results = model(["image1.jpg", "image2.jpg"])  # return a list of Results objects

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

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 statiques, des flux vidéo et différents formats de données. Le tableau indique également si chaque source peut être utilisée en mode streaming avec l'argument stream=True ✅. Le mode streaming 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

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Define path to the image file
source = "path/to/image.jpg"

# Run inference on the source
results = model(source)  # list of Results objects

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 :

Taille fixe ou rectangle minimal (rect)#

Par défaut, predict utilise rect=True, ce qui active si possible le remplissage en rectangle minimal. L'image est mise à l'échelle pour tenir dans imgsz et complétée uniquement jusqu'au multiple de stride supérieur le plus proche ; le tenseur final peut donc être plus petit que imgsz. Le remplissage en rectangle minimal est utilisé uniquement lorsque toutes les images du lot ont la même forme et que le backend le prend en charge (PyTorch .pt, ou ONNX / Triton 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 aux modèles exportés (ONNX, TensorRT, etc.).

Entier ou tuple imgsz

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

Entraînement ou prédiction/export

L’entraînement accepte uniquement un entier imgsz (une liste [h, w] est convertie en sa valeur maximale). La prédiction et l’exportation acceptent soit un entier, soit un tuple (height, width).

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on 'bus.jpg' with 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’images et de vidéos#

YOLO26 prend en charge différents formats d’images et de vidéos, 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 contient les formats d’image Ultralytics valides.

Vidéos#

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

Utilisation des résultats#

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

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # batch inference

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 detection, segmentation, semantic segmentation, depth estimation, classification, pose, and OBB si tu n'en as pas encore choisi une. Chaque prédiction renvoie un objet Results par image ou par trame. Les champs communs ci-dessus sont toujours disponibles, tandis que les données de prédiction spécifiques à 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é sont de type torch.float32 (sauf en cas d'utilisation de la demi-précision, auquel cas il s'agit de torch.float16). Après result.numpy(), les tenseurs deviennent des tableaux NumPy dotés de types de données (dtypes) NumPy correspondants. Les masques d'instance sont des tenseurs binaires torch.uint8, tandis que les masques sémantiques utilisent le plus petit type de données entier pratique 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 être utilisé pour indexer, manipuler et convertir les boîtes englobantes dans différents formats.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.boxes)  # print the Boxes object containing the detection bounding boxes

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 être utilisé pour indexer, manipuler et convertir les masques en segments.

from ultralytics import YOLO

# Load a pretrained YOLO26n-seg Segment model
model = YOLO("yolo26n-seg.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.masks)  # print the Masks object containing the detected instance masks

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 dense des classes pour les résultats de segmentation sémantique. Contrairement à Masks, il ne contient pas un masque binaire par objet et ne fournit pas d’utilitaires pour les polygones.

from ultralytics import YOLO

# Load a pretrained YOLO26n-sem Semantic model
model = YOLO("yolo26n-sem.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.semantic_mask.data)  # print the H x W class-ID map

Points clés#

L’objet Keypoints peut être utilisé pour indexer, manipuler et normaliser les coordonnées.

from ultralytics import YOLO

# Load a pretrained YOLO26n-pose Pose model
model = YOLO("yolo26n-pose.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.keypoints)  # print the Keypoints object containing the detected keypoints

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 peut être utilisé pour obtenir les indices et scores de classification top1 et top5.

from ultralytics import YOLO

# Load a pretrained YOLO26n-cls Classify model
model = YOLO("yolo26n-cls.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.probs)  # print the Probs object containing the detected class probabilities

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 peut être utilisé pour indexer, manipuler et convertir des BBox orientées dans différents formats.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n-obb.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/boats.jpg")  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

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.

Tracé 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 BBox, 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 sont isolées et n’interfèrent pas les unes avec les autres, ce qui évite les conditions de concurrence et assure des sorties cohérentes 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 au thread 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)
    # Process results

# Starting threads that each have their own model instance
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 de l’inférence thread-safe avec YOLO. Ce guide te fournira toutes les informations nécessaires pour éviter les pièges courants et garantir le bon déroulement de ton inférence multithread.

Boucle for sur une source en streaming#

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

# Load the YOLO model
model = YOLO("yolo26n.pt")

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

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO Inference", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
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 à aller au-delà d’un modèle préentraîné ? Vérifie que ta tâche correspond à ton problème, formate tes propres données avec le guide des jeux de données, puis entraîne ton modèle avec celles-ci.

FAQ#