Meet YOLO26: next-gen vision AI.

Link to this sectionChargement de YOLOv5 depuis PyTorch Hub#

📚 Ce guide explique comment charger YOLOv5 🚀 depuis le Hub PyTorch sur https://pytorch.org/hub/ultralytics_yolov5.

Link to this sectionAvant de commencer#

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

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

Cloner ultralytics/yolov5 n'est pas nécessaire — PyTorch Hub récupère le code automatiquement.

Link to this sectionCharger YOLOv5 avec PyTorch Hub#

Link to this sectionExemple simple#

Cet exemple charge un modèle YOLOv5s pré-entraîné depuis PyTorch Hub en tant que model et transmet une image pour l'inférence. 'yolov5s' est le modèle YOLOv5 le plus léger et le plus rapide. Pour plus de détails 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  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

Link to this sectionExemple détaillé#

Cet exemple montre une inférence par lots avec des sources d'images PIL et OpenCV. Les results peuvent être imprimés dans la console, enregistrés dans runs/hub, affichés à l'écran sur les environnements pris en charge, et renvoyés sous forme de tensors 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("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

For all inference options see YOLOv5 AutoShape() forward method.

Link to this sectionParamètres d'inférence#

Les modèles YOLOv5 contiennent divers attributs d'inférence tels que le seuil de confiance, le seuil d'IoU, etc., qui peuvent être définis par :

model.conf = 0.25  # NMS confidence threshold
model.iou = 0.45  # NMS IoU threshold
model.agnostic = False  # NMS class-agnostic
model.multi_label = False  # NMS multiple labels per box
model.classes = None  # (optional list) filter by class, i.e. = [0, 15, 16] for COCO persons, cats and dogs
model.max_det = 1000  # maximum number of detections per image
model.amp = False  # Automatic Mixed Precision (AMP) inference

results = model(im, size=320)  # custom inference size

Link to this sectionAppareil#

Les modèles peuvent être transférés sur n'importe quel appareil après leur création :

model.cpu()  # CPU
model.cuda()  # GPU
model.to(device)  # i.e. device=torch.device(0)

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

model = torch.hub.load("ultralytics/yolov5", "yolov5s", device="cpu")  # load on CPU
Astuce

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

Link to this sectionDésactiver les sorties#

Les modèles peuvent être chargés silencieusement avec _verbose=False :

model = torch.hub.load("ultralytics/yolov5", "yolov5s", _verbose=False)  # load silently

Link to this sectionCanaux 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, qui n'a plus la même forme que la couche d'entrée pré-entraînée. La couche d'entrée restera initialisée avec des poids aléatoires.

Link to this sectionNombre 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 de la couche de sortie, qui n'a plus la même forme que les couches de sortie pré-entraînées. Les couches de sortie resteront initialisées avec des poids aléatoires.

Link to this sectionForcer 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 un nouveau téléchargement de la dernière version de YOLOv5 depuis PyTorch Hub. Les copies en cache se trouvent dans ~/.cache/torch/hub ; supprimer ce dossier a le même effet.

model = torch.hub.load("ultralytics/yolov5", "yolov5s", force_reload=True)  # force reload

Link to this sectionInférence sur capture d'écran#

Pour exécuter une inférence sur l'écran de ton bureau :

import torch
from PIL import ImageGrab

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

# Image
im = ImageGrab.grab()  # take a screenshot

# Inference
results = model(im)

Link to this sectionInférence multi-GPU#

Les modèles YOLOv5 peuvent être chargés sur plusieurs GPU en parallèle avec une inférence par threads :

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

Link to this sectionEntraînement#

Pour charger un modèle YOLOv5 pour l'entraînement plutôt que pour l'inférence, définis autoshape=False. Pour charger un modèle avec des poids initialisés aléatoirement (pour entraîner à partir de zéro), utilise pretrained=False. Tu dois fournir ton propre script d'entraînement dans ce cas. Alternativement, consulte notre Tutoriel sur l'entraînement YOLOv5 avec des données personnalisées pour l'entraînement du modèle.

import torch

model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False)  # load pretrained
model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False, pretrained=False)  # load scratch

Link to this sectionRésultats Base64#

Pour une utilisation avec des services API. Consulte l'exemple Flask REST API pour plus de détails.

import base64
from io import BytesIO

from PIL import Image

results = model(im)  # inference

results.ims  # array of original images (as np array) passed to model for inference
results.render()  # updates results.ims with boxes and labels
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"))  # base64 encoded image with results

Link to this sectionRésultats rognés#

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

results = model(im)  # inference
crops = results.crop(save=True)  # cropped detections dictionary

Link to this sectionRésultats Pandas#

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

results = model(im)  # inference
results.pandas().xyxy[0]  # Pandas DataFrame
Pandas Output (click to expand) 
print(results.pandas().xyxy[0])
#      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

Link to this sectionRésultats triés#

Les résultats peuvent être triés par colonne, par exemple pour trier la détection de chiffres de plaque d'immatriculation de gauche à droite (axe x) :

results = model(im)  # inference
results.pandas().xyxy[0].sort_values("xmin")  # sorted left-right

Link to this sectionRésultats JSON#

Results can be returned in JSON format once converted to .pandas() dataframes using the .to_json() method. The JSON format can be modified using the orient argument. See pandas .to_json() documentation for details.

results = model(ims)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # JSON img1 predictions
JSON Output (click to expand) 
[
    {
        "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"
    }
]

Link to this sectionModèles personnalisés#

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

import torch

model = torch.hub.load("ultralytics/yolov5", "custom", path="path/to/best.pt")  # local model
model = torch.hub.load("path/to/yolov5", "custom", path="path/to/best.pt", source="local")  # local repo

Link to this sectionModèles TensorRT, ONNX et OpenVINO#

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

Astuce
  • TensorRT peut être 2 à 5 fois plus rapide que PyTorch sur les benchmarks GPU.
  • ONNX et OpenVINO peuvent être 2 à 3 fois plus rapides que PyTorch sur 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.mlmodel")  # CoreML (macOS-only)
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s.tflite")  # TFLite
model = torch.hub.load("ultralytics/yolov5", "custom", path="yolov5s_paddle_model/")  # PaddlePaddle

Link to this sectionEnvironnements pris en charge#

Ultralytics propose une gamme d'environnements prêts à l'emploi, chacun pré-installé avec les dépendances essentielles telles que CUDA, CUDNN, Python et PyTorch, pour lancer tes projets.

Link to this sectionÉtat du projet#

YOLOv5 CI

Ce badge indique que tous les tests d'intégration continue (CI) des GitHub Actions de YOLOv5 réussissent. Ces tests CI vérifient rigoureusement la fonctionnalité et les performances de YOLOv5 sous divers aspects clés : entraînement, validation, inférence, export et benchmarks. Ils garantissent un fonctionnement cohérent et fiable sur macOS, Windows et Ubuntu, avec des tests effectués toutes les 24 heures et à chaque nouveau commit.

Contributeurs
GLglenn-jocher13PDpderrenger1RIRizwanMunawar1BUBurhan-Q1

Commentaires