Personalizzazione avanzata
Sia l'interfaccia a riga di comando di Ultralytics YOLO che le interfacce python sono astrazioni di alto livello costruite su esecutori di motori di base. Questa guida si concentra su Trainer engine, spiegando come personalizzarlo per le tue esigenze specifiche.
Guarda: Padroneggiare Ultralytics YOLO: Personalizzazione Avanzata
BaseTrainer
Il BaseTrainer classe fornisce una routine di training generica adattabile a vari task. Personalizzala sovrascrivendo funzioni o operazioni specifiche, rispettando al contempo i formati richiesti. Ad esempio, integra il tuo modello personalizzato e il dataloader sovrascrivendo queste funzioni:
get_model(cfg, weights): Costruisce il modello da addestrare.get_dataloader(): Costruisce il dataloader.
Per maggiori dettagli e codice sorgente, vedere il BaseTrainer Riferimenti.
DetectionTrainer
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, sovraccarica l'esistente get_model funzionalità esistente:
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()
Personalizza ulteriormente il trainer modificando la funzione di perdita o aggiungendo una 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 maggiori informazioni sugli eventi di attivazione dei callback e sui punti di ingresso, consultare la Guida ai callback.
Altri componenti del motore
Personalizza altri componenti come Validators e Predictors allo stesso modo. Per maggiori informazioni, consultare la documentazione relativa a Validatori e Predictors.
Utilizzo di YOLO con Custom Trainers
Il YOLO La classe model fornisce un wrapper di alto livello per le classi Trainer. Puoi sfruttare questa architettura per una maggiore flessibilità nei tuoi flussi di lavoro di machine learning:
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 YOLO personalizzando al contempo il processo di addestramento sottostante per soddisfare le proprie esigenze specifiche.
FAQ
Come posso personalizzare Ultralytics YOLO DetectionTrainer per attività specifiche?
Personalizzare il DetectionTrainer per attività specifiche sovrascrivendo i suoi metodi per adattarsi al tuo modello personalizzato e al dataloader. 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 un'ulteriore personalizzazione, come la modifica della funzione di perdita o l'aggiunta di una callback, consulta la Guida alle Callback.
Quali sono i componenti chiave del BaseTrainer in Ultralytics YOLO?
Il BaseTrainer funge da base per le routine di training, personalizzabile per varie attività sovrascrivendo i suoi metodi generici. I componenti chiave includono:
get_model(cfg, weights): Costruisce il modello da addestrare.get_dataloader(): Costruisce il dataloader.preprocess_batch(): Gestisce la pre-elaborazione dei batch prima del passaggio in avanti del modello.set_model_attributes(): Imposta gli attributi del modello in base alle informazioni del dataset.get_validator(): Restituisce un validatore per la valutazione del modello.
Per maggiori dettagli sulla personalizzazione e sul codice sorgente, vedere il BaseTrainer Riferimenti.
Come posso aggiungere un callback all'Ultralytics YOLO DetectionTrainer?
Aggiungi callback per monitorare e modificare il processo di training in DetectionTrainer. Ecco come aggiungere una callback per registrare i pesi del modello dopo ogni training 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 maggiori dettagli sugli eventi di callback e sui punti di ingresso, fare riferimento alla Guida ai callback.
Perché dovrei usare Ultralytics YOLO per l'addestramento del modello?
Ultralytics YOLO fornisce un'astrazione di alto livello sugli esecutori di motori potenti, rendendolo ideale per lo sviluppo rapido e la personalizzazione. I vantaggi principali includono:
- Facilità d'uso: sia l'interfaccia a riga di comando che quella python semplificano task complessi.
- Prestazioni: ottimizzato per il rilevamento di oggetti in tempo reale e varie applicazioni di visione artificiale.
- Personalizzazione: facilmente estendibile per modelli personalizzati, funzioni di perdita e dataloader.
- Modularità: I componenti possono essere modificati indipendentemente senza influenzare l'intera pipeline.
- Integrazione: Funziona perfettamente con framework e strumenti popolari nell'ecosistema ML.
Scopri di più sulle capacità di YOLO esplorando la pagina principale di Ultralytics YOLO.
Posso usare Ultralytics YOLO DetectionTrainer per modelli non standard?
Sì, il DetectionTrainer è altamente flessibile e personalizzabile per modelli non standard. Eredita da DetectionTrainer e sovraccaricare i metodi per supportare le esigenze specifiche del tuo modello. 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, consulta il DetectionTrainer Riferimenti.
