Bildklassifizierung mit Ultralytics YOLO#

Die Bildklassifizierung ist die einfachste der unterstützten Aufgaben. Dabei wird ein ganzes Bild einer von mehreren vordefinierten Klassen zugeordnet.

Ein Bildklassifizierer gibt eine einzelne Klassenbezeichnung und einen Konfidenzwert aus. Die Bildklassifizierung ist nützlich, wenn du nur wissen musst, zu welcher Klasse ein Bild gehört, aber nicht, wo sich Objekte dieser Klasse befinden oder welche genaue Form sie haben.

Modelle#

Unten findest du YOLO26-Classify-Modelle, die mit dem Datensatz ImageNet vortrainiert wurden.

Modelle werden bei der ersten Verwendung automatisch aus der neuesten Ultralytics-Version heruntergeladen.

• Die Werte für acc geben die Modellgenauigkeit auf dem Validierungssatz des Datensatzes ImageNet an.
  Reproduziere die Ergebnisse mit yolo classify val data=path/to/ImageNet device=0
• Geschwindigkeit, gemittelt über die Validierungsbilder von ImageNet mit ONNX auf CPU und TensorRT10 auf einer NVIDIA-T4-GPU.
  Reproduziere die Ergebnisse mit yolo classify val data=path/to/ImageNet batch=1 device=0|cpu
• Die Werte für Parameter und FLOPs gelten für das fusionierte Modell nach model.fuse(), wodurch Conv- und BatchNorm-Schichten zusammengeführt werden. Vortrainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können daher höhere Werte aufweisen.

Sieh dir die unveröffentlichte YOLO27-Vorschau mit vorläufigen Angaben zu Klassifizierungsgeschwindigkeit und Modellgrößen an.

Trainieren#

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

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-cls.yaml")  # ein neues Modell aus YAML erstellen
model = YOLO("yolo26n-cls.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # aus YAML erstellen und Gewichte übertragen

# Das Modell trainieren
results = model.train(data="mnist160", epochs=100, imgsz=64)

Ausführliche Informationen zum Modus train findest du auf der Seite Trainieren. Klassifizierungsmodelle lassen sich auch mit dem Cloud-Training der Ultralytics Platform trainieren.

Datensatzformat#

Ausführliche Informationen zum Format von YOLO-Klassifizierungsdatensätzen findest du im Datensatzleitfaden. Klassifizierungsdatensätze lassen sich außerdem mit den Anmerkungswerkzeugen der Ultralytics Platform verwalten und beschriften.

Benutzerdefinierte Transformationen#

Die Ultralytics-YOLO-Bildklassifizierung verwendet torchvision.transforms.RandomResizedCrop für das Training und torchvision.transforms.CenterCrop für Validierung und Inferenz. Diese auf Zuschneiden beruhenden Transformationen setzen quadratische Eingaben voraus und können bei Bildern mit extremen Seitenverhältnissen wichtige Bereiche abschneiden. Wenn du das ganze Bild erhalten möchtest, ersetze die Zuschneidevorgänge durch torchvision.transforms.Resize, das das Bild statt des Zuschneidens auf imgsz × imgsz skaliert. Verwende dazu ein benutzerdefiniertes ClassificationDataset, ClassificationTrainer und ClassificationValidator:

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)

        # Füge hier deine benutzerdefinierten Transformationen für das Training hinzu
        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),
            ]
        )

        # Füge hier deine benutzerdefinierten Transformationen für die Validierung hinzu
        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)

Validieren#

Validiere die Genauigkeit eines trainierten YOLO26n-cls-Modells. Es sind keine Argumente erforderlich, da model die Trainingsdaten data und die Argumente als Modelleigenschaften speichert: path/to/best.pt aus dem Beispiel für Trainieren validiert das Modell anhand von MNIST160. Bei offiziellen Gewichten ist ein Trainingsdatenpfad gespeichert, der auf deinem Rechner nicht existiert. Daher wird mit einer Warnung auf den Aufgabenstandardwert imagenet10 zurückgegriffen. Übergib data, um einen anderen Datensatz für die Validierung zu verwenden.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-cls.pt")  # Ein offizielles Modell laden
model = YOLO("path/to/best.pt")  # Ein benutzerdefiniertes Modell laden

# Das Modell validieren
metrics = model.val()  # Keine Argumente erforderlich, Datensatz und Einstellungen werden gespeichert
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

Vorhersagen#

Nutze ein trainiertes YOLO26n-cls-Modell, um Vorhersagen für Bilder auszuführen.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-cls.pt")  # Ein offizielles Modell laden
model = YOLO("path/to/best.pt")  # Ein benutzerdefiniertes Modell laden

# Mit dem Modell Vorhersagen erstellen
results = model("https://ultralytics.com/images/bus.jpg")  # Eine Vorhersage für ein Bild erstellen

# Auf die Ergebnisse zugreifen
for result in results:
    top1 = result.probs.top1  # ID der vorhergesagten Hauptklasse
    top1_conf = result.probs.top1conf  # Konfidenz der obersten Vorhersage
    top1_name = result.names[top1]  # Name der vorhergesagten Hauptklasse

Ausführliche Informationen zum Modus predict findest du auf der Seite Vorhersagen.

Ausgabe der Ergebnisse#

Die Bildklassifizierung gibt für jedes Bild ein Results-Objekt zurück. Das wichtigste Vorhersagefeld ist result.probs. Es enthält den Klassenwahrscheinlichkeitsvektor und Hilfsfunktionen für die besten Vorhersagen.

Task-spezifische Results-Felder für alle Aufgaben findest du im Abschnitt Vorhersageergebnisse nach Aufgabe.

Exportieren#

Ein YOLO26n-cls-Modell in ein anderes Format wie ONNX oder CoreML exportieren

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-cls.pt")  # Ein offizielles Modell laden
model = YOLO("path/to/best.pt")  # Ein benutzerdefiniertes Modell laden

# Modell exportieren
model.export(format="onnx")

Die verfügbaren Exportformate für YOLO26-cls sind in der Tabelle unten aufgeführt. Du kannst mit dem Argument format in jedes Format exportieren, also zum Beispiel mit format='onnx' oder format='engine'. Vorhersagen und Validierungen kannst du direkt mit exportierten Modellen ausführen, zum Beispiel mit yolo predict model=yolo26n-cls.onnx. Nach Abschluss des Exports werden Nutzungsbeispiele für dein Modell angezeigt.

nms=None gibt standardmäßig Rohdaten für die externe NMS aus. Lege nms=False fest, um einen verfügbaren Kopf ohne NMS auszuwählen; nicht unterstützte Formate greifen auf ihren nativen Ausgabepfad zurück. Die obigen Einträge nms kennzeichnen Formate, die NMS mit nms=True integrieren können.

Ausführliche Informationen zu export findest du auf der Seite Export.

Häufig gestellte Fragen#