Skip to content

PyTorch Hub

ūüďö Ce guide explique comment charger YOLOv5 ūüöÄ sur PyTorch Hub https://pytorch.org/hub/ ultralytics_yolov5.

Avant de commencer

Installer requirements.txt dans un Python>=3.8.0 y compris PyTorch>=1.8. Les modèles et les ensembles de données se téléchargent automatiquement à partir de la dernièreversion de YOLOv5 .

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

ūüí° ProTip : Le clonage de https://github.com/ ultralytics/ yolov5 n'est pas n√©cessaire ūüėÉ

Charge YOLOv5 avec PyTorch Hub

Exemple simple

Cet exemple charge un mod√®le YOLOv5s pr√©-entra√ģn√© √† partir de PyTorch Hub sous la forme suivante model et transmet une image pour l'inf√©rence. 'yolov5s' est le mod√®le le plus l√©ger et le plus rapide de YOLOv5 . Pour plus de d√©tails sur tous les mod√®les disponibles, tu peux consulter la LISEZ-MOI.

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

Exemple détaillé

Cet exemple montre Inférence par lots avec LIP et OpenCV sources d'images. results peut être imprimé à la console, sauvés à runs/hub, a montré pour passer au crible les environnements pris en charge, et renvoyée en tant que tenseurs ou pandas cadres de données.

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 résultats de l'inférence sur zidane.jpg YOLO résultats de l'inférence sur le bus.jpg

Pour toutes les options d'inférence, voir YOLOv5 AutoShape() avant méthode.

Paramètres d'inférence

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

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

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

Appareil

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

ūüí° ProTip : Les images d'entr√©e sont automatiquement transf√©r√©es vers le bon appareil mod√®le avant l'inf√©rence.

Sorties de silence

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

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

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, 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 par 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, qui n'ont plus la m√™me forme que les couches de sortie pr√©-entra√ģn√©es. Les couches de sortie resteront initialis√©es par des poids al√©atoires.

Force Reload

Si tu rencontres des problèmes avec les étapes ci-dessus, tu peux configurer 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 à partir de PyTorch Hub .

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

Inférence de capture d'écran

Pour exécuter l'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)

Inférence multi-GPU

YOLOv5 peuvent être chargés sur plusieurs GPU en parallèle avec l'inférence threadée :

import torch
import threading


def run(model, im):
    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()

Formation

Pour charger un mod√®le YOLOv5 pour l'entra√ģnement plut√īt que pour l'inf√©rence, mets autoshape=False. Pour charger un mod√®le avec des poids initialis√©s de fa√ßon al√©atoire (pour l'entra√ģner √† partir de z√©ro), utilise pretrained=False. Dans ce cas, tu dois fournir ton propre script de formation. Tu peux aussi consulter notre YOLOv5 Didacticiel sur les donn√©es personnalis√©es pour l'apprentissage 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

Résultats Base64

À utiliser avec les services API. Voir https://github.com/ultralytics/yolov5/pull/2291 et l'exemple d'API REST de Flask pour plus de détails.

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

Résultats du recadrage

Les résultats peuvent être renvoyés et sauvegardés en tant que cultures de détection :

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

Résultats pour les pandas

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

results = model(im)  # inference
results.pandas().xyxy[0]  # Pandas DataFrame
Sortie des pandas (cliquer pour agrandir)
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

Résultats triés

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

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

Résultats encadrés

Les résultats peuvent être renvoyés et sauvegardés en tant que cultures de détection :

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

Résultats JSON

Les résultats peuvent être renvoyés au format JSON une fois convertis en .pandas() à l'aide de la fonction .to_json() méthode. Le format JSON peut être modifié à l'aide de la méthode orient argument. Voir pandas .to_json() documentation pour plus de détails.

results = model(ims)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # JSON img1 predictions
Sortie JSON (cliquer pour agrandir)
[
  {
    "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 une classe 20 personnalis√©e COV-Mod√®le YOLOv5s entra√ģn√© '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

TensorRTModèles ONNX et OpenVINO

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

ūüí° ProTip : TensorRT peut √™tre jusqu'√† 2-5X plus rapide que PyTorch sur les benchmarks GPU ūüí° ProTip : ONNX et OpenVINO peut √™tre jusqu'√† 2 √† 3 fois plus rapide 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

Environnements pris en charge

Ultralytics fournit une gamme d'environnements prêts à l'emploi, chacun préinstallé avec des dépendances essentielles telles que CUDA, CUDNN, Pythonet PyTorchpour lancer tes projets.

Statut du projet

YOLOv5 CI

Ce badge indique que tous les tests d'int√©gration continue (CI) de YOLOv5 GitHub Actions sont pass√©s avec succ√®s. Ces tests CI v√©rifient rigoureusement la fonctionnalit√© et les performances de YOLOv5 sur diff√©rents aspects cl√©s : entra√ģnement, validation, inf√©rence, exportation 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.



Créé le 2023-11-12, Mis à jour le 2023-12-03
Auteurs : glenn-jocher (3)

Commentaires