Como fazer o fine-tuning do YOLO em um conjunto de dados personalizado

Fine-tuning adapta um modelo pré-treinado para reconhecer novas classes, começando com pesos aprendidos em vez de inicialização aleatória. Em vez de treinar do zero por centenas de épocas, o fine-tuning aproveita os recursos do COCO pré-treinado e converge em dados personalizados em uma fração do tempo.

Este guia aborda o fine-tuning do YOLO26 em conjuntos de dados personalizados, desde o uso básico até técnicas avançadas como congelamento de camadas e treinamento em duas etapas.

Fine-Tuning vs. Treinamento do zero

Um modelo pré-treinado já aprendeu recursos visuais gerais - detecção de bordas, reconhecimento de texturas, compreensão de formas - a partir de milhões de imagens. Aprendizado por transferência (Transfer learning) através do fine-tuning reutiliza esse conhecimento e apenas ensina ao modelo como as novas classes se parecem, por isso ele converge mais rápido e requer menos dados. O treinamento do zero descarta tudo isso e força o modelo a aprender tudo, desde padrões de nível de pixel, o que exige significativamente mais recursos.

Como a transferência de pesos pré-treinados funciona

Quando um modelo pré-treinado passa por fine-tuning em um conjunto de dados com um número diferente de classes (por exemplo, de 80 classes do COCO para 5 classes personalizadas), a Ultralytics realiza uma transferência de pesos com reconhecimento de forma:

1. Backbone e neck são transferidos totalmente - essas camadas extraem recursos visuais gerais e suas formas são independentes do número de classes.
2. Detection head é parcialmente reinicializado - as camadas de saída de classificação (cv3, one2one_cv3) possuem formas vinculadas à contagem de classes (80 vs 5), então elas não podem ser transferidas e são inicializadas aleatoriamente. As camadas de regressão de caixa (cv2, one2one_cv2) no head possuem formas fixas independentemente da contagem de classes, então são transferidas normalmente.
3. A grande maioria dos pesos é transferida ao alterar a contagem de classes. Apenas as camadas específicas de classificação no detection head são reinicializadas - o backbone, o neck e os ramos de regressão de caixa permanecem intactos.

Para conjuntos de dados com o mesmo número de classes que o modelo pré-treinado (por exemplo, fazer fine-tuning de pesos pré-treinados no COCO em outro conjunto de dados de 80 classes), 100% dos pesos são transferidos, incluindo o detection head.

Exemplo básico de fine-tuning

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # load pretrained model
model.train(data="path/to/data.yaml", epochs=50, imgsz=640)

Escolhendo o tamanho do modelo

Modelos maiores têm mais capacidade, mas também mais parâmetros para atualizar, o que pode aumentar o risco de overfitting quando os dados de treinamento são limitados. Começar com um modelo menor (YOLO26n ou YOLO26s) e aumentar a escala apenas se as métricas de validação estagnarem é uma abordagem prática. O tamanho ideal do modelo depende da complexidade da tarefa, do número de classes, da diversidade do conjunto de dados e do hardware disponível para implantação. Consulte a página do modelo YOLO26 completa para ver tamanhos disponíveis e benchmarks de desempenho.

Seleção de otimizador e taxa de aprendizado

A configuração padrão de optimizer=auto seleciona o otimizador e a taxa de aprendizado com base no número total de iterações de treinamento:

• < 10.000 iterações (pequenos conjuntos de dados ou poucas épocas): AdamW com uma taxa de aprendizado baixa calculada automaticamente
• > 10.000 iterações (grandes conjuntos de dados): MuSGD (um otimizador híbrido Muon+SGD) com lr=0.01

Para a maioria das tarefas de fine-tuning, a configuração padrão funciona bem sem qualquer ajuste manual. Considere definir o otimizador explicitamente quando:

• O treinamento estiver instável (a perda apresenta picos ou diverge): tente optimizer=AdamW, lr0=0.001 para uma convergência mais estável
• Fizer fine-tuning de um modelo grande em um conjunto de dados pequeno: uma taxa de aprendizado menor como lr0=0.001 ajuda a preservar recursos pré-treinados

Congelando camadas

Congelar evita que camadas específicas sejam atualizadas durante o treinamento. Isso acelera o treinamento e reduz o overfitting quando o conjunto de dados é pequeno em relação à capacidade do modelo.

O argumento freeze O parâmetro aceita um número inteiro ou uma lista. Um número inteiro freeze=10 congela as primeiras 10 camadas (0 a 9, o que corresponde ao backbone no YOLO26). Uma lista pode conter índices de camadas como freeze=[0, 3, 5] para congelamento parcial do backbone, ou strings de nomes de módulos como freeze=["23.cv2"] para controle refinado sobre ramos específicos dentro de uma camada.

model.train(data="custom.yaml", epochs=50, freeze=10)

A profundidade de congelamento correta depende de quão semelhante o domínio de destino é aos dados pré-treinados e de quantos dados de treinamento estão disponíveis:

A profundidade de congelamento também pode ser tratada como um hiperparâmetro - testar alguns valores (0, 5, 10) e comparar o mAP de validação é uma maneira prática de encontrar a melhor configuração para um conjunto de dados específico.

Hiperparâmetros chave para fine-tuning

O fine-tuning geralmente requer menos ajustes de hiperparâmetros do que o treinamento do zero. Os parâmetros que mais importam são:

• epochs: O fine-tuning converge mais rápido que o treinamento do zero. Comece com um valor moderado e use patience para parar antecipadamente quando as métricas de validação estagnarem.
• patience: O padrão de 100 é projetado para execuções longas. Reduzir isso para 10-20 evita desperdiçar tempo em execuções que já convergiram.
• warmup_epochs: O warmup padrão (3 épocas) aumenta gradualmente a taxa de aprendizado a partir de zero, o que evita que grandes atualizações de gradiente danifiquem recursos pré-treinados nas iterações iniciais. Manter o padrão é recomendado mesmo para fine-tuning.

Para a lista completa de parâmetros de treinamento, veja a referência de configuração de treinamento.

Fine-tuning em duas etapas

O fine-tuning em duas etapas divide o treinamento em duas fases. A primeira etapa congela o backbone e treina apenas o neck e o head, permitindo que as camadas de detecção se adaptem às novas classes sem interromper os recursos pré-treinados. A segunda etapa descongela todas as camadas e treina o modelo completo com uma taxa de aprendizado menor para refinar o backbone para o domínio de destino.

Essa abordagem é particularmente útil quando o domínio de destino difere significativamente do COCO (imagens médicas, imagens aéreas, microscopia), onde o backbone pode precisar de adaptação, mas treinar tudo de uma vez causa instabilidade. Para descongelamento automático com uma abordagem baseada em callback, veja Congelar e Descongelar a Backbone.

from ultralytics import YOLO

# Stage 1: freeze backbone, train head and neck
model = YOLO("yolo26n.pt")
model.train(data="custom.yaml", epochs=20, freeze=10, name="stage1", exist_ok=True)

# Stage 2: unfreeze all, fine-tune with lower lr
model = YOLO("runs/detect/stage1/weights/best.pt")
model.train(data="custom.yaml", epochs=30, lr0=0.001, name="stage2", exist_ok=True)

Problemas comuns

Modelo não produz predições

• Dados de treinamento insuficientes: treinar com muito poucas amostras é a causa mais comum - o modelo não consegue aprender ou generalizar com poucos dados. Garanta exemplos diversos suficientes por classe antes de investigar outras causas.
• Verifique os caminhos do conjunto de dados: caminhos incorretos em data.yaml produzem rótulos vazios silenciosamente. Execute yolo detect val model=yolo26n.pt data=your_data.yaml antes do treinamento para confirmar que os rótulos carregam corretamente.
• Reduza o limite de confiança: se as previsões existirem, mas forem filtradas, tente conf=0.1 durante a inferência.
• Verifique a contagem de classes: garanta que nc em data.yaml corresponda ao número real de classes nos arquivos de rótulos.

O mAP de validação estagna precocemente

• Adicione mais dados: o ajuste fino beneficia-se significativamente de dados de treinamento adicionais, especialmente exemplos diversos com ângulos, iluminação e fundos variados.
• Verifique o equilíbrio das classes: classes sub-representadas terão um AP baixo. Use cls_pw para aplicar a ponderação de classe por frequência inversa (comece com cls_pw=0.25 para desequilíbrio moderado, aumente para 1.0 para desequilíbrio severo).
• Reduza a aumentação: para conjuntos de dados muito pequenos, aumentações pesadas podem prejudicar mais do que ajudar. Tente mosaic=0.5 ou mosaic=0.0.
• Aumente a resolução: para conjuntos de dados com objetos pequenos, tente imgsz=1280 para preservar detalhes.

O desempenho degrada nas classes originais após o ajuste fino

Isso é conhecido como esquecimento catastrófico - o modelo perde conhecimentos previamente aprendidos quando ajustado exclusivamente em novos dados. O esquecimento é quase inevitável sem incluir imagens do conjunto de dados original junto aos novos dados. Para mitigar isso:

• Mescle conjuntos de dados: inclua exemplos das classes originais junto com as novas classes durante o ajuste fino. Essa é a única forma confiável de evitar o esquecimento.
• Congele a backbone e o neck: congelar tanto a backbone quanto o neck para que apenas o detection head seja treinado ajuda em execuções curtas de ajuste fino com uma taxa de aprendizado muito baixa.
• Treine por menos épocas: quanto mais tempo o modelo treina exclusivamente em novos dados, mais o esquecimento aumenta.

FAQ

De quantas imagens preciso para ajustar o YOLO?

Não existe um mínimo fixo - os resultados dependem da complexidade da tarefa, do número de classes e do quão similar o domínio é ao COCO. Imagens mais diversas (iluminação, ângulos e fundos variados) importam mais do que a quantidade bruta. Comece com o que você tem e aumente se as métricas de validação forem insuficientes.

Como faço o ajuste fino do YOLO26 em um conjunto de dados personalizado?

Carregue um arquivo .pt pré-treinado e chame .train() com o caminho para um data.yaml personalizado. O Ultralytics gerencia automaticamente a transferência de pesos, reinicialização do detection head e seleção de otimizador. Veja a seção Basic Fine-Tuning para o exemplo de código completo.

Por que meu modelo YOLO ajustado não está detectando nada?

As causas mais comuns são caminhos incorretos no data.yaml (que produz silenciosamente zero rótulos), uma incompatibilidade entre nc no YAML e os arquivos de rótulos reais, ou um limite de confiança alto demais. Veja Problemas comuns para uma lista completa de solução de problemas.

Quais camadas do YOLO devo congelar para o ajuste fino?

Depende do tamanho do conjunto de dados e da similaridade do domínio. Para conjuntos de dados pequenos com um domínio similar ao COCO, congelar a backbone (freeze=10) previne o overfitting. Para domínios muito diferentes do COCO, deixar todas as camadas descongeladas (freeze=None) permite que a backbone se adapte. Veja Congelando camadas para recomendações detalhadas.

Como evito o esquecimento catastrófico ao ajustar o YOLO em novas classes?

Inclua exemplos das classes originais nos dados de treinamento junto com as novas classes. Se isso não for possível, congelar mais camadas (freeze=10 ou superior) e usar uma taxa de aprendizado menor ajuda a preservar o conhecimento pré-treinado. Veja Performance degrada nas classes originais para mais detalhes.