Ultralytics YOLO27:
Get Started

Personalização avançada#

Tanto a interface de linha de comandos como a interface Python do Ultralytics YOLO são abstrações de alto nível construídas sobre executores do motor base. Este guia centra-se no motor Trainer e explica como o personalizar de acordo com as tuas necessidades específicas.



Assista: Domine o Ultralytics YOLO: personalização avançada
Dica

Para exemplos práticos de personalizações comuns do treinador — métricas personalizadas, função de perda ponderada por classe, gravação do modelo, congelamento do backbone e taxas de aprendizado por camada — consulta o guia Personalizar o treinador.

BaseTrainer#

A classe BaseTrainer fornece uma rotina de treino genérica, adaptável a várias tarefas. Personaliza-a substituindo funções ou operações específicas e respeitando os formatos necessários. Por exemplo, integra o teu próprio modelo personalizado e carregador de dados substituindo estas funções:

  • get_model(cfg, weights): cria o modelo a treinar.
  • get_dataloader(dataset_path, batch_size, rank, mode): cria o carregador de dados.

Para mais detalhes e o código-fonte, consulta a referência de BaseTrainer.

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  # Obtém o melhor modelo

Personalizar o DetectionTrainer#

Para treinar um modelo de deteção personalizado que não seja compatível diretamente, sobrecarrega a funcionalidade existente de 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 executado no fim de cada época, por exemplo, para registar ou carregar os pesos mais recentes. 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 a custom loss function for the model."""

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 para registar os pesos do modelo
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)  # Adiciona aos callbacks existentes
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, da mesma forma. Para mais informações, consulta a documentação de Validadores e Preditores.

Usar YOLO com treinadores personalizados#

A classe de modelo YOLO fornece um wrapper de alto nível para classes de treinador. Podes tirar partido desta arquitetura para teres mais flexibilidade nos teus fluxos de trabalho de aprendizado de máquina:

from ultralytics import YOLO
from ultralytics.models.yolo.detect import DetectionTrainer

# Cria um treinador personalizado
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

# Inicializa o modelo YOLO
model = YOLO("yolo26n.pt")

# Treina com um treinador personalizado
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Esta abordagem permite-te manter a simplicidade da interface YOLO e, ao mesmo tempo, personalizar o processo de treino subjacente de acordo com os teus requisitos específicos.

Perguntas frequentes#

  • Personaliza o DetectionTrainer para tarefas específicas substituindo os seus métodos para adaptar o modelo e o carregador de dados personalizados. Começa por herdar de DetectionTrainer e redefinir 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  # Obtém o melhor modelo

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

  • O BaseTrainer é a base das rotinas de treino e pode ser personalizado para várias tarefas através da substituição dos seus métodos genéricos. Os principais componentes incluem:

    • get_model(cfg, weights): cria o modelo a treinar.
    • get_dataloader(dataset_path, batch_size, rank, mode): cria o carregador de dados.
    • preprocess_batch(): processa previamente os lotes antes da passagem forward do modelo.
    • set_model_attributes(): define os atributos do modelo com base nas informações do conjunto de dados.
    • get_validator(): devolve um validador para a avaliação do modelo.

    Para mais detalhes sobre personalização e código-fonte, consulta a referência de BaseTrainer.

  • Adiciona callbacks para monitorizar e modificar o processo de treino em DetectionTrainer. Eis como adicionar um callback para registar os pesos do modelo após cada época de treino:

    from ultralytics.models.yolo.detect import DetectionTrainer

# Callback para registar os pesos do modelo
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)  # Adiciona aos callbacks existentes
trainer.train()

    Para mais detalhes sobre eventos de callbacks e pontos de entrada, consulta o Guia de callbacks.

  • O Ultralytics YOLO oferece uma abstração de alto nível sobre poderosos executores do motor, o que o torna ideal para desenvolvimento rápido e personalização. Entre as principais vantagens estão:

    • Facilidade de uso: as interfaces de linha de comandos e Python simplificam tarefas complexas.
    • Desempenho: otimizado para deteção de objetos em tempo real e várias aplicações de IA para 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 perfeitamente com frameworks e ferramentas populares do ecossistema de aprendizado de máquina.

    Descobre mais sobre as capacidades do YOLO na página principal do Ultralytics YOLO.

  • Sim, o DetectionTrainer é bastante flexível e pode ser personalizado para modelos fora do padrão. Herda de DetectionTrainer e sobrecarrega métodos para satisfazer as necessidades específicas do teu 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 e exemplos completos, consulta a referência de DetectionTrainer.

Colaboradores
GLglenn-jocher14RAraimbekovm2RIRizwanMunawar2

Comentários