Erweiterte Anpassung

Sowohl das Ultralytics YOLO Command-Line- als auch das Python-Interface sind High-Level-Abstraktionen, die auf Basis-Engine-Executors aufbauen. Dieser Leitfaden konzentriert sich auf die Trainer-Engine und erklärt, wie du sie an deine spezifischen Bedürfnisse anpassen kannst.

BaseTrainer

Die BaseTrainer-Klasse stellt eine generische Trainingsroutine bereit, die an verschiedene Aufgaben angepasst werden kann. Passe sie an, indem du spezifische Funktionen oder Operationen überschreibst und dabei die erforderlichen Formate einhältst. Integriere zum Beispiel dein eigenes benutzerdefiniertes Modell und den Dataloader durch Überschreiben dieser Funktionen:

• 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 kannst du den Ultralytics YOLO DetectionTrainer verwenden und anpassen:

from ultralytics.models.yolo.detect import DetectionTrainer

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

Anpassung des DetectionTrainer

Um ein benutzerdefiniertes Detektionsmodell zu trainieren, das nicht direkt unterstützt wird, überlade die bestehende 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()

Passe den Trainer weiter an, indem du die Loss-Funktion änderst oder einen Callback hinzufügst, um das Modell alle 10 Epochen auf 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, 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 callbacks
trainer.train()

Weitere Informationen zu Callback-Auslöseereignissen 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 für Validators und Predictors.

Verwendung von YOLO mit benutzerdefinierten Trainern

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

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

# Create a custom trainer
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg, weights):
        """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 des YOLO-Interfaces beizubehalten und gleichzeitig den zugrunde liegenden Trainingsprozess an deine spezifischen Anforderungen anzupassen.

FAQ

Wie kann ich den Ultralytics YOLO DetectionTrainer für spezifische Aufgaben anpassen?

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 Methoden wie get_model neu zu definieren, 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, weights):
        """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-Funktion oder das Hinzufügen eines Callbacks, lies den Callbacks Guide.

Was sind die Schlüsselkomponenten des BaseTrainer in Ultralytics YOLO?

Der BaseTrainer dient als Grundlage für Trainingsroutinen und kann durch Überschreiben seiner generischen Methoden an verschiedene Aufgaben angepasst werden. Zu den Schlüsselkomponenten gehören:

• get_model(cfg, weights): Erstellt das zu trainierende Modell.
• get_dataloader(): Erstellt den Dataloader.
• preprocess_batch(): Übernimmt die Batch-Vorverarbeitung vor dem Forward-Pass des Modells.
• set_model_attributes(): Setzt Modellattribute basierend auf Dataset-Informationen.
• get_validator(): Gibt einen Validator für die Modellevaluierung zurück.

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

Wie kann ich einen Callback zum Ultralytics YOLO DetectionTrainer hinzufügen?

Füge Callbacks hinzu, um den Trainingsprozess im DetectionTrainer zu überwachen und zu modifizieren. Hier ist beschrieben, wie du einen Callback hinzufügst, um die Modellgewichte nach jeder Trainings-Epoche 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.

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

Ultralytics YOLO bietet eine High-Level-Abstraktion über leistungsstarke Engine-Executors und ist somit ideal für eine schnelle Entwicklung und Anpassung. Zu den Hauptvorteilen gehören:

• Benutzerfreundlichkeit: Sowohl Command-Line- als auch Python-Interfaces vereinfachen komplexe Aufgaben.
• Leistung: Optimiert für Echtzeit-Objekterkennung und verschiedene Vision-KI-Anwendungen.
• Anpassung: Einfach erweiterbar für benutzerdefinierte Modelle, Loss-Funktionen und Dataloader.
• Modularität: Komponenten können unabhängig voneinander modifiziert werden, ohne die gesamte Pipeline zu beeinträchtigen.
• Integration: Arbeitet nahtlos mit populären Frameworks und Tools im ML-Ökosystem zusammen.

Erfahre mehr über die Fähigkeiten von YOLO auf der Hauptseite von Ultralytics YOLO.

Kann ich den Ultralytics YOLO DetectionTrainer für nicht standardmäßige Modelle verwenden?

Ja, der DetectionTrainer ist hochflexibel 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, weights):
        """Loads a custom detection model."""
        ...

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

Für umfassende Anleitungen und Beispiele prüfe die DetectionTrainer Reference.