Personalização avançada

Ambas as interfaces Ultralytics YOLO linha de comando e Python são simplesmente uma abstração de alto nível nos executores do motor base. Vamos dar uma olhadela ao motor Trainer.

Observa: Dominar Ultralytics YOLOv8 : Personalização avançada

BaseTrainer

O BaseTrainer contém a rotina de formação genérica. Pode ser personalizada para qualquer tarefa com base na substituição das funções ou operações necessárias, desde que sejam seguidos os formatos correctos. Por exemplo, podes suportar o teu próprio modelo personalizado e o teu carregador de dados, substituindo apenas estas funções:

• get_model(cfg, weights) - A função que constrói o modelo a ser treinado
• get_dataloader() - A função que constrói o carregador de dados Mais detalhes e código fonte podem ser encontrados em BaseTrainer Referência

DetectionTrainer

Eis como podes utilizar o YOLOv8 DetectionTrainer e personaliza-o.

from ultralytics.models.yolo.detect import DetectionTrainer

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

Personalização do DetectionTrainer

Personaliza o formador para treinar um modelo de deteção personalizado que não é suportado diretamente. Podes fazer isto simplesmente sobrecarregando a funçã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()

Percebes agora que precisas de personalizar ainda mais o treinador para:

• Personaliza o loss function.
• Acrescenta callback que carrega o modelo para a tua unidade Google a cada 10 epochs Eis como o podes fazer:

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 callback
trainer.train()

Para saberes mais sobre eventos de ativação de Callbacks e ponto de entrada, consulta o nosso Guia de Callbacks

Outros componentes do motor

Existem outros componentes que podem ser personalizados de forma semelhante, como Validators e Predictors. Consulta a secção Referência para obteres mais informações sobre os mesmos.

FAQ

Como é que posso personalizar o Ultralytics YOLOv8 DetectionTrainer para tarefas específicas?

Para personalizar o Ultralytics YOLOv8 DetectionTrainer para uma tarefa específica, podes substituir os seus métodos para os adaptares ao teu modelo personalizado e ao teu carregador de dados. Começa por herdar de DetectionTrainer e depois redefine métodos como get_model para implementar as tuas funcionalidades personalizadas. Vê 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 best model

Para mais personalizações, como alterar o loss function ou adiciona um callback, podes consultar a nossa Guia de Callbacks.

Quais são os principais componentes do BaseTrainer em Ultralytics YOLOv8 ?

O BaseTrainer em Ultralytics YOLOv8 serve de base para rotinas de treino e pode ser personalizado para várias tarefas, substituindo os seus métodos genéricos. Os principais componentes incluem:

• get_model(cfg, weights) para construir o modelo a ser treinado.
• get_dataloader() para construíres o carregador de dados.

Para mais informações sobre a personalização e o código-fonte, consulta a BaseTrainer Referência.

Como é que posso adicionar uma chamada de retorno ao Ultralytics YOLOv8 DetectionTrainer?

Podes adicionar callbacks para monitorizar e modificar o processo de formação em Ultralytics YOLOv8 DetectionTrainer. Por exemplo, aqui está como podes adicionar uma chamada de retorno para registar os pesos do modelo após cada época de treino:

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 informações sobre eventos de retorno de chamada e pontos de entrada, consulta o nosso Guia de retornos de chamada.

Por que razão devo utilizar Ultralytics YOLOv8 para o treino de modelos?

Ultralytics YOLOv8 oferece uma abstração de alto nível em poderosos executores de motores, tornando-o ideal para desenvolvimento e personalização rápidos. As principais vantagens 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.

Sabe mais sobre as capacidades de YOLOv8 visitando Ultralytics YOLO.

Posso utilizar o Ultralytics YOLOv8 DetectionTrainer para modelos não normalizados?

Sim, Ultralytics YOLOv8 DetectionTrainer é altamente flexível e pode ser personalizado para modelos não padronizados. Ao herdar de DetectionTrainerpodes sobrecarregar diferentes métodos para satisfazer as necessidades específicas do teu modelo. Aqui tens 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 mais abrangentes, consulta a documentação do DetectionTrainer.

Comentários