Customização Avançada
Tanto a linha de comando Ultralytics YOLO quanto as interfaces Python são abstrações de alto nível construídas sobre executores de mecanismo de base. Este guia se concentra no Trainer engine, explicando como personalizá-lo para suas necessidades específicas.
Assista: Dominando o Ultralytics YOLO: Personalização Avançada
BaseTrainer
O BaseTrainer A classe fornece uma rotina de treinamento genérica adaptável para várias tarefas. Personalize-a substituindo funções ou operações específicas, respeitando os formatos necessários. Por exemplo, integre seu próprio modelo personalizado e dataloader substituindo 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 o BaseTrainer Referência.
DetectionTrainer
Veja como usar e personalizar o Ultralytics YOLO DetectionTrainer:
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 que não é diretamente suportado, sobrecarregue o existente get_model funcionalidade:
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()
Personalize ainda mais o treinador modificando a função de perda ou adicionando um callback para fazer o upload do 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, 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 callbacks
trainer.train()
Para obter mais informações sobre eventos de acionamento de callback e pontos de entrada, consulte o Guia de Callbacks.
Outros Componentes do Motor
Personalize outros componentes como Validators e Predictors similarmente. Para mais informações, consulte a documentação para Validadores e Predictores.
Usando YOLO com Custom Trainers
O YOLO A classe de modelo fornece um wrapper de alto nível para as classes Trainer. Você pode aproveitar esta 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, weights):
"""Custom code implementation."""
...
# Initialize YOLO model
model = YOLO("yolo11n.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.
FAQ
Como personalizo o Ultralytics YOLO DetectionTrainer para tarefas específicas?
Personalizar o DetectionTrainer para tarefas específicas, substituindo seus métodos para se adaptar ao seu modelo e carregador de dados 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, weights):
"""Loads a custom detection model given configuration and weight files."""
...
trainer = CustomTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # Get the best model
Para mais personalização, 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 base para rotinas de treinamento, personalizável para várias tarefas, substituindo 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 dataloader.preprocess_batch(): Lida com o pré-processamento do lote 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 avaliação do modelo.
Para obter mais detalhes sobre personalização e código fonte, veja o BaseTrainer Referência.
Como posso adicionar um callback ao Ultralytics YOLO DetectionTrainer?
Adicione callbacks para monitorar e modificar o processo de treinamento em DetectionTrainer. Veja como adicionar um callback para registrar os pesos do modelo após cada treinamento época:
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 obter 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 modelo?
O YOLO da Ultralytics fornece uma abstração de alto nível sobre executores de mecanismo poderosos, tornando-o ideal para desenvolvimento e personalização rápidos. 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 dataloaders.
- Modularidade: Os componentes podem ser modificados independentemente sem afetar todo o pipeline.
- Integração: Funciona perfeitamente com frameworks e ferramentas populares no ecossistema de ML.
Saiba mais sobre os recursos do YOLO explorando a página principal do Ultralytics YOLO.
Posso usar o Ultralytics YOLO DetectionTrainer para modelos não padronizados?
Sim, o DetectionTrainer é altamente flexível e personalizável para modelos não padronizados. Herde de DetectionTrainer e sobrecarregue os 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, weights):
"""Loads a custom detection model."""
...
trainer = CustomDetectionTrainer(overrides={...})
trainer.train()
Para instruções e exemplos abrangentes, reveja o DetectionTrainer Referência.
