Ultralytics YOLO27:
Get Started

Personalizzazione avanzata#

Le interfacce a riga di comando e Python di Ultralytics YOLO sono astrazioni di alto livello basate su esecutori del motore di base. Questa guida si concentra sul motore Trainer e spiega come personalizzarlo in base alle tue esigenze specifiche.



Guarda: Padroneggiare Ultralytics YOLO: personalizzazione avanzata
Suggerimento

Per esempi pratici di personalizzazioni comuni del trainer — metriche personalizzate, funzione di perdita pesata per classe, salvataggio del modello, congelamento del backbone e tassi di apprendimento per layer — consulta la guida Personalizzare il Trainer.

BaseTrainer#

La classe BaseTrainer fornisce una routine di addestramento generica, adattabile a varie attività. Personalizzala sovrascrivendo funzioni o operazioni specifiche e rispettando i formati richiesti. Ad esempio, integra il tuo modello personalizzato e il tuo dataloader sovrascrivendo queste funzioni:

  • get_model(cfg, weights): crea il modello da addestrare.
  • get_dataloader(dataset_path, batch_size, rank, mode): crea il dataloader.

Per maggiori dettagli e per il codice sorgente, consulta il riferimento di BaseTrainer.

DetectionTrainer#

Ecco come usare e personalizzare DetectionTrainer di Ultralytics YOLO:

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # Ottieni il modello migliore

Personalizzare DetectionTrainer#

Per addestrare un modello di rilevamento personalizzato non supportato direttamente, sovraccarica la funzionalità esistente di get_model:

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 perdita o aggiungendo una callback eseguita al termine di ogni epoca, ad esempio per registrare o caricare i pesi più recenti. Ecco un esempio:

from ultralytics.models.yolo.detect import DetectionTrainer
from ultralytics.nn.tasks import DetectionModel

class MyCustomModel(DetectionModel):
    def init_criterion(self):
        """Initializes a custom loss function for the model."""

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 per registrare i pesi del modello
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)  # Si aggiunge alle callback esistenti
trainer.train()

Per ulteriori informazioni sugli eventi che attivano le callback e sui punti di ingresso, consulta la Guida alle callback.

Altri componenti del motore#

Personalizza allo stesso modo altri componenti come Validators e Predictors. Per ulteriori informazioni, consulta la documentazione di Validators e Predictors.

Usare YOLO con trainer personalizzati#

La classe del modello YOLO fornisce un wrapper di alto livello per le classi Trainer. Puoi sfruttare questa architettura per ottenere maggiore flessibilità nei tuoi flussi di lavoro di machine learning:

from ultralytics import YOLO
from ultralytics.models.yolo.detect import DetectionTrainer

# Crea un trainer personalizzato
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

# Inizializza il modello YOLO
model = YOLO("yolo26n.pt")

# Addestra con un trainer personalizzato
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Questo approccio ti permette di mantenere la semplicità dell'interfaccia YOLO e di personalizzare al contempo il processo di addestramento sottostante in base alle tue esigenze specifiche.

Domande frequenti#

  • Personalizza DetectionTrainer per attività specifiche sovrascrivendone i metodi, così da adattarlo al tuo modello e al tuo 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  # Ottieni il modello migliore

    Per ulteriori personalizzazioni, come la modifica della funzione di perdita o l'aggiunta di una callback, consulta la Guida alle callback.

  • BaseTrainer è la base delle routine di addestramento e può essere personalizzato per varie attività sovrascrivendone i metodi generici. Tra i componenti principali:

    • get_model(cfg, weights): crea il modello da addestrare.
    • get_dataloader(dataset_path, batch_size, rank, mode): crea il dataloader.
    • preprocess_batch(): gestisce la preelaborazione 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 ulteriori dettagli sulla personalizzazione e sul codice sorgente, consulta il riferimento di BaseTrainer.

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

    from ultralytics.models.yolo.detect import DetectionTrainer

# Callback per registrare i pesi del modello
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)  # Si aggiunge alle callback esistenti
trainer.train()

    Per ulteriori dettagli sugli eventi delle callback e sui punti di ingresso, consulta la Guida alle callback.

  • Ultralytics YOLO offre un'astrazione di alto livello sopra potenti esecutori del motore, ideale per sviluppare e personalizzare rapidamente. Tra i principali vantaggi:

    • Facilità d'uso: le interfacce a riga di comando e Python semplificano le attività complesse.
    • Prestazioni: ottimizzato per il rilevamento degli oggetti in tempo reale e per diverse applicazioni di IA visiva.
    • Personalizzazione: facilmente estensibile con modelli, funzioni di perdita e dataloader personalizzati.
    • Modularità: puoi modificare i componenti in modo indipendente, senza influire sull'intera pipeline.
    • Integrazione: funziona perfettamente con i framework e gli strumenti più diffusi nell'ecosistema ML.

    Scopri di più sulle capacità di YOLO visitando la pagina principale di Ultralytics YOLO.

  • Sì, DetectionTrainer è altamente flessibile e personalizzabile per i modelli non standard. Eredita da DetectionTrainer e sovraccarica 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 di DetectionTrainer.

Collaboratori
GLglenn-jocher14RAraimbekovm2RIRizwanMunawar2

Commenti