Personalização Avançada

Tanto a interface de linha de comando quanto a interface Python do Ultralytics YOLO são abstrações de alto nível construídas sobre executores de motor base. Este guia foca no motor Trainer, explicando como personalizá-lo para suas necessidades específicas.

BaseTrainer

A classe BaseTrainer fornece uma rotina de treinamento genérica adaptável a várias tarefas. Personalize-a sobrescrevendo funções ou operações específicas, aderindo aos formatos exigidos. Por exemplo, integre seu próprio modelo personalizado e dataloader sobrescrevendo estas funções:

• get_model(cfg, weights): Constrói o modelo a ser treinado.
• get_dataloader(): Constrói o dataloader.

Para mais detalhes e código-fonte, veja a Referência do BaseTrainer.

DetectionTrainer

Veja como usar e personalizar o DetectionTrainer do Ultralytics YOLO:

from ultralytics.models.yolo.detect import DetectionTrainer

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

Personalizando o DetectionTrainer

Para treinar um modelo de detecção personalizado não suportado diretamente, sobrescreva a funcionalidade get_model existente:

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()

Personalize ainda mais o trainer modificando a função de perda ou adicionando um callback para enviar o modelo para o Google Drive a cada 10 épocas. Aqui está um exemplo:

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()

Para mais informações sobre eventos de gatilho de callback e pontos de entrada, veja o Guia de Callbacks.

Outros Componentes do Motor

Personalize outros componentes como Validators e Predictors da mesma forma. Para mais informações, consulte a documentação para Validators e Predictors.

Usando YOLO com Trainers Personalizados

A classe de modelo YOLO fornece um wrapper de alto nível para classes Trainer. Você pode aproveitar essa arquitetura para maior flexibilidade em seus fluxos de trabalho de aprendizado de máquina:

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)

Esta abordagem permite que você mantenha a simplicidade da interface YOLO enquanto personaliza o processo de treinamento subjacente para atender aos seus requisitos específicos.

Perguntas Frequentes

Como personalizo o DetectionTrainer do Ultralytics YOLO para tarefas específicas?

Personalize o DetectionTrainer para tarefas específicas sobrescrevendo seus métodos para se adaptar ao seu modelo e dataloader personalizados. Comece herdando de DetectionTrainer e redefina métodos como get_model para implementar funcionalidades personalizadas. Aqui está um exemplo:

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

Para personalizações adicionais, como alterar a função de perda ou adicionar um callback, consulte o Guia de Callbacks.

Quais são os principais componentes do BaseTrainer no Ultralytics YOLO?

O BaseTrainer serve como a base para rotinas de treinamento, personalizável para várias tarefas ao sobrescrever seus métodos genéricos. Os componentes principais incluem:

• get_model(cfg, weights): Constrói o modelo a ser treinado.
• get_dataloader(): Constrói o dataloader.
• preprocess_batch(): Lida com o pré-processamento de lote antes da passagem direta do modelo.
• set_model_attributes(): Define atributos do modelo com base nas informações do dataset.
• get_validator(): Retorna um validador para avaliação do modelo.

Para mais detalhes sobre personalização e código-fonte, veja a Referência do BaseTrainer.

Como posso adicionar um callback ao DetectionTrainer do Ultralytics YOLO?

Adicione callbacks para monitorar e modificar o processo de treinamento no DetectionTrainer. Veja como adicionar um callback para registrar os pesos do modelo após cada época de treinamento:

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()

Para mais detalhes sobre eventos de callback e pontos de entrada, consulte o Guia de Callbacks.

Por que devo usar o Ultralytics YOLO para treinamento de modelos?

O Ultralytics YOLO fornece uma abstração de alto nível sobre executores de motor poderosos, tornando-o ideal para desenvolvimento rápido e personalização. Os principais benefícios incluem:

• Facilidade de Uso: Tanto a linha de comando quanto as interfaces Python simplificam tarefas complexas.
• Desempenho: Otimizado para detecção de objetos em tempo real e várias aplicações de visão computacional com IA.
• Personalização: Facilmente extensível para modelos personalizados, funções de perda e dataloaders.
• Modularidade: Componentes podem ser modificados independentemente sem afetar todo o pipeline.
• Integração: Funciona perfeitamente com frameworks e ferramentas populares no ecossistema de aprendizado de máquina.

Saiba mais sobre as capacidades do YOLO explorando a página principal do Ultralytics YOLO.

Posso usar o DetectionTrainer do Ultralytics YOLO para modelos não padrão?

Sim, o DetectionTrainer é altamente flexível e personalizável para modelos não padrão. Herde do DetectionTrainer e sobrescreva métodos para suportar as necessidades específicas do seu modelo. Aqui está um exemplo simples:

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()

Para instruções abrangentes e exemplos, revise a Referência do DetectionTrainer.