Zum Inhalt springen

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.

Projektstatus

YOLOv5 CI

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)

Kommentare