Prédiction de modèle avec Ultralytics YOLO

Introduction

Dans le monde de l'apprentissage automatique et de la vision par ordinateur, le processus visant à donner un sens aux 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 une inférence haute performance en temps réel sur une large gamme de sources de données.

Applications concrètes

Fabrication	Sports	Sécurité
Détection de pièces détachées automobiles	Détection de joueurs de football	Détection de chute de personnes

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 en temps réel à 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 : 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 tes modèles en tant que points de terminaison d'API sur 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 soient 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 d'objets Results économe en mémoire. Active cela en définissant stream=True dans la méthode d'appel du prédicteur.
• Traitement par lots : Traite plusieurs images ou images vidéo dans un seul lot, réduisant encore le temps total d'inférence.
• Facile à intégrer : 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 d'objets Results économe en mémoire lorsque stream=True est passé 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 indiqué dans le tableau ci-dessous. Les sources incluent 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 bénéfique 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 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 paramètres par défaut :

Forme fixe vs rectangle minimum (rect)

Par défaut, predict utilise rect=True, ce qui active le remplissage par rectangle minimum lorsque cela est possible. L'image est mise à l'échelle pour tenir dans imgsz et complétée uniquement jusqu'au multiple de foulée (stride) le plus proche, le tenseur final peut donc être plus petit que imgsz. Le remplissage par rectangle minimum 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 / 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. C'est recommandé lorsque tu as besoin d'une taille d'entrée fixe pour correspondre aux modèles exportés (ONNX, TensorRT, etc.).

imgsz entier vs tuple

• Un entier imgsz=640 devient une cible carrée (640, 640) après l'arrondi du 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 vs prédiction/export

Training accepts only a single integer imgsz (a [h, w] list is coerced to the largest value). Predict and export accept either an integer or a (height, width) tuple.

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

Les objets Results possèdent les méthodes suivantes :

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

Boxes

L'objet Boxes peut être utilisé pour indexer, manipuler et convertir des boîtes englobantes vers 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, type et description :

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

Masks

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

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

Keypoints

L'objet Keypoints peut être utilisé pour indexer, manipuler et normaliser des 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 indexer et obtenir les indices top1 et top5 ainsi que les scores de classification.

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

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

Tracer les 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 originale. Cette méthode renvoie l'image annotée sous forme de tableau NumPy, permettant un affichage ou une sauvegarde 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 le résultat :

Inférence thread-safe

Assurer 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 ne s'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 thread-local 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, veuillez consulter notre Guide d'inférence thread-safe YOLO. Ce guide te fournira toutes les informations nécessaires pour éviter les pièges courants et assurer le bon fonctionnement de ton inférence multithread.

Boucle for de source en streaming

Voici un script Python utilisant OpenCV (cv2) et YOLO pour exécuter l'inférence sur des images 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. Tu peux quitter la boucle en appuyant sur 'q'.

FAQ

Qu'est-ce que Ultralytics YOLO et son mode predict pour l'inférence en temps réel ?

Ultralytics YOLO est un modèle de pointe pour la détection d'objets, la segmentation et la classification en temps réel. Son mode predict permet aux utilisateurs d'effectuer une inférence à haute vitesse sur diverses sources de données telles que des images, des vidéos et des flux en direct. Conçu pour la performance et la polyvalence, il offre également des modes de traitement par lots et de streaming. Pour plus de détails sur ses fonctionnalités, consulte le mode predict de Ultralytics YOLO.

Comment puis-je exécuter l'inférence en utilisant Ultralytics YOLO sur différentes sources de données ?

Ultralytics YOLO peut traiter une large gamme de sources de données, y compris 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 pour diverses sources d'inférence dans la documentation.

Comment puis-je optimiser la vitesse d'inférence et l'utilisation de la mémoire de YOLO ?

Pour optimiser la vitesse d'inférence et gérer efficacement la mémoire, tu peux utiliser le mode streaming en réglant stream=True dans la méthode d'appel du prédicteur. Le mode streaming génère un générateur économe en mémoire d'objets Results au lieu de charger toutes les images en mémoire. Pour le traitement de longues vidéos ou de grands jeux de données, le mode streaming est particulièrement utile. Apprends-en plus sur le mode streaming.

Quels arguments d'inférence Ultralytics YOLO prend-il en charge ?

La méthode model.predict() dans YOLO prend en charge divers arguments tels que conf, iou, imgsz, device, et plus encore. Ces arguments te permettent de personnaliser le processus d'inférence, en définissant des paramètres comme les seuils de confiance, la taille de l'image et le périphérique utilisé pour le calcul. Des descriptions détaillées de ces arguments se trouvent dans la section arguments d'inférence.

Comment puis-je visualiser et enregistrer les résultats des prédictions YOLO ?

Après avoir exécuté l'inférence avec YOLO, les objets Results contiennent des méthodes pour afficher et 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 ex. result.save("path/to/result.jpg")). Pour une liste complète de ces méthodes, consulte la section travailler avec les résultats.