Classification d'images

La classification d'images est la plus simple des trois tâches et consiste à classer une image entière dans l'une des classes prédéfinies.

Le résultat d'un classificateur d'images est une étiquette de classe unique et un score de confiance. La classification d'images est utile lorsque tu as seulement besoin de savoir à quelle classe appartient une image et que tu n'as pas besoin de connaître l'emplacement ou la forme exacte des objets de cette classe.

Modèles

Les modèles de classification pré-entraînés YOLO26 sont présentés ici. Les modèles de détection (Detect), de segmentation (Segment) et de pose (Pose) sont pré-entraînés sur le jeu de données COCO, tandis que les modèles de classification (Classify) sont pré-entraînés sur le jeu de données ImageNet.

Les modèles sont téléchargés automatiquement depuis la dernière version d'Ultralytics lors de la première utilisation.

• Les valeurs acc sont les précisions des modèles sur le jeu de validation ImageNet.
  Reproduis cela avec yolo val classify data=path/to/ImageNet device=0
• La vitesse (Speed) est calculée en moyenne sur les images de validation ImageNet en utilisant une instance Amazon EC2 P4d.
  Reproduis cela avec yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Les valeurs Params et FLOPs correspondent au modèle fusionné après model.fuse(), qui fusionne les couches Conv et BatchNorm. Les points de contrôle (checkpoints) pré-entraînés conservent l'architecture d'entraînement complète et peuvent afficher des nombres plus élevés.

Entraînement

Entraîne YOLO26n-cls sur le jeu de données MNIST160 pendant 100 époques avec une taille d'image de 64. Pour une liste complète des arguments disponibles, consulte la page 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, 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)

Format de jeu de données

Le format du jeu de données de classification YOLO peut être trouvé en détail dans le Guide des jeux de données. Les jeux de données de classification peuvent également être gérés et étiquetés sur la Plateforme Ultralytics.

Validation

Valide la précision du modèle YOLO26n-cls entraîné sur le jeu de données MNIST160. Aucun argument n'est nécessaire car le model conserve ses data d'entraînement et ses arguments en tant qu'attributs de modèle.

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

Prédire

Utilise un modèle YOLO26n-cls entraîné pour effectuer des prédictions sur des images.

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

Vois tous les détails du mode predict sur la page Predict.

Exportation

Exporte un modèle YOLO26n-cls vers un format différent comme ONNX, CoreML, etc.

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

Les formats d'exportation disponibles pour YOLO26-cls se trouvent dans le tableau ci-dessous. Tu peux exporter vers n'importe quel format en utilisant l'argument format, par ex. format='onnx' ou format='engine'. Tu peux prédire ou valider directement sur les modèles exportés, par ex. yolo predict model=yolo26n-cls.onnx. Des exemples d'utilisation sont montrés pour ton modèle une fois l'exportation terminée.

Voir les détails complets sur l'export dans la page Export.

FAQ

Quel est l'objectif de YOLO26 dans la classification d'images ?

Les modèles YOLO26, comme yolo26n-cls.pt, sont conçus pour une classification d'images efficace. Ils attribuent une étiquette de classe unique à une image entière ainsi qu'un score de confiance. Cela est particulièrement utile pour les applications où il suffit de connaître la classe spécifique d'une image, plutôt que d'identifier l'emplacement ou la forme des objets dans l'image.

Comment entraîner un modèle YOLO26 pour la classification d'images ?

Pour entraîner un modèle YOLO26, tu peux utiliser Python ou des commandes CLI. Par exemple, pour entraîner un modèle yolo26n-cls sur le jeu de données MNIST160 pendant 100 époques avec une taille d'image de 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)

Pour plus d'options de configuration, visite la page Configuration.

Où puis-je trouver des modèles de classification YOLO26 pré-entraînés ?

Les modèles de classification YOLO26 pré-entraînés se trouvent dans la section Modèles. Les modèles comme yolo26n-cls.pt, yolo26s-cls.pt, yolo26m-cls.pt, etc., sont pré-entraînés sur le jeu de données ImageNet et peuvent être facilement téléchargés et utilisés pour diverses tâches de classification d'images.

Comment exporter un modèle YOLO26 entraîné vers différents formats ?

Tu peux exporter un modèle YOLO26 entraîné vers différents formats en utilisant Python ou des commandes CLI. Par exemple, pour exporter un modèle au format 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")

Pour des options d'exportation détaillées, réfère-toi à la page Exportation.

Comment valider un modèle de classification YOLO26 entraîné ?

Pour valider la précision d'un modèle entraîné sur un jeu de données comme MNIST160, tu peux utiliser les commandes Python ou CLI suivantes :

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

Pour plus d'informations, visite la section Validation.