Classificazione delle immagini con Ultralytics YOLO#

Image classification è il più semplice dei task supportati e consiste nel classificare un'intera immagine in una tra un insieme di 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 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, i modelli Semantic sono preaddestrati sul dataset Cityscapes e i modelli Classify sono preaddestrati sul dataset ImageNet.

I Models vengono scaricati automaticamente dall'ultimo release di Ultralytics al primo utilizzo.

• I valori di acc rappresentano l'accuratezza del modello sul set di validazione del dataset ImageNet.
  Riproduci con yolo val classify data=path/to/ImageNet device=0
• Velocità mediata 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 sono per il modello fuso dopo model.fuse(), che unisce i layer Conv e BatchNorm. I checkpoint preaddestrati mantengono l'intera architettura di training e potrebbero mostrare conteggi più alti.

Addestramento#

Addestra YOLO26n-cls sul dataset MNIST160 per 100 epochs con dimensione immagine 64. Per un elenco completo degli argomenti disponibili, consulta la pagina Configuration.

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="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 è descritto in dettaglio nella Dataset Guide. I dataset di classificazione possono anche essere gestiti ed etichettati con gli Ultralytics Platform annotation tools.

Valutazione#

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

Previsione#

Usa 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

Visualizza i dettagli completi della modalità predict nella pagina Predict.

Output dei risultati#

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

Per i campi specifici dell'attività Results relativi a ogni attività, consulta la sezione Risultati di predizione 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 disponibili per YOLO26-cls sono elencati nella tabella sottostante. Puoi esportare in qualsiasi formato utilizzando l'argomento format, ad es. format='onnx' o format='engine'. Puoi effettuare previsioni o validazioni direttamente sui modelli esportati, ad es. yolo predict model=yolo26n-cls.onnx. Gli esempi d'uso vengono mostrati per il tuo modello al termine dell'esportazione.

Visualizza i dettagli completi di export nella pagina Export.

FAQ#