Personalização avançada
Tanto a linha de comandos do Ultralytics YOLO como as interfaces Python são abstracções de alto nível construídas sobre executores de motores de base. Este guia centra-se na interface Trainer explicando como personalizá-lo de acordo com as suas necessidades específicas.
Ver: Dominar Ultralytics YOLO : Personalização avançada
BaseTrainer
O BaseTrainer A classe fornece uma rotina de formação genérica adaptável a várias tarefas. Personalize-a substituindo funções ou operações específicas, respeitando os formatos necessários. Por exemplo, integre o seu 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 obter mais detalhes e o código-fonte, consulte o BaseTrainer Referência.
DetectionTrainer
Eis como utilizar 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
Personalização do DetectionTrainer
Para treinar um modelo de deteção personalizado não suportado diretamente, sobrecarregue o 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 retorno de chamada para carregar o modelo no 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 mais informações sobre eventos de acionamento de callbacks e pontos de entrada, consulte o Guia de Callbacks.
Outros componentes do motor
Personalizar outros componentes como Validators e Predictors da mesma forma. Para mais informações, consulte a documentação do Validadores e Preditores.
Utilização do YOLO com formadores personalizados
O YOLO A classe Model fornece um invólucro de alto nível para as classes Trainer. Pode aproveitar esta arquitetura para obter maior flexibilidade nos seus fluxos de trabalho de aprendizagem automática:
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-lhe manter a simplicidade da interface YOLO e, ao mesmo tempo, personalizar o processo de formação subjacente de acordo com as suas necessidades específicas.
FAQ
Como é que posso personalizar o Ultralytics YOLO DetectionTrainer para tarefas específicas?
Personalizar o DetectionTrainer para tarefas específicas, substituindo os seus métodos para os adaptar ao seu modelo personalizado e ao seu carregador de dados. Comece por herdar de DetectionTrainer e redefinir 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, 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ções, como alterar a função de perda ou adicionar uma chamada de retorno, consulte o Guia de chamadas de retorno.
Quais são os principais componentes do BaseTrainer no Ultralytics YOLO?
O BaseTrainer serve de base para rotinas de formação, personalizáveis 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(): Trata do pré-processamento em lote antes da passagem do modelo para a frente.set_model_attributes(): Define os atributos do modelo com base nas informações do conjunto de dados.get_validator(): Devolve um validador para avaliação do modelo.
Para obter mais detalhes sobre personalização e código-fonte, consulte o BaseTrainer Referência.
Como é que posso adicionar uma chamada de retorno ao Ultralytics YOLO DetectionTrainer?
Adicionar chamadas de retorno para monitorizar e modificar o processo de formação em DetectionTrainer. Eis como adicionar uma chamada de retorno para registar os pesos do modelo após cada treino é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 retorno de chamada e pontos de entrada, consulte o Guia de retornos de chamada.
Por que razão devo utilizar o Ultralytics YOLO para o treino de modelos?
Ultralytics YOLO fornece uma abstração de alto nível sobre poderosos executores de motores, tornando-o ideal para um rápido desenvolvimento e personalização. Os principais benefícios incluem:
- Facilidade de utilização: As interfaces de linha de comandos e Python simplificam tarefas complexas.
- Desempenho: Optimizado para deteção de objectos 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 de forma independente sem afetar todo o pipeline.
- Integração: Funciona sem problemas com estruturas e ferramentas populares no ecossistema de ML.
Saiba mais sobre as capacidades do YOLO explorando as principais Ultralytics YOLO página principal.
Posso utilizar o Ultralytics YOLO DetectionTrainer para modelos não normalizados?
Sim, o DetectionTrainer é altamente flexível e personalizável para modelos não normalizados. Herdar de DetectionTrainer e métodos de sobrecarga para apoiar 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 obter instruções e exemplos completos, consulte o DetectionTrainer Referência.
