Melhores práticas de aprendizado de máquina e dicas para treinamento de modelos#

Introdução#

Um dos passos mais importantes ao trabalhar num computer vision project é o treino de modelos. Antes de chegares a este passo, precisas de define your goals e collect and annotate your data. Depois de preprocessing the data para garantir que está limpos e consistentes, podes avançar para o treino do teu modelo.

Model training é o processo de ensinar o teu modelo a reconhecer padrões visuais e a fazer previsões a partir dos teus dados, moldando diretamente a precisão da tua aplicação. Este guia aborda boas práticas, técnicas de otimização e dicas de resolução de problemas para te ajudar a treinar os teus modelos de visão computacional de forma eficaz.

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 que está nessas imagens, e as previsões são comparadas aos rótulos ou conteúdos reais para calcular erros. Esses erros mostram o quão longe as previsões do modelo estão dos valores verdadeiros.

Durante o treino, o modelo faz previsões de forma iterativa, calcula erros e atualiza os seus parâmetros através de um processo chamado backpropagation. Neste processo, o modelo ajusta os seus parâmetros internos (pesos e vieses) para reduzir os erros. Ao repetir este ciclo várias vezes, o modelo melhora gradualmente a sua precisão. Com o tempo, aprende a reconhecer padrões complexos como formas, cores e texturas.

Este processo de aprendizagem torna possível que o modelo de computer vision execute várias tasks, incluindo object detection, instance segmentation, semantic segmentation e image classification. O objetivo final é criar um modelo capaz de generalizar a sua aprendizagem para imagens novas e nunca antes vistas, para que possa compreender com precisão dados visuais em aplicações do mundo real.

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

Treinamento em grandes conjuntos de dados#

Existem alguns aspectos diferentes para pensar quando você está planejando usar um grande conjunto de dados para treinar um modelo. Por exemplo, você pode ajustar o tamanho do lote (batch size), controlar a utilização da GPU, optar por usar treinamento multiescala, etc. Vamos percorrer cada uma dessas opções detalhadamente.

Tamanho do lote e utilização da GPU#

Ao treinar modelos em grandes conjuntos de dados, utilizar sua GPU de forma eficiente é fundamental. O tamanho do lote (batch size) é um fator importante. É o número de amostras de dados que um modelo de aprendizado de máquina processa em uma única iteração de treinamento. Usando o tamanho máximo de lote suportado pela sua GPU, você pode aproveitar ao máximo suas capacidades e reduzir o tempo que o treinamento do modelo leva. No entanto, você quer evitar ficar sem memória da GPU. Se você encontrar erros de memória, reduza o tamanho do lote incrementalmente até que o modelo treine sem problemas.

No que diz respeito ao YOLO26, podes definir o parâmetro batch em Train mode arguments para corresponder à capacidade da tua GPU. Num único acelerador, batch=-1 faz o perfil do modelo e escolhe um batch size que visa aproximadamente 60% de utilização de memória; uma fração como batch=0.70 visa uma quota diferente. As execuções em multi-GPU requerem um tamanho de lote global explícito que seja um múltiplo da contagem de dispositivos. No CPU e no Apple silicon, o AutoBatch avisa e reverte para batch=16.

Treinamento em subconjunto#

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

Quando se trata do YOLO26, podes implementar facilmente o treino por subconjuntos com o parâmetro fraction. Usa um rácio como fraction=0.1 para 10% dos dados de treino, um inteiro como fraction=300 para exatamente 300 imagens de treino, ou uma lista [train, val, test] como fraction=[300, 100, 0] para limitar cada divisão e ignorar as imagens de teste. Listas de dois itens como [300, 100] deixam a divisão de teste completa. Os conjuntos de dados NDJSON selecionam registos espaçados uniformemente antes de os descarregar, pelo que execuções repetidas reutilizam exatamente o mesmo subconjunto. Esta técnica suporta iterações rápidas e afinação antes de avançar para o conjunto de dados completo.

Treinamento multiescala#

O treino multi-escala é uma técnica que melhora a capacidade de generalização do teu modelo ao treiná-lo em imagens de vários tamanhos. O teu modelo pode aprender a detetar objetos a diferentes escalas e distâncias e tornar-se mais robusto.

Por exemplo, quando treinas o YOLO26, podes ativar o aumento de escala definindo o parâmetro scale. Este parâmetro ajusta o tamanho das imagens de treino por um fator especificado, simulando objetos a diferentes distâncias. Por exemplo, definir scale=0.5 aplica aleatoriamente um zoom nas imagens de treino por um fator entre 0,5 e 1,5 durante o treino. A configuração deste parâmetro permite que o teu modelo experimente uma variedade de escalas de imagem e melhore as suas capacidades de deteção em diferentes tamanhos de objetos e cenários.

O Ultralytics também suporta treino multiescala de tamanho de imagem através do parâmetro multi_scale. Ao contrário de scale, que aplica zoom às imagens e depois preenche/corta de volta para imgsz, multi_scale altera o próprio imgsz em cada lote (arredondado para o stride do modelo). Por exemplo, com imgsz=640 e multi_scale=0.25, o tamanho do treino é amostrado de 480 até 800 em passos de stride (por exemplo, 480, 512, 544, ..., 800), enquanto multi_scale=0.0 mantém um tamanho fixo.

Cache#

O 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 gasta esperando que os dados sejam carregados do disco. O modelo pode receber dados continuamente sem atrasos causados por operações de E/S de disco.

A colocação em cache pode ser controlada ao treinar o YOLO26 utilizando o parâmetro cache:

• cache=True: Armazena as imagens do conjunto de dados na RAM, proporcionando a velocidade de acesso mais rápida, mas à custa de um maior 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 de cada vez.
• cache=False: Desativa a colocação em cache, dependendo inteiramente de E/S de disco, o que é a opção mais lenta.

Treinamento de precisão mista#

O treino de precisão mista utiliza tipos de vírgula flutuante de 16 bits (FP16) e de 32 bits (FP32). Os pontos fortes do FP16 e do FP32 são aproveitados utilizando o FP16 para um cálculo mais rápido e o FP32 para manter a precisão onde necessário. A maioria das operações da neural network são feitas em FP16 para beneficiar de um cálculo mais rápido e de um menor uso de memória. No entanto, uma cópia mestra dos pesos do modelo é mantida em FP32 para garantir a precisão durante os passos de atualização de pesos. Podes lidar com modelos maiores ou tamanhos de lote maiores dentro das mesmas restrições de hardware.

Para implementar o treino de precisão mista, terás de modificar os teus scripts de treino e garantir que o teu hardware (como GPUs) o suporta. Muitos frameworks modernos de deep learning, tais como PyTorch e TensorFlow, oferecem suporte nativo para precisão mista.

O treino de precisão mista é simples ao trabalhar com o YOLO26: o AMP já está ativado por predefinição (amp=True). Numa CUDA GPU, o YOLO executa uma verificação de capacidade única no início do treino e reverte para o FP32 completo se falhar; no CPU e no Apple silicon, o AMP é ignorado por completo. Define amp=False para forçar o FP32.

Pesos Pré-treinados#

Usar pesos pré-treinados é uma forma inteligente de acelerar o processo de treino do teu modelo. Os pesos pré-treinados vêm de modelos já treinados em grandes conjuntos de dados, dando ao teu modelo uma vantagem inicial. O transfer learning adapta modelos pré-treinados a tarefas novas e relacionadas. Afinar um modelo pré-treinado envolve começar com estes pesos e depois continuar o treino no teu conjunto de dados específico. Este método de treino resulta em tempos de treino mais rápidos e, frequentemente, num melhor desempenho, porque o modelo começa com uma sólida compreensão das características básicas.

Os pesos pré-treinados vêm do argumento model, pelo que model=yolo26n.pt já começa com os pesos COCO. O parâmetro pretrained controla se esses pesos são mantidos (True, a predefinição), descartados (False) ou substituídos por outro ponto de controlo (pretrained=path/to/best.pt). Definir pretrained=True num modelo *.yaml não obtém os pesos por si só. Consulta How to Fine-Tune YOLO on a Custom Dataset para ver o fluxo de trabalho completo de transferência de aprendizagem.

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

Existem algumas outras técnicas a considerar ao lidar com um grande conjunto de dados:

• Learning Rate Schedulers: A implementação de planeadores de taxa de aprendizagem ajusta dinamicamente a taxa de aprendizagem durante o treino. Uma taxa de aprendizagem bem sintonizada pode evitar que o modelo ultrapasse os mínimos e melhorar a estabilidade. Ao treinar o YOLO26, o parâmetro lrf ajuda a gerir o planeamento da taxa de aprendizagem, definindo a taxa de aprendizagem final como uma fração da taxa inicial. Para um comportamento que nenhum argumento expõe, como taxas de aprendizagem por camada ou corte de gradientes, subclass the trainer.
• Treinamento distribuído: Para lidar com grandes conjuntos de dados, o treinamento distribuído pode mudar o jogo. Você pode reduzir o tempo de treinamento espalhando a carga de trabalho de treinamento por múltiplas GPUs ou máquinas. Esta abordagem é particularmente valiosa para projetos de escala empresarial com recursos computacionais substanciais.
• Formato de memória channels-last: channels_last=True utiliza o layout de memória NHWC em CUDA, o que pode melhorar o desempenho da convolução em hardware compatível. Outros dispositivos emitem um aviso e mantêm o layout predefinido.

O número de épocas para treinar#

Ao treinar um modelo, uma epoch refere-se a uma passagem completa por todo o conjunto de dados de treino. Durante uma época, o modelo processa cada exemplo no conjunto de treino uma vez e atualiza os seus parâmetros com base no algoritmo de aprendizagem. São habitualmente necessárias múltiplas épocas para permitir que o modelo aprenda e refine os seus parâmetros ao longo do tempo.

Uma pergunta comum que surge é como determinar o número de épocas para treinar o modelo. Um bom ponto de partida são 300 épocas. Se o modelo sofrer de overfitting prematuramente, podes reduzir o número de épocas. Se o overfitting não ocorrer após 300 épocas, podes estender o treino para 600, 1200 ou mais épocas.

No entanto, o número ideal de épocas pode variar com base no tamanho do teu conjunto de dados e nos objetivos do projeto. Conjuntos de dados maiores podem exigir mais épocas para o modelo aprender eficazmente, enquanto conjuntos de dados menores podem precisar de menos épocas para evitar o overfitting. No que respeita ao YOLO26, podes definir o parâmetro epochs no teu script de treino.

Parada antecipada (Early Stopping)#

A parada antecipada é uma técnica valiosa para otimizar o treinamento de modelos. Ao monitorar o desempenho de validação, você pode interromper o treinamento assim que o modelo parar de melhorar. Você pode economizar recursos computacionais e evitar o overfitting.

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

Para o YOLO26, podes ativar a paragem antecipada (early stopping) definindo o parâmetro patience na tua configuração de treino. Por exemplo, patience=5 significa que o treino parará se não houver melhoria nas métricas de validação durante 5 épocas consecutivas. Utilizar este método garante que o processo de treino permanece eficiente e atinge um desempenho ótimo sem computação excessiva.

Escolhendo entre treinamento na nuvem e local#

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

O treino na cloud oferece escalabilidade e hardware potente, sendo ideal para lidar com grandes conjuntos de dados e modelos complexos. Plataformas como o Google Cloud, AWS e Azure fornecem acesso a pedido a GPUs e TPUs de alto desempenho, acelerando os tempos de treino e permitindo experiências com modelos maiores. No entanto, o treino na cloud pode ser dispendioso, especialmente durante longos períodos, e a transferência de dados pode aumentar os custos e a latência.

O treinamento local oferece maior controle e personalização, permitindo que você adapte seu ambiente às necessidades específicas e evite custos contínuos de nuvem. Pode ser mais econômico para projetos de longo prazo e, como seus dados permanecem no local, é mais seguro. No entanto, o hardware local pode ter limitações de recursos e exigir manutenção, o que pode levar a tempos de treinamento mais longos para modelos grandes.

Selecionando um otimizador#

Um otimizador é um algoritmo que ajusta os pesos da tua rede neural para minimizar a loss function, que mede o desempenho do modelo. Em termos mais simples, o otimizador ajuda o modelo a aprender ajustando os seus parâmetros para reduzir os erros. Escolher o otimizador certo afeta diretamente a rapidez 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 parâmetros. Para estabilidade, você pode começar com uma taxa de aprendizado moderada e diminuí-la gradualmente ao longo do tempo para melhorar o aprendizado a longo prazo. Além disso, definir o momento determina quanta influência as atualizações passadas têm nas atualizações atuais. Um valor comum para momento é cerca de 0.9. Geralmente, ele fornece um bom equilíbrio.

Otimizadores comuns#

Diferentes otimizadores têm várias forças e fraquezas. Vamos dar uma olhada em alguns otimizadores comuns.

• SGD (Stochastic Gradient Descent - Descida de Gradiente Estocástica):

  • 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 ser lento para convergir e pode ficar preso em mínimos locais.

• Adam (Adaptive Moment Estimation):

  • Combina os benefícios do SGD com momento e RMSProp.
  • Ajusta a taxa de aprendizado para cada parâmetro com base em estimativas dos primeiros e segundos momentos dos gradientes.
  • Bem adequado para dados ruidosos e gradientes esparsos.
  • Eficiente e geralmente requer menos afinação. Para execuções de treino mais curtas, o optimizer=auto do YOLO26 seleciona o AdamW (que está intimamente relacionado) em vez do próprio Adam.

• RMSProp (Root Mean Square Propagation):

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

• MuSGD (Híbrido Muon + SGD):

  • Combina atualizações estilo SGD com comportamento inspirado em Muon para maior estabilidade em treinamento em larga escala.
  • Uma boa escolha quando você deseja generalização tipo SGD, mas precisa de uma convergência mais suave do que o SGD puro.
  • Especialmente relevante para YOLO26 training recipes; se tiveres dúvidas, começa com optimizer=auto e compara com o MuSGD no teu conjunto de dados.

Para o YOLO26, o parâmetro optimizer permite escolher entre vários otimizadores, incluindo SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam e RMSProp, ou podes defini-lo como auto para seleção automática com base no número de iterações de treino.

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

Conectando-se com a comunidade#

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

Recursos da comunidade#

• GitHub Issues: Visita o YOLO26 GitHub repository e usa o separador Issues para fazer perguntas, reportar bugs e sugerir novas funcionalidades. A comunidade e os mantenedores são muito ativos e estão prontos a ajudar.
• Ultralytics Discord Server: Junta-te ao Ultralytics Discord server para conversar com outros utilizadores e programadores, obter suporte e partilhar as tuas experiências.

Documentação Oficial#

• Ultralytics YOLO26 Documentation: Vê a official YOLO26 documentation para guias detalhados e dicas úteis sobre vários projetos de visão computacional.

Usar esses recursos ajudará você a resolver desafios e manter-se atualizado com as últimas tendências e práticas na comunidade de visão computacional.

Principais conclusões#

O treino de modelos de visão computacional envolve seguir boas práticas, otimizar as tuas estratégias e resolver problemas à medida que surgem. Técnicas como o ajuste de tamanhos de lote, treino com precision mista e início com pesos pré-treinados podem fazer com que os teus modelos funcionem melhor e treinem mais rapidamente. Métodos como o treino por subconjuntos e a paragem antecipada ajudam-te a poupar tempo e recursos. Manteres-te ligado à comunidade e a par das novas tendências ajudar-te-á a continuar a melhorar as tuas capacidades de treino de modelos.

FAQ#