YOLO Vision 2026:

YOLOv5 aus PyTorch Hub laden#

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

Bevor du beginnst#

Installiere requirements.txt in einer Python>=3.8.0-Umgebung einschließlich PyTorch>=1.8. Modelle und Datensätze werden automatisch aus dem neuesten YOLOv5-Release 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 ein Bild zur Inferenz. 'yolov5s' ist das kleinste und schnellste 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  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

Detailliertes Beispiel#

Dieses Beispiel zeigt eine Batch-Inferenz mit PIL- und OpenCV-Bildquellen. results kann in 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 findest du in der AutoShape()-Forward-Methode von YOLOv5.

Inference-Einstellungen#

YOLOv5-Modelle enthalten verschiedene Inferenzattribute wie Konfidenzschwellenwert, IoU-Schwellenwert usw., die folgendermaßen festgelegt werden können:

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

Gerät#

Modelle können nach ihrer 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 jedem device erstellt werden:

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

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

Ausgaben unterdrücken#

Modelle können mit _verbose=False ohne Ausgaben geladen werden:

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

Eingabekanäle#

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

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

In diesem Fall besteht das Modell aus vortrainierten Gewichten mit Ausnahme der allerersten Eingangsschicht, deren Form nicht mehr der der vortrainierten Eingangsschicht entspricht. Die Eingangsschicht bleibt 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 der vortrainierten Ausgabeschichten entspricht. Die Ausgabeschichten bleiben mit zufälligen Gewichten initialisiert.

Neuladen erzwingen#

Falls bei den obigen Schritten Probleme auftreten, kann das Setzen von force_reload=True helfen, indem der vorhandene Cache verworfen und der Download der neuesten YOLOv5-Version aus PyTorch Hub erzwungen wird. Zwischengespeicherte Kopien befinden sich in ~/.cache/torch/hub; das Löschen dieses Ordners erzielt denselben Effekt.

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

Inferenz mit Bildschirmaufnahmen#

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()  # take a screenshot

# Inference
results = model(im)

Inferenz mit mehreren GPUs#

YOLOv5-Modelle können mit Inferenz über mehrere Threads parallel 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 zum Trainieren statt zur Inferenz zu laden, setze autoshape=False. Um ein Modell mit zufällig initialisierten Gewichten zu laden (für ein Training von Grund auf), verwende pretrained=False. In diesem Fall musst du dein eigenes Trainingsskript bereitstellen. Alternativ findest du in unserem Tutorial zum Trainieren mit benutzerdefinierten Daten zu YOLOv5 weitere Informationen zum 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#

Zur Verwendung mit API-Diensten. Einzelheiten findest du im Beispiel zur Flask REST API.

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

Zugeschnittene Ergebnisse#

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

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

Pandas-Ergebnisse#

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

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

Sortierte Ergebnisse#

Ergebnisse können nach Spalten sortiert werden, beispielsweise um die Erkennung von Ziffern auf Kennzeichen von links nach rechts (x-Achse) zu sortieren:

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

JSON-Ergebnisse#

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

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

Benutzerdefinierte Modelle#

Dieses Beispiel lädt ein benutzerdefiniertes, mit VOC trainiertes YOLOv5s-Modell mit 20 Klassen als 'best.pt' über 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 die Inferenz mit den meisten YOLOv5-Exportformaten, einschließlich benutzerdefiniert trainierter Modelle. Einzelheiten zum Exportieren von Modellen findest du im Tutorial zum Exportieren nach TFLite, ONNX, CoreML und TensorRT.

Tipp
  • TensorRT kann bei GPU-Benchmarks 2- bis 5-mal schneller als PyTorch sein.
  • ONNX und OpenVINO können bei CPU-Benchmarks 2- bis 3-mal schneller als PyTorch sein.
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 stellt eine Reihe sofort einsatzbereiter Umgebungen bereit, in denen wichtige Abhängigkeiten wie CUDA, CUDNN, Python und PyTorch bereits installiert sind, damit du deine Projekte schnell starten kannst.

Projektstatus#

YOLOv5 CI

Dieses Abzeichen zeigt an, dass alle GitHub-Actions für YOLOv5-Tests zur kontinuierlichen Integration (CI) erfolgreich durchlaufen. Diese CI-Tests prüfen 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 durchgeführt.

Mitwirkende
RAraimbekovm1PDpderrenger1GLglenn-jocher1

Kommentare