Ultralytics YOLO27:
Get Started

Erweiterte Anpassung#

Sowohl die Befehlszeilen- als auch die Python-Schnittstelle von Ultralytics YOLO sind hochrangige Abstraktionen, die auf den Basis-Engine-Ausführern aufbauen. Diese Anleitung konzentriert sich auf die Engine Trainer und erklärt, wie du sie an deine spezifischen Anforderungen anpassen kannst.



Ansehen: Ultralytics YOLO meistern: Erweiterte Anpassungsmöglichkeiten
Tipp

Praktische Beispiele für gängige Anpassungen des Trainers – eigene Metriken, klassengewichteter Loss, Speichern des Modells, Einfrieren des Backbones und Lernraten pro Schicht – findest du in der Anleitung Trainer anpassen.

BaseTrainer#

Die Klasse BaseTrainer stellt eine allgemeine Trainingsroutine bereit, die sich für verschiedene Aufgaben anpassen lässt. Passe sie an, indem du bestimmte Funktionen oder Vorgänge überschreibst und dabei die erforderlichen Formate einhältst. Du kannst beispielsweise dein eigenes Modell und deinen eigenen Dataloader integrieren, indem du diese Funktionen überschreibst:

  • get_model(cfg, weights): Erstellt das zu trainierende Modell.
  • get_dataloader(dataset_path, batch_size, rank, mode): Erstellt den Dataloader.

Weitere Einzelheiten und den Quellcode findest du in der Referenz zu BaseTrainer.

DetectionTrainer#

So verwendest und passt du den Ultralytics-YOLO-DetectionTrainer an:

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # Das beste Modell abrufen

DetectionTrainer anpassen#

Um ein benutzerdefiniertes Erkennungsmodell zu trainieren, das nicht direkt unterstützt wird, überschreibe die vorhandene Funktionalität von get_model:

from ultralytics.models.yolo.detect import DetectionTrainer

class CustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Loads a custom detection model given configuration and weight files."""

trainer = CustomTrainer(overrides={...})
trainer.train()

Passe den Trainer weiter an, indem du die Loss-Funktion änderst oder einen Callback hinzufügst, der am Ende jeder Epoche ausgeführt wird, beispielsweise um die neuesten Gewichte zu protokollieren oder hochzuladen. Hier ein Beispiel:

from ultralytics.models.yolo.detect import DetectionTrainer
from ultralytics.nn.tasks import DetectionModel

class MyCustomModel(DetectionModel):
    def init_criterion(self):
        """Initializes a custom loss function for the model."""

class CustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Returns a customized detection model instance configured with specified config and weights."""
        return MyCustomModel(...)

# Callback zum Protokollieren der Modellgewichte
def log_model(trainer):
    """Logs the path of the last model weight used by the trainer."""
    last_weight_path = trainer.last
    print(last_weight_path)

trainer = CustomTrainer(overrides={...})
trainer.add_callback("on_train_epoch_end", log_model)  # Ergänzt die vorhandenen Callbacks
trainer.train()

Weitere Informationen zu Callback-Ereignissen und Einstiegspunkten findest du in der Callbacks-Anleitung.

Weitere Engine-Komponenten#

Passe andere Komponenten wie Validators und Predictors auf ähnliche Weise an. Weitere Informationen findest du in der Dokumentation zu Validatoren und Prädiktoren.

YOLO mit benutzerdefinierten Trainern verwenden#

Die Modellklasse YOLO stellt einen hochrangigen Wrapper für Trainer-Klassen bereit. Diese Architektur ermöglicht dir flexiblere Arbeitsabläufe beim maschinellen Lernen:

from ultralytics import YOLO
from ultralytics.models.yolo.detect import DetectionTrainer

# Einen benutzerdefinierten Trainer erstellen
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

# YOLO-Modell initialisieren
model = YOLO("yolo26n.pt")

# Mit einem benutzerdefinierten Trainer trainieren
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Mit diesem Ansatz behältst du die einfache YOLO-Schnittstelle bei und kannst gleichzeitig den zugrunde liegenden Trainingsprozess an deine spezifischen Anforderungen anpassen.

Häufig gestellte Fragen#

  • Passe DetectionTrainer an bestimmte Aufgaben an, indem du seine Methoden überschreibst und so an dein benutzerdefiniertes Modell und deinen Dataloader anpasst. Leite dazu zunächst eine Klasse von DetectionTrainer ab und definiere Methoden wie get_model neu, um eigene Funktionen zu implementieren. Hier ein Beispiel:

    from ultralytics.models.yolo.detect import DetectionTrainer

class CustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Loads a custom detection model given configuration and weight files."""

trainer = CustomTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # Das beste Modell abrufen

    Weitere Anpassungsmöglichkeiten, etwa das Ändern der Loss-Funktion oder das Hinzufügen eines Callbacks, findest du in der Callbacks-Anleitung.

  • BaseTrainer bildet die Grundlage für Trainingsroutinen und lässt sich durch Überschreiben seiner allgemeinen Methoden an verschiedene Aufgaben anpassen. Zu den wichtigsten Komponenten gehören:

    • get_model(cfg, weights): Erstellt das zu trainierende Modell.
    • get_dataloader(dataset_path, batch_size, rank, mode): Erstellt den Dataloader.
    • preprocess_batch(): Verarbeitet Batches vor dem Forward-Pass des Modells.
    • set_model_attributes(): Legt Modellattribute anhand der Informationen zum Datensatz fest.
    • get_validator(): Gibt einen Validator für die Modellbewertung zurück.

    Weitere Einzelheiten zur Anpassung und zum Quellcode findest du in der Referenz zu BaseTrainer.

  • Füge Callbacks hinzu, um den Trainingsprozess in DetectionTrainer zu überwachen und zu verändern. So fügst du einen Callback hinzu, der die Modellgewichte nach jeder Trainings-Epoche protokolliert:

    from ultralytics.models.yolo.detect import DetectionTrainer

# Callback zum Protokollieren der Modellgewichte
def log_model(trainer):
    """Logs the path of the last model weight used by the trainer."""
    last_weight_path = trainer.last
    print(last_weight_path)

trainer = DetectionTrainer(overrides={...})
trainer.add_callback("on_train_epoch_end", log_model)  # Ergänzt die vorhandenen Callbacks
trainer.train()

    Weitere Einzelheiten zu Callback-Ereignissen und Einstiegspunkten findest du in der Callbacks-Anleitung.

  • Ultralytics YOLO bietet eine hochrangige Abstraktion leistungsstarker Engine-Ausführer und eignet sich damit ideal für schnelle Entwicklung und Anpassungen. Zu den wichtigsten Vorteilen gehören:

    • Einfache Bedienung: Sowohl die Befehlszeilen- als auch die Python-Schnittstelle vereinfachen komplexe Aufgaben.
    • Leistung: Optimiert für die Objekterkennung in Echtzeit und verschiedene Anwendungen der visuellen KI.
    • Anpassbarkeit: Du kannst eigene Modelle, Loss-Funktionen und Dataloader problemlos ergänzen.
    • Modularität: Komponenten lassen sich unabhängig voneinander ändern, ohne die gesamte Pipeline zu beeinträchtigen.
    • Integration: Funktioniert nahtlos mit gängigen Frameworks und Werkzeugen im ML-Ökosystem.

    Mehr über die Möglichkeiten von YOLO erfährst du auf der Hauptseite zu Ultralytics YOLO.

  • Ja, DetectionTrainer ist sehr flexibel und lässt sich für nicht standardmäßige Modelle anpassen. Leite eine Klasse von DetectionTrainer ab und überschreibe Methoden, um die Anforderungen deines spezifischen Modells zu erfüllen. Hier ein einfaches Beispiel:

    from ultralytics.models.yolo.detect import DetectionTrainer

class CustomDetectionTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Loads a custom detection model."""

trainer = CustomDetectionTrainer(overrides={...})
trainer.train()

    Ausführliche Anleitungen und Beispiele findest du in der DetectionTrainer-Referenz.

Mitwirkende
GLglenn-jocher14RAraimbekovm2RIRizwanMunawar2

Kommentare