Personalizzazione avanzata

Entrambe le interfacce Ultralytics YOLO a riga di comando e Python sono semplicemente un'astrazione di alto livello sugli esecutori del motore di base. Diamo un'occhiata al motore Trainer.

Guarda: Mastering Ultralytics YOLOv8 : Personalizzazione avanzata

Allenatore di base

BaseTrainer contiene la routine di formazione generica. Può essere personalizzato per qualsiasi attività, sovrascrivendo le funzioni o le operazioni necessarie, purché vengano rispettati i formati corretti. Ad esempio, puoi supportare un modello e un dataloader personalizzati semplicemente sovrascrivendo queste funzioni:

• get_model(cfg, weights) - La funzione che costruisce il modello da addestrare
• get_dataloader() - La funzione che costruisce il dataloader Maggiori dettagli e codice sorgente sono disponibili in BaseTrainer Riferimento

Addestratore di rilevamento

Ecco come puoi utilizzare la funzione YOLOv8 DetectionTrainer e personalizzarlo.

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # get best model

Personalizzare il DetectionTrainer

Personalizziamo il trainer per addestrare un modello di rilevamento personalizzato che non è supportato direttamente. Puoi farlo semplicemente sovraccaricando la funzione esistente the 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()

Ora ti rendi conto che devi personalizzare ulteriormente il trainer:

• Personalizza il sito loss function.
• Aggiungi callback che carica il modello sul tuo Google Drive ogni 10 minuti. epochs Ecco come puoi farlo:

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 callback
trainer.train()

Per saperne di più sugli eventi di attivazione delle Callback e sul punto di ingresso, consulta la nostra Guida alle Callback.

Altri componenti del motore

Ci sono altri componenti che possono essere personalizzati in modo simile, come ad esempio Validators e Predictors. Per ulteriori informazioni, consulta la sezione Riferimenti.

DOMANDE FREQUENTI

Come posso personalizzare Ultralytics YOLOv8 DetectionTrainer per attività specifiche?

Per personalizzare l'interfaccia Ultralytics YOLOv8 DetectionTrainer per un compito specifico, puoi sovrascrivere i suoi metodi per adattarli al tuo modello e al tuo dataloader personalizzato. Inizia ereditando da DetectionTrainer e poi ridefinire metodi come get_model per implementare le tue 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 best model

Per ulteriori personalizzazioni, come ad esempio la modifica dell'opzione loss function o l'aggiunta di un callbackpuoi fare riferimento al nostro Guida ai callback.

Quali sono i componenti chiave del BaseTrainer in Ultralytics YOLOv8 ?

Il BaseTrainer in Ultralytics YOLOv8 serve come base per le routine di allenamento e può essere personalizzato per vari compiti sovrascrivendo i suoi metodi generici. I componenti chiave includono:

• get_model(cfg, weights) per costruire il modello da addestrare.
• get_dataloader() per costruire il dataloader.

Per ulteriori dettagli sulla personalizzazione e sul codice sorgente, consulta la sezione BaseTrainer Riferimento.

Come posso aggiungere un callback a Ultralytics YOLOv8 DetectionTrainer?

Puoi aggiungere delle callback per monitorare e modificare il processo di formazione in Ultralytics YOLOv8 DetectionTrainer. Ad esempio, ecco come aggiungere un callback per registrare i pesi del modello dopo ogni epoch di allenamento:

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, consulta la nostra Guida ai callback.

Perché dovrei utilizzare Ultralytics YOLOv8 per l'addestramento dei modelli?

Ultralytics YOLOv8 offre un'astrazione di alto livello su potenti motori esecutori, rendendola 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.

Per saperne di più sulle capacità di YOLOv8 visita il sito Ultralytics YOLO.

Posso utilizzare Ultralytics YOLOv8 DetectionTrainer per modelli non standard?

Sì, Ultralytics YOLOv8 DetectionTrainer è altamente flessibile e può essere personalizzato per modelli non standard. Ereditando da DetectionTrainerpuoi sovraccaricare diversi metodi per supportare le esigenze del tuo 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 più completi, consulta la documentazione di DetectionTrainer.

Commenti