Prédiction de modèle avec Ultralytics YOLO

Introduction

Dans le monde de l'apprentissage automatique et de la vision par ordinateur, le processus qui consiste à donner un sens aux données visuelles est appelé « inférence » ou « prédiction ». Ultralytics YOLO11 offre une fonctionnalité puissante appelée mode de prédiction, conçue pour l'inférence en temps réel et à haute performance sur un large éventail de sources de données.

Regarder : Comment extraire les sorties du modèle Ultralytics YOLO pour des projets personnalisés.

Applications concrètes

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

Pourquoi utiliser Ultralytics YOLO pour l'inférence ?

Voici pourquoi vous devriez envisager le mode de prédiction de YOLO11 pour vos différents besoins d'inférence :

• Polyvalence : Capable de faire des inférences sur des images, des vidéos et même des flux en direct.
• Performance : 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 : Divers paramètres pour ajuster le comportement d'inférence du modèle en fonction de vos besoins spécifiques.

Principales caractéristiques du mode Prédiction

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

• Compatibilité avec plusieurs sources de données : Que vos 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 de prédiction est là pour vous.
• Mode de diffusion en continu : Utilisez la fonction de diffusion en continu pour générer un générateur d'objets économe en mémoire. Results Activez cette fonction en définissant stream=True dans la méthode d'appel du prédicteur.
• Traitement par lots : La possibilité de traiter plusieurs images ou trames vidéo dans un seul lot, ce qui accélère encore le temps d'inférence.
• Facilité d'intégration : S'intègre facilement aux pipelines de données existants et aux autres composants logiciels, grâce à son API flexible.

Les modèles Ultralytics YOLO renvoient soit une liste python de Results objets, ou un générateur Python de Results objets à faible consommation de mémoire lorsque stream=True est transmis au modèle pendant l'inférence :

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # pretrained YOLO11n 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

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # pretrained YOLO11n model

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

# Process results generator
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

YOLO11 peut traiter différents types de sources d'entrée pour l'inférence, comme indiqué dans 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 images en mémoire.

Vous trouverez ci-dessous des exemples de code pour utiliser chaque type de source :

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

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

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define current screenshot as source
source = "screen"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define remote image or video URL
source = "https://ultralytics.com/images/bus.jpg"

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

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Open an image using PIL
source = Image.open("path/to/image.jpg")

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

import cv2

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Read an image using OpenCV
source = cv2.imread("path/to/image.jpg")

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

import numpy as np

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random numpy array of HWC shape (640, 640, 3) with values in range [0, 255] and type uint8
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype="uint8")

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

import torch

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a path to a CSV file with images, URLs, videos and directories
source = "path/to/file.csv"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to video file
source = "path/to/video.mp4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to directory containing images and videos for inference
source = "path/to/dir"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a glob search for all JPG files in a directory
source = "path/to/dir/*.jpg"

# OR define a recursive glob search for all JPG files including subdirectories
source = "path/to/dir/**/*.jpg"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define source as YouTube video URL
source = "https://youtu.be/LNwODJXcvt4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Single stream with batch-size 1 inference
source = "rtsp://example.com/media.mp4"  # RTSP, RTMP, TCP, or IP streaming address

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Multiple streams with batched inference (e.g., batch-size 8 for 8 streams)
source = "path/to/list.streams"  # *.streams text file with one streaming address per line

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

rtsp://example.com/media1.mp4
rtsp://example.com/media2.mp4
rtmp://example2.com/live
tcp://192.168.1.100:554
...

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on the source
results = model(source=0, stream=True)  # generator 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 :

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on 'bus.jpg' with arguments
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.5)

Arguments d'inférence :

Arguments de visualisation :

Formats d'image et de vidéo

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

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.

Travailler avec les résultats

Tous les Ultralytics predict() les appels renverront une liste de Results objets :

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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

Results les objets ont les attributs suivants :

Results les objets ont les méthodes suivantes :

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

Boîtes

Boxes L'objet peut être utilisé pour indexer, manipuler et convertir des boîtes englobantes en différents formats.

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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 pour les Boxes méthodes et propriétés de la classe, y compris leur nom, leur type et leur description :

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

Masques

Masks L'objet peut être utilisé pour indexer, manipuler et convertir des masques en segments.

from ultralytics import YOLO

# Load a pretrained YOLO11n-seg Segment model
model = YOLO("yolo11n-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 pour les Masks méthodes et propriétés de la classe, y compris leur nom, leur type et leur description :

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

Points clés

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

from ultralytics import YOLO

# Load a pretrained YOLO11n-pose Pose model
model = YOLO("yolo11n-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 pour les Keypoints méthodes et propriétés de la classe, y compris leur nom, leur type et leur description :

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

Probabilités

Probs L'objet peut être utilisé pour indexer, obtenir top1 et top5 les indices et les scores de classification.

from ultralytics import YOLO

# Load a pretrained YOLO11n-cls Classify model
model = YOLO("yolo11n-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 des propriétés pour la Probs classe :

Pour plus de détails, consultez la Probs documentation de la classe.

OBB

OBB object 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 YOLO11n model
model = YOLO("yolo11n-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 pour les OBB méthodes et propriétés de la classe, y compris leur nom, leur type et leur description :

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

Tracer les résultats

L'argument plot() méthode dans Results objects 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, ce qui permet de l'afficher ou de l'enregistrer facilement.

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.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")

plot() Paramètres de la méthode

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

Inférence Thread-Safe

Assurer la sécurité des threads pendant l'inférence est crucial lorsque vous exécutez 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 les unes avec les autres, évitant ainsi les conditions de concurrence et assurant des sorties cohérentes et fiables.

Lors de l'utilisation de 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 de 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=("yolo11n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo11n.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, veuillez consulter notre Guide d'inférence thread-safe YOLO. Ce guide vous fournira toutes les informations nécessaires pour éviter les pièges courants et garantir le bon fonctionnement de votre inférence multithread.

Source de streaming for-loop

Voici un script python utilisant OpenCV (cv2) et YOLO pour exécuter l'inférence sur les trames vidéo. Ce script suppose que vous avez déjà installé les packages nécessaires (opencv-python et ultralytics).

import cv2

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo11n.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 trame 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'.

FAQ

Qu'est-ce qu'Ultralytics YOLO et son mode de 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 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, consultez le mode predict d'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 un large éventail de sources de données, y compris des images individuelles, des vidéos, des répertoires, des URL et des flux. Vous pouvez spécifier la source de données dans l'appel model.predict() call. For example, use 'image.jpg' pour une image locale ou 'https://ultralytics.com/images/bus.jpg' pour une URL. Consultez les exemples détaillés pour diverses sources d'inférence dans la documentation.

Comment 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, vous pouvez utiliser le mode de streaming en définissant stream=True dans la méthode d'appel du prédicteur. Le mode de diffusion en continu génère un générateur à faible consommation de mémoire de Results objets au lieu de charger toutes les images en mémoire. Le mode de diffusion en continu est particulièrement utile pour le traitement de longues vidéos ou de grands ensembles de données. Apprenez-en davantage sur le mode de diffusion en continu.

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

L'argument model.predict() méthode dans YOLO prend en charge divers arguments tels que conf, iou, imgsz, device, et plus encore. Ces arguments vous 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 dispositif utilisé pour le calcul. Des descriptions détaillées de ces arguments sont disponibles dans la section consacrée aux arguments d'inférence section.

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

Après avoir exécuté l'inférence avec YOLO, les Results objets contiennent des méthodes pour afficher et enregistrer les images annotées. Vous pouvez utiliser des méthodes comme result.show() et result.save(filename="result.jpg") pour visualiser et enregistrer les résultats. Pour une liste complète de ces méthodes, consultez la section consacrée à l'utilisation des résultats section.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 5 jours

Commentaires