Classificazione delle immagini con Ultralytics YOLO#

La classificazione delle immagini è la più semplice tra le attività supportate 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 solo a quale classe appartiene un'immagine e non hai bisogno di sapere dove si trovano gli oggetti di quella classe o quale sia la loro forma esatta.

Modelli#

Qui sono mostrati i modelli Classify preaddestrati di YOLO26. I modelli Detect, Segment e Pose sono preaddestrati sul dataset COCO, i modelli Semantic sono preaddestrati su Cityscapes e i modelli Classify sono preaddestrati sul dataset ImageNet.

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

• I valori di acc rappresentano l'accuratezza dei modelli sul set di validazione del dataset ImageNet.
  Riproduci con yolo val classify data=path/to/ImageNet device=0
• La velocità è calcolata come media sulle immagini di validazione di ImageNet utilizzando un'istanza Amazon EC2 P4d.
  Riproduci con yolo val classify 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 conservano l'architettura completa di addestramento e possono mostrare conteggi più elevati.

Consulta l' anteprima di YOLO27 non rilasciata per la velocità di classificazione preliminare e le dimensioni dei modelli.

Addestramento#

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

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.yaml")  # build a new model from YAML
model = YOLO("yolo26n-cls.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)

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 = ""):
        """Initialize a customized classification dataset with enhanced data augmentation transforms."""
        super().__init__(root, args, augment, prefix)

        # Add your custom training transforms here
        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),
            ]
        )

        # Add your custom validation transforms here
        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=mode)

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)

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)

Formato del dataset#

Il formato dei dataset di classificazione YOLO è descritto in dettaglio nella Guida ai dataset. I dataset di classificazione possono anche essere gestiti ed etichettati con gli strumenti di annotazione della piattaforma Ultralytics.

Val#

Valida l'accuratezza del modello YOLO26n-cls addestrato sul dataset MNIST160. Non sono necessari argomenti, poiché model conserva il proprio data di addestramento e gli argomenti come attributi del modello.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

Predizione#

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

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    top1 = result.probs.top1  # top predicted class ID
    top1_conf = result.probs.top1conf  # top prediction confidence
    top1_name = result.names[top1]  # top predicted class name

Consulta la pagina Predict per tutti i dettagli sulla modalità predict.

Output dei risultati#

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

Per i campi Results specifici dell'attività in tutte le attività, consulta la sezione Risultati delle predizioni per attività.

Esportazione#

Esporta un modello YOLO26n-cls in un formato diverso, come ONNX, CoreML, ecc.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

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

nms=None utilizza i valori predefiniti per gli output grezzi per la NMS esterna. Imposta nms=False per selezionare una testa senza NMS disponibile; i formati non supportati ricorrono al loro percorso di output nativo. Le voci nms sopra indicano i formati che possono incorporare la NMS con nms=True.

Consulta la pagina Export per tutti i dettagli su export.

FAQ#