Personalizzazione Avanzata

Sia l'interfaccia a riga di comando di Ultralytics YOLO che quella Python sono astrazioni di alto livello costruite 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 addestramento generica adattabile a varie attività. 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 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

Personalizzazione del 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=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 ulteriori 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 simile. Per maggiori informazioni, fai riferimento alla documentazione per Validators e Predictors.

Utilizzare YOLO con Trainer Personalizzati

La classe 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 pur personalizzando il processo di addestramento sottostante per soddisfare i tuoi requisiti specifici.

FAQ

Come posso personalizzare il DetectionTrainer di Ultralytics YOLO per attività specifiche?

Personalizza il DetectionTrainer per attività specifiche 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=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 un'ulteriore personalizzazione, 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 addestramento, 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 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 per il codice sorgente, consulta il riferimento BaseTrainer.

Come posso aggiungere un callback al DetectionTrainer di Ultralytics YOLO?

Aggiungi callback per monitorare e modificare il processo di addestramento nel DetectionTrainer. Ecco come aggiungere un callback per registrare i pesi del modello dopo ogni epoca 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 Callback.

Perché dovrei usare Ultralytics YOLO per l'addestramento 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 le interfacce a riga di comando che quelle Python semplificano compiti complessi.
• Prestazioni: 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'intero 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=None, weights=None, verbose=True):
        """Loads a custom detection model."""
        ...

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

Per istruzioni ed esempi completi, consulta il riferimento DetectionTrainer.