Treinamento de Modelo com Ultralytics YOLO

Introdução

Treinar um modelo de deep learning envolve fornecer dados a ele e ajustar seus parâmetros para que ele possa fazer previsões precisas. O modo Train no Ultralytics YOLO26 foi projetado para o treinamento eficaz e eficiente de modelos de detecção de objetos, utilizando totalmente as capacidades do hardware moderno. Este guia visa cobrir todos os detalhes necessários para você começar a treinar seus próprios modelos usando o robusto conjunto de recursos do YOLO26.

Por que escolher o Ultralytics YOLO para treinamento?

Aqui estão alguns motivos convincentes para optar pelo modo Train do YOLO26:

• Eficiência: Aproveite ao máximo seu hardware, esteja você em uma configuração de GPU única ou escalando em múltiplas GPUs.
• Versatilidade: Treine em conjuntos de dados personalizados, além daqueles prontamente disponíveis como COCO, VOC e ImageNet.
• Fácil de usar: Interfaces CLI e Python simples, porém poderosas, para uma experiência de treinamento direta.
• Flexibilidade de Hiperparâmetros: Uma ampla gama de hiperparâmetros personalizáveis para ajustar o desempenho do modelo. Para um controle mais profundo, você pode personalizar o treinador por conta própria.
• Treinamento em Nuvem: Treine em GPUs na nuvem através da Ultralytics Platform com métricas em tempo real e criação automática de checkpoints.

Principais Recursos do Modo Train

Os itens a seguir são alguns recursos notáveis do modo Train do YOLO26:

• Download Automático de Conjunto de Dados: Conjuntos de dados padrão como COCO, VOC e ImageNet são baixados automaticamente no primeiro uso.
• Suporte a Multi-GPU: Escale seus esforços de treinamento perfeitamente em várias GPUs para acelerar o processo.
• Configuração de Hiperparâmetros: A opção de modificar hiperparâmetros através de arquivos de configuração YAML ou argumentos de CLI.
• Visualização e Monitoramento: Rastreamento em tempo real de métricas de treinamento e visualização do processo de aprendizado para melhores insights.

Exemplos de Uso

Treine o YOLO26n no conjunto de dados COCO8 por 100 epochs com tamanho de imagem 640. O dispositivo de treinamento pode ser especificado usando o argumento device. Se nenhum argumento for passado, a GPU device=0 será usada quando disponível; caso contrário, device='cpu' será usado. Consulte a seção de Argumentos abaixo para uma lista completa de argumentos de treinamento.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.yaml")  # build a new model from YAML
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Treinamento Multi-GPU

O treinamento Multi-GPU permite uma utilização mais eficiente dos recursos de hardware disponíveis, distribuindo a carga de treinamento em várias GPUs. Este recurso está disponível tanto através da API Python quanto da interface de linha de comando. Para habilitar o treinamento multi-GPU, especifique os IDs dos dispositivos de GPU que você deseja usar.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with 2 GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Train the model with the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

python -m torch.distributed.run --nproc_per_node 2 your_training_script.py

Treinamento com GPU Ociosa

O Treinamento com GPU Ociosa permite a seleção automática das GPUs menos utilizadas em sistemas multi-GPU, otimizando o uso de recursos sem seleção manual da GPU. Este recurso identifica as GPUs disponíveis com base em métricas de utilização e disponibilidade de VRAM.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train using the single most idle GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Train using the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

O algoritmo de auto-seleção prioriza GPUs com:

1. Menores percentuais de utilização atual
2. Maior memória disponível (VRAM livre)
3. Menor temperatura e consumo de energia

Este recurso é especialmente valioso em ambientes de computação compartilhados ou ao executar vários trabalhos de treinamento em diferentes modelos. Ele se adapta automaticamente às mudanças nas condições do sistema, garantindo a alocação ideal de recursos sem intervenção manual.

Treinamento Apple Silicon MPS

Com o suporte para chips de silício da Apple integrado aos modelos Ultralytics YOLO, agora é possível treinar seus modelos em dispositivos que utilizam a poderosa estrutura Metal Performance Shaders (MPS). O MPS oferece uma maneira de alto desempenho de executar tarefas de computação e processamento de imagem no silício personalizado da Apple.

Para habilitar o treinamento em chips de silício da Apple, você deve especificar 'mps' como seu dispositivo ao iniciar o processo de treinamento. Abaixo está um exemplo de como você pode fazer isso em Python e via linha de comando:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Ao aproveitar o poder computacional dos chips de silício da Apple, isso permite um processamento mais eficiente das tarefas de treinamento. Para orientações mais detalhadas e opções de configuração avançadas, consulte a documentação do PyTorch MPS.

Retomando Treinamentos Interrompidos

Retomar o treinamento de um estado salvo anteriormente é um recurso crucial ao trabalhar com modelos de deep learning. Isso pode ser útil em vários cenários, como quando o processo de treinamento foi interrompido inesperadamente, ou quando você deseja continuar treinando um modelo com novos dados ou por mais épocas.

Quando o treinamento é retomado, o Ultralytics YOLO carrega os pesos do último modelo salvo e também restaura o estado do otimizador, o agendador de taxa de aprendizado e o número da época. Isso permite que você continue o processo de treinamento perfeitamente de onde parou.

Você pode retomar facilmente o treinamento no Ultralytics YOLO definindo o argumento resume como True ao chamar o método train e especificando o caminho para o arquivo .pt contendo os pesos do modelo parcialmente treinado.

Abaixo está um exemplo de como retomar um treinamento interrompido usando Python e via linha de comando:

from ultralytics import YOLO

# Load a model
model = YOLO("path/to/last.pt")  # load a partially trained model

# Resume training
results = model.train(resume=True)

Ao definir resume=True, a função train continuará o treinamento de onde parou, usando o estado armazenado no arquivo 'path/to/last.pt'. Se o argumento resume for omitido ou definido como False, a função train iniciará uma nova sessão de treinamento.

Lembre-se de que os checkpoints são salvos no final de cada época por padrão, ou em intervalos fixos usando o argumento save_period, então você deve completar pelo menos 1 época para retomar uma execução de treinamento.

Definições de Treino

As configurações de treinamento para modelos YOLO abrangem vários hiperparâmetros e configurações usadas durante o processo de treinamento. Essas configurações influenciam o desempenho, a velocidade e a precisão do modelo. As principais configurações de treinamento incluem tamanho do lote, taxa de aprendizado, momentum e decaimento de peso. Além disso, a escolha do otimizador, função de perda e a composição do conjunto de dados de treinamento podem afetar o processo de treinamento. Ajustes cuidadosos e experimentação com essas configurações são cruciais para otimizar o desempenho.

Otimizador MuSGD

No YOLO26, MuSGD é um otimizador híbrido que combina atualizações padrão de SGD com atualizações ortogonalizadas estilo Muon.

É recomendado para execuções de treinamento mais longas do YOLO26 e conjuntos de dados maiores, onde atualizações Muon ortogonalizadas podem ajudar a estabilizar a otimização.

Apenas parâmetros com param.ndim >= 2 (como pesos convolucionais) recebem a atualização estilo Muon junto com SGD, enquanto parâmetros de menor dimensão, como camadas de normalização de lote e termos de viés, permanecem no SGD padrão.

Quando optimizer=auto é usado, o Ultralytics seleciona automaticamente o MuSGD para execuções de treinamento mais longas (normalmente quando iterações > 10000). Para execuções mais curtas, o treinador volta para o AdamW.

Exemplo de uso:

yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGD

Veja a implementação em ultralytics/optim/muon.py e a lógica de auto-seleção do otimizador em BaseTrainer.build_optimizer.

Configurações de Aumento e Hiperparâmetros

As técnicas de aumento são essenciais para melhorar a robustez e o desempenho dos modelos YOLO, introduzindo variabilidade nos dados de treinamento, ajudando o modelo a generalizar melhor para dados não vistos. A tabela a seguir descreve o propósito e o efeito de cada argumento de aumento:

Essas configurações podem ser ajustadas para atender aos requisitos específicos do conjunto de dados e da tarefa em questão. Experimentar com valores diferentes pode ajudar a encontrar a estratégia de aumento ideal que leva ao melhor desempenho do modelo.

Logging

Ao treinar um modelo YOLO26, você pode achar valioso acompanhar o desempenho do modelo ao longo do tempo. É aqui que o registro (logging) entra em cena. O Ultralytics YOLO oferece suporte a três tipos de loggers - Comet, ClearML e TensorBoard.

Para usar um logger, selecione-o no menu suspenso no snippet de código acima e execute-o. O logger escolhido será instalado e inicializado.

Comet

Comet é uma plataforma que permite a cientistas de dados e desenvolvedores rastrear, comparar, explicar e otimizar experimentos e modelos. Ela oferece funcionalidades como métricas em tempo real, diffs de código e rastreamento de hiperparâmetros.

Para usar o Comet:

# pip install comet_ml
import comet_ml

comet_ml.init()

Lembre-se de entrar na sua conta Comet no site deles e obter sua chave de API. Você precisará adicioná-la às suas variáveis de ambiente ou ao seu script para registrar seus experimentos.

ClearML

ClearML é uma plataforma de código aberto que automatiza o rastreamento de experimentos e ajuda no compartilhamento eficiente de recursos. Ela foi projetada para ajudar equipes a gerenciar, executar e reproduzir seu trabalho de ML de forma mais eficiente.

Para usar o ClearML:

# pip install clearml
import clearml

clearml.browser_login()

Após executar este script, você precisará entrar na sua conta ClearML no navegador e autenticar sua sessão.

TensorBoard

TensorBoard é um kit de ferramentas de visualização para TensorFlow. Ele permite que você visualize seu grafo do TensorFlow, plote métricas quantitativas sobre a execução do seu grafo e mostre dados adicionais, como imagens que passam por ele.

Para usar o TensorBoard no Google Colab:

load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Para usar o TensorBoard localmente, execute o comando abaixo e veja os resultados em localhost:6006.

tensorboard --logdir ultralytics/runs # replace with 'runs' directory

Isso carregará o TensorBoard e o direcionará para o diretório onde seus logs de treino estão salvos.

Após configurar seu logger, você pode prosseguir com o treinamento do seu modelo. Todas as métricas de treino serão registradas automaticamente na plataforma escolhida, e você poderá acessar esses logs para monitorar o desempenho do seu modelo ao longo do tempo, comparar diferentes modelos e identificar áreas para melhoria.

Perguntas Frequentes

Posso treinar sem uma GPU local?

Sim. A Plataforma Ultralytics suporta treino na nuvem com créditos gratuitos para começar. Faça o upload do seu conjunto de dados, selecione um modelo e uma GPU e treine diretamente pelo navegador. Consulte o guia de treino na nuvem para mais detalhes.

Como treino um modelo de detecção de objetos usando o Ultralytics YOLO26?

Para treinar um modelo de detecção de objetos usando o Ultralytics YOLO26, você pode usar a API Python ou a CLI. Abaixo está um exemplo para ambos:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Para mais detalhes, consulte a seção Configurações de Treino.

Quais são os principais recursos do modo de Treino do Ultralytics YOLO26?

Os principais recursos do modo de Treino do Ultralytics YOLO26 incluem:

• Download Automático de Conjunto de Dados: Baixa automaticamente conjuntos de dados padrão como COCO, VOC e ImageNet.
• Suporte a Múltiplas GPUs: Escala o treino entre várias GPUs para processamento mais rápido.
• Configuração de Hiperparâmetros: Personalize hiperparâmetros através de arquivos YAML ou argumentos de CLI.
• Visualização e Monitoramento: Rastreamento em tempo real de métricas de treino para melhores insights.

Esses recursos tornam o treino eficiente e personalizável para suas necessidades. Para mais detalhes, consulte a seção Principais Recursos do Modo de Treino.

Como retomo um treinamento de uma sessão interrompida no Ultralytics YOLO26?

Para retomar o treino de uma sessão interrompida, defina o argumento resume como True e especifique o caminho para o último checkpoint salvo.

from ultralytics import YOLO

# Load the partially trained model
model = YOLO("path/to/last.pt")

# Resume training
results = model.train(resume=True)

Confira a seção sobre Retomada de Treinamentos Interrompidos para mais informações.

Como treino um modelo em um conjunto de dados desbalanceado?

O desbalanceamento de classes ocorre quando algumas classes têm significativamente menos exemplos do que outras nos seus dados de treino. Isso pode fazer com que o modelo tenha um desempenho ruim em classes raras. O Ultralytics YOLO suporta ponderação de classe através do argumento cls_pw para resolver esse problema.

O argumento cls_pw controla o poder de ponderação de classe com base na frequência inversa da classe:

• cls_pw=0.0 (padrão): Desativa a ponderação de classe
• cls_pw=1.0: Aplica ponderação completa de frequência inversa
• Valores entre 0.0 e 1.0: Fornecem ponderação parcial para desbalanceamento moderado

The class weights are computed as (1.0 / class_counts) ^ cls_pw and normalized so their mean equals 1.0.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.pt")

# Train with full class weighting for severely imbalanced data
results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0)

# Or use partial weighting (0.25) for moderate imbalance
results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)

Posso treinar modelos YOLO26 em chips Apple silicon?

Sim, o Ultralytics YOLO26 suporta treinamento em chips Apple silicon utilizando a estrutura Metal Performance Shaders (MPS). Especifique 'mps' como seu dispositivo de treino.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.pt")

# Train the model on Apple silicon chip (M1/M2/M3/M4)
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Para mais detalhes, consulte a seção Treino com Apple Silicon MPS.

Quais são as configurações comuns de treino e como as configuro?

O Ultralytics YOLO26 permite que você configure uma variedade de configurações de treino, como tamanho de lote, taxa de aprendizado, épocas e mais, através de argumentos. Aqui está uma breve visão geral:

Para um guia detalhado sobre as configurações de treino, confira a seção Configurações de Treino.