Práticas recomendadas e dicas de aprendizado de máquina para treinar modelos#

Introdução#

Uma das etapas mais importantes ao trabalhar em um projeto de visão computacional é o treinamento do modelo. Antes de chegar a esta etapa, você precisa definir seus objetivos e coletar e anotar seus dados. Depois de pré-processar os dados para garantir que estejam limpos e consistentes, você pode começar a treinar seu modelo.

O treinamento de modelos é o processo de ensinar seu modelo a reconhecer padrões visuais e fazer previsões com base nos seus dados, e influencia diretamente a precisão da sua aplicação. Este guia aborda práticas recomendadas, técnicas de otimização e dicas para solucionar problemas, ajudando você a treinar seus modelos de visão computacional com eficiência.

Como treinar um modelo de aprendizado de máquina#

Um modelo de visão computacional é treinado ajustando seus parâmetros internos para minimizar erros. Inicialmente, o modelo recebe um grande conjunto de imagens rotuladas. Ele faz previsões sobre o conteúdo dessas imagens, e as previsões são comparadas com os rótulos ou conteúdos reais para calcular os erros. Esses erros mostram o quanto as previsões do modelo se afastam dos valores verdadeiros.

Durante o treinamento, o modelo faz previsões de forma iterativa, calcula erros e atualiza seus parâmetros por meio de um processo chamado retropropagação. Nesse processo, o modelo ajusta seus parâmetros internos (pesos e vieses) para reduzir os erros. Ao repetir esse ciclo muitas vezes, o modelo melhora gradualmente sua precisão. Com o tempo, ele aprende a reconhecer padrões complexos, como formas, cores e texturas.

Esse processo de aprendizado permite que o modelo de visão computacional execute várias tarefas, incluindo detecção de objetos, segmentação de instâncias, segmentação semântica e classificação de imagens. O objetivo final é criar um modelo capaz de generalizar o que aprendeu para imagens novas e ainda não vistas, de modo que possa interpretar dados visuais com precisão em aplicações do mundo real.

Agora que sabemos o que acontece nos bastidores quando treinamos um modelo, vamos ver os pontos que devemos considerar ao treinar um modelo.

Treinamento com grandes conjuntos de dados#

Há alguns aspectos diferentes a considerar ao planejar o uso de um conjunto de dados grande para treinar um modelo. Por exemplo, você pode ajustar o tamanho do lote, controlar a utilização da GPU, optar pelo treinamento multiescala etc. Vamos analisar cada uma dessas opções em detalhes.

Tamanho do lote e utilização da GPU#

Ao treinar modelos com grandes conjuntos de dados, é essencial usar a GPU com eficiência. O tamanho do lote é um fator importante. Ele corresponde ao número de amostras de dados que um modelo de aprendizado de máquina processa em uma única iteração de treinamento. Usando o maior tamanho de lote compatível com sua GPU, você pode aproveitar ao máximo os recursos dela e reduzir o tempo de treinamento do modelo. No entanto, é importante evitar ficar sem memória da GPU. Se ocorrerem erros de memória, reduza o tamanho do lote gradualmente até que o modelo treine sem problemas.

Com YOLO26, você pode definir o parâmetro batch nos argumentos do modo de treinamento de acordo com a capacidade da sua GPU. Em um único acelerador, batch=-1 analisa o perfil do modelo e escolhe um tamanho de lote que visa aproximadamente 60% de utilização da memória; uma fração como batch=0.70 visa outra proporção. Execuções com várias GPUs exigem um tamanho global explícito de lote que seja múltiplo da quantidade de dispositivos. Em CPU e no silício da Apple, o AutoBatch emite um aviso e usa batch=16 como alternativa.

Treinamento com subconjuntos#

O treinamento com subconjuntos é uma estratégia eficaz que consiste em treinar seu modelo com um conjunto menor de dados que representa o conjunto de dados maior. Isso pode economizar tempo e recursos, especialmente durante o desenvolvimento e os testes iniciais do modelo. Se você estiver com pouco tempo ou experimentando diferentes configurações de modelo, o treinamento com subconjuntos é uma boa opção.

Com YOLO26, você pode implementar facilmente o treinamento com subconjuntos usando o parâmetro fraction. Use uma proporção como fraction=0.1 para selecionar 10% dos dados de treinamento, um número inteiro como fraction=300 para selecionar exatamente 300 imagens de treinamento ou uma lista [train, val, test], como fraction=[300, 100, 0], para limitar cada divisão e ignorar as imagens de teste. Listas com dois itens, como [300, 100], mantêm completa a divisão de teste. Os conjuntos de dados NDJSON selecionam registros igualmente espaçados antes de baixá-los, então execuções repetidas reutilizam exatamente o mesmo subconjunto. Essa técnica permite fazer iterações e ajustes rapidamente antes de usar o conjunto de dados completo.

Treinamento multiescala#

O treinamento multiescala é uma técnica que melhora a capacidade de generalização do modelo, treinando-o com imagens de tamanhos variados. Seu modelo pode aprender a detectar objetos em diferentes escalas e distâncias e se tornar mais robusto.

Por exemplo, ao treinar YOLO26, você pode ativar a aumentação de escala definindo o parâmetro scale. Esse parâmetro ajusta o tamanho das imagens de treinamento por um fator especificado, simulando objetos a diferentes distâncias. Por exemplo, definir scale=0.5 aplica aleatoriamente zoom às imagens de treinamento com um fator entre 0,5 e 1,5 durante o treinamento. Configurar esse parâmetro permite que seu modelo processe diferentes escalas de imagem e melhore sua capacidade de detecção em vários tamanhos e cenários de objetos.

A Ultralytics também oferece suporte ao treinamento multiescala com tamanho de imagem por meio do parâmetro multi_scale. Diferentemente de scale, que aplica zoom às imagens e depois adiciona preenchimento ou recorta de volta para imgsz, multi_scale altera o próprio imgsz a cada lote (arredondado para o stride do modelo). Por exemplo, com imgsz=640 e multi_scale=0.25, o tamanho de treinamento é selecionado entre 480 e 800 em intervalos de stride (por exemplo, 480, 512, 544, ..., 800), enquanto multi_scale=0.0 mantém um tamanho fixo.

Armazenamento em cache#

O armazenamento em cache é uma técnica importante para melhorar a eficiência do treinamento de modelos de aprendizado de máquina. Ao armazenar imagens pré-processadas na memória, o cache reduz o tempo que a GPU passa esperando o carregamento de dados do disco. O modelo pode receber dados continuamente, sem atrasos causados por operações de E/S do disco.

O armazenamento em cache durante o treinamento de YOLO26 pode ser controlado pelo parâmetro cache:

• cache=True: Armazena as imagens do conjunto de dados na RAM, proporcionando o acesso mais rápido, mas aumentando o uso de memória.
• cache='disk': Armazena as imagens no disco. É mais lento que a RAM, mas mais rápido do que carregar dados novos a cada vez.
• cache=False: Desativa o armazenamento em cache e depende totalmente da E/S do disco, sendo a opção mais lenta.

Treinamento com precisão mista#

O treinamento com precisão mista usa tipos de ponto flutuante de 16 bits (FP16) e 32 bits (FP32). Ele aproveita os pontos fortes de FP16 e FP32 usando FP16 para acelerar os cálculos e FP32 para manter a precisão quando necessário. A maioria das operações da rede neural é realizada em FP16 para acelerar os cálculos e reduzir o uso de memória. No entanto, uma cópia mestre dos pesos do modelo é mantida em FP32 para garantir a precisão durante as atualizações dos pesos. Assim, você pode lidar com modelos maiores ou tamanhos de lote maiores dentro das mesmas limitações de hardware.

Para implementar o treinamento com precisão mista, você precisa modificar seus scripts de treinamento e garantir que seu hardware (como as GPUs) ofereça suporte a esse recurso. Muitas bibliotecas modernas de aprendizado profundo, como PyTorch e TensorFlow, oferecem suporte integrado à precisão mista.

O treinamento com precisão mista é simples com YOLO26: o AMP já vem ativado por padrão (amp=True). Em uma GPU CUDA, YOLO faz uma verificação de compatibilidade única no início do treinamento e usa FP32 completo como alternativa se a verificação falhar; em CPU e no silício da Apple, o AMP é totalmente ignorado. Defina amp=False para forçar FP32.

Pesos pré-treinados#

Usar pesos pré-treinados é uma maneira eficaz de acelerar o treinamento do modelo. Os pesos pré-treinados vêm de modelos já treinados com grandes conjuntos de dados e dão uma vantagem inicial ao seu modelo. O aprendizado por transferência adapta modelos pré-treinados a tarefas novas e relacionadas. Ajustar um modelo pré-treinado envolve começar com esses pesos e continuar o treinamento com seu conjunto de dados específico. Esse método reduz o tempo de treinamento e costuma proporcionar melhor desempenho, pois o modelo começa com uma compreensão sólida dos recursos básicos.

Os pesos pré-treinados vêm do argumento model, então model=yolo26n.pt já começa com pesos COCO. O parâmetro pretrained controla se esses pesos são mantidos (True, padrão), descartados (False) ou substituídos por outro ponto de verificação (pretrained=path/to/best.pt). Definir pretrained=True em um modelo *.yaml não baixa os pesos por conta própria. Consulte Como ajustar YOLO a um conjunto de dados personalizado para ver o fluxo de trabalho completo de aprendizado por transferência.

Outras técnicas a considerar ao lidar com um conjunto de dados grande#

Há algumas outras técnicas que você pode considerar ao lidar com um conjunto de dados grande:

• Agendadores da taxa de aprendizado: A implementação de agendadores da taxa de aprendizado ajusta dinamicamente a taxa de aprendizado durante o treinamento. Uma taxa de aprendizado bem ajustada pode impedir que o modelo ultrapasse os mínimos e melhorar a estabilidade. Ao treinar YOLO26, o parâmetro lrf ajuda a gerenciar o agendamento da taxa de aprendizado, definindo a taxa de aprendizado final como uma fração da taxa inicial. Para comportamentos não expostos por nenhum argumento, como taxas de aprendizado por camada ou recorte de gradiente, crie uma subclasse do treinador.
• Treinamento distribuído: Para lidar com grandes conjuntos de dados, o treinamento distribuído pode fazer uma grande diferença. Você pode reduzir o tempo de treinamento distribuindo a carga de trabalho entre várias GPUs ou máquinas. Essa abordagem é especialmente valiosa em projetos empresariais que contam com recursos computacionais substanciais.
• Formato de memória channels-last: O treinamento com CUDA usa automaticamente o layout de memória NHWC, que é mais rápido, no PyTorch 1.11 e versões posteriores, exceto no Windows, onde as medições indicaram desempenho mais lento. Defina channels_last=True para forçá-lo ou channels_last=False para manter NCHW; no PyTorch 1.10 e versões anteriores, em CPU e em MPS, NCHW continua sendo o padrão.

Número de épocas de treinamento#

Ao treinar um modelo, uma época corresponde a uma passagem completa por todo o conjunto de dados de treinamento. Durante uma época, o modelo processa cada exemplo do conjunto de treinamento uma vez e atualiza seus parâmetros com base no algoritmo de aprendizado. Em geral, são necessárias várias épocas para que o modelo aprenda e refine seus parâmetros ao longo do tempo.

Uma pergunta comum é como determinar por quantas épocas treinar o modelo. Um bom ponto de partida são 300 épocas. Se o modelo começar a apresentar sobreajuste logo no início, você pode reduzir o número de épocas. Se o sobreajuste não ocorrer após 300 épocas, você pode estender o treinamento para 600, 1200 ou mais épocas.

No entanto, o número ideal de épocas pode variar de acordo com o tamanho do conjunto de dados e os objetivos do projeto. Conjuntos de dados maiores podem exigir mais épocas para que o modelo aprenda de forma eficaz, enquanto conjuntos menores podem precisar de menos épocas para evitar sobreajuste. Com YOLO26, você pode definir o parâmetro epochs no script de treinamento.

Parada antecipada#

A parada antecipada é uma técnica valiosa para otimizar o treinamento do modelo. Monitorando o desempenho da validação, você pode interromper o treinamento quando o modelo parar de melhorar. Assim, é possível economizar recursos computacionais e evitar sobreajuste.

O processo envolve definir um parâmetro de paciência, que determina quantas épocas aguardar por uma melhora nas métricas de validação antes de interromper o treinamento. Se o desempenho do modelo não melhorar durante esse período, o treinamento é interrompido para evitar desperdício de tempo e recursos.

Para YOLO26, você pode ativar a parada antecipada definindo o parâmetro de paciência na configuração de treinamento. Por exemplo, patience=5 significa que o treinamento será interrompido se as métricas de validação não melhorarem por 5 épocas consecutivas. Esse método mantém o processo de treinamento eficiente e permite alcançar um desempenho ideal sem computação excessiva.

Escolhendo entre treinamento na nuvem e local#

Há duas opções para treinar seu modelo: treinamento na nuvem e treinamento local.

O treinamento na nuvem oferece escalabilidade e hardware potente, sendo ideal para lidar com grandes conjuntos de dados e modelos complexos. Plataformas como Google Cloud, AWS e Azure oferecem acesso sob demanda a GPUs e TPUs de alto desempenho, acelerando o treinamento e permitindo experimentos com modelos maiores. No entanto, o treinamento na nuvem pode ser caro, especialmente por longos períodos, e a transferência de dados pode aumentar os custos e a latência.

O treinamento local oferece mais controle e personalização, permitindo adaptar o ambiente às suas necessidades específicas e evitar custos contínuos com a nuvem. Ele pode ser mais econômico em projetos de longo prazo e, como os dados permanecem nas suas instalações, é mais seguro. No entanto, o hardware local pode ter limitações de recursos e exigir manutenção, o que pode prolongar o treinamento de modelos grandes.

Como selecionar um otimizador#

Um otimizador é um algoritmo que ajusta os pesos da sua rede neural para minimizar a função de perda, que mede o desempenho do modelo. Em termos simples, o otimizador ajuda o modelo a aprender ajustando seus parâmetros para reduzir os erros. Escolher o otimizador certo afeta diretamente a velocidade e a precisão com que o modelo aprende.

Você também pode ajustar os parâmetros do otimizador para melhorar o desempenho do modelo. Ajustar a taxa de aprendizado define o tamanho dos passos ao atualizar os parâmetros. Para obter estabilidade, você pode começar com uma taxa de aprendizado moderada e reduzi-la gradualmente ao longo do tempo para melhorar o aprendizado a longo prazo. Além disso, definir o momentum determina quanta influência as atualizações anteriores têm sobre as atualizações atuais. Um valor comum para o momentum é cerca de 0,9. Em geral, esse valor oferece um bom equilíbrio.

Otimizadores comuns#

Os diferentes otimizadores têm vários pontos fortes e fracos. Vamos conhecer alguns otimizadores comuns.

• SGD (Descida do Gradiente Estocástico):

  • Atualiza os parâmetros do modelo usando o gradiente da função de perda em relação aos parâmetros.
  • É simples e eficiente, mas pode convergir lentamente e ficar preso em mínimos locais.

• Adam (Estimativa Adaptativa de Momentos):

  • Combina as vantagens do SGD com momentum e do RMSProp.
  • Ajusta a taxa de aprendizado de cada parâmetro com base em estimativas do primeiro e do segundo momentos dos gradientes.
  • É adequado para dados ruidosos e gradientes esparsos.
  • É eficiente e, em geral, exige menos ajustes. Para treinamentos mais curtos, o optimizer=auto do YOLO26 seleciona o AdamW, que é estreitamente relacionado, em vez do próprio Adam.

• RMSProp (Propagação da Raiz do Quadrado Médio):

  • Ajusta a taxa de aprendizado de cada parâmetro dividindo o gradiente por uma média móvel das magnitudes dos gradientes recentes.
  • Ajuda a lidar com o problema do desaparecimento do gradiente e é eficaz para redes neurais recorrentes.

• MuSGD (híbrido de Muon + SGD):

  • Combina atualizações no estilo SGD com comportamentos inspirados no Muon para melhorar a estabilidade do treinamento em larga escala.
  • É uma boa opção quando você quer a capacidade de generalização do SGD, mas precisa de uma convergência mais suave do que a do SGD básico.
  • É especialmente relevante para receitas de treinamento do YOLO26; se não tiver certeza, comece com optimizer=auto e compare com o MuSGD no seu conjunto de dados.

No YOLO26, o parâmetro optimizer permite escolher entre vários otimizadores, incluindo SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam e RMSProp, ou defini-lo como auto para selecionar automaticamente com base no número de iterações de treinamento.

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

Conecte-se à comunidade#

Fazer parte de uma comunidade de entusiastas de visão computacional pode ajudar você a resolver problemas e aprender mais rápido. Veja algumas formas de se conectar, obter ajuda e compartilhar ideias.

Recursos da comunidade#

• Problemas no GitHub: acesse o repositório do YOLO26 no GitHub e use a aba Issues para fazer perguntas, relatar bugs e sugerir recursos. A comunidade e os mantenedores são muito ativos e estão prontos para ajudar.
• Servidor do Ultralytics no Discord: entre no servidor do Ultralytics no Discord para conversar com outros usuários e desenvolvedores, obter suporte e compartilhar suas experiências.

Documentação oficial#

• Documentação do Ultralytics YOLO26: consulte a documentação oficial do YOLO26 para ver guias detalhados e dicas úteis sobre vários projetos de visão computacional.

Usar esses recursos ajudará você a resolver desafios e acompanhar as últimas tendências e práticas da comunidade de visão computacional.

Principais conclusões#

Treinar modelos de visão computacional envolve seguir boas práticas, otimizar suas estratégias e resolver problemas conforme eles surgem. Técnicas como ajustar o tamanho do lote, treinar com precisão mista e começar com pesos pré-treinados podem melhorar o desempenho dos modelos e acelerar o treinamento. Métodos como o treinamento com subconjuntos e a parada antecipada ajudam a economizar tempo e recursos. Manter-se conectado à comunidade e acompanhar as novas tendências ajudará você a continuar aprimorando suas habilidades de treinamento de modelos.

Perguntas frequentes#