Prédiction de modèle avec Ultralytics YOLO#

Introduction#

Dans le monde 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 offre une fonctionnalité puissante connue sous le nom de mode de prédiction (predict mode), conçue pour une inférence haute performance en temps réel sur un large éventail de sources de données.

Applications concrètes#

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

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

• Polyvalence : Capable d'exécuter l'inférence sur des images, des vidéos et même des flux en direct.
• Performance : Conçu pour un traitement ultra-rapide en temps réel sans sacrifier la précision.
• Facilité d'utilisation : Interfaces Python et CLI intuitives pour un déploiement et des tests rapides.
• Hautement personnalisable : Divers réglages et paramètres pour ajuster le comportement d'inférence du modèle selon tes besoins spécifiques.
• Prêt pour la production : Déploie des modèles en tant que points de terminaison d'inférence Ultralytics Platform avec mise à l'échelle automatique et surveillance, 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, incluant :

• Compatibilité avec de multiples 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 prédiction te couvre.
• Mode streaming : Utilise la fonctionnalité de streaming pour générer un générateur économe en mémoire d'objets Results. Active cette option 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 produit les résultats un par un, ce qui s'avère particulièrement utile pour les vidéos longues et les flux en direct.
• Traitement par lots : Traite plusieurs images ou trames vidéo en un seul lot, réduisant encore le temps total d'inférence.
• Intégration facile : Intègre-le facilement avec tes 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 lors de 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 le montre le tableau ci-dessous. Les sources comprennent des images statiques, des flux vidéo et divers 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 avantageux pour le traitement de vidéos ou de flux en direct car il crée un générateur de résultats au lieu de charger toutes les trames en mémoire.

Tu trouveras ci-dessous 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 passés au moment de l'inférence pour remplacer les valeurs par défaut :

Forme fixe vs rectangle minimal (rect)#

Par défaut, predict utilise rect=True, ce qui active le remplissage par rectangle minimal lorsque cela est possible. L'image est mise à l'échelle pour tenir dans imgsz et n'est remplie que jusqu'au multiple de pas le plus proche, de sorte que le tenseur final peut ê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 ONNX dynamique / Triton). Sinon, les images sont remplies jusqu'à la cible entière imgsz.

Utilise rect=False pour toujours remplir jusqu'à la cible complète imgsz. Ceci est recommandé lorsque tu as besoin d'une taille d'entrée fixe pour correspondre aux modèles exportés (ONNX, TensorRT, etc.).

Entier vs tuple imgsz

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

Entraînement vs prédiction/export

L'entraînement n'accepte qu'un seul entier imgsz (une liste [h, w] est convertie à la valeur la plus grande). Predict et export 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'image et de vidéo#

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

Images#

Le tableau ci-dessous contient les formats d'image valides pour Ultralytics.

Vidéos#

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

Travailler avec les résultats#

Tous les appels Ultralytics predict() renverront 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 la détection, la segmentation, la segmentation sémantique, l'estimation de profondeur, la classification, la pose et l'OBB si tu n'en as pas encore choisi une. 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 spécifiques à la tâche sont stockées dans les champs ci-dessous. Les tenseurs de coordonnées, de confiance et de probabilité sont en torch.float32 sauf si la demi-précision est utilisée, auquel cas ils sont en 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 plus petit type de données entier pratique pour les ID de classe : torch.uint8, torch.int16 ou torch.int32, selon le nombre de classes.

Les objets Results possèdent les 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 des boîtes englobantes en 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, incluant 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 des 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, incluant 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 classe dense pour les résultats de segmentation sémantique. Contrairement à Masks, elle ne contient pas un masque binaire par objet et ne fournit pas d'assistants 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

Keypoints#

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, incluant leur nom, leur type et leur description :

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

Probs#

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ésumant les 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 boîtes englobantes orientées en 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, incluant leur nom, leur type et leur description :

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

Visualisation des résultats#

La méthode plot() dans les 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, permettant un affichage ou un enregistrement facile.

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() prend en charge divers arguments pour personnaliser la sortie :

Inférence thread-safe#

Garantir la sécurité des threads lors de l'inférence est crucial lorsque tu exécutes plusieurs modèles YOLO en parallèle sur différents threads. L'inférence thread-safe garantit que les prédictions de chaque thread sont isolées et n'interfèrent pas entre elles, évitant les conditions de concurrence et assurant des résultats cohérents et fiables.

Lorsque tu utilises des modèles YOLO dans une application multi-threadée, il est important d'instancier des objets de modèle distincts pour chaque thread ou d'employer un stockage local au thread pour é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 un aperçu approfondi de l'inférence thread-safe avec les modèles YOLO et des instructions étape par étape, consulte notre guide d'inférence thread-safe 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 pour source en streaming#

Voici un script Python utilisant OpenCV (cv2) et YOLO pour exécuter l'inférence sur des trames vidéo. Ce script suppose que tu as déjà installé les paquets 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 exécutera des prédictions sur chaque image de la vidéo, visualisera les résultats et les affichera dans une fenêtre. La boucle peut être quittée en appuyant sur 'q'.

Et après ?#

Prêt à aller au-delà d'un modèle pré-entraîné ? Confirme que ta tâche correspond à ton problème, formate tes propres données avec le guide des datasets, puis entraîne-toi dessus.

FAQ#