Classification d’images avec Ultralytics YOLO#

La classification d’images est la plus simple des tâches prises en charge ; elle consiste à classer une image entière dans une classe parmi un ensemble de classes prédéfinies.

Un classificateur d’images renvoie une seule étiquette de classe et un score de confiance. La classification d’images est utile lorsque tu as seulement besoin de connaître la classe d’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 sur le jeu de données ImageNet sont présentés ci-dessous.

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

• Les valeurs acc correspondent aux précisions des modèles sur le jeu de validation ImageNet.
  Reproduis les résultats avec yolo classify val data=path/to/ImageNet device=0
• Vitesse moyenne sur les images de validation ImageNet avec ONNX sur CPU et TensorRT10 sur un GPU NVIDIA T4.
  Reproduis les résultats avec yolo classify val 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 d’entraînement complète et peuvent donc afficher des valeurs plus élevées.

Consulte l’aperçu non publié de YOLO27 pour découvrir les premières mesures de vitesse de classification et les tailles des modèles.

Entraînement#

Entraîne YOLO26n-cls sur le jeu de données MNIST160 pendant 100 époques, avec une taille d’image de 64. Consulte la page Configuration pour obtenir la liste complète des arguments disponibles.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-cls.yaml")  # créer un nouveau modèle à partir du fichier YAML
model = YOLO("yolo26n-cls.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # créer à partir du fichier YAML et transférer les poids

# Entraîner le modèle
results = model.train(data="mnist160", epochs=100, imgsz=64)

Consulte la page Entraînement pour obtenir tous les détails du mode train. Les modèles de classification peuvent aussi être entraînés dans le cloud avec Ultralytics Platform.

Format du jeu de données#

Le Guide des jeux de données décrit en détail le format des jeux de données de classification YOLO. Les jeux de données de classification peuvent aussi être gérés et annotés avec les outils d’annotation d’Ultralytics Platform.

Transformations personnalisées#

La classification Ultralytics YOLO utilise torchvision.transforms.RandomResizedCrop pour l’entraînement et torchvision.transforms.CenterCrop pour la validation et l’inférence. Ces transformations basées sur le recadrage supposent des entrées carrées et peuvent éliminer des régions importantes des images aux rapports d’aspect extrêmes. Pour conserver l’image entière, remplace les recadrages par torchvision.transforms.Resize, qui redimensionne en imgsz × imgsz au lieu de recadrer, à l’aide d’un ClassificationDataset, d’un ClassificationTrainer et d’un ClassificationValidator personnalisés :

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 = "", names=None):
        """Initialize a customized classification dataset with enhanced data augmentation transforms."""
        super().__init__(root, args, augment, prefix, names)

        # Ajoute ici tes transformations personnalisées d’entraînement
        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),
            ]
        )

        # Ajoute ici tes transformations personnalisées de validation
        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="train" if mode == "train" else self.args.split,
            names=self.data["names"],
        )

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, names=self.names)

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)

Validation#

Valide la précision du modèle YOLO26n-cls entraîné. Aucun argument n’est nécessaire, car le model conserve ses data d’entraînement et ses arguments comme attributs du modèle : path/to/best.pt de l’exemple d’entraînement valide le modèle sur MNIST160. Les poids officiels enregistrent un chemin vers le jeu de données d’entraînement qui n’existe pas sur ta machine ; ils utilisent donc le imagenet10 par défaut de la tâche et affichent un avertissement. Transmets data pour valider le modèle sur un autre jeu de données.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-cls.pt")  # charger un modèle officiel
model = YOLO("path/to/best.pt")  # charger un modèle personnalisé

# Valider le modèle
metrics = model.val()  # aucun argument nécessaire, le jeu de données et les paramètres sont mémorisés
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

# Charger un modèle
model = YOLO("yolo26n-cls.pt")  # charger un modèle officiel
model = YOLO("path/to/best.pt")  # charger un modèle personnalisé

# Effectuer des prédictions avec le modèle
results = model("https://ultralytics.com/images/bus.jpg")  # effectuer une prédiction sur une image

# Accéder aux résultats
for result in results:
    top1 = result.probs.top1  # ID de la classe prédite en première position
    top1_conf = result.probs.top1conf  # score de confiance de la prédiction en première position
    top1_name = result.names[top1]  # nom de la classe prédite en première position

Consulte les détails complets du mode predict sur la page Predict.

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 et des assistants pour les prédictions les mieux classées.

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

Export#

Exporter un modèle YOLO26n-cls vers un autre format comme ONNX, CoreML, etc.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-cls.pt")  # charger un modèle officiel
model = YOLO("path/to/best.pt")  # charger un modèle personnalisé

# Exporter le modèle
model.export(format="onnx")

Les formats d’export disponibles pour YOLO26-cls figurent dans le tableau ci-dessous. Tu peux exporter vers n’importe quel format à l’aide de l’argument format, par exemple format='onnx' ou format='engine'. Tu peux effectuer des prédictions ou valider directement sur les modèles exportés, par exemple yolo predict model=yolo26n-cls.onnx. Des exemples d’utilisation de ton modèle s’affichent une fois l’export terminé.

nms=None produit par défaut des sorties brutes pour la NMS externe. Définis nms=False pour sélectionner une tête disponible sans NMS ; les formats non pris en charge utilisent leur voie de sortie native. Les entrées nms ci-dessus désignent les formats qui peuvent intégrer la NMS avec nms=True.

Consulte tous les détails de export sur la page Exportation.

FAQ#