Vai al contenuto

Classificazione delle immagini

Esempi di classificazione delle immagini

La classificazione delle immagini è la più semplice delle tre attività e comporta la classificazione di un'intera immagine in una di una serie 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 è necessario sapere solo a quale classe appartiene un'immagine e non è necessario sapere dove si trovano gli oggetti di quella classe o qual è la loro forma esatta.



Guarda: Esplora le attività Ultralytics YOLO: Classificazione delle immagini utilizzando Ultralytics HUB

Suggerimento

I modelli di classificazione YOLO11 utilizzano il -cls suffisso, cioè yolo11n-cls.pt e sono pre-addestrati su ImageNet.

Modelli

I modelli di classificazione YOLO11 pre-addestrati sono mostrati qui. I modelli Detect, Segment e Pose sono pre-addestrati sul dataset COCO, mentre i modelli Classify sono pre-addestrati sul dataset ImageNet.

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

Modello dimensione
(pixel)
acc
top1
acc
top5
Velocità
CPU ONNX
(ms)
Velocità
T4 TensorRT10
(ms)
parametri
(M)
FLOPs
(B) a 224
YOLO11n-cls 224 70.0 89.4 5.0 ± 0.3 1.1 ± 0.0 1.6 0.5
YOLO11s-cls 224 75.4 92.7 7.9 ± 0.2 1.3 ± 0.0 5.5 1.6
YOLO11m-cls 224 77.3 93.9 17.2 ± 0.4 2.0 ± 0.0 10.4 5.0
YOLO11l-cls 224 78.3 94.3 23.2 ± 0.3 2.8 ± 0.0 12.9 6.2
YOLO11x-cls 224 79.5 94.9 41.4 ± 0.9 3.8 ± 0.0 28.4 13.7
  • acc i valori sono le accuratezze del modello sul ImageNet set di convalida del dataset.
    Riproduci tramite yolo val classify data=path/to/ImageNet device=0
  • Velocità calcolata come media sulle immagini val di ImageNet usando un Amazon EC2 P4d instance.
    Riproduci tramite yolo val classify data=path/to/ImageNet batch=1 device=0|cpu

Addestramento

Addestra YOLO11n-cls sul dataset MNIST160 per 100 epoche con una dimensione dell'immagine di 64. Per un elenco completo degli argomenti disponibili, consulta la pagina Configurazione.

Esempio

from ultralytics import YOLO

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

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)
# Build a new model from YAML and start training from scratch
yolo classify train data=mnist160 model=yolo11n-cls.yaml epochs=100 imgsz=64

# Start training from a pretrained *.pt model
yolo classify train data=mnist160 model=yolo11n-cls.pt epochs=100 imgsz=64

# Build a new model from YAML, transfer pretrained weights to it and start training
yolo classify train data=mnist160 model=yolo11n-cls.yaml pretrained=yolo11n-cls.pt epochs=100 imgsz=64

Suggerimento

La classificazione Ultralytics YOLO utilizza 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 inavvertitamente ritagliare regioni importanti da immagini con proporzioni estreme, causando potenzialmente la perdita di informazioni visive critiche durante l'addestramento. Per preservare l'immagine completa mantenendone le proporzioni, considera l'utilizzo di torchvision.transforms.Resize invece delle trasformazioni di ritaglio.

Puoi implementare questo personalizzando la tua pipeline di aumento tramite un ClassificationDataset e ClassificationTrainer.

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("yolo11n-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 set di dati

Il formato del dataset di classificazione YOLO può essere trovato in dettaglio nella Guida al dataset.

Valutazione

Convalida il modello YOLO11n-cls addestrato accuratezza sul dataset MNIST160. Non sono necessari argomenti poiché il model mantiene il suo training data e gli argomenti come attributi del modello.

Esempio

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-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
yolo classify val model=yolo11n-cls.pt  # val official model
yolo classify val model=path/to/best.pt # val custom model

Suggerimento

Come menzionato in sezione di training, puoi gestire proporzioni estreme durante l'addestramento utilizzando un ClassificationTrainer. È necessario applicare lo stesso approccio per ottenere risultati di convalida coerenti implementando un ClassificationValidator quando si richiama il metodo val() metodo. Fare riferimento all'esempio di codice completo nella sezione di training per i dettagli di implementazione.

Predizione

Utilizza un modello YOLO11n-cls addestrato per eseguire previsioni sulle immagini.

Esempio

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-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
yolo classify predict model=yolo11n-cls.pt source='https://ultralytics.com/images/bus.jpg'  # predict with official model
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model

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

Esportazione

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

Esempio

from ultralytics import YOLO

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

# Export the model
model.export(format="onnx")
yolo export model=yolo11n-cls.pt format=onnx  # export official model
yolo export model=path/to/best.pt format=onnx # export custom trained model

I formati di esportazione YOLO11-cls disponibili sono nella tabella sottostante. Puoi esportare in qualsiasi formato usando il format argomento, ad esempio format='onnx' oppure format='engine'. Puoi prevedere o convalidare direttamente sui modelli esportati, ad esempio yolo predict model=yolo11n-cls.onnx. Esempi di utilizzo vengono mostrati per il tuo modello dopo che l'esportazione è stata completata.

Formato format Argomento Modello Metadati Argomenti
PyTorch - yolo11n-cls.pt -
TorchScript torchscript yolo11n-cls.torchscript imgsz, half, dynamic, optimize, nms, batch, device
ONNX onnx yolo11n-cls.onnx imgsz, half, dynamic, simplify, opset, nms, batch, device
OpenVINO openvino yolo11n-cls_openvino_model/ imgsz, half, dynamic, int8, nms, batch, data, fraction, device
TensorRT engine yolo11n-cls.engine imgsz, half, dynamic, simplify, workspace, int8, nms, batch, data, fraction, device
CoreML coreml yolo11n-cls.mlpackage imgsz, half, int8, nms, batch, device
TF SavedModel saved_model yolo11n-cls_saved_model/ imgsz, keras, int8, nms, batch, device
TF GraphDef pb yolo11n-cls.pb imgsz, batch, device
TF Lite tflite yolo11n-cls.tflite imgsz, half, int8, nms, batch, data, fraction, device
TF Edge TPU edgetpu yolo11n-cls_edgetpu.tflite imgsz, device
TF.js tfjs yolo11n-cls_web_model/ imgsz, half, int8, nms, batch, device
PaddlePaddle paddle yolo11n-cls_paddle_model/ imgsz, batch, device
MNN mnn yolo11n-cls.mnn imgsz, batch, int8, half, device
NCNN ncnn yolo11n-cls_ncnn_model/ imgsz, half, batch, device
IMX500 imx yolo11n-cls_imx_model/ imgsz, int8, data, fraction, device
RKNN rknn yolo11n-cls_rknn_model/ imgsz, batch, name, device

Vedi tutti i export dettagli nella Esportazione pagina.

FAQ

Qual è lo scopo di YOLO11 nella classificazione delle immagini?

I modelli YOLO11, come yolo11n-cls.pt, sono progettati per una classificazione efficiente delle immagini. Assegnano una singola etichetta di classe a un'intera immagine insieme a un punteggio di confidenza. Ciò è 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 posso addestrare un modello YOLO11 per la classificazione delle immagini?

Per addestrare un modello YOLO11, puoi utilizzare i comandi python o CLI. Ad esempio, per addestrare un yolo11n-cls modello sul dataset MNIST160 per 100 epoche con una dimensione dell'immagine di 64:

Esempio

from ultralytics import YOLO

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

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)
yolo classify train data=mnist160 model=yolo11n-cls.pt epochs=100 imgsz=64

Per ulteriori opzioni di configurazione, visita la pagina Configurazione.

Dove posso trovare modelli di classificazione YOLO11 pre-addestrati?

I modelli di classificazione YOLO11 pre-addestrati sono disponibili nella Modelli sezione. Modelli come yolo11n-cls.pt, yolo11s-cls.pt, yolo11m-cls.pt, ecc., sono pre-addestrati sul ImageNet dataset e possono essere facilmente scaricati e utilizzati per varie attività di classificazione delle immagini.

Come posso esportare un modello YOLO11 addestrato in diversi formati?

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

Esempio

from ultralytics import YOLO

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

# Export the model to ONNX
model.export(format="onnx")
yolo export model=yolo11n-cls.pt format=onnx # export the trained model to ONNX format

Per opzioni di esportazione dettagliate, consulta la pagina Esportazione.

Come posso convalidare un modello di classificazione YOLO11 addestrato?

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

Esempio

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-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
yolo classify val model=yolo11n-cls.pt # validate the trained model

Per ulteriori informazioni, visita la sezione Convalida.



📅 Creato 1 anno fa ✏️ Aggiornato 6 giorni fa

Commenti