Ultralytics YOLO27:

Erweiterte Anpassung#

Sowohl die Ultralytics YOLO-Befehlszeilenschnittstelle als auch die Python-Schnittstelle sind High-Level-Abstraktionen, die auf Basis-Engine-Executors aufbauen. Dieser Leitfaden konzentriert sich auf die Trainer-Engine und erklärt, wie du diese für deine spezifischen Anforderungen anpasst.



Watch: Mastering Ultralytics YOLO: Advanced Customization
Tipp

Praktische Beispiele für gängige Trainer-Anpassungen – benutzerdefinierte Metriken, klassengewichteter Verlust, Modellabspeicherung, Einfrieren des Backbones und schichtbezogene Lernraten – findest du im Leitfaden Customizing Trainer.

BaseTrainer#

Die Klasse BaseTrainer stellt eine allgemeine Trainingsroutine bereit, die für verschiedene Aufgaben angepasst werden kann. Passe sie an, indem du bestimmte Funktionen oder Operationen überschreibst und dabei die erforderlichen Formate einhältst. Integriere beispielsweise dein eigenes benutzerdefiniertes Modell und deinen eigenen Dataloader, indem du folgende Funktionen überschreibst:

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

Weitere Details und den Quellcode findest du in der BaseTrainer Reference.

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  # Get the best model

Anpassen des DetectionTrainer#

Um ein benutzerdefiniertes Erkennungsmodell zu trainieren, das nicht direkt unterstützt wird, überlade die bestehende 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 function änderst oder einen callback hinzufügst, um das Modell alle 10 epochs zu Google Drive hochzuladen. Hier ist ein Beispiel:

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

class MyCustomModel(DetectionModel):
    def init_criterion(self):
        """Initializes the loss function and adds a callback for uploading the model to Google Drive every 10 epochs."""

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 to upload model weights
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)  # Adds to existing callbacks
trainer.train()

Weitere Informationen zu auslösenden Ereignissen von Callbacks und Einstiegspunkten findest du im Callbacks Guide.

Weitere Engine-Komponenten#

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

Verwendung von YOLO mit benutzerdefinierten Trainern#

Die Modellklasse YOLO bietet einen High-Level-Wrapper für Trainer-Klassen. Du kannst diese Architektur nutzen, um eine größere Flexibilität in deinen Machine-Learning-Workflows zu erreichen:

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

# Create a custom trainer
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

# Initialize YOLO model
model = YOLO("yolo26n.pt")

# Train with custom trainer
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Dieser Ansatz ermöglicht es dir, die Einfachheit der YOLO-Schnittstelle beizubehalten und gleichzeitig den zugrunde liegenden Trainingsprozess an deine spezifischen Anforderungen anzupassen.

FAQ#

  • Passe den DetectionTrainer für spezifische Aufgaben an, indem du seine Methoden überschreibst, um sie an dein benutzerdefiniertes Modell und deinen Dataloader anzupassen. Beginne damit, von DetectionTrainer zu erben, und definiere Methoden wie get_model neu, um benutzerdefinierte Funktionalitäten zu implementieren. Hier ist 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  # Get the best model

    Für weitere Anpassungen, wie das Ändern der loss function oder das Hinzufügen eines callback, schaue in den Callbacks Guide.

  • Der BaseTrainer dient als Grundlage für Trainingsroutinen und kann für verschiedene Aufgaben angepasst werden, indem seine generischen Methoden überschrieben werden. Zu den Schlüsselkomponenten gehören:

    • get_model(cfg, weights): Erstellt das zu trainierende Modell.
    • get_dataloader(): Erstellt den Dataloader.
    • preprocess_batch(): Verarbeitet die Stapel-Vorverarbeitung vor dem Vorwärtsdurchlauf des Modells.
    • set_model_attributes(): Legt Modellattribute basierend auf Datensatzinformationen fest.
    • get_validator(): Gibt einen Validator zur Modellauswertung zurück.

    Weitere Details zur Anpassung und zum Quellcode findest du in der BaseTrainer Reference.

  • Füge Callbacks hinzu, um den Trainingsprozess in DetectionTrainer zu überwachen und zu modifizieren. So fügst du einen Callback hinzu, um Modellgewichte nach jeder Trainings-epoch zu protokollieren:

    from ultralytics.models.yolo.detect import DetectionTrainer

# Callback to upload model weights
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)  # Adds to existing callbacks
trainer.train()

    Weitere Details zu Callback-Ereignissen und Einstiegspunkten findest du im Callbacks Guide.

  • Ultralytics YOLO bietet eine High-Level-Abstraktion über leistungsstarke Engine-Executors, wodurch es sich ideal für die schnelle Entwicklung und Anpassung eignet. Zu den Hauptvorteilen gehören:

    • Benutzerfreundlichkeit: Sowohl die Befehlszeilenschnittstelle als auch die Python-Schnittstelle vereinfachen komplexe Aufgaben.
    • Leistung: Optimiert für object detection in Echtzeit und verschiedene Vision-KI-Anwendungen.
    • Anpassbarkeit: Leicht erweiterbar für benutzerdefinierte Modelle, loss functions und Dataloader.
    • Modularität: Komponenten können unabhängig voneinander modifiziert werden, ohne die gesamte Pipeline zu beeinträchtigen.
    • Integration: Funktioniert nahtlos mit gängigen Frameworks und Tools im ML-Ökosystem.

    Erfahre mehr über die Funktionen von YOLO, indem du die Hauptseite von Ultralytics YOLO erkundest.

  • Ja, der DetectionTrainer ist äußerst flexibel und für nicht standardmäßige Modelle anpassbar. Erbe von DetectionTrainer und überlade Methoden, um die Anforderungen deines spezifischen Modells zu unterstützen. Hier ist 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()

    Umfassende Anweisungen und Beispiele findest du in der DetectionTrainer Reference.

Mitwirkende
GLglenn-jocher13RAraimbekovm2RIRizwanMunawar2

Kommentare