Erweiterte Anpassungen

Sowohl die Ultralytics YOLO Befehlszeilen- als auch die Python-Schnittstellen 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 bietet eine generische Trainingsroutine, die für verschiedene Aufgaben anpassbar ist. Passe sie an, indem du spezifische Funktionen oder Operationen überschreibst und dabei die erforderlichen Formate einhältst. Integriere beispielsweise 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.

Für weitere Details und den Quellcode siehe die BaseTrainer Referenz.

DetectionTrainer

Hier erfährst du, wie du den Ultralytics YOLO DetectionTrainer:

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 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 Verlustfunktion ä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 Entry-Points findest du im Callbacks-Leitfaden.

Weitere Engine-Komponenten

Passe andere Komponenten wie Validators und Predictors ähnlich an. Weitere Informationen findest du in der Dokumentation für Validatoren und Prädiktoren.

Verwendung von YOLO mit benutzerdefinierten Trainern

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

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 der YOLO-Schnittstelle beizubehalten und gleichzeitig den zugrunde liegenden Trainingsprozess an deine spezifischen Anforderungen anzupassen.

FAQ

Wie passe ich den Ultralytics YOLO DetectionTrainer für spezifische Aufgaben an?

Passe den DetectionTrainer für spezifische Aufgaben an, indem du dessen Methoden überschreibst, um sie an dein benutzerdefiniertes Modell und deinen Dataloader anzupassen. Beginne, indem du von DetectionTrainer erbst und Methoden wie get_model neu definierst, 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 z. B. das Ändern der Verlustfunktion änderst oder einen callback, siehe die Callbacks-Leitfaden.

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

Die BaseTrainer dient als Grundlage für Trainingsroutinen und ist durch Überschreiben seiner generischen Methoden für verschiedene Aufgaben anpassbar. Zu den Schlüsselkomponenten gehören:

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

Weitere Details zu Anpassungen und Quellcode findest du unter BaseTrainer Referenz.

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

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

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

zu protokollieren. Weitere Details zu Callback-Ereignissen und Entry-Points findest du im Callbacks-Leitfaden.

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

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

• Benutzerfreundlichkeit: Sowohl Befehlszeilen- als auch Python-Schnittstellen vereinfachen komplexe Aufgaben.
• Leistung: Optimiert für Echtzeit-Objekterkennungs und verschiedene Vision-KI-Anwendungen.
• Anpassbarkeit: Einfach erweiterbar für benutzerdefinierte Modelle, Loss-Funktionen und Dataloader.
• Modularität: Komponenten können unabhängig voneinander geändert werden, ohne die gesamte Pipeline zu beeinflussen.
• Integration: Funktioniert nahtlos mit gängigen Frameworks und Tools im ML-Ökosystem.

Erfahre mehr über die Funktionen von YOLO, indem du die Haupt-Ultralytics YOLO Seite erkundest.

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 spezifischen Anforderungen deines 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 Anweisungen und Beispiele, schau dir die DetectionTrainer Referenz.