Personalizzazione avanzata
Sia la riga di comando di Ultralytics YOLO che le interfacce Python sono astrazioni di alto livello costruite sugli esecutori del motore di base. Questa guida si concentra sull'interfaccia Trainer e spiega come personalizzarlo in base alle proprie esigenze specifiche.
Guarda: Mastering Ultralytics YOLO : Personalizzazione avanzata
Allenatore di base
Il BaseTrainer fornisce una routine di allenamento generica adattabile a vari compiti. È possibile personalizzarla sovrascrivendo funzioni o operazioni specifiche, rispettando i formati richiesti. Ad esempio, è possibile integrare un modello e un dataloader personalizzati sovrascrivendo queste funzioni:
get_model(cfg, weights): Costruisce il modello da addestrare.get_dataloader(): Costruisce il dataloader.
Per maggiori dettagli e per il codice sorgente, consultare il file BaseTrainer Riferimento.
Allenatore di rilevamento
Ecco come utilizzare e personalizzare Ultralytics YOLO DetectionTrainer:
from ultralytics.models.yolo.detect import DetectionTrainer
trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # Get the best model
Personalizzazione del DetectionTrainer
Per addestrare un modello di rilevamento personalizzato non direttamente supportato, sovraccaricare l'opzione esistente get_model funzionalità:
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()
È possibile personalizzare ulteriormente l'addestratore modificando la funzione di perdita o aggiungendo un callback per caricare il modello su Google Drive ogni 10 epoche. Ecco un esempio:
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()
Per ulteriori informazioni sugli eventi di attivazione delle callback e sui punti di ingresso, consultare la Guida alle callback.
Altri componenti del motore
Personalizzare altri componenti come Validators e Predictors analogamente. Per ulteriori informazioni, consultare la documentazione di Validatori e Predittori.
Utilizzo di YOLO con i formatori personalizzati
Il YOLO fornisce un wrapper di alto livello per le classi Trainer. È possibile sfruttare questa architettura per una maggiore flessibilità nei flussi di lavoro dell'apprendimento automatico:
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)
Questo approccio consente di mantenere la semplicità dell'interfaccia di YOLO , personalizzando al contempo il processo di formazione sottostante in base alle proprie esigenze specifiche.
FAQ
Come posso personalizzare Ultralytics YOLO DetectionTrainer per compiti specifici?
Personalizzare il DetectionTrainer per compiti specifici, sovrascrivendo i suoi metodi per adattarli al modello e al dataloader personalizzati. Si inizia ereditando da DetectionTrainer e ridefinire metodi come get_model per implementare funzionalità personalizzate. Ecco un esempio:
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
Per ulteriori personalizzazioni, come la modifica della funzione di perdita o l'aggiunta di un callback, consultare la Guida ai callback.
Quali sono i componenti chiave del BaseTrainer in Ultralytics YOLO?
Il BaseTrainer serve come base per le routine di allenamento, personalizzabili per vari compiti sovrascrivendo i suoi metodi generici. I componenti principali includono:
get_model(cfg, weights): Costruisce il modello da addestrare.get_dataloader(): Costruisce il dataloader.preprocess_batch(): Gestisce la preelaborazione batch prima del passaggio del modello.set_model_attributes(): Imposta gli attributi del modello in base alle informazioni del set di dati.get_validator(): Restituisce un validatore per la valutazione del modello.
Per ulteriori dettagli sulla personalizzazione e sul codice sorgente, vedere la sezione BaseTrainer Riferimento.
Come posso aggiungere un callback a Ultralytics YOLO DetectionTrainer?
Aggiungere callback per monitorare e modificare il processo di addestramento in DetectionTrainer. Ecco come aggiungere un callback per registrare i pesi del modello dopo ogni allenamento epoca:
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()
Per ulteriori dettagli sugli eventi di callback e sui punti di ingresso, consultare la Guida alle callback.
Perché dovrei usare Ultralytics YOLO per l'addestramento dei modelli?
Ultralytics YOLO offre un'astrazione di alto livello su potenti esecutori di motori, rendendolo ideale per uno sviluppo e una personalizzazione rapidi. I vantaggi principali includono:
- Facilità d'uso: le interfacce a riga di comando e Python semplificano le attività complesse.
- Prestazioni: Ottimizzato per il rilevamento di oggetti in tempo reale e per varie applicazioni di intelligenza artificiale.
- Personalizzazione: Facilmente estendibile per modelli, funzioni di perdita e dataloader personalizzati.
- Modularità: I componenti possono essere modificati in modo indipendente senza influenzare l'intera pipeline.
- Integrazione: Funziona senza problemi con i framework e gli strumenti più diffusi nell'ecosistema ML.
Per saperne di più sulle funzionalità di YOLO, esplorate le pagine principali di Ultralytics YOLO pagina principale di Ultralytics YOLO.
Posso utilizzare Ultralytics YOLO DetectionTrainer per modelli non standard?
Sì, il DetectionTrainer è altamente flessibile e personalizzabile per modelli non standard. Eredita da DetectionTrainer e i metodi di sovraccarico per supportare le esigenze del modello specifico. Ecco un semplice esempio:
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()
Per istruzioni ed esempi completi, consultare il documento DetectionTrainer Riferimento.
