Personalizzazione avanzata#

Sia l'interfaccia a riga di comando che quella in Python di Ultralytics YOLO sono astrazioni di alto livello basate su executor di engine di base. Questa guida si concentra sull'engine Trainer, spiegando come personalizzarlo per le tue esigenze specifiche.

BaseTrainer#

La classe BaseTrainer fornisce una routine di training generica adattabile a vari task. Personalizzala eseguendo l'override di funzioni o operazioni specifiche pur rispettando i formati richiesti. Ad esempio, integra il tuo modello personalizzato e il tuo dataloader eseguendo l'override di queste funzioni:

• get_model(cfg, weights): Costruisce il modello da addestrare.
• get_dataloader(): Costruisce il dataloader.

Per maggiori dettagli e per il codice sorgente, consulta il Riferimento su BaseTrainer.

DetectionTrainer#

Ecco come usare e personalizzare il DetectionTrainer di Ultralytics YOLO:

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 detection personalizzato non supportato direttamente, esegui l'overload della funzionalità get_model esistente:

from ultralytics.models.yolo.detect import DetectionTrainer

class CustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Loads a custom detection model given configuration and weight files."""

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

Personalizza ulteriormente il trainer modificando la funzione di loss 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=None, weights=None, verbose=True):
        """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, consulta la Guida ai Callback.

Altri componenti dell'engine#

Personalizza altri componenti come Validators e Predictors in modo analogo. Per maggiori informazioni, fai riferimento alla documentazione per Validators e Predictors.

Uso di YOLO con trainer personalizzati#

La classe del modello YOLO 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=None, weights=None, verbose=True):
        """Custom code implementation."""

# Initialize YOLO model
model = YOLO("yolo26n.pt")

# Train with custom trainer
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Questo approccio ti consente di mantenere la semplicità dell'interfaccia YOLO personalizzando al contempo il processo di training sottostante per soddisfare i tuoi requisiti specifici.

FAQ#

Come posso personalizzare il DetectionTrainer di Ultralytics YOLO per task specifici?#

Personalizza il DetectionTrainer per task specifici eseguendo l'override dei suoi metodi per adattarli al tuo modello personalizzato e al tuo dataloader. Inizia ereditando da DetectionTrainer e ridefinisci 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=None, weights=None, verbose=True):
        """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 loss o l'aggiunta di un callback, fai riferimento alla Guida ai Callback.

Quali sono i componenti chiave del BaseTrainer in Ultralytics YOLO?#

Il BaseTrainer funge da base per le routine di training, personalizzabili per vari task eseguendo l'override dei suoi metodi generici. I componenti chiave includono:

• get_model(cfg, weights): Costruisce il modello da addestrare.
• get_dataloader(): Costruisce il dataloader.
• preprocess_batch(): Gestisce il pre-processing 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 validator per la valutazione del modello.

Per maggiori dettagli sulla personalizzazione e sul codice sorgente, consulta il Riferimento su BaseTrainer.

Come posso aggiungere un callback al DetectionTrainer di Ultralytics YOLO?#

Aggiungi callback per monitorare e modificare il processo di training in DetectionTrainer. Ecco come aggiungere un callback per registrare i pesi del modello dopo ogni epoca di training:

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 dei callback e sui punti di ingresso, fai riferimento alla Guida ai Callback.

Perché dovrei usare Ultralytics YOLO per il training dei modelli?#

Ultralytics YOLO fornisce un'astrazione di alto livello su potenti executor di engine, 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 in Python semplificano i task complessi.
• Performance: Ottimizzato per il rilevamento di oggetti in tempo reale e varie applicazioni di IA visiva.
• Personalizzazione: Facilmente estendibile per modelli personalizzati, funzioni di loss e dataloader.
• Modularità: I componenti possono essere modificati indipendentemente senza influire sull'intera pipeline.
• Integrazione: Funziona perfettamente con i framework e gli strumenti più diffusi nell'ecosistema ML.

Scopri di più sulle funzionalità di YOLO esplorando la pagina principale di Ultralytics YOLO.

Posso usare il DetectionTrainer di Ultralytics YOLO per modelli non standard?#

Sì, il DetectionTrainer è estremamente flessibile e personalizzabile per modelli non standard. Eredita da DetectionTrainer ed esegui l'overload dei 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=None, weights=None, verbose=True):
        """Loads a custom detection model."""

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

Per istruzioni complete ed esempi, rivedi il Riferimento su DetectionTrainer.