PyTorch Nabe

📚 Diese Anleitung erklärt, wie man YOLOv5 🚀 von PyTorch Hub unter https://pytorch. org/hub/ultralytics_yolov5.

Bevor Sie beginnen

Installieren Sie die Datei 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 😃

Laden Sie 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 finden Sie 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 Stapelverknüpfung mit PIL und OpenCV Bildquellen. results kann sein gedruckt zu trösten, gespeichert zu runs/hub, zeigte für den Bildschirm in unterstützten Umgebungen, und zurückgegeben 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 zu zidane.jpg YOLO Inferenzergebnisse im Bus.jpg

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

Inferenz-Einstellungen

YOLOv5 Modelle enthalten verschiedene Inferenzattribute wie Konfidenzschwelle, IoU-Schwelle usw., die durch eingestellt 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

Die 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 beliebigen device:

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

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

Stummschaltung Ausgänge

Modelle können im Stillen geladen werden mit _verbose=False:

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

Eingangskanäle

Zum Laden eines vortrainierten YOLOv5s-Modells mit 4 Eingangskanälen anstelle der standardmäßigen 3:

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 wie die vortrainierte Eingabeschicht hat. Die Eingabeschicht wird weiterhin mit Zufallsgewichten initialisiert.

Anzahl der Klassen

Um ein vortrainiertes YOLOv5s-Modell mit 10 statt der standardmäßigen 80 Ausgabeklassen 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 dieselbe Form wie die vorher trainierten Ausgabeschichten haben. Die Ausgabeschichten werden weiterhin mit Zufallsgewichten initialisiert.

Nachladen erzwingen

Wenn Sie mit den obigen Schritten Probleme haben, setzen Sie force_reload=True kann helfen, indem der vorhandene Cache gelöscht und ein neuer Download der neuesten Version von YOLOv5 von PyTorch Hub erzwungen wird.

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

Screenshot Inferenz

So führen Sie die Inferenz auf Ihrem 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 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()

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 müssen Sie Ihr eigenes Skript zur Verfügung stellen. Alternativ können Sie 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

Zur Verwendung mit API-Diensten. Siehe https://github.com/ultralytics / yolov5/pull/2291 und 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 als Erkennungsfrüchte zurückgegeben und 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, d. h. die Nummernschilderkennung wird von links nach rechts sortiert (x-Achse):

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

Box-Cropped Ergebnisse

Die Ergebnisse können als Erkennungsfrüchte zurückgegeben und 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, nachdem sie in .pandas() Datenrahmen unter Verwendung der .to_json() Methode. Das JSON-Format kann mit der Methode orient Argument. Siehe Pandas .to_json() Dokumentation für Einzelheiten.

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

Kundenspezifische 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 bei Benchmarks bis zu 2-3X schneller sein als PyTorch 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 vorinstalliert sind, z. B. CUDA, CUDNN, Python, und PyTorchvorinstalliert, um Ihre Projekte in Gang zu bringen.

Kostenlose GPU Notizbücher:
Google Wolke: GCP-Schnellstart-Anleitung
Amazon: AWS Schnellstart-Anleitung
Azure: AzureML-Schnellstart-Anleitung
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 Schlüsselbereichen: 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 jeder neuen Übertragung durchgeführt werden.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 1 Monat