Link to this sectionClassification d'images#

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

La sortie 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 connaître la classe à laquelle 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.

Link to this sectionModèles#

Les modèles de classification YOLO26 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 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 Ultralytics lors de leur 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
• Vitesse 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 combine 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.

Link to this sectionEntraîner (Train)#

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):
        """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="imagenet1000", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet1000", validator=CustomizedValidator, imgsz=224, batch=64)

Link to this sectionFormat 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.

Link to this sectionValider (Val)#

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

Link to this sectionPrédire (Predict)#

Utilise un modèle YOLO26n-cls entraîné pour exécuter 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 Predict.

Link to this sectionSortie 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 Predict Results by Task.

Link to this sectionExporter (Export)#

Exporte un modèle YOLO26n-cls vers un format différent tel que 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 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 affichés pour ton modèle une fois l'exportation terminée.

Consulte les détails complets de export sur la page Export.

Link to this sectionFAQ#

Link to this sectionQuel est l'objectif de YOLO26 dans la classification d'images ?#

Les modèles YOLO26, tels que yolo26n-cls.pt, sont conçus pour une classification d'images efficace. Ils attribuent une seule étiquette de classe à 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.

Link to this sectionComment 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.

Link to this sectionOù 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.

Link to this sectionComment 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 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, reporte-toi à la page Export.

Link to this sectionComment 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 Validate.