YOLO Vision 2026:

Personalizzazione avanzata#

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



Watch: Mastering Ultralytics YOLO: Advanced Customization
Suggerimento

Per esempi pratici di personalizzazioni comuni del trainer — metriche personalizzate, loss pesata per classe, salvataggio del modello, congelamento del backbone e tassi di apprendimento per livello — consulta la guida Customizing Trainer.

BaseTrainer#

La classe BaseTrainer fornisce una routine di addestramento generica adattabile a vari compiti. Personalizzala sovrascrivendo funzioni o operazioni specifiche nel rispetto dei formati richiesti. Ad esempio, integra il tuo modello personalizzato e il tuo dataloader sovrascrivendo queste funzioni:

  • get_model(cfg, weights): Costruisce il modello da addestrare.
  • get_dataloader(): Costruisce il dataloader.

Per ulteriori dettagli e codice sorgente, consulta il BaseTrainer Reference.

DetectionTrainer#

Ecco come usare e personalizzare l'Ultralytics YOLO DetectionTrainer:

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 direttamente supportato, 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 loss function o aggiungendo un callback per caricare il modello su Google Drive ogni 10 epochs. 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 Callbacks Guide.

Altri componenti dell'engine#

Personalizza altri componenti come Validators e Predictors allo stesso modo. Per maggiori informazioni, fai riferimento alla documentazione per Validators e Predictors.

Uso di 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=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 personalizzando al contempo il processo di training sottostante per soddisfare i tuoi requisiti specifici.

FAQ#

  • Personalizza DetectionTrainer per compiti specifici sovrascrivendo i suoi metodi per adattarli al tuo modello personalizzato e al tuo dataloader. 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 ulteriori personalizzazioni, come la modifica della loss function o l'aggiunta di un callback, fai riferimento alla Callbacks Guide.

  • Il BaseTrainer funge da base per le routine di addestramento, personalizzabili per vari compiti 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-processamento 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 validatore per la valutazione del modello.

    Per ulteriori dettagli sulla personalizzazione e sul codice sorgente, consulta il BaseTrainer Reference.

  • Aggiungi callback per monitorare e modificare il processo di addestramento in DetectionTrainer. Ecco come aggiungere un callback per registrare 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 di callback e sui punti di ingresso, fai riferimento alla Callbacks Guide.

  • 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 l'interfaccia a riga di comando che quella in Python semplificano i task complessi.
    • Performance: Ottimizzato per il object detection in tempo reale e varie applicazioni di IA visiva.
    • Customization: Facilmente estendibile per modelli personalizzati, loss functions e dataloader.
    • Modularità: I componenti possono essere modificati indipendentemente 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 esplorando la pagina principale di Ultralytics YOLO.

  • Sì, il DetectionTrainer è altamente flessibile e personalizzabile per 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 complete ed esempi, rivedi il DetectionTrainer Reference.

Collaboratori
GLglenn-jocher13RAraimbekovm2RIRizwanMunawar2

Commenti