PyTorch Nabe

📚 Dieser Leitfaden erklärt, wie du YOLOv5 🚀 von PyTorch Hub unter https://pytorch.org/hub/ultralytics_yolov5.

Bevor du anfängst

Installiere die requirements.txt in einer Python>=3.8.0 Umgebung, einschließlich PyTorch>=1.8. Modelle und Datensätze werden automatisch von der neuestenVersion von YOLOv5 heruntergeladen.

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

💡 ProTip: Klonen https://github.com/ultralytics / yolov5 ist nicht erforderlich 😃

Last YOLOv5 mit PyTorch Hub

Einfaches Beispiel

Dieses Beispiel lädt ein vortrainiertes YOLOv5s-Modell von PyTorch Hub als model und übergibt ein Bild zur Inferenz. 'yolov5s' ist das leichteste und schnellste Modell YOLOv5 . Einzelheiten zu allen verfügbaren Modellen findest du in der 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

Ausführliches Beispiel

Dieses Beispiel zeigt Bündelungsschluss mit PIL und OpenCV Bildquellen. results kann sein gedruckt zu trösten, gespeichert zu runs/hub, zeigte auf unterstützten Umgebungen zu screenen, und wurde als Tensoren oder Pandas Dataframes.

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 inferenzergebnisse auf zidane.jpg YOLO Inferenzergebnisse im Bus.jpg

Für alle Inferenzoptionen siehe YOLOv5 AutoShape() weiter Methode.

Inferenz-Einstellungen

YOLOv5 Modelle enthalten verschiedene Inferenzattribute wie Vertrauensschwelle, IoU-Schwelle usw., die von dir festgelegt werden können:

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

Gerät

Modelle können nach der Erstellung auf jedes Gerät übertragen werden:

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

Modelle können auch direkt auf jeder device:

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

💡 ProTipp: Eingabebilder werden vor der Inferenz automatisch auf das richtige Modellgerät übertragen.

Stummschaltung Ausgänge

Modelle können lautlos geladen werden mit _verbose=False:

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

Eingangskanäle

Um ein vortrainiertes YOLOv5s-Modell mit 4 Eingangskanälen statt der standardmäßigen 3 zu laden:

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

In diesem Fall besteht das Modell aus vortrainierten Gewichten , mit Ausnahme der allerersten Eingabeschicht, die nicht mehr dieselbe Form hat wie die vortrainierte Eingabeschicht. Die Eingabeschicht wird weiterhin mit Zufallsgewichten initialisiert.

Anzahl der Klassen

Um ein vortrainiertes YOLOv5s-Modell mit 10 statt der standardmäßigen 80 Ausgangsklassen zu laden:

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

In diesem Fall besteht das Modell aus vorher trainierten Gewichten , mit Ausnahme der Ausgabeschichten, die nicht mehr die gleiche Form wie die vorher trainierten Ausgabeschichten haben. Die Ausgabeschichten werden weiterhin mit Zufallsgewichten initialisiert.

Nachladen erzwingen

Wenn du mit den oben genannten Schritten Probleme hast, kannst du die force_reload=True kann helfen, indem du den vorhandenen Cache löschst und einen neuen Download der neuesten YOLOv5 Version von PyTorch Hub erzwingst.

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

Screenshot Inferenz

So führst du die Inferenz auf deinem Desktop-Bildschirm aus:

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)

Multi-GPU-Inferenz

YOLOv5 Modelle können parallel auf mehrere GPUs geladen werden, wobei die Inferenz in Threads erfolgt:

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

Ausbildung

Um ein YOLOv5 Modell für das Training und nicht für die Inferenz zu laden, setzen Sie autoshape=False. Um ein Modell mit zufällig initialisierten Gewichten zu laden (um von Grund auf zu trainieren), verwenden Sie pretrained=False. In diesem Fall musst du dein eigenes Trainingsskript erstellen. Alternativ kannst du auch unser YOLOv5 Tutorial "Benutzerdefinierte Daten trainieren für das Modelltraining.

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

Base64 Ergebnisse

Für die Verwendung mit API-Diensten. Siehe https://github.com/ultralytics/yolov5/pull/2291 und das Flask REST API Beispiel für Details.

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

Abgeschnittene Ergebnisse

Die Ergebnisse können zurückgegeben und als Erkennungsfrüchte gespeichert werden:

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

Pandas Ergebnisse

Die Ergebnisse können als Pandas DataFrames zurückgegeben werden:

results = model(im)  # inference
results.pandas().xyxy[0]  # Pandas DataFrame

Pandas Output (zum Vergrößern klicken)

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

Sortierte Ergebnisse

Die Ergebnisse können nach Spalten sortiert werden, z. B. um die Nummernschilderkennung von links nach rechts zu sortieren (x-Achse):

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

Box-Cropped Ergebnisse

Die Ergebnisse können zurückgegeben und als Erkennungsfrüchte gespeichert werden:

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

JSON-Ergebnisse

Die Ergebnisse können im JSON-Format zurückgegeben werden, sobald sie in .pandas() Dataframes mit der .to_json() Methode. Das JSON-Format kann mit der Methode orient Argument. Siehe Pandas .to_json() Dokumentation für Details.

results = model(ims)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # JSON img1 predictions

JSON-Ausgabe (zum Erweitern klicken)

[
  {
    "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"
  }
]

Benutzerdefinierte Modelle

Dieses Beispiel lädt eine benutzerdefinierte 20-Klasse VOC-trainiertes YOLOv5s-Modell 'best.pt' mit 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

TensorRT, ONNX und OpenVINO Modelle

PyTorch Hub unterstützt Inferenzen für die meisten YOLOv5 Exportformate, einschließlich benutzerdefinierter trainierter Modelle. Siehe TFLite, ONNX, CoreML, TensorRT Export-Tutorial für Details zum Exportieren von Modellen.

💡 ProTip: TensorRT kann bis zu 2-5x schneller sein als PyTorch bei GPU-Benchmarks 💡 ProTip: ONNX und OpenVINO kann bis zu 2-3x schneller sein als PyTorch bei CPU-Benchmarks

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

Unterstützte Umgebungen

Ultralytics bietet eine Reihe gebrauchsfertiger Umgebungen, die jeweils mit wichtigen Abhängigkeiten wie CUDA, CUDNN vorinstalliert sind, Python, und PyTorch, um deine Projekte zu starten.

Kostenlose GPU-Notebooks:
Google Cloud: GCP Schnellstart-Anleitung
Amazon: AWS Schnellstart-Anleitung
Azure: AzureML Schnellstartanleitung
Docker: Docker Schnellstart-Anleitung

Projektstatus

Dieses Abzeichen zeigt an, dass alle YOLOv5 GitHub Actions Continuous Integration (CI) Tests erfolgreich bestanden wurden. Diese CI-Tests überprüfen die Funktionalität und Leistung von YOLOv5 in verschiedenen Bereichen: Training, Validierung, Inferenz, Export und Benchmarks. Sie gewährleisten einen konsistenten und zuverlässigen Betrieb unter macOS, Windows und Ubuntu. Die Tests werden alle 24 Stunden und bei jeder neuen Übertragung durchgeführt.

Erstellt am 2023-11-12, Aktualisiert am 2023-12-03
Autoren: glenn-jocher (3)