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 non de connaître l'emplacement ou la forme exacte des objets de cette classe.

Modèles

Les modèles Classify pré-entraînés de YOLO26 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 Semantic 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 leur première utilisation.

• Les valeurs acc correspondent aux précisions des modèles sur le jeu de validation de ImageNet.
  Reproduis avec yolo val classify data=path/to/ImageNet device=0
• Vitesse calculée sur des images de validation ImageNet en utilisant une instance Amazon EC2 P4d.
  Reproduis avec yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Les valeurs de Params et FLOPs correspondent au modèle fusionné après model.fuse(), qui regroupe les couches Conv et BatchNorm. Les points de contrôle 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 de jeu de données de classification YOLO est détaillé 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

# 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

Voir les détails complets du mode predict sur 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é de classe et des aides pour les meilleures prédictions.

Pour les champs Results spécifiques à chaque tâche, consulte la section Résultats de prédiction par tâche.

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 sont dans le tableau ci-dessous. Tu peux exporter vers n'importe quel format en utilisant l'argument format, par exemple format='onnx' ou format='engine'. Tu peux prédire ou valider directement sur les modèles exportés, par exemple yolo predict model=yolo26n-cls.onnx. Des exemples d'utilisation sont affichés pour ton modèle une fois l'exportation terminée.

Consulte les détails complets de export sur 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. C'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 à l'intérieur de l'image.

Comment puis-je 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. Des 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 puis-je exporter un modèle YOLO26 entraîné vers différents formats ?

Tu peux exporter un modèle YOLO26 entraîné vers divers formats en utilisant Python ou des commandes CLI. Par exemple, pour exporter un modèle vers le 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, reporte-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 Valider.