Treinamento de modelos com o Ultralytics YOLO#

Introdução#

Treinar um modelo de aprendizado profundo envolve fornecer dados e ajustar os parâmetros para que ele possa fazer previsões precisas. O modo de treinamento do Ultralytics YOLO26 foi desenvolvido para treinar modelos de detecção de objetos de forma eficaz e eficiente, aproveitando ao máximo os recursos do hardware moderno. Este guia aborda todos os detalhes necessários para começar a treinar seus próprios modelos usando o conjunto robusto de recursos do YOLO26. Se você ainda não instalou o Ultralytics, comece pelo Guia de início rápido.

Confira a prévia inédita do YOLO27 para ver exemplos de treinamento planejados.

Por que escolher o Ultralytics YOLO para treinamento?#

Aqui estão alguns bons motivos para escolher o modo de treinamento do YOLO26:

• Eficiência: Aproveite ao máximo seu hardware, seja em uma configuração com uma única GPU ou em uma escala que utilize várias GPUs.
• Versatilidade: Treine com conjuntos de dados personalizados, além dos disponíveis, como COCO, VOC e ImageNet.
• Facilidade de uso: Interfaces simples, mas poderosas, de CLI e Python para uma experiência de treinamento descomplicada.
• Flexibilidade de hiperparâmetros: Uma ampla variedade de hiperparâmetros personalizáveis para ajustar o desempenho do modelo. Para ter mais controle, você pode personalizar o treinador.
• Treinamento na nuvem: Treine em GPUs na nuvem pela plataforma Ultralytics, com métricas em tempo real e salvamento automático de checkpoints.

Principais recursos do modo de treinamento#

Veja a seguir alguns recursos importantes do modo de treinamento do YOLO26:

• Download automático de conjuntos de dados: As configurações de conjuntos de dados que incluem uma fonte de download são baixadas automaticamente no primeiro uso, por exemplo, yolo train data=coco8.yaml. Consulte a Visão geral dos conjuntos de dados para conhecer os formatos e conjuntos de dados compatíveis.
• Suporte a várias GPUs: Amplie facilmente o treinamento para várias GPUs e acelere o processo.
• Configuração de hiperparâmetros: É possível modificar os hiperparâmetros por meio de arquivos de configuração YAML ou argumentos da CLI.
• Visualização e monitoramento: Acompanhe as métricas de treinamento em tempo real e visualize o processo de aprendizado para obter melhores insights.

Exemplos de uso#

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

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n.yaml")  # crie um novo modelo a partir de YAML
model = YOLO("yolo26n.pt")  # carregue um modelo pré-treinado (recomendado para treinamento)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # crie a partir de YAML e transfira os pesos

# Treinar o modelo
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

Treinamento com várias GPUs#

O treinamento com várias GPUs permite utilizar os recursos de hardware disponíveis com mais eficiência, distribuindo a carga de treinamento entre várias GPUs. Esse recurso está disponível tanto pela API Python quanto pela interface de linha de comando. Para ativar o treinamento com várias GPUs, especifique os IDs dos dispositivos GPU que deseja usar.

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n.pt")  # carregue um modelo pré-treinado (recomendado para treinamento)

# Treine o modelo com duas GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Treine o modelo com as duas GPUs mais ociosas
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

O treinamento em GPU AMD usa uma versão do PyTorch com ROCm e a sintaxe padrão device=0 ou device=cuda:0. Consulte o guia de integração com AMD para obter informações sobre a instalação do ROCm, treinamento com várias GPUs, observações sobre AMP e inferência do MIGraphX com modelos exportados.

O treinamento em GPU Intel usa device=xpu:0 ou vários IDs XPU com uma versão do PyTorch que fornece XCCL.

Treinamento em NPU Huawei Ascend#

O Ultralytics oferece suporte ao treinamento e à validação em NPUs Huawei Ascend por meio de torch_npu. Instale versões compatíveis entre si do CANN, PyTorch e torch_npu seguindo o guia de instalação da extensão Ascend para PyTorch e, em seguida, carregue o ambiente CANN antes de iniciar o Ultralytics:

source /usr/local/Ascend/ascend-toolkit/set_env.sh

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Treine em uma NPU Ascend
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Treine em duas NPUs Ascend com HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Os recursos padrão de treinamento, incluindo AMP, validação, salvamento de checkpoints e retomada, usam a NPU ativa. O AutoBatch está disponível para treinamento com uma única NPU, enquanto vários IDs de NPU iniciam o treinamento distribuído por meio do HCCL. Consulte o guia de integração com Huawei Ascend para saber como exportar e implantar modelos após o treinamento.

Treinamento em GPU ociosa#

O treinamento em GPU ociosa seleciona automaticamente as GPUs menos utilizadas em sistemas com várias GPUs, otimizando o uso de recursos sem exigir a seleção manual de uma GPU. Esse recurso identifica as GPUs disponíveis com base nas métricas de utilização e na disponibilidade de VRAM.

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n.pt")  # carregue um modelo pré-treinado (recomendado para treinamento)

# Treine usando a GPU mais ociosa
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Treine usando as duas GPUs mais ociosas
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

O algoritmo de seleção automática prioriza GPUs com:

1. Percentuais de utilização atuais mais baixos
2. Mais memória disponível (VRAM livre)

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

Treinamento com MPS no Apple Silicon#

Com a integração do suporte aos chips Apple silicon nos 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 para executar cálculos e tarefas de processamento de imagem nos chips personalizados da Apple.

Para ativar o treinamento em chips Apple silicon, especifique 'mps' como dispositivo ao iniciar o processo de treinamento. Veja a seguir um exemplo de como fazer isso em Python e pela linha de comando:

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n.pt")  # carregue um modelo pré-treinado (recomendado para treinamento)

# Treine o modelo com MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

Ao aproveitar a capacidade computacional dos chips Apple silicon, isso permite processar as tarefas de treinamento com mais eficiência. Para orientações mais detalhadas e opções avançadas de configuração, consulte a documentação do PyTorch MPS.

Retomada de treinamentos interrompidos#

Retomar o treinamento a partir de um estado salvo anteriormente é um recurso essencial ao trabalhar com modelos de aprendizado profundo. Isso pode ser útil em vários cenários, como quando o processo de treinamento é 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 da taxa de aprendizado, o número da época e o conjunto de dados. Isso permite continuar o processo de treinamento sem interrupções, a partir do ponto em que foi interrompido. Passe um data= explícito junto com resume para continuar com outro conjunto de dados, em vez do conjunto de dados do checkpoint.

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 do arquivo .pt que contém os pesos do modelo parcialmente treinado.

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

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("path/to/last.pt")  # carregar um modelo parcialmente treinado

# Retomar o treinamento
results = model.train(resume=True)

Ao definir resume=True, a função train continuará o treinamento do ponto em que foi interrompido, 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, por padrão, os checkpoints são salvos ao final de cada época, ou em intervalos fixos usando o argumento save_period; portanto, você precisa concluir pelo menos 1 época para retomar uma execução de treinamento.

Configurações de treino#

As configurações de treinamento dos modelos YOLO abrangem vários hiperparâmetros e configurações usados durante o processo de treinamento. Essas configurações influenciam o desempenho, a velocidade e a precisão do modelo. Entre as principais configurações de treinamento estão o tamanho do lote, a taxa de aprendizado, o momentum e a regularização dos pesos. Além disso, a escolha do otimizador, da função de perda e da composição do conjunto de dados de treinamento pode afetar o processo de treinamento. O ajuste cuidadoso e a experimentação com essas configurações são essenciais 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 no estilo Muon.

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

Somente os pesos lineares 2D e os filtros convolucionais 4D (remodelados para 2D) recebem a atualização no estilo Muon junto com SGD; todos os outros parâmetros, como os pesos de normalização em lote e os termos de viés, permanecem com o SGD padrão.

Quando optimizer=auto é usado, o Ultralytics seleciona automaticamente MuSGD para execuções de treinamento mais longas (normalmente quando as iterações > 10000). Para execuções mais curtas, o treinador usa AdamW. No modo auto, o treinador também seleciona a taxa de aprendizado, portanto um lr0 fornecido pelo usuário é ignorado. Para controlar essas configurações manualmente, selecione um otimizador explicitamente, por exemplo, optimizer=AdamW lr0=0.001.

Exemplo de uso:

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

Confira 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 de dados e hiperparâmetros#

As técnicas de aumento de dados são essenciais para melhorar a robustez e o desempenho dos modelos YOLO, pois introduzem variabilidade nos dados de treinamento e ajudam o modelo a generalizar melhor para dados não vistos. A tabela a seguir apresenta a finalidade e o efeito de cada argumento de aumento de dados:

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

Registro de dados#

As métricas de treinamento, os gráficos e os checkpoints são sempre gravados no diretório da execução, e o Ultralytics também os transmite a qualquer rastreador de experimentos que você tenha instalado e ativado: Comet, ClearML, TensorBoard, MLflow, Weights & Biases e DVCLive. Cada registrador pode ser ativado ou desativado nas configurações do Ultralytics, por exemplo, com yolo settings tensorboard=True. As três configurações mais comuns são mostradas abaixo.

Comet#

Comet é uma plataforma que permite a cientistas de dados e desenvolvedores acompanhar, comparar, explicar e otimizar experimentos e modelos. A plataforma oferece recursos como métricas em tempo real, diferenças no código e acompanhamento de hiperparâmetros.

Para usar o Comet:

# pip install comet_ml
import comet_ml

comet_ml.login()

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

ClearML#

ClearML é uma plataforma de código aberto que automatiza o acompanhamento de experimentos e ajuda a compartilhar recursos com eficiência. Ela foi projetada para ajudar as equipes a gerenciar, executar e reproduzir seu trabalho de ML com mais eficiência.

Para usar o ClearML:

# pip install clearml
import clearml

clearml.browser_login()

Depois de executar este script, você precisará entrar na sua conta do ClearML pelo navegador e autenticar sua sessão.

TensorBoard#

TensorBoard é um conjunto de ferramentas de visualização para TensorFlow. Ele permite visualizar o grafo do TensorFlow, gerar gráficos de métricas quantitativas sobre a execução do grafo e exibir dados adicionais, como as 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 consulte os resultados em localhost:6006.

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

Isso carregará o TensorBoard e o direcionará ao diretório onde os registros do treinamento estão salvos.

Depois de configurar o registrador, você pode iniciar o treinamento do modelo. Todas as métricas de treinamento serão registradas automaticamente na plataforma escolhida, e você poderá acessar esses registros para acompanhar o desempenho do modelo ao longo do tempo, comparar diferentes modelos e identificar áreas que podem ser aprimoradas.

O que fazer a seguir#

Valide seu modelo treinado com dados separados para verificar sua precisão no mundo real e, em seguida, exporte o modelo para ONNX, TensorRT ou outro formato de implantação. Vai treinar com seus próprios dados em vez do COCO8? Formate-os primeiro usando o guia de conjuntos de dados.

Perguntas frequentes#