Prédiction du modèle avec Ultralytics YOLO

Introduction

In the world of machine learning and computer vision, the process of making sense out of visual data is called 'inference' or 'prediction'. Ultralytics YOLO11 offers a powerful feature known as predict mode that is tailored for high-performance, real-time inference on a wide range of data sources.

Regarde : How to Extract the Outputs from Ultralytics YOLO Model for Custom Projects.

Applications dans le monde réel

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

Pourquoi utiliser Ultralytics YOLO pour l'inférence ?

Here's why you should consider YOLO11's predict mode for your various inference needs:

• Polyvalence : Capable de faire des déductions sur des images, des vidéos et même des flux en direct.
• Performance: Engineered for real-time, high-speed processing without sacrificing accuracy.
• Facilité d'utilisation : interfaces intuitives Python et CLI 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 en fonction de tes besoins spécifiques.

Caractéristiques principales du mode Predict

YOLO11's predict mode is designed to be robust and versatile, featuring:

• Compatibilité avec plusieurs sources de données : Que tes données se présentent sous 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édictif te couvre.
• Mode streaming : Utilise la fonction de diffusion en continu pour générer un générateur efficace en termes de mémoire de Results objets. Active cette fonction en paramétrant stream=True dans la méthode d'appel du prédicteur.
• Traitement par lots : La possibilité de traiter plusieurs images ou trames vidéo en un seul lot, ce qui accélère encore le temps d'inférence.
• Facilité d'intégration : intègre facilement les pipelines de données existants et d'autres composants logiciels, grâce à son API flexible.

Ultralytics YOLO renvoient soit une liste Python de Results ou un générateur Python à mémoire réduite de Results objets 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 can process different types of input sources for inference, as shown in the table below. The sources include static images, video streams, and various data formats. The table also indicates whether each source can be used in streaming mode with the argument stream=True ✅. Le mode Streaming est avantageux pour le traitement 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.

Tu trouveras ci-dessous des exemples de code pour l'utilisation de 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 de déduction

model.predict() accepte plusieurs arguments qui peuvent être passés 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("bus.jpg", save=True, imgsz=320, conf=0.5)

Arguments d'inférence :

Arguments de visualisation :

Formats d'images et de vidéos

YOLO11 supports various image and video formats, as specified in ultralytics/data/utils.py. See the tables below for the valid suffixes and example predict commands.

Images

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

Vidéos

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

Travailler avec les résultats

Tous Ultralytics predict() renverra 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("bus.jpg")  # list of 1 Results object
results = model(["bus.jpg", "zidane.jpg"])  # list of 2 Results objects

Results Les objets ont les attributs suivants :

Results ont les méthodes suivantes :

Pour plus de détails, voir le Results documentation sur les classes.

Boîtes

Boxes peut être utilisé pour indexer, manipuler et convertir les boîtes de délimitation dans différents formats.

from ultralytics import YOLO

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

# Run inference on an image
results = model("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 les méthodes et les propriétés de la classe, y compris leur nom, leur type et leur description :

Pour plus de détails, voir le Boxes documentation sur les classes.

Masques

Masks 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("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 les méthodes et les propriétés de la classe, y compris leur nom, leur type et leur description :

Pour plus de détails, voir le Masks documentation sur les classes.

Points clés

Keypoints 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("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 les méthodes et les propriétés de la classe, y compris leur nom, leur type et leur description :

Pour plus de détails, voir le Keypoints documentation sur les classes.

Probs

Probs peut être utilisé pour indexer, obtenir top1 et top5 indices et 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("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 qui résume les méthodes et les propriétés de la fonction Probs classe :

Pour plus de détails, voir le Probs documentation sur les classes.

OBB

OBB peut être utilisé pour indexer, manipuler et convertir des boîtes de délimitation orientées dans différents formats.

from ultralytics import YOLO

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

# Run inference on an image
results = model("bus.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 les méthodes et les propriétés de la classe, y compris leur nom, leur type et leur description :

Pour plus de détails, voir le OBB documentation sur les classes.

Tracer les résultats

Le plot() méthode en Results facilite la visualisation des prédictions en superposant les objets détectés (tels que les boîtes de délimitation, 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(["bus.jpg", "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

Le plot() prend en charge divers arguments pour personnaliser la sortie :

Inférence sûre pour les threads

Assurer la sécurité des threads pendant 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 les unes avec les autres, ce qui permet d'éviter les conditions de course et d'assurer des résultats cohérents et fiables.

Lorsque tu utilises les 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 pour les threads 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=("yolo11n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo11n.pt", "image2.jpg")).start()

Pour un examen approfondi de l'inférence à sécurité thread avec les modèles YOLO et des instructions étape par étape, tu peux te référer à notre guide de l'inférence à sécurité threadYOLO . Ce guide te fournira toutes les informations nécessaires pour éviter les pièges les plus courants et garantir le bon déroulement de ton inférence multithread.

Source de diffusion en continu for-Boucle

Voici un script Python utilisant OpenCV (cv2) and YOLO to run inference on video frames. This script assumes you have already installed the necessary packages (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écute des prédictions sur chaque image de la vidéo, visualise les résultats et les affiche dans une fenêtre. La boucle peut être quittée en appuyant sur 'q'.

FAQ

What is Ultralytics YOLO and its predict mode for real-time inference?

Ultralytics YOLO is a state-of-the-art model for real-time object detection, segmentation, and classification. Its predict mode allows users to perform high-speed inference on various data sources such as images, videos, and live streams. Designed for performance and versatility, it also offers batch processing and streaming modes. For more details on its features, check out the Ultralytics YOLO predict mode.

How can I run inference using Ultralytics YOLO on different data sources?

Ultralytics YOLO can process a wide range of data sources, including individual images, videos, directories, URLs, and streams. You can specify the data source in the model.predict() appel. 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 des différents sources d'inférence dans la documentation.

How do I optimize YOLO inference speed and memory usage?

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 de Results au lieu de charger toutes les images dans la mémoire. Pour le traitement de longues vidéos ou de grands ensembles de données, le mode streaming est particulièrement utile. Pour en savoir plus mode streaming.

What inference arguments does Ultralytics YOLO support?

Le model.predict() method in YOLO supports various arguments such as conf, iou, imgsz, deviceet 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 l'appareil utilisé pour le calcul. Des descriptions détaillées de ces arguments sont disponibles dans la section arguments d'inférence section.

How can I visualize and save the results of YOLO predictions?

After running inference with YOLO, the 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. Pour obtenir une liste complète de ces méthodes, reporte-toi à la rubrique Travailler avec les résultats section.

📅 Created 11 months ago ✏️ Updated 9 days ago

Commentaires