Link to this sectionTreinamento de Modelo com Ultralytics YOLO#

Link to this sectionIntrodução#

O treinamento de um modelo de deep learning envolve fornecer dados e ajustar seus parâmetros para que ele possa fazer previsões precisas. O modo Train no Ultralytics YOLO26 foi desenvolvido para o treinamento eficaz e eficiente de modelos de detecção de objetos, utilizando plenamente os recursos de hardware modernos. Este guia visa cobrir todos os detalhes de que precisas para começar a treinar os teus próprios modelos usando o robusto conjunto de funcionalidades do YOLO26.

Link to this sectionPor 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 ajustar o desempenho do modelo. Para um controlo mais aprofundado, podes personalizar o treinador diretamente.
• Treinamento em Nuvem: Treina em GPUs na nuvem através da Ultralytics Platform com métricas em tempo real e verificação automática de pontos de controlo (checkpointing).

Link to this sectionPrincipais Funcionalidades do Modo Train#

As seguintes são algumas das funcionalidades 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 na primeira utilização.
• 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.

Link to this sectionExemplos de uso#

Treina 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, o GPU device=0 será usado quando disponível; caso contrário, device='cpu' será usado. Consulta 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)

Link to this sectionTreinamento 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

Link to this sectionTreinamento 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.

Link to this sectionTreinamento 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 obter orientações mais detalhadas e opções de configuração avançadas, por favor, consulta a documentação do PyTorch MPS.

Link to this sectionRetomar 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 learning rate e o número da época. Isto permite-te continuar o processo de treinamento sem problemas a partir de onde foi deixado.

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 que contém 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.

Lembra-te de que os checkpoints são salvos no final de cada época por padrão, ou em intervalos fixos usando o argumento save_period, portanto deves completar pelo menos 1 época para retomar um treinamento.

Link to this sectionConfigurações de Treinamento#

As configurações de treinamento para modelos YOLO abrangem vários hiperparâmetros e configurações usadas durante o processo de treinamento. Estas configurações influenciam o desempenho, a velocidade e a accuracy do modelo. As principais configurações de treinamento incluem tamanho do lote (batch size), taxa de aprendizado (learning rate), momento e decaimento de peso (weight decay). Além disso, a escolha do otimizador, da loss function e da composição do conjunto de dados de treinamento pode impactar o processo. O ajuste cuidadoso e a experimentação com essas configurações são cruciais para otimizar o desempenho.

Link to this sectionOtimizador 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 parâmetros com param.ndim >= 2 (como pesos convolucionais) recebem a atualização ao estilo Muon juntamente com o SGD, enquanto parâmetros de menor dimensão, como camadas de normalização de lote e termos de 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 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 auto-seleção de otimizador em BaseTrainer.build_optimizer.

Link to this sectionConfigurações de Aumentação e Hiperparâmetros#

Técnicas de aumentação 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 aumentação:

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.

Link to this sectionRegistro (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 ação. 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 trecho de código acima e execute-o. O logger escolhido será instalado e inicializado.

Link to this sectionComet#

Comet é uma plataforma que permite a cientistas de dados e desenvolvedores rastrear, comparar, explicar e otimizar experimentos e modelos. Ele 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.

Link to this sectionClearML#

ClearML é uma plataforma de código aberto que automatiza o rastreamento de experimentos e ajuda no compartilhamento eficiente de recursos. Ela é 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.

Link to this sectionTensorBoard#

TensorBoard é um kit de ferramentas de visualização para TensorFlow. Ele permite visualizar seu grafo do TensorFlow, plotar métricas quantitativas sobre a execução do seu grafo e exibir 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 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.

Link to this sectionFAQ#

Link to this sectionPosso treinar sem uma GPU local?#

Sim. A Plataforma Ultralytics suporta treinamento na nuvem com créditos gratuitos para você começar. Carregue seu conjunto de dados, selecione um modelo e uma GPU e treine diretamente pelo navegador. Veja o guia de treinamento na nuvem para detalhes.

Link to this sectionComo 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 Treinamento.

Link to this sectionQuais são os principais recursos do modo de Treinamento do Ultralytics YOLO26?#

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

• Download Automático de Conjuntos de Dados: Baixa automaticamente conjuntos de dados padrão como COCO, VOC e ImageNet.
• Suporte a Multi-GPU: Escala o treinamento em múltiplas GPUs para processamento mais rápido.
• Configuração de Hiperparâmetros: Personalize hiperparâmetros por meio de arquivos YAML ou argumentos da CLI.
• Visualização e Monitoramento: Rastreamento em tempo real de métricas de treinamento para melhores insights.

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

Link to this sectionComo retomo o treinamento de uma sessão interrompida no Ultralytics YOLO26?#

Para retomar o treinamento 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)

Verifique a seção sobre Retomando Treinamentos Interrompidos para mais informações.

Link to this sectionComo 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 treinamento. Isso pode fazer com que o modelo tenha um desempenho ruim em classes raras. O Ultralytics YOLO suporta ponderação de classes por meio do argumento cls_pw para resolver esse 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 ponderação de frequência inversa total
• 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)

Link to this sectionPosso treinar modelos YOLO26 em chips de silício da Apple?#

Sim, o Ultralytics YOLO26 suporta treinamento em chips de silício da Apple utilizando o framework Metal Performance Shaders (MPS). Especifique 'mps' como seu dispositivo de treinamento.

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 Treinamento MPS em Apple Silicon.

Link to this sectionQuais são as configurações comuns de treinamento e como as configuro?#

O Ultralytics YOLO26 permite que você configure uma variedade de definições de treinamento, como tamanho do lote, taxa de aprendizado, épocas e mais, por meio de argumentos. Aqui está uma breve visão geral:

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