Boas práticas e dicas de aprendizagem automática para o treino de modelos#

Introdução#

Um dos passos mais importantes ao trabalhar num projeto de visão computacional é o treino do modelo. Antes de chegar a esta etapa, precisas de definir os teus objetivos e recolher e anotar os teus dados. Depois de pré-processar os dados para garantir que estão limpos e consistentes, podes avançar para o treino do teu modelo.

O treino de modelos é 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 apresenta boas práticas, técnicas de otimização e dicas de resolução de problemas para te ajudar a treinar eficazmente os teus modelos de visão computacional.

Como treinar um modelo de aprendizagem automática#

Um modelo de visão computacional é treinado ajustando os seus parâmetros internos para minimizar os erros. Inicialmente, o modelo recebe um grande conjunto de imagens anotadas. Faz previsões sobre o que está nessas imagens, e as previsões são comparadas com as anotações ou conteúdos reais para calcular os erros. Estes erros mostram o quanto as previsões do modelo se afastam dos valores verdadeiros.

Durante o treino, o modelo faz previsões iterativamente, calcula erros e atualiza os seus parâmetros através de um processo chamado retropropagação. Neste processo, o modelo ajusta os seus parâmetros internos (pesos e vieses) para reduzir os erros. Ao repetir este ciclo muitas 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 permite que o modelo de visão computacional execute várias tarefas, incluindo deteçã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 não vistas, compreendendo assim os dados visuais com precisão em aplicações do mundo real.

Agora que sabemos o que acontece nos bastidores quando treinamos um modelo, vejamos os aspetos a considerar durante o treino.

Treino com grandes conjuntos de dados#

Há vários aspetos a considerar quando planeias utilizar um grande conjunto de dados para treinar um modelo. Por exemplo, podes ajustar o tamanho do lote, controlar a utilização da GPU, optar pelo treino multiescala, entre outras opções. Vamos analisar cada uma delas em detalhe.

Tamanho do lote e utilização da GPU#

Ao treinar modelos com grandes conjuntos de dados, utilizar a tua GPU de forma eficiente é essencial. O tamanho do lote é um fator importante. É o número de amostras de dados que um modelo de aprendizagem automática processa numa única iteração de treino. Ao utilizares o tamanho máximo do lote suportado pela tua GPU, podes tirar o máximo partido das suas capacidades e reduzir o tempo necessário para treinar o modelo. No entanto, deves evitar esgotar a memória da GPU. Se encontrares erros de memória, reduz gradualmente o tamanho do lote até o modelo treinar sem problemas.

No caso do YOLO26, podes definir o parâmetro batch nos argumentos do modo Train de acordo com a capacidade da tua GPU. Num único acelerador, batch=-1 analisa o perfil do modelo e escolhe um tamanho do lote visando aproximadamente 60% de utilização da memória; uma fração como batch=0.70 visa uma percentagem diferente. As execuções com várias GPUs exigem um tamanho global do lote explícito que seja múltiplo do número de dispositivos. Em CPU e Apple silicon, o AutoBatch emite um aviso e recorre a batch=16.

Treino com subconjuntos#

O treino com subconjuntos é uma estratégia inteligente que consiste em treinar o teu modelo com um conjunto de dados mais pequeno, representativo do conjunto maior. Pode poupar tempo e recursos, especialmente durante o desenvolvimento e os testes iniciais do modelo. Se tiveres pouco tempo ou estiveres a experimentar diferentes configurações de modelo, o treino com subconjuntos é uma boa opção.

No caso do YOLO26, podes implementar facilmente o treino com subconjuntos através do parâmetro fraction. Usa uma proporção como fraction=0.1 para 10% dos dados de treino, um número 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 com dois itens, como [300, 100], mantêm a divisão de teste completa. Os conjuntos de dados NDJSON selecionam registos espaçados uniformemente antes de os descarregar, pelo que as execuções repetidas reutilizam exatamente o mesmo subconjunto. Esta técnica permite iterações e afinações rápidas antes de utilizar o conjunto de dados completo.

Treino multiescala#

O treino multiescala é uma técnica que melhora a capacidade de generalização do teu modelo através do treino com imagens de tamanhos variados. O teu modelo pode aprender a detetar objetos a diferentes escalas e distâncias, tornando-se mais robusto.

Por exemplo, ao treinares 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 às imagens de treino por um fator entre 0.5 e 1.5 durante o treino. Configurar este parâmetro permite ao teu modelo experimentar uma variedade de escalas de imagem e melhorar a sua capacidade de deteção em diferentes tamanhos e cenários de objetos.

A Ultralytics também suporta treino multiescala baseado no tamanho da imagem através do parâmetro multi_scale. Ao contrário de scale, que aplica zoom às imagens e depois adiciona preenchimento ou recorta novamente 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 de treino é amostrado de 480 a 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 treino de modelos de aprendizagem automática. Ao armazenar imagens pré-processadas na memória, o cache reduz o tempo que a GPU passa à espera que os dados sejam carregados do disco. O modelo pode receber dados continuamente, sem atrasos causados por operações de E/S do disco.

O cache pode ser controlado ao treinar o YOLO26 através do parâmetro cache:

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

Treino com precisão mista#

O treino com precisão mista utiliza tipos de ponto flutuante de 16 bits (FP16) e 32 bits (FP32). Aproveita os pontos fortes de ambos, utilizando FP16 para cálculos mais rápidos e FP32 para manter a precisão quando necessário. A maioria das operações da rede neuronal é executada em FP16 para beneficiar de cálculos mais rápidos e menor utilização de memória. No entanto, é mantida uma cópia principal dos pesos do modelo em FP32 para garantir a precisão durante as etapas de atualização dos pesos. Podes assim trabalhar com modelos ou tamanhos de lote maiores dentro das mesmas limitações de hardware.

Para implementar o treino com precisão mista, terás de modificar os teus scripts de treino e garantir que o teu hardware (como as GPUs) o suporta. Muitas frameworks modernas de aprendizagem profunda, como PyTorch e TensorFlow, oferecem suporte integrado para precisão mista.

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

Pesos pré-treinados#

Utilizar pesos pré-treinados é uma forma inteligente de acelerar o processo de treino do teu modelo. Os pesos pré-treinados provêm de modelos já treinados com grandes conjuntos de dados, dando uma vantagem inicial ao teu modelo. A aprendizagem por transferência adapta modelos pré-treinados a tarefas novas e relacionadas. Fazer fine-tuning de um modelo pré-treinado consiste em começar com esses pesos e continuar o treino no teu conjunto de dados específico. Este método resulta em tempos de treino mais rápidos e, muitas vezes, num melhor desempenho, porque o modelo começa com uma compreensão sólida das características básicas.

Os pesos pré-treinados provêm do argumento model, pelo que model=yolo26n.pt já começa com pesos COCO. O parâmetro pretrained controla se esses pesos são mantidos (True, a predefinição), descartados (False) ou substituídos por outro checkpoint (pretrained=path/to/best.pt). Definir pretrained=True num modelo *.yaml não descarrega pesos por si só. Consulta Como fazer fine-tuning do YOLO num conjunto de dados personalizado para conheceres o fluxo completo de aprendizagem por transferência.

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

Há algumas outras técnicas a considerar ao trabalhar com um grande conjunto de dados:

• Agendadores da taxa de aprendizagem: A implementação de agendadores da taxa de aprendizagem ajusta dinamicamente a taxa de aprendizagem durante o treino. Uma taxa de aprendizagem bem afinada pode impedir que o modelo ultrapasse os mínimos e melhorar a estabilidade. Ao treinar o YOLO26, o parâmetro lrf ajuda a gerir o agendamento da taxa de aprendizagem, definindo a taxa de aprendizagem final como uma fração da taxa inicial. Para comportamentos que nenhum argumento expõe, como taxas de aprendizagem por camada ou clipping de gradientes, cria uma subclasse do trainer.
• Treino distribuído: Para trabalhar com grandes conjuntos de dados, o treino distribuído pode transformar completamente o processo. Podes reduzir o tempo de treino distribuindo a carga de trabalho por várias GPUs ou máquinas. Esta abordagem é particularmente valiosa para projetos à escala empresarial com recursos computacionais substanciais.
• Formato de memória de canais no final: O treino com CUDA utiliza automaticamente o layout de memória NHWC mais rápido no PyTorch 1.11 e mais recente, exceto no Windows, onde foi mais lento. Define channels_last=True para o forçar ou channels_last=False para manter o NCHW; o PyTorch 1.10 e anteriores, a CPU e o MPS mantêm-se em NCHW por predefinição.

Número de épocas de treino#

Ao treinar um modelo, uma época corresponde a uma passagem completa por todo o conjunto de dados de treino. Durante uma época, o modelo processa cada exemplo do conjunto de treino uma vez e atualiza os seus parâmetros com base no algoritmo de aprendizagem. Normalmente são necessárias várias épocas para permitir que o modelo aprenda e aperfeiçoe os seus parâmetros ao longo do tempo.

Uma pergunta comum é como determinar o número de épocas durante as quais se deve treinar o modelo. Um bom ponto de partida são 300 épocas. Se o modelo sofrer overfitting cedo, podes reduzir o número de épocas. Se não ocorrer overfitting após 300 épocas, podes prolongar o treino para 600, 1200 ou mais épocas.

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

Paragem antecipada#

A paragem antecipada é uma técnica valiosa para otimizar o treino do modelo. Ao monitorizar o desempenho de validação, podes interromper o treino quando o modelo deixar de melhorar. Assim, poupas recursos computacionais e evitas overfitting.

O processo consiste em 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 treino. Se o desempenho do modelo não melhorar durante essas épocas, o treino é interrompido para evitar desperdício de tempo e recursos.

No YOLO26, podes ativar a paragem antecipada definindo o parâmetro de paciência na configuração de treino. Por exemplo, patience=5 significa que o treino será interrompido se não houver melhoria nas métricas de validação durante 5 épocas consecutivas. Este método garante que o processo de treino permanece eficiente e alcança um desempenho ideal sem computação excessiva.

Escolher entre treino na cloud e treino local#

Existem duas opções para treinar o teu modelo: treino na cloud e treino local.

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

O treino local proporciona maior controlo e personalização, permitindo adaptar o ambiente às tuas necessidades específicas e evitar custos contínuos da cloud. Pode ser mais económico para projetos de longo prazo e, como os teus dados permanecem nas tuas instalações, é mais seguro. No entanto, o hardware local pode ter limitações de recursos e exigir manutenção, o que pode resultar em tempos de treino mais longos para modelos grandes.

Selecionar um otimizador#

Um otimizador é um algoritmo que ajusta os pesos da tua rede neuronal para minimizar a função de perda, que mede o desempenho do modelo. Em termos 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 da aprendizagem do modelo.

Também podes afinar os parâmetros do otimizador para melhorar o desempenho do modelo. Ajustar a taxa de aprendizagem define o tamanho dos passos ao atualizar os parâmetros. Para obter estabilidade, podes começar com uma taxa de aprendizagem moderada e reduzi-la gradualmente ao longo do tempo para melhorar a aprendizagem a longo prazo. Além disso, definir o momentum determina a influência que as atualizações anteriores têm nas atualizações atuais. Um valor comum para o momentum é cerca de 0.9. Em geral, proporciona um bom equilíbrio.

Otimizadores comuns#

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

• SGD (Descida Estocástica do Gradiente):

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

• Adam (Estimativa de Momentos Adaptativos):

  • Combina os benefícios do SGD com momentum e do RMSProp.
  • Ajusta a taxa de aprendizagem 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, requer menos afinação. Para execuções de treino mais curtas, o optimizer=auto do YOLO26 seleciona o AdamW, estreitamente relacionado, em vez do próprio Adam.

• RMSProp (Propagação da Média Quadrática):

  • Ajusta a taxa de aprendizagem 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 neuronais recorrentes.

• MuSGD (híbrido Muon + SGD):

  • Combina atualizações ao estilo SGD com um comportamento inspirado no Muon para melhorar a estabilidade no treino em grande escala.
  • É uma boa escolha quando queres uma generalização semelhante à do SGD, mas precisas de uma convergência mais suave do que a do SGD básico.
  • É especialmente relevante para receitas de treino do YOLO26; se não tiveres a certeza, começa com optimizer=auto e compara-o com o MuSGD no teu 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 uma seleção automática baseada no número de iterações de treino.

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

Ligar-te à comunidade#

Fazer parte de uma comunidade de entusiastas de visão computacional pode ajudar-te a resolver problemas e a aprender mais rapidamente. Eis algumas formas de estabelecer ligação, obter ajuda e partilhar ideias.

Recursos da comunidade#

• Issues do GitHub: Visita o repositório do YOLO26 no GitHub e utiliza o separador Issues para fazer perguntas, comunicar erros e sugerir novas funcionalidades. A comunidade e os responsáveis pela manutenção são muito ativos e estão prontos para ajudar.
• Servidor Discord da Ultralytics: Junta-te ao servidor Discord da Ultralytics para conversar com outros utilizadores e programadores, obter suporte e partilhar as tuas experiências.

Documentação oficial#

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

A utilização destes recursos ajudar-te-á a resolver desafios e a manter-te atualizado sobre as tendências e práticas mais recentes da comunidade de visão computacional.

Principais Conclusões#

Treinar modelos de visão computacional implica seguir boas práticas, otimizar as tuas estratégias e resolver os problemas à medida que surgem. Técnicas como ajustar o tamanho dos lotes, o treino com precisão mista e começar com pesos pré-treinados podem melhorar o desempenho dos teus modelos e acelerar o treino. Métodos como o treino com subconjuntos e a paragem antecipada ajudam-te a poupar tempo e recursos. Manter-te ligado à comunidade e acompanhar as novas tendências ajudar-te-á a continuar a melhorar as tuas competências de treino de modelos.

Perguntas frequentes#