Bildklassifizierung mit Ultralytics YOLO#

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

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

Modelle#

Hier werden vortrainierte YOLO26-Classify-Modelle gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem Datensatz COCO vortrainiert, Semantic-Modelle auf Cityscapes und Classify-Modelle auf dem Datensatz ImageNet.

Modelle werden bei der ersten Verwendung automatisch aus dem neuesten Release von Ultralytics heruntergeladen.

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

Sieh dir die unreleased YOLO27 preview an, um vorläufige Klassifizierungsgeschwindigkeiten und Modellgrößen zu erfahren.

Trainieren#

Trainiere YOLO26n-cls 100 Epochen lang mit einer Bildgröße von 64 auf dem Datensatz MNIST160. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite 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="imagenet", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet", validator=CustomizedValidator, imgsz=224, batch=64)

Datensatzformat#

Das Format von YOLO-Klassifizierungsdatensätzen wird ausführlich im Datensatzleitfaden beschrieben. Klassifizierungsdatensätze können außerdem mit den Annotationstools der Ultralytics Platform verwaltet und beschriftet werden.

Validierung#

Validiere die Genauigkeit des trainierten YOLO26n-cls-Modells auf dem Datensatz MNIST160. Es sind keine Argumente erforderlich, da model seine Trainings-data und Argumente als Modelleigenschaften beibehä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

Vorhersage#

Verwende ein trainiertes YOLO26n-cls-Modell, um Vorhersagen für Bilder 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

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

Ausgabe der Ergebnisse#

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

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

Export#

Exportiere ein YOLO26n-cls-Modell in ein anderes Format wie ONNX, CoreML usw.

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

Die verfügbaren Exportformate für YOLO26-cls findest du in der folgenden Tabelle. Du kannst mit dem Argument format in jedes Format exportieren, also beispielsweise mit format='onnx' oder format='engine'. Du kannst direkt auf exportierten Modellen Vorhersagen ausführen oder sie validieren, beispielsweise mit yolo predict model=yolo26n-cls.onnx. Nach Abschluss des Exports werden Nutzungsbeispiele für dein Modell angezeigt.

nms=None verwendet standardmäßig Rohausgaben für externes NMS. Setze nms=False, um einen verfügbaren NMS-freien Kopf auszuwählen; nicht unterstützte Formate greifen auf ihren nativen Ausgabepfad zurück. Die Einträge nms oben identifizieren Formate, die NMS mit nms=True einbetten können.

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

FAQ#