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 YOLO : Personalizzazione avanzata

Allenatore di base

BaseTrainer contiene la routine di addestramento generica. Può essere personalizzato per qualsiasi compito, sovrascrivendo le funzioni o le operazioni richieste, purché si seguano i formati corretti. Ad esempio, è possibile 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

Allenatore di rilevamento

Ecco come si può utilizzare il YOLO11 DetectionTrainer e personalizzarlo.

from ultralytics.models.yolo.detect import DetectionTrainer

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

Personalizzazione del DetectionTrainer

Personalizziamo il trainer per addestrare un modello di rilevamento personalizzato che non è supportato direttamente. È possibile farlo semplicemente sovraccaricando l'esistente metodo 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()

A questo punto ci si rende conto che è necessario personalizzare ulteriormente il trainer:

• Personalizzare il loss function.
• Aggiungi callback che carica il modello sull'unità Google ogni 10 minuti. epochs Ecco come fare:

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, consultare 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, consultare la sezione Riferimento.

FAQ

Come si può personalizzare Ultralytics YOLO11 DetectionTrainer per compiti specifici?

Per personalizzare il Ultralytics YOLO11 DetectionTrainer per un compito specifico, si possono sovrascrivere i suoi metodi per adattarli al modello e al dataloader personalizzati. Si inizia ereditando da DetectionTrainer e poi ridefinire metodi come get_model per implementare le 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 la modifica dell'opzione loss function o l'aggiunta di un callbackè possibile fare riferimento al nostro Guida ai callback.

Quali sono i componenti chiave del BaseTrainer in Ultralytics YOLO11 ?

Il BaseTrainer in Ultralytics YOLO11 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 maggiori dettagli sulla personalizzazione e sul codice sorgente, vedere il file BaseTrainer Riferimento.

Come posso aggiungere un callback a Ultralytics YOLO11 DetectionTrainer?

È possibile aggiungere callback per monitorare e modificare il processo di addestramento in Ultralytics YOLO11 DetectionTrainer. Per esempio, ecco come aggiungere un callback per registrare i pesi del modello dopo ogni allenamento 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 ulteriori dettagli sugli eventi di callback e sui punti di ingresso, consultare la nostra Guida ai callback.

Perché utilizzare Ultralytics YOLO11 per l'addestramento dei modelli?

Ultralytics YOLO11 offre un'astrazione di alto livello su potenti esecutori di motori, 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 YOLO11, visitate il sito Ultralytics YOLO.

È possibile utilizzare Ultralytics YOLO11 DetectionTrainer per modelli non standard?

Sì, Ultralytics YOLO11 DetectionTrainer è altamente flessibile e può essere personalizzato per modelli non standard. Ereditando da DetectionTrainerè possibile sovraccaricare diversi metodi per supportare le esigenze del 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, consultare la documentazione di DetectionTrainer.

📅C reato 1 anno fa ✏️ Aggiornato 1 mese fa

Commenti