Treinamento de Modelos com o 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 de treinamento no Ultralytics YOLO26 foi projetado para um 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 que você precisa para 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 de treinamento 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 próprio treinador.
• Treinamento na 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 de Treinamento

Os seguintes são alguns recursos notáveis do modo de treinamento 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 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 CLI.
• Visualização e Monitoramento: Rastreamento em tempo real das 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 dos 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 ao distribuir a carga de treinamento entre várias GPUs. Esse 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 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 em GPU Ociosa

O Treinamento em GPU Ociosa permite a seleção automática das GPUs menos utilizadas em sistemas multi-GPU, otimizando o uso de recursos sem a seleção manual da GPU. Esse 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 seleção automática prioriza GPUs com:

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

Esse recurso é especialmente valioso em ambientes de computação compartilhados ou ao executar múltiplos 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 MPS no Apple Silicon

Com o suporte para chips Apple Silicon integrado nos modelos Ultralytics YOLO, agora é possível treinar seus modelos em dispositivos que utilizam o poderoso framework 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 Apple Silicon, 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 Apple Silicon, 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 a partir 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 epochs.

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 epoch. 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 epoch por padrão, ou em intervalos fixos usando o argumento save_period, portanto, você deve concluir pelo menos 1 epoch 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 (batch size), taxa de aprendizado, momentum e decaimento de peso (weight decay). Além disso, a escolha do otimizador, da função de perda e a composição do conjunto de dados de treinamento podem impactar o processo. O ajuste cuidadoso e a experimentação com essas configurações são cruciais para otimizar o desempenho.

Otimizador MuSGD

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

Ele é recomendado para execuções de treinamento mais longas do YOLO26 e conjuntos de dados maiores, onde as 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 o SGD, enquanto parâmetros de menor dimensão, como camadas de normalização em lote e termos de viés (bias), permanecem no SGD padrão.

Quando optimizer=auto é usado, o Ultralytics seleciona automaticamente o MuSGD para execuções de treinamento mais longas (tipicamente quando as 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 seleção automática 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 mãos. Experimentar com valores diferentes pode ajudar a encontrar a estratégia de aumento ideal que leva ao melhor desempenho do modelo.

Registro (Logging)

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

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

Comet

Comet é uma plataforma que permite que cientistas de dados e desenvolvedores rastreiem, comparem, expliquem e otimizem experimentos e modelos. Ele fornece funcionalidades como métricas em tempo real, diferenças de código (code diffs) e rastreamento de hiperparâmetros.

Para usar o Comet:

# pip install comet_ml
import comet_ml

comet_ml.init()

Lembra-te de iniciar sessão na tua conta Comet no site deles e obter a tua chave API. Precisarás de adicioná-la às tuas variáveis de ambiente ou ao teu script para registar as tuas experiências.

ClearML

ClearML é uma plataforma de código aberto que automatiza o rastreamento de experiências e ajuda na partilha eficiente de recursos. Foi concebida para ajudar as equipas a gerir, executar e reproduzir o 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, precisarás de iniciar sessão na tua conta ClearML no navegador e autenticar a tua sessão.

TensorBoard

TensorBoard é um kit de ferramentas de visualização para TensorFlow. Permite visualizar o teu grafo do TensorFlow, plotar métricas quantitativas sobre a execução do teu grafo e mostrar 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, executa o comando abaixo e visualiza os resultados em localhost:6006.

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

Isto carregará o TensorBoard e direcioná-lo-á para o diretório onde os teus registos de treino estão guardados.

Após configurar o teu logger, podes prosseguir com o treino do teu modelo. Todas as métricas de treino serão registadas automaticamente na plataforma escolhida, e podes aceder a estes registos para monitorizar o desempenho do teu modelo ao longo do tempo, comparar diferentes modelos e identificar áreas de melhoria.

FAQ

Posso treinar sem uma GPU local?

Sim. A Ultralytics Platform suporta treino na nuvem com créditos gratuitos para começares. Carrega o teu conjunto de dados, seleciona um modelo e uma GPU, e treina diretamente a partir do navegador. Vê o guia de treino na nuvem para detalhes.

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

Para treinar um modelo de deteção de objetos usando Ultralytics YOLO26, podes usar a API de Python ou a CLI. Abaixo encontras 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, consulta a secção Definições de Treino.

Quais são as principais funcionalidades do modo de Treino do Ultralytics YOLO26?

As principais funcionalidades do modo de Treino do Ultralytics YOLO26 incluem:

• Transferência Automática de Conjuntos de Dados: Transfere automaticamente conjuntos de dados padrão como COCO, VOC e ImageNet.
• Suporte Multi-GPU: Escala o treino através de múltiplas GPUs para um processamento mais rápido.
• Configuração de Hiperparâmetros: Personaliza hiperparâmetros através de ficheiros YAML ou argumentos da CLI.
• Visualização e Monitorização: Rastreamento em tempo real de métricas de treino para melhores insights.

Estas funcionalidades tornam o treino eficiente e personalizável para as tuas necessidades. Para mais detalhes, vê a secção Principais Funcionalidades do Modo de Treino.

Como retomo o treino a partir de uma sessão interrompida no Ultralytics YOLO26?

Para retomar o treino a partir de uma sessão interrompida, define o argumento resume como True e especifica o caminho para o último checkpoint guardado.

from ultralytics import YOLO

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

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

Consulta a secção sobre Retomar Treinos Interrompidos para mais informações.

Como treino um modelo num conjunto de dados desequilibrado?

O desequilíbrio de classes ocorre quando algumas classes têm significativamente menos exemplos do que outras nos teus dados de treino. Isto pode fazer com que o modelo tenha um desempenho fraco em classes raras. O Ultralytics YOLO suporta a ponderação de classes através do argumento cls_pw para resolver este problema.

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

• cls_pw=0.0 (padrão): Desativa a ponderação de classes
• cls_pw=1.0: Aplica uma ponderação de frequência inversa total
• Valores entre 0.0 e 1.0: Fornecem ponderação parcial para desequilíbrios moderados

Os pesos das classes são calculados como (1.0 / class_counts) ^ cls_pw e normalizados para que a sua média seja igual a 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 o treino em chips Apple silicon utilizando a estrutura Metal Performance Shaders (MPS). Especifica 'mps' como o teu 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, consulta a secção Treino MPS em Apple Silicon.

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

O Ultralytics YOLO26 permite configurar uma variedade de definições de treino, tais como tamanho do lote, taxa de aprendizagem, épocas e mais, através de argumentos. Aqui tens uma breve visão geral:

Para um guia aprofundado sobre definições de treino, consulta a secção Definições de Treino.