YOLO Vision 2026:

Caricamento di YOLOv5 da PyTorch Hub#

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

Prima di iniziare#

Installa requirements.txt in un ambiente Python>=3.8.0, includendo PyTorch>=1.8. Modelli e dataset vengono scaricati automaticamente dall'ultima release di YOLOv5.

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

La clonazione di ultralytics/yolov5 non è necessaria: PyTorch Hub recupera automaticamente il codice.

Carica 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, consulta il 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 l'inferenza in batch con sorgenti di immagini PIL e OpenCV. results può essere stampato nella console, salvato in runs/hub, visualizzato sullo schermo negli ambienti supportati e restituito come tensori o DataFrame pandas.

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

Per tutte le opzioni di inferenza, consulta il metodo forward di YOLOv5 AutoShape().

Impostazioni dell'inferenza#

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

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

Dispositivo#

I modelli possono essere trasferiti a 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 di input vengono trasferite automaticamente al dispositivo corretto del modello prima dell'inferenza.

Disattivazione dell'output#

I modelli possono essere caricati senza output con _verbose=False:

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

Canali di input#

Per caricare un modello YOLOv5s preaddestrato con 4 canali di input anziché i 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 livello di input, che non ha più la stessa forma del livello di input preaddestrato. Il livello di input rimarrà inizializzato con pesi casuali.

Numero di classi#

Per caricare un modello YOLOv5s preaddestrato con 10 classi di output anziché le 80 predefinite:

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

In questo caso, il modello sarà composto da pesi preaddestrati tranne che per i livelli di output, che non hanno più la stessa forma dei livelli di output preaddestrati. I livelli di output rimarranno inizializzati con pesi casuali.

Ricaricamento forzato#

Se riscontri problemi con i passaggi precedenti, impostare force_reload=True può aiutare eliminando la cache esistente e forzando un nuovo download dell'ultima versione di YOLOv5 da PyTorch Hub. Le copie memorizzate nella cache si trovano in ~/.cache/torch/hub; eliminare quella cartella produce lo stesso effetto.

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

Inferenza da screenshot#

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 multi-GPU#

I modelli YOLOv5 possono essere caricati su più GPU in parallelo con l'inferenza basata su 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()

Addestramento#

Per caricare un modello YOLOv5 per l'addestramento anziché per l'inferenza, imposta autoshape=False. Per caricare un modello con pesi inizializzati casualmente (per addestrarlo da zero), usa pretrained=False. In questo caso devi fornire il tuo script di addestramento. In alternativa, consulta il nostro Tutorial sull'addestramento di dati personalizzati di YOLOv5 per l'addestramento dei modelli.

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#

Per l'utilizzo con servizi API. Per maggiori dettagli, consulta l'esempio di 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

Risultati ritagliati#

I risultati possono essere restituiti e salvati come ritagli delle rilevazioni:

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

Risultati pandas#

I risultati possono essere restituiti come DataFrame pandas:

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

Risultati ordinati#

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

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

Risultati JSON#

I risultati possono essere restituiti in formato JSON dopo essere stati convertiti in DataFrame .pandas() tramite il metodo .to_json(). Il formato JSON può essere modificato usando l'argomento orient. Per maggiori dettagli, consulta la documentazione di pandas .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"
    }
]

Modelli personalizzati#

Questo esempio carica con PyTorch Hub un modello YOLOv5s personalizzato addestrato su VOC con 20 classi, 'best.pt'.

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

Modelli TensorRT, ONNX e OpenVINO#

PyTorch Hub supporta l'inferenza nella maggior parte dei formati di esportazione di YOLOv5, inclusi i modelli addestrati personalizzati. Per maggiori dettagli sull'esportazione dei modelli, consulta il tutorial sull'esportazione in TFLite, ONNX, CoreML e TensorRT.

Suggerimento
  • TensorRT può essere da 2 a 5 volte più veloce di PyTorch nei benchmark su GPU.
  • ONNX e OpenVINO possono essere da 2 a 3 volte più veloci di PyTorch nei benchmark su CPU.
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 offre una serie di ambienti pronti all'uso, ciascuno con dipendenze essenziali preinstallate, come CUDA, CUDNN, Python e PyTorch, per avviare rapidamente i tuoi progetti.

Stato del progetto#

YOLOv5 CI

Questo badge indica che tutti i test di GitHub Actions di YOLOv5 per l'integrazione continua (CI) vengono superati correttamente. Questi test di CI verificano rigorosamente la funzionalità e le prestazioni di YOLOv5 sotto diversi aspetti fondamentali: addestramento, convalida, inferenza, esportazione e benchmark. Garantiscono un funzionamento coerente e affidabile su macOS, Windows e Ubuntu, con test eseguiti ogni 24 ore e a ogni nuovo commit.

Collaboratori
RAraimbekovm1PDpderrenger1GLglenn-jocher1

Commenti