Link to this sectionClassificazione immagini#

La classificazione delle immagini è il compito più semplice tra quelli supportati 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 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.

Link to this sectionModelli#

Qui sono mostrati i modelli Classify preaddestrati 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 dall'ultima release di Ultralytics al primo utilizzo.

• I valori acc sono le precisioni 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 Params e FLOPs si riferiscono al modello fuso dopo model.fuse(), che unisce i livelli Conv e BatchNorm. I checkpoint preaddestrati mantengono l'architettura di training completa e potrebbero mostrare conteggi più elevati.

Link to this sectionAddestramento#

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):
        """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)

Link to this sectionFormato 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.

Link to this sectionValutazione#

Valida la precisione del modello YOLO26n-cls addestrato sul dataset MNIST160. Non sono necessari argomenti poiché il model mantiene i suoi data e argomenti di addestramento 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

Link to this sectionPrevisione#

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

Vedi tutti i dettagli della modalità predict nella pagina Predict.

Link to this sectionOutput dei risultati#

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

Per i campi Results specifici per ogni attività, vedi la sezione Predizioni dei Risultati per Attività.

Link to this sectionEsportazione#

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 nella tabella sottostante. Puoi esportare in qualsiasi formato usando l'argomento format, ad esempio format='onnx' o format='engine'. Puoi predire o validare direttamente sui modelli esportati, ad esempio yolo predict model=yolo26n-cls.onnx. Esempi di utilizzo vengono mostrati per il tuo modello dopo che l'esportazione è completata.

Vedi i dettagli completi dell'export nella pagina Export.

Link to this sectionFAQ#

Link to this sectionQual è lo scopo di YOLO26 nella classificazione delle immagini?#

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

Link to this sectionCome addestro un modello YOLO26 per la classificazione delle immagini?#

Per addestrare un modello YOLO26, puoi usare Python o i comandi CLI. Ad esempio, per addestrare un modello yolo26n-cls sul dataset MNIST160 per 100 epoche con 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.

Link to this sectionDove posso trovare i modelli di classificazione YOLO26 preaddestrati?#

I modelli di classificazione YOLO26 preaddestrati si possono trovare 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 vari compiti di classificazione delle immagini.

Link to this sectionCome posso esportare un modello YOLO26 addestrato in formati diversi?#

Puoi esportare un modello YOLO26 addestrato in vari formati utilizzando Python o i comandi CLI. Ad esempio, per esportare un modello nel 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, consulta la pagina Esportazione.

Link to this sectionCome valido un modello di classificazione YOLO26 addestrato?#

Per validare la precisione di un modello addestrato su un dataset come MNIST160, puoi usare 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.