Personalizzazione avanzata

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

BaseTrainer

La classe BaseTrainer fornisce una routine di addestramento generica adattabile a vari task. Personalizzala sovrascrivendo funzioni o operazioni specifiche, rispettando i formati richiesti. Ad esempio, integra il tuo modello e 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, consulta il riferimento di BaseTrainer.

DetectionTrainer

Ecco come utilizzare 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

Personalizzare il DetectionTrainer

Per addestrare un modello di rilevamento personalizzato non supportato direttamente, sovrascrivi la funzionalità get_model 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 loss o aggiungendo un callback per caricare il modello su Google Drive ogni 10 epoch. 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, consulta la Guida ai Callbacks.

Altri componenti del motore

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

Utilizzare 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, 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)

Questo approccio ti consente di mantenere la semplicità dell'interfaccia YOLO mentre personalizzi il processo di addestramento 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 sovrascrivendo i suoi metodi per adattarli al tuo modello e dataloader personalizzati. 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, 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 cambiare la funzione di loss o aggiungere un callback, fai riferimento alla Guida ai Callbacks.

Quali sono i componenti chiave del BaseTrainer in Ultralytics YOLO?

Il BaseTrainer funge da base per le routine di addestramento, personalizzabile per vari task 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 il pre-processing del batch prima del passaggio in avanti (forward pass) 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 per il codice sorgente, consulta il riferimento di BaseTrainer.

Come posso aggiungere un callback al DetectionTrainer di Ultralytics YOLO?

Aggiungi callback per monitorare e modificare il processo di addestramento in DetectionTrainer. Ecco come aggiungere un callback per loggare i pesi del modello dopo ogni epoch di addestramento:

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 Callbacks.

Perché dovrei usare Ultralytics YOLO per l'addestramento dei modelli?

Ultralytics YOLO fornisce un'astrazione di alto livello su potenti executor del motore, rendendolo ideale per lo sviluppo rapido e la personalizzazione. I benefici principali includono:

• Facilità d'uso: Sia le interfacce a riga di comando che Python semplificano i task complessi.
• Performance: Ottimizzato per il rilevamento di oggetti in tempo reale e varie applicazioni di visione artificiale.
• Personalizzazione: Facilmente estensibile per modelli personalizzati, funzioni di loss e dataloader.
• Modularità: I componenti possono essere modificati indipendentemente senza influire sull'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 il DetectionTrainer di Ultralytics YOLO per modelli non standard?

Sì, il DetectionTrainer è altamente flessibile e personalizzabile per modelli non standard. Eredita da DetectionTrainer e sovrascrivi 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, rivedi il riferimento del DetectionTrainer.