Classificazione di immagini

La classificazione di immagini è la più semplice delle tre attività e consiste nel classificare un'intera immagine in una di un insieme di classi predefinite.

L'output di un classificatore di immagini è una singola etichetta di classe e un punteggio di confidenza. La classificazione di immagini è utile quando hai bisogno di 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

I modelli di Classificazione preaddestrati YOLO26 sono mostrati qui. I modelli Detect, Segment e Pose sono preaddestrati sul dataset COCO, mentre i modelli Classify sono preaddestrati sul dataset ImageNet.

I modelli vengono scaricati automaticamente dall'ultima release di Ultralytics al primo utilizzo.

• I valori acc sono le accuratezze del modello sul set di validazione del dataset ImageNet.
  Riproducibile tramite yolo val classify data=path/to/ImageNet device=0
• Velocità mediata su immagini di validazione ImageNet utilizzando un'istanza Amazon EC2 P4d.
  Riproducibile tramite yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• I valori Params e FLOPs si riferiscono al modello fuso dopo model.fuse(), che unisce i livelli Conv e BatchNorm. I checkpoint preaddestrati mantengono l'intera architettura di addestramento e potrebbero mostrare conteggi più elevati.

Train

Addestra YOLO26n-cls sul dataset MNIST160 per 100 epoche a una dimensione immagine di 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, mode: str = "train"):
        """Build a customized dataset for classification standalone validation."""
        return CustomizedDataset(root=img_path, args=self.args, augment=mode == "train", prefix=self.args.split)

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

Formato del dataset

Il formato del dataset di classificazione YOLO può essere trovato in dettaglio nella Guida ai Dataset. I dataset di classificazione possono anche essere gestiti ed etichettati sulla Piattaforma Ultralytics.

Val

Valida l'accuratezza del modello YOLO26n-cls addestrato sul dataset MNIST160. Non sono necessari argomenti poiché il model mantiene i suoi 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

Predict

Usa un modello YOLO26n-cls addestrato per eseguire previsioni su 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

Vedi i dettagli completi della modalità predict nella pagina Previsione.

Export

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 disponibili per YOLO26-cls sono nella tabella sottostante. Puoi esportare in qualsiasi formato utilizzando l'argomento format, ad esempio format='onnx' o format='engine'. Puoi effettuare previsioni o validazioni direttamente sui modelli esportati, ad esempio yolo predict model=yolo26n-cls.onnx. Gli esempi di utilizzo vengono mostrati per il tuo modello una volta completata l'esportazione.

Vedi i dettagli completi su export nella pagina Esportazione.

FAQ

Qual è lo scopo di YOLO26 nella classificazione di immagini?

I modelli YOLO26, come yolo26n-cls.pt, sono progettati per un'efficiente classificazione di immagini. Assegnano una singola etichetta di classe a un'intera immagine insieme a un punteggio di confidenza. Questo è particolarmente utile per le applicazioni in cui è sufficiente conoscere la classe specifica di un'immagine, piuttosto che identificare la posizione o la forma degli oggetti all'interno dell'immagine.

Come faccio ad addestrare un modello YOLO26 per la classificazione di immagini?

Per addestrare un modello YOLO26, puoi utilizzare i comandi Python o CLI. Ad esempio, per addestrare un modello yolo26n-cls sul dataset MNIST160 per 100 epoche a una dimensione immagine di 64:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load a pretrained model (recommended for training)

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

Per ulteriori opzioni di configurazione, visita la pagina Configurazione.

Dove posso trovare modelli di classificazione YOLO26 preaddestrati?

I modelli di classificazione YOLO26 preaddestrati si trovano nella sezione Modelli. Modelli come yolo26n-cls.pt, yolo26s-cls.pt, yolo26m-cls.pt, ecc., sono preaddestrati sul dataset ImageNet e possono essere facilmente scaricati e utilizzati per varie attività di classificazione di immagini.

Come posso esportare un modello YOLO26 addestrato in formati diversi?

Puoi esportare un modello YOLO26 addestrato in vari formati utilizzando i comandi Python o CLI. Ad esempio, per esportare un modello in formato ONNX:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load the trained model

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

Per opzioni di esportazione dettagliate, fai riferimento alla pagina Esportazione.

Come faccio a validare un modello di classificazione YOLO26 addestrato?

Per validare l'accuratezza di un modello addestrato su un dataset come MNIST160, puoi utilizzare i seguenti comandi Python o CLI:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load the trained model

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

Per ulteriori informazioni, visita la sezione Validazione.