Classification d’images avec Ultralytics YOLO#

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

La sortie d’un classificateur d’images est une seule étiquette de classe accompagnée d’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 savoir où se trouvent les objets de cette classe ni quelle est leur forme exacte.

Modèles#

Les modèles YOLO26 Classify préentraînés sont présentés ici. Les modèles Detect, Segment et Pose sont préentraînés sur le jeu de données COCO, les modèles sémantiques sont préentraînés sur Cityscapes, et les modèles 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 correspondent aux précisions des modèles sur l’ensemble de validation du jeu de données ImageNet.
  Reproduis-les avec yolo val classify data=path/to/ImageNet device=0
• La vitesse est calculée comme la moyenne sur les images de validation d’ImageNet à l’aide d’une instance Amazon EC2 P4d.
  Reproduis-la avec yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Les valeurs de Params et de FLOPs correspondent au modèle fusionné après model.fuse(), qui fusionne les couches Conv et BatchNorm. Les checkpoints préentraînés conservent l'architecture complète d'entraînement et peuvent donc afficher des valeurs plus élevées.

Consulte l'aperçu non publié de YOLO27 pour connaître la vitesse de classification préliminaire et les tailles des modèles.

Entraîner#

Entraîne YOLO26n-cls sur le jeu de données MNIST160 pendant 100 époques, avec une taille d’image de 64. Pour obtenir la 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):
        """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="imagenet", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet", validator=CustomizedValidator, imgsz=224, batch=64)

Format du dataset#

Le format des jeux de données de classification YOLO est décrit 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 annotés avec les outils d’annotation d’Ultralytics Platform.

Validation#

Valide l’exactitude du modèle YOLO26n-cls entraîné sur le jeu de données MNIST160. Aucun argument n’est nécessaire, car le model conserve son data d’entraînement et ses arguments comme attributs du 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édiction#

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

# 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

Consulte les détails complets du mode predict dans la page Prédiction.

Sortie des résultats#

La classification d’images renvoie un objet Results par image. Le champ de prédiction principal est result.probs, qui contient le vecteur de probabilités des classes ainsi que des utilitaires pour les prédictions les plus probables.

Pour connaître les champs Results spécifiques à chaque tâche, consulte la section Résultats des prédictions par tâche.

Exportation#

Exporte un modèle YOLO26n-cls vers un autre format, 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 YOLO26-cls disponibles figurent dans le tableau ci-dessous. Tu peux exporter vers n’importe quel format à l’aide de l’argument format, c’est-à-dire format='onnx' ou format='engine'. Tu peux effectuer des prédictions ou valider directement sur les modèles exportés, c’est-à-dire yolo predict model=yolo26n-cls.onnx. Des exemples d’utilisation sont présentés pour ton modèle une fois l’exportation terminée.

nms=None utilise par défaut des sorties brutes pour NMS externe. Définis nms=False pour sélectionner une tête sans NMS disponible ; les formats non pris en charge reviennent à leur chemin de sortie natif. Les entrées nms ci-dessus identifient les formats capables d'intégrer NMS avec nms=True.

Consulte les détails complets du mode export dans la page Exportation.

FAQ#