Ultralytics YOLO27:
Get Started

YOLOv5 aus PyTorch Hub laden#

📚 Diese Anleitung erklärt, wie du YOLOv5 🚀 aus dem PyTorch Hub unter https://pytorch.org/hub/ultralytics_yolov5 lädst.

Vor dem Start#

Installiere requirements.txt in einer Python>=3.8.0-Umgebung, einschließlich PyTorch>=1.8. Modelle und Datensätze werden automatisch aus der neuesten YOLOv5-Veröffentlichung heruntergeladen.

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

Das Klonen von ultralytics/yolov5 ist nicht erforderlich – PyTorch Hub ruft den Code automatisch ab.

YOLOv5 mit PyTorch Hub laden#

Einfaches Beispiel#

Dieses Beispiel lädt ein vortrainiertes YOLOv5s-Modell aus PyTorch Hub als model und übergibt ihm ein Bild zur Inferenz. 'yolov5s' ist ein kleines, schnelles YOLOv5-Modell. 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  Konfidenz  Klasse    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 Inference mit Stapelverarbeitung mit Bildquellen aus PIL und OpenCV. results kann auf der Konsole ausgegeben, unter runs/hub gespeichert, in unterstützten Umgebungen auf dem Bildschirm angezeigt und als Tensoren oder pandas-DataFrames zurückgegeben werden.

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

Alle Inferenzoptionen zum Vorwärtslauf findest du in der YOLOv5-AutoShape()-Methode.

Inferenzeinstellungen#

YOLOv5-Modelle besitzen verschiedene Inferenzattribute, etwa Konfidenzschwelle, IoU-Schwelle usw., die sich folgendermaßen festlegen lassen:

model.conf = 0.25  # NMS-Konfidenzschwelle
model.iou = 0.45  # NMS-IoU-Schwelle
model.agnostic = False  # Klassenunabhängiges NMS
model.multi_label = False  # Mehrere Labels pro Box bei NMS
model.classes = None  # (optionale Liste) nach Klasse filtern, z. B. = [0, 15, 16] für Personen, Katzen und Hunde in COCO
model.max_det = 1000  # Maximale Anzahl erkannter Objekte pro Bild
model.amp = False  # Inferenz mit automatischer gemischter Genauigkeit (AMP)

results = model(im, size=320)  # Benutzerdefinierte Inferenzgröße

Gerät#

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

model.cpu()  # CPU
model.cuda()  # GPU
model.to(device)  # z. B. device=torch.device(0)

Modelle können auch direkt auf jedem device erstellt werden:

model = torch.hub.load("ultralytics/yolov5", "yolov5s", device="cpu")  # Auf CPU laden
Tipp

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

Ausgaben unterdrücken#

Modelle lassen sich mit _verbose=False ohne Ausgaben laden:

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

Eingabekanäle#

So lädst du ein vortrainiertes YOLOv5s-Modell mit 4 statt der standardmäßigen 3 Eingabekanäle:

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

In diesem Fall besteht das Modell aus vortrainierten Gewichten, mit Ausnahme der ersten Eingabeschicht, deren Form nicht mehr der Form der vortrainierten Eingabeschicht entspricht. Die Eingabeschicht wird weiterhin mit zufälligen Gewichten initialisiert.

Anzahl der Klassen#

So lädst du ein vortrainiertes YOLOv5s-Modell mit 10 statt der standardmäßigen 80 Ausgabeklassen:

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

In diesem Fall besteht das Modell aus vortrainierten Gewichten, mit Ausnahme der Ausgabeschichten, deren Form nicht mehr der Form der vortrainierten Ausgabeschichten entspricht. Die Ausgabeschichten werden weiterhin mit zufälligen Gewichten initialisiert.

Erneutes Laden erzwingen#

Wenn bei den oben genannten Schritten Probleme auftreten, kann force_reload=True helfen: Dabei wird der vorhandene Cache verworfen und die neueste YOLOv5-Version erneut aus PyTorch Hub heruntergeladen. Zwischengespeicherte Kopien befinden sich in ~/.cache/torch/hub; wenn du diesen Ordner löschst, erzielst du denselben Effekt.

model = torch.hub.load("ultralytics/yolov5", "yolov5s", force_reload=True)  # Erneutes Laden erzwingen

Inferenz mit Bildschirmaufnahme#

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

import torch
from PIL import ImageGrab

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

# Image
im = ImageGrab.grab()  # Einen Screenshot aufnehmen

# Inference
results = model(im)

Inferenz mit mehreren GPUs#

YOLOv5-Modelle können für parallele Inferenz mit mehreren Threads auf mehrere GPUs geladen werden:

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

Training#

Um ein YOLOv5-Modell statt für die Inferenz für das Training zu laden, setze autoshape=False. Um ein Modell mit zufällig initialisierten Gewichten zu laden und von Grund auf zu trainieren, verwende pretrained=False. In diesem Fall musst du dein eigenes Trainingsskript bereitstellen. Alternativ findest du in unserem Tutorial zum Trainieren mit eigenen Daten für YOLOv5 weitere Informationen zum Modelltraining.

import torch

model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False)  # Vortrainiertes Modell laden
model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False, pretrained=False)  # Mit zufälligen Gewichten laden

Base64-Ergebnisse#

Zur Verwendung mit API-Diensten. Einzelheiten findest du im Beispiel für die Flask-REST-API.

import base64
from io import BytesIO

from PIL import Image

results = model(im)  # inference

results.ims  # Array der Originalbilder (als np-Array), das dem Modell zur Inferenz übergeben wird
results.render()  # Aktualisiert results.ims mit Boxen und 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-kodiertes Bild mit Ergebnissen

Zugeschnittene Ergebnisse#

Ergebnisse können als zugeschnittene Erkennungen zurückgegeben und gespeichert werden:

results = model(im)  # inference
crops = results.crop(save=True)  # Dictionary der zugeschnittenen Erkennungen

Pandas-Ergebnisse#

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

results = model(im)  # inference
results.pandas().xyxy[0]  # Pandas-DataFrame
Pandas-Ausgabe (zum Aufklappen klicken) 
print(results.pandas().xyxy[0])
# xmin    ymin    xmax   ymax  Konfidenz  Klasse    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#

Ergebnisse können nach Spalte sortiert werden, z. B. um die Ziffern eines Nummernschilds von links nach rechts (x-Achse) zu sortieren:

results = model(im)  # inference
results.pandas().xyxy[0].sort_values("xmin")  # Von links nach rechts sortiert

JSON-Ergebnisse#

Ergebnisse können im JSON-Format zurückgegeben werden, nachdem sie mit der Methode .to_json() in .pandas()-DataFrames umgewandelt wurden. Das JSON-Format lässt sich mit dem Argument orient ändern. Einzelheiten findest du in der pandas-Dokumentation zu .to_json().

results = model(im)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # JSON-Vorhersagen für img1
JSON-Ausgabe (zum Aufklappen 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 mit PyTorch Hub ein benutzerdefiniertes, auf 20 Klassen trainiertes YOLOv5s-Modell VOC 'best.pt'.

import torch

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

TensorRT-, ONNX- und OpenVINO-Modelle#

PyTorch Hub unterstützt die Inferenz mit den meisten YOLOv5-Exportformaten, einschließlich benutzerdefiniert trainierter Modelle. Weitere Informationen zum Exportieren von Modellen findest du in der Anleitung zum Export mit TFLite, ONNX, CoreML und TensorRT.

Tipp
  • TensorRT kann bei GPU-Benchmarks 2- bis 5-mal schneller sein als PyTorch.
  • ONNX und OpenVINO können bei CPU-Benchmarks 2- bis 3-mal schneller sein als PyTorch.
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 (nur macOS)
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 verschiedene sofort einsatzbereite Umgebungen, in denen wichtige Abhängigkeiten wie CUDA, CUDNN, Python und PyTorch bereits installiert sind, damit du schnell mit deinen Projekten loslegen kannst.

Projektstatus#

YOLOv5 CI

Dieses Badge zeigt an, dass alle GitHub-Actions von YOLOv5 für die kontinuierliche Integration (CI) erfolgreich durchlaufen. Diese CI-Tests prüfen gründlich die Funktionalität und Leistung von YOLOv5 in verschiedenen wichtigen 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 sowie bei jedem neuen Commit ausgeführt.

Häufig gestellte Fragen#

  • Nein. torch.hub.load("ultralytics/yolov5", ...) lädt den Code beim ersten Aufruf in ~/.cache/torch/hub und die Gewichte herunter. Es müssen nur die Pakete in requirements.txt installiert werden.

  • Verwende den Einstiegspunkt custom mit dem Prüfpunktpfad: torch.hub.load("ultralytics/yolov5", "custom", path="runs/train/exp/weights/best.pt"). Füge source="local" und einen lokalen Repository-Pfad hinzu, um das Modell ohne Netzwerkzugriff zu laden.

  • Ja. Übergib die exportierte Datei an denselben custom-Loader. YOLOv5 wählt anhand der Dateiendung das passende Backend aus, zum Beispiel yolov5s.onnx, yolov5s.engine oder yolov5s_openvino_model/.

  • Übergib force_reload=True, um das Repository aus dem Cache zu entfernen und den neuesten Code abzurufen, oder lösche ~/.cache/torch/hub manuell. Dadurch werden auch neue YOLOv5-Versionen abgerufen.

  • results.xyxy[0] gibt einen Tensor mit [x1, y1, x2, y2, confidence, class] Zeilen zurück, results.pandas().xyxy[0] gibt einen DataFrame mit Klassennamen zurück, und .to_json(orient="records") erzeugt daraus JSON.

Mitwirkende
GLglenn-jocher3RAraimbekovm1PDpderrenger1

Kommentare