Ultralytics YOLO27:
Get Started

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. I modelli e i dataset vengono scaricati automaticamente dall'ultima release di YOLOv5.

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

Non è necessario clonare ultralytics/yolov5: PyTorch Hub recupera automaticamente il codice.

Caricare 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' è un modello YOLOv5 piccolo e veloce. Per informazioni 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 immagini sorgenti 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 di inferenza#

I modelli YOLOv5 includono vari attributi di inferenza, come la soglia di confidenza, la soglia IoU e così via, che puoi impostare nel modo seguente:

model.conf = 0.25  # Soglia di confidenza NMS
model.iou = 0.45  # Soglia IoU NMS
model.agnostic = False  # NMS senza distinzione tra classi
model.multi_label = False  # NMS con più etichette per riquadro
model.classes = None  # (lista facoltativa) filtra per classe, ad esempio = [0, 15, 16] per persone, gatti e cani COCO
model.max_det = 1000  # numero massimo di rilevamenti per immagine
model.amp = False  # inferenza con precisione mista automatica (AMP)

results = model(im, size=320)  # dimensione di inferenza personalizzata

Dispositivo#

Dopo la creazione, puoi trasferire i modelli su qualsiasi dispositivo:

model.cpu()  # CPU
model.cuda()  # GPU
model.to(device)  # ad es. device=torch.device(0)

Puoi anche creare i modelli direttamente su qualsiasi device:

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

Prima dell'inferenza, le immagini di input vengono trasferite automaticamente sul dispositivo corretto del modello.

Disattivare l'output#

Puoi caricare i modelli senza output con _verbose=False:

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

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 primissimo livello di input, che non ha più la stessa forma del livello di input preaddestrato. Il livello di input manterrà i pesi inizializzati casualmente.

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 manterranno i pesi inizializzati casualmente.

Forza ricaricamento#

Se riscontri problemi con i passaggi precedenti, impostare force_reload=True può essere d'aiuto: elimina la cache esistente e forza il 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)  # forza ricaricamento

Inferenza da screenshot#

Per eseguire l'inferenza sullo schermo del tuo desktop:

import torch
from PIL import ImageGrab

# Model
model = torch.hub.load("ultralytics/yolov5", "yolov5s")

# Image
im = ImageGrab.grab()  # acquisisci uno screenshot

# Inference
results = model(im)

Inferenza multi-GPU#

Puoi caricare i modelli YOLOv5 su più GPU in parallelo, usando l'inferenza con 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 per addestrare modelli con dati personalizzati di YOLOv5 per l'addestramento dei modelli.

import torch

model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False)  # carica preaddestrato
model = torch.hub.load("ultralytics/yolov5", "yolov5s", autoshape=False, pretrained=False)  # carica da zero

Risultati Base64#

Da usare con i servizi API. Per i dettagli, consulta l'esempio Flask REST API.

import base64
from io import BytesIO

from PIL import Image

results = model(im)  # inference

results.ims  # array delle immagini originali (come array np) passate al modello per l'inferenza
results.render()  # aggiorna results.ims con riquadri ed etichette
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"))  # immagine codificata in base64 con i risultati

Risultati ritagliati#

Puoi restituire e salvare i risultati come ritagli dei rilevamenti:

results = model(im)  # inference
crops = results.crop(save=True)  # dizionario dei rilevamenti ritagliati

Risultati Pandas#

Puoi restituire i risultati come DataFrame Pandas:

results = model(im)  # inference
results.pandas().xyxy[0]  # DataFrame Pandas
Output pandas (fai 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#

Puoi ordinare i risultati per colonna, ad esempio per ordinare da sinistra a destra (asse x) i numeri delle targhe rilevate:

results = model(im)  # inference
results.pandas().xyxy[0].sort_values("xmin")  # ordinati da sinistra a destra

Risultati JSON#

Puoi restituire i risultati in formato JSON dopo averli convertiti in DataFrame .pandas() usando il metodo .to_json(). Puoi modificare il formato JSON con l'argomento orient. Per i dettagli, consulta la documentazione di pandas .to_json().

results = model(im)  # inference
results.pandas().xyxy[0].to_json(orient="records")  # previsioni JSON img1
Output JSON (fai 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 un modello YOLOv5s personalizzato, addestrato su 20 classi VOC, 'best.pt', con PyTorch Hub.

import torch

model = torch.hub.load("ultralytics/yolov5", "custom", path="path/to/best.pt")  # modello locale
model = torch.hub.load("path/to/yolov5", "custom", path="path/to/best.pt", source="local")  # repository locale

Modelli TensorRT, ONNX e OpenVINO#

PyTorch Hub supporta l'inferenza con la maggior parte dei formati di esportazione YOLOv5, compresi i modelli addestrati su dati personalizzati. Consulta il tutorial sull'esportazione in TFLite, ONNX, CoreML e TensorRT per i dettagli sull'esportazione dei modelli.

Suggerimento
  • TensorRT può essere 2-5× più veloce di PyTorch nei benchmark GPU.
  • ONNX e OpenVINO possono essere 2-3× più veloci di PyTorch nei benchmark 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.mlpackage")  # CoreML (solo macOS)
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 gamma di ambienti pronti all'uso, ciascuno con le dipendenze essenziali già installate, come CUDA, CUDNN, Python e PyTorch, per dare il via ai tuoi progetti.

Stato del progetto#

YOLOv5 CI

Questo badge indica che tutti i test di integrazione continua (CI) di YOLOv5 GitHub Actions sono superati correttamente. Questi test CI verificano rigorosamente la funzionalità e le prestazioni di YOLOv5 in diversi ambiti chiave: addestramento, validazione, 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.

Domande frequenti#

  • No. torch.hub.load("ultralytics/yolov5", ...) scarica il codice in ~/.cache/torch/hub e i pesi al primo utilizzo. È necessario installare solo i pacchetti in requirements.txt.

  • Usa il punto di ingresso custom con il percorso del checkpoint: torch.hub.load("ultralytics/yolov5", "custom", path="runs/train/exp/weights/best.pt"). Aggiungi source="local" e un percorso al repository locale per caricarlo senza accesso alla rete.

  • Sì. Passa il file esportato allo stesso loader custom e YOLOv5 seleziona il backend corrispondente in base all'estensione, ad esempio yolov5s.onnx, yolov5s.engine o yolov5s_openvino_model/.

  • Passa force_reload=True per eliminare il repository memorizzato nella cache e scaricare il codice più recente, oppure elimina manualmente ~/.cache/torch/hub. In questo modo vengono acquisiti anche i nuovi rilasci di YOLOv5.

  • results.xyxy[0] restituisce un tensore con righe [x1, y1, x2, y2, confidence, class], results.pandas().xyxy[0] restituisce un DataFrame con i nomi delle classi e .to_json(orient="records") applicato a quel DataFrame genera JSON.

Collaboratori
GLglenn-jocher3RAraimbekovm1PDpderrenger1

Commenti