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 as tuas necessidades específicas.

BaseTrainer#

A classe BaseTrainer fornece uma rotina de treinamento genérica adaptável para várias tarefas. Podes personalizá-la substituindo funções ou operações específicas, desde que adiras aos formatos necessários. Por exemplo, integra o teu próprio modelo e carregador de dados personalizados substituindo estas funções:

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

Para mais detalhes e código-fonte, vê a BaseTrainer Reference.

DetectionTrainer#

Eis 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, sobrecarrega a funcionalidade existente 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()

Personaliza ainda mais o treinador modificando a função de perda ou adicionando um callback para enviar o modelo para o Google Drive a cada 10 épocas. Eis 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 acionamento de callbacks e pontos de entrada, consulta o Guia de Callbacks.

Outros Componentes do Motor#

Personaliza outros componentes como Validators e Predictors de forma semelhante. Para mais informações, consulta a documentação de Validators e Predictors.

Usando YOLO com Treinadores Personalizados#

A classe de modelo YOLO fornece um wrapper de alto nível para as classes Trainer. Podes aproveitar esta arquitetura para obter maior flexibilidade nos teus 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-te manter a simplicidade da interface YOLO enquanto personalizas o processo de treinamento subjacente para atender aos teus requisitos específicos.

FAQ#

Como posso personalizar o DetectionTrainer do Ultralytics YOLO para tarefas específicas?#

Personaliza o DetectionTrainer para tarefas específicas substituindo os seus métodos para se adaptarem ao teu modelo e carregador de dados personalizados. Começa herdando de DetectionTrainer e redefinia métodos como get_model para implementar funcionalidades personalizadas. Eis 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, consulta o Guia de Callbacks.

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

O BaseTrainer serve como base para as rotinas de treinamento, sendo personalizável para várias tarefas através da substituição dos seus métodos genéricos. Os principais componentes incluem:

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

Para mais detalhes sobre personalização e código-fonte, vê a BaseTrainer Reference.

Como posso adicionar um callback ao DetectionTrainer do Ultralytics YOLO?#

Adiciona callbacks para monitorar e modificar o processo de treinamento no DetectionTrainer. Eis 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 callbacks e pontos de entrada, consulta o Guia de Callbacks.

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

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

• Facilidade de Uso: As interfaces de linha de comando e Python simplificam tarefas complexas.
• Desempenho: Otimizado para detecção de objetos em tempo real e várias aplicações de IA de visão.
• Personalização: Facilmente extensível para modelos personalizados, funções de perda e carregadores de dados.
• Modularidade: Os componentes podem ser modificados independentemente sem afetar todo o pipeline.
• Integração: Funciona perfeitamente com estruturas e ferramentas populares no ecossistema de ML.

Sabe 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. Herda de DetectionTrainer e sobrecarrega métodos para atender às necessidades específicas do teu modelo. Eis 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, consulta a DetectionTrainer Reference.