Ultralytics YOLO27 :
Get Started

Charger YOLOv5 depuis PyTorch Hub#

📚 Ce guide explique comment charger YOLOv5 🚀 depuis PyTorch Hub à l’adresse https://pytorch.org/hub/ultralytics_yolov5.

Avant de commencer#

Installe requirements.txt dans un environnement Python>=3.8.0, avec PyTorch>=1.8. Les modèles et les jeux de données sont téléchargés automatiquement depuis la dernière version de YOLOv5.

pip install -r https://raw.githubusercontent.com/ultralytics/yolov5/master/requirements.txt
Conseil

Il n’est pas nécessaire de cloner ultralytics/yolov5 — PyTorch Hub récupère le code automatiquement.

Charger YOLOv5 avec PyTorch Hub#

Exemple simple#

Cet exemple charge un modèle YOLOv5s préentraîné depuis PyTorch Hub sous la forme de model et lui transmet une image pour l’inférence. 'yolov5s' est un modèle YOLOv5 petit et rapide. Pour en savoir plus sur tous les modèles disponibles, consulte le README.

import torch

# Model
model = torch.hub.load("ultralytics/yolov5", "yolov5s")

# Image
im = "https://ultralytics.com/images/zidane.jpg"

# Inference
results = model(im)

results.pandas().xyxy[0]
# xmin    ymin    xmax   ymax  confiance  classe    nom
# 0  749.50   43.50  1148.0  704.5    0.874023      0  person
# 1  433.50  433.50   517.5  714.5    0.687988     27     tie
# 2  114.75  195.75  1095.0  708.0    0.624512      0  person
# 3  986.00  304.00  1028.0  420.0    0.286865     27     tie

Exemple détaillé#

Cet exemple présente l’inférence par lots avec des sources d’images PIL et OpenCV. results peut être affiché dans la console, enregistré dans runs/hub, affiché à l’écran dans les environnements pris en charge et renvoyé sous forme de tenseurs ou de DataFrames pandas.

import cv2
import torch
from PIL import Image

# Model
model = torch.hub.load("ultralytics/yolov5", "yolov5s")

# Images
for f in "zidane.jpg", "bus.jpg":
    torch.hub.download_url_to_file(f"https://ultralytics.com/images/{f}", f)  # download 2 images
im1 = Image.open("zidane.jpg")  # PIL image
im2 = cv2.imread("bus.jpg")[..., ::-1]  # OpenCV image (BGR to RGB)

# Inference
results = model([im1, im2], size=640)  # batch of images

# Results
results.print()
results.save()  # or .show()

results.xyxy[0]  # im1 predictions (tensor)
results.pandas().xyxy[0]  # im1 predictions (pandas)
#      xmin    ymin    xmax   ymax  confidence  class    name
# 0  749.50   43.50  1148.0  704.5    0.874023      0  person
# 1  433.50  433.50   517.5  714.5    0.687988     27     tie
# 2  114.75  195.75  1095.0  708.0    0.624512      0  person
# 3  986.00  304.00  1028.0  420.0    0.286865     27     tie
YOLO inference results on zidane.jpg YOLO inference results on bus.jpg

Pour connaître toutes les options d’inférence, consulte la méthode forward de AutoShape() de YOLOv5.

Paramètres d’inférence#

Les modèles YOLOv5 possèdent divers attributs d’inférence, comme le seuil de confiance, le seuil IoU, etc., qui peuvent être définis ainsi :

model.conf = 0.25  # seuil de confiance NMS
model.iou = 0.45  # seuil IoU NMS
model.agnostic = False  # NMS indépendant de la classe
model.multi_label = False  # plusieurs étiquettes NMS par boîte
model.classes = None  # (liste facultative) filtrer par classe, par exemple = [0, 15, 16] pour les personnes, les chats et les chiens de COCO
model.max_det = 1000  # nombre maximal de détections par image
model.amp = False  # inférence avec précision mixte automatique (AMP)

results = model(im, size=320)  # taille d’inférence personnalisée

Appareil#

Après leur création, les modèles peuvent être transférés vers n’importe quel appareil :

model.cpu()  # CPU
model.cuda()  # GPU
model.to(device)  # c.-à-d. device=torch.device(0)

Les modèles peuvent aussi être créés directement sur n’importe quel device :

model = torch.hub.load("ultralytics/yolov5", "yolov5s", device="cpu")  # charger sur CPU
Conseil

Les images d’entrée sont automatiquement transférées vers l’appareil du modèle approprié avant l’inférence.

Désactiver l’affichage des sorties#

Les modèles peuvent être chargés sans afficher de sortie avec _verbose=False :

model = torch.hub.load("ultralytics/yolov5", "yolov5s", _verbose=False)  # charger sans afficher de sortie

Canaux d’entrée#

Pour charger un modèle YOLOv5s préentraîné avec 4 canaux d’entrée au lieu des 3 par défaut :

model = torch.hub.load("ultralytics/yolov5", "yolov5s", channels=4)

Dans ce cas, le modèle sera composé de poids préentraînés à l’exception de la toute première couche d’entrée, dont la forme diffère désormais de celle de la couche d’entrée préentraînée. La couche d’entrée conservera une initialisation avec des poids aléatoires.

Nombre de classes#

Pour charger un modèle YOLOv5s préentraîné avec 10 classes de sortie au lieu des 80 par défaut :

model = torch.hub.load("ultralytics/yolov5", "yolov5s", classes=10)

Dans ce cas, le modèle sera composé de poids préentraînés à l’exception des couches de sortie, dont la forme diffère désormais de celle des couches de sortie préentraînées. Les couches de sortie conserveront une initialisation avec des poids aléatoires.

Forcer le rechargement#

Si tu rencontres des problèmes avec les étapes ci-dessus, définir force_reload=True peut aider en supprimant le cache existant et en forçant le téléchargement d’une nouvelle version de YOLOv5 depuis PyTorch Hub. Les copies en cache se trouvent dans ~/.cache/torch/hub ; supprimer ce dossier produit le même effet.

model = torch.hub.load("ultralytics/yolov5", "yolov5s", force_reload=True)  # forcer le rechargement

Inférence sur une capture d’écran#

Pour lancer une inférence sur l’écran de ton ordinateur :

import torch
from PIL import ImageGrab

# Model
model = torch.hub.load("ultralytics/yolov5", "yolov5s")

# Image
im = ImageGrab.grab()  # prendre une capture d’écran

# Inference
results = model(im)

Inférence multi-GPU#

Les modèles YOLOv5 peuvent être chargés en parallèle sur plusieurs GPU grâce à l’inférence multithread :

import threading

import torch

def run(model, im):
    """Performs inference on an image using a given model and saves the output; model must support `.save()` method."""
    results = model(im)
    results.save()

# Models
model0 = torch.hub.load("ultralytics/yolov5", "yolov5s", device=0)
model1 = torch.hub.load("ultralytics/yolov5", "yolov5s", device=1)

# Inference
threading.Thread(target=run, args=[model0, "https://ultralytics.com/images/zidane.jpg"], daemon=True).start()
threading.Thread(target=run, args=[model1, "https://ultralytics.com/images/bus.jpg"], daemon=True).start()

Entraînement#

Pour charger un modèle YOLOv5 en vue de l’entraîner plutôt que de lancer une inférence, définis autoshape=False. Pour charger un modèle dont les poids sont initialisés aléatoirement (afin de l’entraîner à partir de zéro), utilise pretrained=False. Dans ce cas, tu dois fournir ton propre script d’entraînement. Tu peux également consulter notre tutoriel sur l’entraînement avec des données personnalisées YOLOv5 pour entraîner le modèle.

import torch

model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False)  # charger un modèle préentraîné
model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False, pretrained=False)  # charger un modèle initialisé à partir de zéro

Résultats en base64#

À utiliser avec des services API. Consulte l’exemple Flask REST API pour en savoir plus.

import base64
from io import BytesIO

from PIL import Image

results = model(im)  # inference

results.ims  # tableau des images d’origine (sous forme de tableau np) transmis au modèle pour l’inférence
results.render()  # met à jour results.ims avec les boîtes et les étiquettes
for im in results.ims:
    buffered = BytesIO()
    im_base64 = Image.fromarray(im)
    im_base64.save(buffered, format="JPEG")
    print(base64.b64encode(buffered.getvalue()).decode("utf-8"))  # image encodée en base64 avec les résultats

Résultats recadrés#

Les résultats peuvent être renvoyés et enregistrés sous forme de recadrages des détections :

results = model(im)  # inference
crops = results.crop(save=True)  # dictionnaire des détections recadrées

Résultats pandas#

Les résultats peuvent être renvoyés sous forme de DataFrames pandas :

results = model(im)  # inference
results.pandas().xyxy[0]  # DataFrame pandas
Sortie Pandas (cliquer pour développer) 
print(results.pandas().xyxy[0])
# xmin    ymin    xmax   ymax  confiance  classe    nom
# 0  749.50   43.50  1148.0  704.5    0.874023      0  person
# 1  433.50  433.50   517.5  714.5    0.687988     27     tie
# 2  114.75  195.75  1095.0  708.0    0.624512      0  person
# 3  986.00  304.00  1028.0  420.0    0.286865     27     tie

Résultats triés#

Les résultats peuvent être triés par colonne, par exemple pour trier de gauche à droite (axe x) les chiffres détectés sur une plaque d’immatriculation :

results = model(im)  # inference
results.pandas().xyxy[0].sort_values("xmin")  # triés de gauche à droite

Résultats JSON#

Les résultats peuvent être renvoyés au format JSON après avoir été convertis en DataFrames .pandas() avec la méthode .to_json(). Le format JSON peut être modifié à l’aide de l’argument orient. Consulte la documentation de pandas .to_json() pour en savoir plus.

results = model(im)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # prédictions JSON img1
Sortie JSON (cliquer pour développer) 
[
    {
        "xmin": 749.5,
        "ymin": 43.5,
        "xmax": 1148.0,
        "ymax": 704.5,
        "confidence": 0.8740234375,
        "class": 0,
        "name": "person"
    },
    {
        "xmin": 433.5,
        "ymin": 433.5,
        "xmax": 517.5,
        "ymax": 714.5,
        "confidence": 0.6879882812,
        "class": 27,
        "name": "tie"
    },
    {
        "xmin": 115.25,
        "ymin": 195.75,
        "xmax": 1096.0,
        "ymax": 708.0,
        "confidence": 0.6254882812,
        "class": 0,
        "name": "person"
    },
    {
        "xmin": 986.0,
        "ymin": 304.0,
        "xmax": 1028.0,
        "ymax": 420.0,
        "confidence": 0.2873535156,
        "class": 27,
        "name": "tie"
    }
]

Modèles personnalisés#

Cet exemple charge avec PyTorch Hub un modèle YOLOv5s personnalisé entraîné sur 20 classes VOC 'best.pt'.

import torch

model = torch.hub.load("ultralytics/yolov5", "custom", path="path/to/best.pt")  # modèle local
model = torch.hub.load("path/to/yolov5", "custom", path="path/to/best.pt", source="local")  # dépôt local

Modèles TensorRT, ONNX et OpenVINO#

PyTorch Hub prend en charge l’inférence dans la plupart des formats d’export YOLOv5, y compris les modèles entraînés sur mesure. Consulte le tutoriel sur l’export TFLite, ONNX, CoreML et TensorRT pour en savoir plus sur l’export de modèles.

Conseil
  • TensorRT peut être 2 à 5 fois plus rapide que PyTorch dans les benchmarks GPU.
  • ONNX et OpenVINO peuvent être 2 à 3 fois plus rapides que PyTorch dans les benchmarks CPU.
import torch

model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.pt")  # PyTorch
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.torchscript")  # TorchScript
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.onnx")  # ONNX
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s_openvino_model/")  # OpenVINO
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.engine")  # TensorRT
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.mlpackage")  # CoreML (macOS uniquement)
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.tflite")  # TFLite
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s_paddle_model/")  # PaddlePaddle

Environnements pris en charge#

Ultralytics propose un ensemble d’environnements prêts à l’emploi, chacun préinstallé avec les dépendances essentielles comme CUDA, CUDNN, Python et PyTorch, pour te permettre de démarrer tes projets.

État du projet#

YOLOv5 CI

Ce badge indique que tous les tests d’intégration continue (CI) de GitHub Actions pour YOLOv5 réussissent. Ces tests CI vérifient rigoureusement le fonctionnement et les performances de YOLOv5 dans plusieurs domaines clés : entraînement, validation, inférence, exportation et tests de performance. Ils garantissent un fonctionnement cohérent et fiable sur macOS, Windows et Ubuntu, grâce à des tests effectués toutes les 24 heures et à chaque nouveau commit.

FAQ#

  • Non. torch.hub.load("ultralytics/yolov5", ...) télécharge le code dans ~/.cache/torch/hub ainsi que les poids lors de la première utilisation. Seuls les packages dans requirements.txt doivent être installés.

  • Utilise le point d’entrée custom avec le chemin du checkpoint : torch.hub.load("ultralytics/yolov5", "custom", path="runs/train/exp/weights/best.pt"). Ajoute source="local" et le chemin d’un dépôt local pour charger le modèle sans accès au réseau.

  • Oui. Transmets le fichier exporté au même chargeur custom ; YOLOv5 sélectionne le backend correspondant à partir du suffixe, par exemple yolov5s.onnx, yolov5s.engine ou yolov5s_openvino_model/.

  • Transmets force_reload=True pour supprimer le dépôt mis en cache et récupérer le dernier code, ou supprime manuellement ~/.cache/torch/hub. Cela permet également de récupérer les nouvelles versions de YOLOv5.

  • results.xyxy[0] renvoie un tenseur de lignes [x1, y1, x2, y2, confidence, class], results.pandas().xyxy[0] renvoie un DataFrame contenant les noms des classes et .to_json(orient="records") appliqué à ce DataFrame produit du JSON.

Contributeurs
GLglenn-jocher3RAraimbekovm1PDpderrenger1

Commentaires