Como fazer o ajuste fino (fine-tuning) do YOLO em um conjunto de dados personalizado#

Fine-tuning adapta um modelo pré-treinado para reconhecer novas classes começando a partir de 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 pré-treinados do COCO e converge em dados personalizados em uma fração do tempo.

Este guia aborda o fine-tuning de YOLO26 em datasets personalizados, desde o uso básico até técnicas avançadas como layer freezing e two-stage training.

Fine-Tuning vs. Treinamento do zero#

Um modelo pré-treinado já aprendeu recursos visuais gerais - detecção de bordas, reconhecimento de textura, compreensão de formas - a partir de milhões de imagens. O Transfer learning por meio do fine-tuning reutiliza esse conhecimento e apenas ensina ao modelo a aparência das novas classes, e é por isso que ele converge mais rápido e exige 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 funciona a transferência de pesos pré-treinados#

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 consciente da forma (shape-aware):

1. Backbone e neck transferem totalmente - estas camadas extraem características visuais gerais e suas formas são independentes do número de classes.
2. O cabeçote de detecção é parcialmente reinicializado - as camadas de saída de classificação (cv3, one2one_cv3) têm formas vinculadas à contagem de classes (80 vs 5), portanto, elas não podem ser transferidas e são inicializadas aleatoriamente. As camadas de regressão de caixa (cv2, one2one_cv2) no cabeçote têm formas fixas, independentemente da contagem de classes, portanto, elas são transferidas normalmente.
3. A vasta maioria dos pesos é transferida ao alterar a contagem de classes. Por exemplo, o fine-tuning do YOLO26n do COCO (80 classes) para um conjunto de dados de 5 classes transfere 606 de 708 tensores de peso: apenas as camadas de classificação dependentes da contagem de classes são reinicializadas, enquanto a 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 a cabeça de detecção.

Transfere Classes com Aliases de Nomes#

O Ultralytics transfere linhas correspondentes da camada de classificação por nome de classe entre datasets, ignorando maiúsculas/minúsculas e espaços em branco ao redor. Quando classes equivalentes usam nomes diferentes, renomeia as classes do checkpoint de origem na memória antes de carregar. Isso preserva os pesos de classificação pré-treinados para conceitos compartilhados que, de outra forma, seriam tratados como não correspondentes e inicializados aleatoriamente.

Este exemplo de Objects365 v2 para COCO renomeia as classes de origem no checkpoint carregado, que train() então repassa como os pesos pré-treinados:

from ultralytics import YOLO

# Source Objects365 v2 name -> target COCO name
ALIASES = {
    "wild bird": "bird",
    "handbag/satchel": "handbag",
    "luggage": "suitcase",
    "bowl/basin": "bowl",
    "orange/tangerine": "orange",
    "monitor/tv": "tv",
    "stuffed toy": "teddy bear",
    "hair dryer": "hair drier",
}

model = YOLO("path/to/yolo26s-objects365.pt")
model.model.names = {i: ALIASES.get(name, name) for i, name in model.model.names.items()}
model.train(data="coco.yaml", epochs=100, imgsz=640)

Exemplo básico de fine-tuning#

from ultralytics import YOLO

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

Escolhendo um tamanho de 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 dataset e do hardware disponível para implantação. Consulte a página do modelo YOLO26 completa para tamanhos disponíveis e benchmarks de desempenho.

Seleção de otimizador e taxa de aprendizado#

A configuração padrão 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 (datasets grandes): 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 está instável (picos de perda ou divergência): tente optimizer=AdamW, lr0=0.001 para uma convergência mais estável
• Fazendo fine-tuning de um modelo grande em um dataset pequeno: uma taxa de aprendizado menor, como lr0=0.001, ajuda a preservar os recursos pré-treinados

Congelando camadas#

O congelamento impede que camadas específicas sejam atualizadas durante o treinamento. Isso acelera o treinamento e reduz o overfitting quando o dataset é pequeno em relação à capacidade do modelo.

O parâmetro freeze aceita um número inteiro ou uma lista. Um número inteiro freeze=10 congela as primeiras 10 camadas (índices 0-9), o que cobre a maior parte do backbone do YOLO26. O backbone abrange as camadas 0-10, portanto, freeze=10 deixa o bloco C2PSA final (camada 10) treinable; use freeze=11 para congelar todo o backbone. Uma lista pode conter índices de camadas como freeze=[0, 3, 5] para o congelamento parcial do backbone, ou strings de nomes de módulos como freeze=["23.cv2", "23.one2one_cv2"] para controle refinado sobre ramificações específicas dentro de uma camada (aqui, ambas as ramificações de regressão de caixa do cabeçote de detecção).

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

A profundidade correta de congelamento 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 - tentar alguns valores (0, 5, 10) e comparar o mAP de validação é uma forma prática de encontrar a melhor configuração para um conjunto de dados específico.

Principais hiperparâmetros 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 do que o treinamento do zero. Comece com um valor moderado e use patience para parar mais cedo quando as métricas de validação estagnarem.
• patience: O padrão de 100 foi projetado para execuções longas de treinamento. Reduzir isso para 10-20 evita desperdiçar tempo em execuções que já convergiram.
• warmup_epochs: O aquecimento padrão (3 épocas) aumenta gradualmente a taxa de aprendizado a partir de zero, o que evita que grandes atualizações de gradiente danifiquem os recursos pré-treinados nas primeiras iterações. Recomenda-se manter o padrão mesmo para o fine-tuning.

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

Fine-tuning em dois estágios#

O fine-tuning em dois estágios divide o treinamento em duas fases. O primeiro estágio congela a backbone e treina apenas o neck e a cabeça, permitindo que as camadas de detecção se adaptem às novas classes sem interromper as características pré-treinadas. O segundo estágio descongela todas as camadas e treina o modelo completo com uma taxa de aprendizado menor para refinar a 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 o descongelação automática com uma abordagem baseada em callback, consulte Freezing and Unfreezing the 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 previsões#

• Dados de treinamento insuficientes: treinar com pouquíssimas 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.
• Verificar os caminhos do dataset: caminhos incorretos em data.yaml produzem silenciosamente zero rótulos. Execute yolo detect val model=yolo26n.pt data=custom.yaml antes do treinamento para confirmar se os rótulos são carregados corretamente.
• Diminuir o limite de confiança: se as previsões existirem, mas forem filtradas, tente conf=0.1 durante a inferência.
• Verificar a contagem de classes: certifique-se de que nc em data.yaml corresponda ao número real de classes nos arquivos de rótulos.

mAP de validação estagna precocemente#

• Adicione mais dados: o fine-tuning se beneficia significativamente de dados de treinamento adicionais, especialmente exemplos diversos com ângulos, iluminação e planos de fundo variados.
• Verificar o balanceamento de classes: classes sub-representadas terão 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 grave).
• Reduzir a augmentação: para datasets muito pequenos, augmentações pesadas podem atrapalhar mais do que ajudar. Tente mosaic=0.5 ou mosaic=0.0.
• Aumentar a resolução: para datasets com objetos pequenos, tente imgsz=1280 para preservar os detalhes.

O desempenho degrada nas classes originais após o fine-tuning#

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

• Mescle conjuntos de dados: inclua exemplos das classes originais junto com as novas classes durante o fine-tuning. Esta é a única maneira confiável de evitar o esquecimento.
• Congele backbone e neck: congelar tanto a backbone quanto o neck para que apenas a cabeça de detecção treine ajuda em execuções curtas de fine-tuning 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#