Link to this sectionPrédiction de modèle avec Ultralytics YOLO#

Link to this sectionIntroduction#

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 offre une fonctionnalité puissante appelée mode prédiction, conçue pour une inférence haute performance en temps réel à travers une large gamme de sources de données.

Link to this sectionApplications concrètes#

Fabrication	Sports	Sécurité
Détection de pièces détachées de véhicule	Détection de joueurs de football	Détection de chutes de personnes

Link to this sectionPourquoi 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 haute vitesse 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'API sur Ultralytics Platform avec mise à l'échelle automatique et surveillance, ou exécute l'inférence localement.

Link to this sectionFonctionnalité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 d'objets Results efficace 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 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 retournent soit une liste Python d'objets Results, soit un générateur d'objets Results efficace en mémoire lorsque stream=True est passé 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

Link to this sectionSources 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 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 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

Link to this sectionArguments 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 :

Link to this sectionForme fixe vs rectangle minimum (rect)#

Par défaut, predict utilise rect=True, ce qui active le remplissage rectangle-minimum lorsque c'est possible. L'image est redimensionnée pour tenir dans imgsz et complétée uniquement jusqu'au multiple de stride le plus proche, donc le tenseur final peut être plus petit que imgsz. Le remplissage rectangle-minimum 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 complète imgsz.

Utilise rect=False pour toujours compléter jusqu'à la cible complète imgsz. Cela 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 :

Link to this sectionFormats 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 de prédiction.

Link to this sectionImages#

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

Link to this sectionVidéos#

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

Link to this sectionTravailler 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 :

Link to this sectionRésultats par tâche#

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, de confiance et de probabilité sont en torch.float32 à moins qu'une demi-précision ne soit 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 type de données entier le plus 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.

Link to this sectionBoî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, incluant leur nom, type et description :

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

Link to this sectionMasques#

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

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

Link to this sectionSemanticMask#

SemanticMask stocke une carte de classe 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'assistants de polygone.

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

Link to this sectionKeypoints#

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

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

Link to this sectionProbs#

L'objet Probs peut être utilisé pour indexer, 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.

Link to this sectionOBB#

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

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

Link to this sectionVisualisation 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 originale. 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")

Link to this sectionParamètres de la méthode plot()#

La méthode plot() prend en charge divers arguments pour personnaliser la sortie :

Link to this sectionInfé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 examen approfondi de l'inférence thread-safe avec les modèles YOLO et des instructions étape par étape, consulte notre Guide d'inférence YOLO thread-safe. Ce guide te fournira toutes les informations nécessaires pour éviter les pièges courants et garantir que ton inférence multi-threadée se déroule sans encombre.

Link to this sectionBoucle for de source de 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 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 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'.

Link to this sectionFAQ#

Link to this sectionQu'est-ce que Ultralytics YOLO et son mode prédiction pour l'inférence en temps réel ?#

Ultralytics YOLO est un modèle de pointe pour la détection d'objets, la segmentation d'instances, la segmentation sémantique et la classification en temps réel. Son mode prédiction 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 propose également des modes de traitement par lots et de streaming. Pour plus de détails sur ses fonctionnalités, consulte le mode prédiction d'Ultralytics YOLO.

Link to this sectionComment 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 URLs 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.

Link to this sectionComment 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 définissant stream=True dans la méthode d'appel du prédicteur. Le mode streaming génère un générateur d'objets Results économe en mémoire 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. En savoir plus sur le mode streaming.

Link to this sectionQuels 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 tels que 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.

Link to this sectionComment 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 exemple, result.save("path/to/result.jpg")). Pour une liste complète de ces méthodes, réfère-toi à la section travailler avec les résultats.