YOLO Vision 2026:

Personalização Avançada#

Tanto a interface de linha de comando do Ultralytics YOLO quanto a interface em Python 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.



Watch: Mastering Ultralytics YOLO: Advanced Customization
Dica

Para exemplos práticos de personalizações comuns de treinadores — métricas personalizadas, perda ponderada por classe, salvamento de modelos, congelamento de backbone e taxas de aprendizado por camada — consulta o guia Customizing Trainer.

BaseTrainer#

A classe BaseTrainer fornece uma rotina de treinamento genérica adaptável para várias tarefas. Personaliza-a substituindo funções ou operações específicas, mantendo a conformidade com 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): Constrói o modelo a ser treinado.
  • get_dataloader(): Constrói o carregador de dados.

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

DetectionTrainer#

Eis 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 não suportado diretamente, sobrepõe 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 para carregar 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 disparo de callbacks e pontos de entrada, consulta o Guia de Callbacks.

Outros Componentes do Motor#

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

Usando YOLO com Treinadores Personalizados#

A classe de modelo YOLO fornece um wrapper de alto nível para classes de Treinador. Podes aproveitar esta arquitetura para 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#

  • Personaliza o DetectionTrainer para tarefas específicas substituindo os seus métodos para adaptar ao teu modelo personalizado e carregador de dados. Começa herdando de DetectionTrainer e redefina 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 mais personalizações, como alterar a função de perda ou adicionar um callback, consulta o Guia de Callbacks.

  • O BaseTrainer serve como base para rotinas de treinamento, 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(): Lida com o pré-processamento de lotes antes da passagem direta do modelo.
    • set_model_attributes(): Define atributos do modelo com base nas informações do conjunto de dados.
    • get_validator(): Retorna um validador para avaliação do modelo.

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

  • Adiciona callbacks para monitorar e modificar o processo de treinamento em 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.

  • 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.

  • Sim, o DetectionTrainer é altamente flexível e personalizável para modelos não padronizados. Herda de DetectionTrainer e sobrepõe métodos para suportar as 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, revê a Referência DetectionTrainer.

Contribuidores
GLglenn-jocher13RAraimbekovm2RIRizwanMunawar2

Comentários