Bildklassifizierung mit Ultralytics YOLO#

Image classification ist die einfachste der unterstützten Aufgaben und beinhaltet die Klassifizierung eines gesamten Bildes in eine von mehreren vordefinierten Klassen.

Die Ausgabe eines Bildklassifikators ist ein einzelnes Klassenlabel und ein Konfidenzwert. Die Bildklassifizierung ist nützlich, wenn du nur wissen musst, zu welcher Klasse ein Bild gehört, und nicht wissen musst, wo sich Objekte dieser Klasse befinden oder welche exakte Form sie haben.

Models#

Vorab trainierte YOLO26 Classify-Modelle werden hier gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem COCO-Datensatz vorab trainiert, Semantic-Modelle auf Cityscapes und Classify-Modelle auf dem ImageNet-Datensatz.

Modelle werden bei der ersten Verwendung automatisch vom neuesten Ultralytics-Release heruntergeladen.

• acc-Werte sind Modellgenauigkeiten auf dem Validierungssatz des ImageNet-Datensatzes.
  Reproduzieren mit yolo val classify data=path/to/ImageNet device=0
• Geschwindigkeit gemittelt über ImageNet-Val-Bilder unter Verwendung einer Amazon EC2 P4d-Instanz.
  Reproduzieren mit yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Params- und FLOPs-Werte gelten für das fusionierte Modell nach model.fuse(), welches Conv- und BatchNorm-Schichten zusammenführt. Vortrainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können höhere Anzahlen aufweisen.

Trainieren#

Trainiere YOLO26n-cls auf dem MNIST160-Datensatz für 100 Epochen bei einer Bildgröße von 64. Eine vollständige Liste der verfügbaren Argumente findest du auf der Configuration-Seite.

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)

Datensatzformat#

Das Format für YOLO-Klassifizierungsdatensätze findest du detailliert im Dataset Guide. Klassifizierungsdatensätze können auch mit Ultralytics Platform annotation tools verwaltet und mit Labels versehen werden.

Validieren#

Validiere die Genauigkeit des trainierten YOLO26n-cls-Modells auf dem MNIST160-Datensatz. Es sind keine Argumente erforderlich, da der model seine Trainings-data und Argumente als Modellattribute behält.

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

Vorhersagen#

Verwende ein trainiertes YOLO26n-cls-Modell, um Vorhersagen auf Bildern auszuführen.

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

Weitere Details zum predict-Modus findest du auf der Predict-Seite.

Ergebnisausgabe#

Die Bildklassifizierung liefert ein Results-Objekt pro Bild. Das primäre Vorhersagefeld ist result.probs, welches den Klassenwahrscheinlichkeitsvektor und Hilfsmittel für Top-Vorhersagen enthält.

Aufgabenspezifische Results-Felder für alle Aufgaben findest du im Abschnitt Predict Results by Task.

Exportieren#

Exportiere ein YOLO26n-cls-Modell in ein anderes Format wie 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")

Verfügbare YOLO26-cls-Exportformate sind in der Tabelle unten aufgeführt. Du kannst mit dem Argument format in jedes Format exportieren, d. h. format='onnx' oder format='engine'. Du kannst direkt mit exportierten Modellen vorhersagen oder validieren, d. h. yolo predict model=yolo26n-cls.onnx. Anwendungsbeispiele werden nach Abschluss des Exports für dein Modell angezeigt.

Weitere Details zum export-Modus findest du auf der Export-Seite.

FAQ#