Erweiterte Anpassung

Sowohl die Kommandozeilenschnittstelle Ultralytics YOLO als auch die Schnittstelle Python sind lediglich eine Abstraktion der Basis-Engine-Executors. Werfen wir einen Blick auf die Trainer-Engine.

Pass auf: Mastering Ultralytics YOLOv8 : Erweiterte Anpassungen

BaseTrainer

Der BaseTrainer enthält die generische Trainingsroutine. Er kann für jede Aufgabe angepasst werden, indem die erforderlichen Funktionen oder Operationen überschrieben werden, solange die richtigen Formate eingehalten werden. Du kannst zum Beispiel dein eigenes benutzerdefiniertes Modell und deinen eigenen Dataloader unterstützen, indem du diese Funktionen einfach überschreibst:

• get_model(cfg, weights) - Die Funktion, die das zu trainierende Modell erstellt
• get_dataloader() - Die Funktion, die den Dataloader aufbaut Weitere Details und Quellcode findest du in BaseTrainer Referenz

DetectionTrainer

Hier erfährst du, wie du die YOLOv8 DetectionTrainer und passe sie an.

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # get best model

Anpassen des DetectionTrainers

Lass uns den Trainer anpassen um ein benutzerdefiniertes Erkennungsmodell zu trainieren die nicht direkt unterstützt wird. Du kannst dies tun, indem du einfach die bestehende Methode get_model Funktionalität:

from ultralytics.models.yolo.detect import DetectionTrainer


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


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

Du merkst jetzt, dass du den Trainer weiter anpassen musst, um:

• Anpassen der loss function.
• hinzufügen callback das Modell nach jeweils 10 Minuten auf dein Google Drive hochlädt. epochs So kannst du es tun:

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, weights):
        """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 callback
trainer.train()

Mehr über Callback-Ereignisse und den Einstiegspunkt erfährst du in unserem Callbacks Guide

Andere Motorkomponenten

Es gibt andere Komponenten, die ähnlich angepasst werden können, wie Validators und Predictors. Weitere Informationen dazu findest du im Abschnitt Referenz.

FAQ

Wie kann ich den Ultralytics YOLOv8 DetectionTrainer für bestimmte Aufgaben anpassen?

Zum Anpassen der Ultralytics YOLOv8 DetectionTrainer für eine bestimmte Aufgabe, kannst du seine Methoden überschreiben, um sie an dein eigenes Modell und deinen Datenlader anzupassen. Beginne mit dem Erben von DetectionTrainer und definieren Sie dann Methoden wie get_model um deine eigenen Funktionen zu implementieren. Hier ist ein Beispiel:

from ultralytics.models.yolo.detect import DetectionTrainer


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


trainer = CustomTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # get best model

Für weitere Anpassungen wie das Ändern der loss function oder das Hinzufügen einer callbackkannst du auf unsere Rückrufe Leitfaden.

Was sind die wichtigsten Komponenten des BaseTrainers in Ultralytics YOLOv8 ?

Die BaseTrainer in Ultralytics YOLOv8 dient als Grundlage für Trainingsroutinen und kann für verschiedene Aufgaben angepasst werden, indem die generischen Methoden überschrieben werden. Zu den wichtigsten Komponenten gehören:

• get_model(cfg, weights) um das zu trainierende Modell zu erstellen.
• get_dataloader() um den Dataloader zu erstellen.

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

Wie kann ich dem Ultralytics YOLOv8 DetectionTrainer einen Callback hinzufügen?

Du kannst Rückrufe hinzufügen, um den Trainingsprozess zu überwachen und zu ändern in Ultralytics YOLOv8 DetectionTrainer. So kannst du zum Beispiel einen Callback hinzufügen, der die Modellgewichte nach jeder Trainingsepoche protokolliert:

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 in unserem Callbacks Guide.

Warum sollte ich Ultralytics YOLOv8 für das Modelltraining verwenden?

Ultralytics YOLOv8 bietet eine High-Level-Abstraktion auf leistungsstarke Engine Executors und ist damit ideal für eine schnelle Entwicklung und Anpassung. Die wichtigsten Vorteile sind:

• Benutzerfreundlichkeit: Sowohl die Kommandozeilen- als auch die Python Schnittstelle vereinfachen komplexe Aufgaben.
• Leistung: Optimiert für Echtzeit-Objekterkennung und verschiedene KI-Anwendungen.
• Anpassungen: Leicht erweiterbar für benutzerdefinierte Modelle, Verlustfunktionen und Dataloader.

Mehr über die Möglichkeiten von YOLOv8 erfährst du unter Ultralytics YOLO.

Kann ich den Ultralytics YOLOv8 DetectionTrainer auch für nicht standardisierte Modelle verwenden?

Ja, Ultralytics YOLOv8 DetectionTrainer ist sehr flexibel und kann für nicht standardisierte Modelle angepasst werden. Durch die Vererbung von DetectionTrainerkannst du verschiedene Methoden überladen, um die Bedürfnisse deines speziellen Modells zu erfüllen. Hier ist ein einfaches Beispiel:

from ultralytics.models.yolo.detect import DetectionTrainer


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


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

Ausführlichere Anweisungen und Beispiele findest du in der DetectionTrainer-Dokumentation.

Kommentare