PyTorch Mozzo

📚 Questa guida spiega come caricare YOLOv5 🚀 da PyTorch Hub all'indirizzo https://pytorch.org/hub/ultralytics_yolov5.

Prima di iniziare

Installare il file requirements.txt in un file Python>=3.8.0 incluso PyTorch>=1.8. I modelli e i dataset vengono scaricati automaticamente dall'ultimarelease di YOLOv5 .

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

💡 Suggerimento: non è necessario clonare https://github.com/ultralytics / yolov5 😃

Carico YOLOv5 con PyTorch Hub

Esempio semplice

Questo esempio carica un modello YOLOv5s preaddestrato da PyTorch Hub come model e passa un'immagine per l'inferenza. 'yolov5s' è il modello YOLOv5 più leggero e veloce. Per informazioni dettagliate su tutti i modelli disponibili, consultare il sito 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

Esempio dettagliato

Questo esempio mostra inferenza in batch con PIL e OpenCV fonti delle immagini. results può essere stampato alla console, salvato a runs/hub, mostrato per la proiezione sugli ambienti supportati e restituito come tensori o panda 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 risultati dell'inferenza su zidane.jpg

Per tutte le opzioni di inferenza, vedere YOLOv5 AutoShape() in avanti metodo.

Impostazioni di inferenza

YOLOv5 I modelli contengono vari attributi di inferenza, come la soglia di confidenza, la soglia IoU e così via, che possono essere impostati da:

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

Dispositivo

I modelli possono essere trasferiti su qualsiasi dispositivo dopo la creazione:

model.cpu()  # CPU
model.cuda()  # GPU
model.to(device)  # i.e. device=torch.device(0)

I modelli possono anche essere creati direttamente su qualsiasi device:

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

💡 Suggerimento: le immagini in ingresso vengono trasferite automaticamente al dispositivo modello corretto prima dell'inferenza.

Uscite di silenzio

I modelli possono essere caricati silenziosamente con _verbose=False:

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

Canali di ingresso

Per caricare un modello YOLOv5s pre-addestrato con 4 canali di ingresso invece dei 3 predefiniti:

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

In questo caso il modello sarà composto da pesi preaddestrati , tranne che per il primo strato di input, che non avrà più la stessa forma dello strato di input preaddestrato. Lo strato di input rimarrà inizializzato con pesi casuali.

Numero di classi

Per caricare un modello YOLOv5s pre-addestrato con 10 classi di output invece delle 80 predefinite:

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

In questo caso il modello sarà composto da pesi preaddestrati , tranne che per gli strati di uscita, che non avranno più la stessa forma degli strati di uscita preaddestrati. Gli strati di uscita rimarranno inizializzati con pesi casuali.

Ricarica forzata

Se si riscontrano problemi con i passaggi sopra descritti, impostare force_reload=True può essere utile scaricando la cache esistente e forzando un nuovo download dell'ultima versione di YOLOv5 da PyTorch Hub.

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

Inferenza delle schermate

Per eseguire l'inferenza sullo schermo del desktop:

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)

Inferenza multiplaGPU

YOLOv5 I modelli possono essere caricati su più GPU in parallelo con l'inferenza in thread:

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

Formazione

Per caricare un modello YOLOv5 per l'addestramento piuttosto che per l'inferenza, impostare autoshape=False. Per caricare un modello con pesi inizializzati in modo casuale (per addestrarlo da zero) si usa pretrained=False. In questo caso è necessario fornire il proprio script di formazione. In alternativa, consultare il nostro YOLOv5 Esercitazione sui dati personalizzati del treno per l'addestramento del modello.

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

Risultati Base64

Da usare con i servizi API. Vedere https://github.com/ultralytics / yolov5/pull/2291 e l'esempio di API REST di Flask per i dettagli.

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

Risultati ritagliati

I risultati possono essere restituiti e salvati come colture di rilevamento:

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

Risultati dei panda

I risultati possono essere restituiti come DataFrames di Pandas:

results = model(im)  # inference
results.pandas().xyxy[0]  # Pandas DataFrame

Output di Pandas (fare clic per espandere)

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

Risultati ordinati

I risultati possono essere ordinati per colonna, ad esempio per ordinare il rilevamento delle cifre della targa da sinistra a destra (asse x):

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

Risultati ritagliati in un riquadro

I risultati possono essere restituiti e salvati come colture di rilevamento:

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

Risultati JSON

I risultati possono essere restituiti in formato JSON una volta convertiti in .pandas() utilizzando il metodo .to_json() metodo. Il formato JSON può essere modificato utilizzando il metodo orient argomento. Vedere pandas .to_json() documentazione per i dettagli.

results = model(ims)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # JSON img1 predictions

Output JSON (fare clic per espandere)

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

Modelli personalizzati

Questo esempio carica una classe 20 personalizzata VOC-Modello YOLOv5s addestrato 'best.pt' con 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 e OpenVINO Modelli

PyTorch Hub supporta l'inferenza sulla maggior parte dei formati di esportazione di YOLOv5 , compresi i modelli addestrati in modo personalizzato. Vedere il tutorial sull'esportazione di TFLite, ONNX, CoreML, TensorRT per i dettagli sull'esportazione dei modelli.

💡 Suggerimento: TensorRT può essere fino a 2-5 volte più veloce di PyTorch nei GPU benchmark 💡 Suggerimento: ONNX e OpenVINO può essere fino a 2-3 volte più veloce di PyTorch nei benchmark. CPU benchmark

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

Ambienti supportati

Ultralytics fornisce una serie di ambienti pronti all'uso, ognuno dei quali è preinstallato con le dipendenze essenziali quali CUDA, CUDNN, Python, e PyTorchper avviare i vostri progetti.

Taccuini gratuiti GPU:
Google Cloud: Guida rapida a GCP
Amazon: Guida rapida AWS
Azure: Guida rapida ad AzureML
Docker: Guida rapida a Docker

Stato del progetto

Questo badge indica che tutti i test di Continuous Integration (CI) di YOLOv5 GitHub Actions sono stati superati con successo. Questi test CI verificano rigorosamente la funzionalità e le prestazioni di YOLOv5 in vari aspetti chiave: formazione, validazione, inferenza, esportazione e benchmark. Assicurano un funzionamento coerente e affidabile su macOS, Windows e Ubuntu, con test condotti ogni 24 ore e su ogni nuovo commit.

📅C reato 1 anno fa ✏️ Aggiornato 1 mese fa