Meet YOLO26: next-gen vision AI.

Link to this sectionLaden von YOLOv5 über PyTorch Hub#

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

Link to this sectionBevor du beginnst#

Installiere requirements.txt in einer Python>=3.8.0-Umgebung, einschließlich PyTorch>=1.8. Modelle und Datensätze werden automatisch mit 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 lädt den Code automatisch.

Link to this sectionLade YOLOv5 mit PyTorch Hub#

Link to this sectionEinfaches Beispiel#

Dieses Beispiel lädt ein vortrainiertes YOLOv5s-Modell über den PyTorch Hub als model und übergibt ein Bild für die Inferenz. 'yolov5s' ist das leichteste und schnellste YOLOv5-Modell. Für Details zu allen verfügbaren Modellen lies bitte die 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 sectionDetailliertes Beispiel#

Dieses Beispiel zeigt batched inference mit PIL- und OpenCV-Bildquellen. results können in der Konsole ausgegeben, unter runs/hub gespeichert, auf unterstützten Systemen auf dem Bildschirm angezeigt und als tensors 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("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.

Link to this sectionInferenz-Einstellungen#

YOLOv5-Modelle enthalten verschiedene Inferenzattribute wie Confidence-Threshold, IoU-Threshold usw., die wie folgt eingestellt 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

Link to this sectionGerät#

Modelle können nach der Erstellung auf jedes beliebige 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 einem bestimmten device erstellt werden:

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

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

Link to this sectionAusgaben unterdrücken#

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

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

Link to this sectionEingabekanäle#

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

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

In diesem Fall besteht das Modell aus vortrainierten Gewichten, außer der allerersten Eingabeschicht, die nicht mehr dieselbe Form wie die vortrainierte Eingabeschicht hat. Die Eingabeschicht bleibt mit zufälligen Gewichten initialisiert.

Link to this sectionAnzahl der Klassen#

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

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

In diesem Fall besteht das Modell aus vortrainierten Gewichten, außer den Ausgabeschichten, die nicht mehr dieselbe Form wie die vortrainierten Ausgabeschichten haben. Die Ausgabeschichten bleiben mit zufälligen Gewichten initialisiert.

Link to this sectionErneutes Laden erzwingen#

Falls du bei den oben genannten Schritten auf Probleme stößt, kann das Setzen von force_reload=True helfen, indem der vorhandene Cache verworfen und ein frischer Download der neuesten YOLOv5-Version über PyTorch Hub erzwungen wird. Zwischengespeicherte Kopien befinden sich in ~/.cache/torch/hub; das Löschen dieses Ordners hat den gleichen Effekt.

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

Link to this sectionBildschirm-Inferenz#

Um eine Inferenz auf deinem Desktop-Bildschirm auszuführen:

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 sectionMulti-GPU-Inferenz#

YOLOv5-Modelle können mit threaded Inferenz 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()

Link to this sectionTraining#

Um ein YOLOv5-Modell zum Trainieren statt für die Inferenz zu laden, setze autoshape=False. Um ein Modell mit zufällig initialisierten Gewichten zu laden (um von Grund auf zu trainieren), verwende pretrained=False. In diesem Fall musst du dein eigenes Trainingsskript bereitstellen. Alternativ sieh dir unser YOLOv5-Tutorial zum Trainieren mit benutzerdefinierten Daten an.

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 sectionBase64-Ergebnisse#

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

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 sectionZugeschnittene Ergebnisse#

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

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

Link to this sectionPandas-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

Link to this sectionSortierte Ergebnisse#

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

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

Link to this sectionJSON-Ergebnisse#

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 sectionBenutzerdefinierte Modelle#

Dieses Beispiel lädt ein benutzerdefiniertes, auf VOC trainiertes 20-Klassen-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

Link to this sectionTensorRT-, ONNX- und OpenVINO-Modelle#

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

Tipp
  • TensorRT kann auf GPU-Benchmarks 2-5-mal schneller sein als PyTorch.
  • ONNX und OpenVINO können auf CPU-Benchmarks 2-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.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 sectionUnterstützte Umgebungen#

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

Link to this sectionProjektstatus#

YOLOv5 CI

Dieses Badge zeigt an, dass alle YOLOv5 GitHub Actions Continuous Integration (CI)-Tests erfolgreich sind. Diese CI-Tests überprüfen rigoros die Funktionalität und Leistung von YOLOv5 in verschiedenen wichtigen Aspekten: Training, Validierung, Inferenz, Export und Benchmarks. Sie gewährleisten einen konsistenten und zuverlässigen Betrieb unter macOS, Windows und Ubuntu, wobei die Tests alle 24 Stunden und bei jedem neuen Commit durchgeführt werden.

Mitwirkende
GLglenn-jocher1

Kommentare