Classificazione delle immagini con Ultralytics YOLO#

La classificazione delle immagini è il più semplice tra i task supportati e consiste nell'assegnare un'intera immagine a una delle classi predefinite.

L'output di un classificatore di immagini è una singola etichetta di classe e un punteggio di confidenza. La classificazione delle immagini è utile quando ti serve sapere soltanto a quale classe appartiene un'immagine e non hai bisogno di conoscere la posizione degli oggetti di quella classe o la loro forma esatta.

Modelli#

Di seguito sono mostrati i modelli YOLO26 Classify preaddestrati sul dataset ImageNet.

I modelli vengono scaricati automaticamente dalla più recente release di Ultralytics al primo utilizzo.

• I valori di acc rappresentano l'accuratezza dei modelli sul set di validazione ImageNet.
  Riproduci con yolo classify val data=path/to/ImageNet device=0
• Velocità media sulle immagini di validazione ImageNet con ONNX su CPU e TensorRT10 su una GPU NVIDIA T4.
  Riproduci con yolo classify val data=path/to/ImageNet batch=1 device=0|cpu
• I valori di Params e FLOPs si riferiscono al modello fuso dopo model.fuse(), che unisce i layer Conv e BatchNorm. I checkpoint preaddestrati mantengono l'architettura di addestramento completa e possono riportare valori più alti.

Consulta l'anteprima non rilasciata di YOLO27 per i dati preliminari sulla velocità di classificazione e sulle dimensioni dei modelli.

Addestra#

Addestra YOLO26n-cls sul dataset MNIST160 per 100 epoche con una dimensione delle immagini di 64. Per l'elenco completo degli argomenti disponibili, consulta la pagina Configurazione.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n-cls.yaml")  # crea un nuovo modello dal file YAML
model = YOLO("yolo26n-cls.pt")  # carica un modello preaddestrato (consigliato per l'addestramento)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # crea dal file YAML e trasferisci i pesi

# Addestra il modello
results = model.train(data="mnist160", epochs=100, imgsz=64)

Consulta la pagina Addestramento per i dettagli completi della modalità train. Puoi addestrare i modelli di classificazione anche con l'addestramento cloud di Ultralytics Platform.

Formato del dataset#

La Guida ai dataset illustra nel dettaglio il formato dei dataset di classificazione YOLO. Puoi anche gestire ed etichettare i dataset di classificazione con gli strumenti di annotazione di Ultralytics Platform.

Trasformazioni personalizzate#

La classificazione Ultralytics YOLO usa torchvision.transforms.RandomResizedCrop per l'addestramento e torchvision.transforms.CenterCrop per la validazione e l'inferenza. Queste trasformazioni basate sul ritaglio presuppongono input quadrati e possono eliminare regioni importanti delle immagini con rapporti d'aspetto estremi. Per mantenere l'immagine intera, sostituisci i ritagli con torchvision.transforms.Resize, che ridimensiona a imgsz × imgsz invece di ritagliare, tramite ClassificationDataset, ClassificationTrainer e ClassificationValidator personalizzati:

import torch
import torchvision.transforms as T

from ultralytics import YOLO
from ultralytics.data.dataset import ClassificationDataset
from ultralytics.models.yolo.classify import ClassificationTrainer, ClassificationValidator

class CustomizedDataset(ClassificationDataset):
    """A customized dataset class for image classification with enhanced data augmentation transforms."""

    def __init__(self, root: str, args, augment: bool = False, prefix: str = "", names=None):
        """Initialize a customized classification dataset with enhanced data augmentation transforms."""
        super().__init__(root, args, augment, prefix, names)

        # Aggiungi qui le tue trasformazioni di addestramento personalizzate
        train_transforms = T.Compose(
            [
                T.Resize((args.imgsz, args.imgsz)),
                T.RandomHorizontalFlip(p=args.fliplr),
                T.RandomVerticalFlip(p=args.flipud),
                T.RandAugment(interpolation=T.InterpolationMode.BILINEAR),
                T.ColorJitter(brightness=args.hsv_v, contrast=args.hsv_v, saturation=args.hsv_s, hue=args.hsv_h),
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
                T.RandomErasing(p=args.erasing, inplace=True),
            ]
        )

        # Aggiungi qui le tue trasformazioni di validazione personalizzate
        val_transforms = T.Compose(
            [
                T.Resize((args.imgsz, args.imgsz)),
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
            ]
        )
        self.torch_transforms = train_transforms if augment else val_transforms

class CustomizedTrainer(ClassificationTrainer):
    """A customized trainer class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str, mode: str = "train", batch=None):
        """Build a customized dataset for classification training and the validation during training."""
        return CustomizedDataset(
            root=img_path,
            args=self.args,
            augment=mode == "train",
            prefix="train" if mode == "train" else self.args.split,
            names=self.data["names"],
        )

class CustomizedValidator(ClassificationValidator):
    """A customized validator class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str):
        """Build a customized dataset for classification standalone validation (no augmentation)."""
        return CustomizedDataset(root=img_path, args=self.args, augment=False, prefix=self.args.split, names=self.names)

model = YOLO("yolo26n-cls.pt")
model.train(data="imagenet", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet", validator=CustomizedValidator, imgsz=224, batch=64)

Convalida#

Convalida l'accuratezza di un modello YOLO26n-cls addestrato. Non servono argomenti, perché model conserva data usato per l'addestramento e i relativi argomenti come attributi del modello: path/to/best.pt dell'esempio di addestramento esegue la validazione su MNIST160. I pesi ufficiali registrano un percorso del dataset di addestramento che non esiste sul tuo computer, quindi, con un avviso, ripiegano sul valore predefinito del task imagenet10. Passa data per eseguire la validazione su un altro dataset.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n-cls.pt")  # carica un modello ufficiale
model = YOLO("path/to/best.pt")  # carica un modello personalizzato

# Convalida il modello
metrics = model.val()  # non servono argomenti, il dataset e le impostazioni vengono ricordati
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

Predici#

Usa un modello YOLO26n-cls addestrato per eseguire predizioni sulle immagini.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n-cls.pt")  # carica un modello ufficiale
model = YOLO("path/to/best.pt")  # carica un modello personalizzato

# Esegui previsioni con il modello
results = model("https://ultralytics.com/images/bus.jpg")  # esegui una previsione su un’immagine

# Accedi ai risultati
for result in results:
    top1 = result.probs.top1  # ID della classe con la predizione più probabile
    top1_conf = result.probs.top1conf  # confidenza della predizione più probabile
    top1_name = result.names[top1]  # nome della classe con la predizione più probabile

Consulta la pagina Previsione per i dettagli completi sulla modalità predict.

Output dei risultati#

La classificazione delle immagini restituisce un oggetto Results per immagine. Il campo principale della predizione è result.probs, che contiene il vettore delle probabilità delle classi e funzioni helper per le predizioni principali.

Per consultare i campi Results specifici di ogni attività, visita la sezione Risultati delle previsioni per attività.

Esporta#

Esporta un modello YOLO26n-cls in un altro formato, ad esempio ONNX, CoreML, ecc.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n-cls.pt")  # carica un modello ufficiale
model = YOLO("path/to/best.pt")  # carica un modello personalizzato

# Esporta il modello
model.export(format="onnx")

I formati di esportazione disponibili per YOLO26-cls sono elencati nella tabella seguente. Puoi esportare in qualsiasi formato usando l'argomento format, ad esempio format='onnx' o format='engine'. Puoi eseguire predizioni o validazioni direttamente sui modelli esportati, ad esempio yolo predict model=yolo26n-cls.onnx. Al termine dell'esportazione vengono mostrati esempi d'uso per il tuo modello.

nms=None restituisce per impostazione predefinita output grezzi per NMS esterno. Imposta nms=False per selezionare una head disponibile senza NMS; i formati non supportati utilizzano il proprio percorso di output nativo. Le voci nms qui sopra identificano i formati che possono integrare NMS con nms=True.

Consulta i dettagli completi di export nella pagina Esportazione.

Domande frequenti#