Erweiterte Anpassung
Sowohl die Ultralytics YOLO-Befehlszeile als auch die Python-Schnittstellen sind High-Level-Abstraktionen, die auf Basis-Engine-Executoren aufbauen. Dieser Leitfaden konzentriert sich auf die Trainer Engine, in der erläutert wird, wie Sie diese an Ihre spezifischen Bedürfnisse anpassen können.
Ansehen: Ultralytics YOLO meistern: Erweiterte Anpassung
BaseTrainer
Die BaseTrainer Klasse bietet eine generische Trainingsroutine, die an verschiedene Aufgaben angepasst werden kann. Passen Sie sie an, indem Sie bestimmte Funktionen oder Operationen überschreiben und dabei die erforderlichen Formate einhalten. Integrieren Sie beispielsweise Ihr eigenes benutzerdefiniertes Modell und Ihren eigenen Dataloader, indem Sie diese Funktionen überschreiben:
get_model(cfg, weights): Erstellt das zu trainierende Modell.get_dataloader(): Erstellt den Dataloader.
Weitere Details und Quellcode finden Sie im BaseTrainer Referenz.
DetectionTrainer
Hier erfahren Sie, wie Sie Ultralytics YOLO verwenden und anpassen können DetectionTrainer:
from ultralytics.models.yolo.detect import DetectionTrainer
trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # Get the best model
Anpassen des DetectionTrainers
Um ein benutzerdefiniertes Erkennungsmodell zu trainieren, das nicht direkt unterstützt wird, überladen Sie das vorhandene get_model Funktionalität überschreiben:
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()
Passen Sie den Trainer weiter an, indem Sie die Verlustfunktion modifizieren oder einen Callback hinzufügen, 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-Triggerereignissen und -Einstiegspunkten finden Sie im Callbacks Guide.
Andere Engine-Komponenten
Passen Sie andere Komponenten wie Validators und Predictors ähnlich. Weitere Informationen finden Sie 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 die Trainer-Klassen. Sie können diese Architektur für mehr Flexibilität in Ihren 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("yolo11n.pt")
# Train with custom trainer
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)
Dieser Ansatz ermöglicht es Ihnen, die Einfachheit der YOLO-Schnittstelle beizubehalten und gleichzeitig den zugrunde liegenden Trainingsprozess an Ihre spezifischen Anforderungen anzupassen.
FAQ
Wie kann ich den Ultralytics YOLO DetectionTrainer für spezifische Aufgaben anpassen?
Anpassen des DetectionTrainer für bestimmte Aufgaben, indem Sie ihre Methoden überschreiben, um sie an Ihr benutzerdefiniertes Modell und Ihren Datensatz anzupassen. Beginnen Sie mit der Vererbung von DetectionTrainer und definieren Sie Methoden wie get_model um benutzerdefinierte 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 the best model
Für weitere Anpassungen, wie z. B. das Ändern der Loss-Funktion oder das Hinzufügen eines Callbacks, konsultieren Sie den Callbacks-Leitfaden.
Was sind die Hauptkomponenten des BaseTrainers in Ultralytics YOLO?
Die BaseTrainer dient als Grundlage für Trainingsroutinen, die für verschiedene Aufgaben angepasst werden können, indem ihre generischen Methoden überschrieben werden. Zu den Hauptkomponenten gehören:
get_model(cfg, weights): Erstellt das zu trainierende Modell.get_dataloader(): Erstellt den Dataloader.preprocess_batch(): Verarbeitet die Batch-Vorverarbeitung vor dem Modell-Forward-Pass.set_model_attributes(): Legt Modellattribute basierend auf Datensatzinformationen fest.get_validator(): Gibt einen Validator für die Modellbewertung zurück.
Weitere Details zur Anpassung und zum Quellcode finden Sie im BaseTrainer Referenz.
Wie kann ich dem Ultralytics YOLO DetectionTrainer einen Callback hinzufügen?
Fügen Sie Callbacks hinzu, um den Trainingsprozess in zu überwachen und zu modifizieren DetectionTrainer. Hier erfahren Sie, wie Sie einen Callback hinzufügen, um Modellgewichte nach jedem Training zu protokollieren. 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()
Weitere Informationen zu Callback-Ereignissen und -Einstiegspunkten finden Sie 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 schnelle Entwicklung und Anpassung. Zu den wichtigsten Vorteilen gehören:
- Benutzerfreundlichkeit: Sowohl die Befehlszeilen- als auch die Python-Schnittstelle vereinfachen komplexe Aufgaben.
- Performance: Optimiert für Echtzeit-Objekterkennung und verschiedene Vision-KI-Anwendungen.
- Anpassbarkeit: Leicht erweiterbar für benutzerdefinierte Modelle, Loss-Funktionen und Dataloader.
- Modularität: Komponenten können unabhängig voneinander modifiziert werden, ohne den gesamten Pipeline zu beeinträchtigen.
- Integration: Funktioniert nahtlos mit gängigen Frameworks und Tools im ML-Ökosystem.
Erfahren Sie mehr über die Fähigkeiten von YOLO, indem Sie die Hauptseite von Ultralytics YOLO besuchen.
Kann ich den Ultralytics YOLO DetectionTrainer für nicht standardmäßige Modelle verwenden?
Ja, die DetectionTrainer ist hochflexibel und anpassbar für nicht standardmäßige Modelle. Erben von DetectionTrainer und überladen Sie Methoden, um die spezifischen Anforderungen Ihres 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 lesen Sie die DetectionTrainer Referenz.
