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 possa fazer previsões precisas. O modo de treino no Ultralytics YOLO26 foi projetado para o treinamento eficaz e eficiente de modelos de detecção de objetos, utilizando plenamente as capacidades de hardware moderno. Este guia tem como objetivo cobrir todos os detalhes necessários para começares a treinar os teus próprios modelos usando o conjunto robusto de recursos do YOLO26. Se ainda não instalaste o Ultralytics, começa pelo Guia de início rápido.

Por que Escolher o Ultralytics YOLO para Treinamento?#

Aqui estão algumas razões convincentes para optar pelo modo Train do YOLO26:

• Eficiência: Aproveita ao máximo o teu hardware, estejas a usar uma configuração de GPU única ou a escalar através de múltiplas GPUs.
• Versatilidade: Treina 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, mas poderosas, para uma experiência de treinamento direta.
• Flexibilidade de Hiperparâmetros: Uma ampla gama de hiperparâmetros personalizáveis para afinar o desempenho do modelo. Para um controle mais profundo, podes personalizar o próprio treinador.
• Treinamento na Nuvem: Treina em GPUs na nuvem através da Ultralytics Platform com métricas em tempo real e salvamento automático de pontos de verificação (checkpointing).

Principais Funcionalidades do Modo Train#

As seguintes são algumas das funcionalidades notáveis do modo Train do YOLO26:

• Download Automático de Dataset: As configurações de dataset com uma origem de download são baixadas automaticamente no primeiro uso, por exemplo, yolo train data=coco8.yaml. Consulta a Visão geral de datasets para ver formatos e datasets suportados.
• Suporte a Múltiplas GPUs: Escala os teus esforços de treinamento perfeitamente através de 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#

Treina o YOLO26n no dataset COCO8 por 100 épocas 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á usada. Consulta a seção de Argumentos abaixo para obter 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 com Múltiplas GPUs#

O treinamento com múltiplas GPUs permite uma utilização mais eficiente dos recursos de hardware disponíveis ao distribuir a carga de treinamento por várias GPUs. Esta funcionalidade está disponível tanto através da API Python quanto da interface de linha de comando. Para ativar o treinamento com múltiplas GPUs, especifica os IDs dos dispositivos GPU que desejas 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

O treinamento em GPU AMD utiliza uma compilação ROCm do PyTorch com a sintaxe padrão device=0 ou device=cuda:0. Consulta o Guia de integração AMD para ver a instalação e o status atual de suporte ao MIGraphX, DirectML e Ryzen AI NPU.

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

Treino em NPU Huawei Ascend#

O Ultralytics suporta treinamento e validação em NPUs Huawei Ascend através de torch_npu. Instala versões mutuamente compatíveis do CANN, PyTorch e torch_npu seguindo o Guia de instalação do Ascend Extension for PyTorch, e depois carrega 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")

# Train on one Ascend NPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Train across two Ascend NPUs with HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Os recursos de treinamento padrão, incluindo AMP, validação, criação de pontos de verificação (checkpointing) e retomada, utilizam 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 através do HCCL. Consulta o Guia de integração Huawei Ascend para exportação e implantação de modelos após o treinamento.

Treinamento em GPU Ociosa#

O Treinamento em GPU Ociosa permite a seleção automática das GPUs menos utilizadas em sistemas com múltiplas GPUs, otimizando o uso de recursos sem seleção manual de GPU. Esta funcionalidade 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 percentagens de utilização atual
2. Maior memória disponível (VRAM livre)
3. Menor temperatura e consumo de energia

Esta funcionalidade é especialmente valiosa em ambientes de computação partilhada ou ao executar múltiplos trabalhos de treinamento em diferentes modelos. Ela adapta-se automaticamente a condições variáveis 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 os teus 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 ativar o treinamento em chips Apple silicon, deves especificar 'mps' como o teu dispositivo ao iniciar o processo de treinamento. Abaixo está um exemplo de como podes fazer isto 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, isto permite um processamento mais eficiente das tarefas de treinamento. Para orientações mais detalhadas e opções de configuração avançadas, consulta a documentação do PyTorch MPS.

Retomar Treinamentos Interrompidos#

Retomar o treinamento a partir de um estado salvo anteriormente é uma funcionalidade crucial ao trabalhar com modelos de deep learning. Isto pode ser útil em várias situações, como quando o processo de treinamento foi interrompido inesperadamente, ou quando desejas continuar a treinar 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. Isto permite-te continuar o processo de treinamento de forma integrada a partir de onde parou.

Podes 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, utilizando 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.

Lembra-te de que os pontos de verificação são salvos no final de cada época por predefinição, ou em intervalos fixos usando o argumento save_period, por isso deves concluir pelo menos 1 época para retomar uma execução de treinamento.

Configurações de Treinamento#

As configurações de treinamento para 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. As principais configurações de treinamento incluem o tamanho do lote (batch size), a taxa de aprendizado, o momentum e a decaimento de peso (weight decay). Além disso, a escolha do otimizador, da função de perda e da composição do dataset de treinamento pode afetar o processo de treinamento. 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 ao estilo Muon.

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

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

Quando optimizer=auto é utilizado, 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 recorre ao AdamW.

Exemplo de uso:

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

Consulta a implementação em ultralytics/optim/muon.py e a lógica de seleção automática de otimizador em BaseTrainer.build_optimizer.

Configurações de Aumentação e Hiperparâmetros#

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

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

Registro (Logging)#

Ao treinar um modelo YOLO26, podes achar útil acompanhar o desempenho do modelo ao longo do tempo. É aqui que entram os registos (logging). O Ultralytics YOLO oferece suporte a três tipos de registadores (loggers) - Comet, ClearML e TensorBoard.

Para usar um logger, selecione-o no menu suspenso no trecho 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 programadores rastrear, comparar, explicar e otimizar experimentos e modelos. Ele fornece 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 na partilha eficiente de recursos. Foi concebida para ajudar 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, você precisará entrar na sua conta ClearML no navegador e autenticar sua sessão.

TensorBoard#

TensorBoard é um kit de ferramentas de visualização para o TensorFlow. Permite-te visualizar o teu grafo do TensorFlow, traçar 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

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

Após configurar seu logger, você pode prosseguir com o treinamento do seu modelo. Todas as métricas de treinamento 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.

O que vem a seguir#

Valida o teu modelo treinado contra dados reservados para verificar a sua precisão no mundo real, depois exporta-o para ONNX, TensorRT ou outro formato de implantação. Vais treinar com os teus próprios dados em vez de COCO8? Formata-os primeiro com o Guia de Datasets.

FAQ#