Como ajustar o YOLO a um conjunto de dados personalizado#

O ajuste fino adapta um modelo pré-treinado para reconhecer novas classes, partindo de pesos já aprendidos em vez de uma inicialização aleatória. Em vez de treinar do zero por centenas de épocas, o ajuste fino aproveita as características pré-treinadas do COCO e converge com dados personalizados em uma fração do tempo.

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

Ajuste fino versus treinamento do zero#

Um modelo pré-treinado já aprendeu características visuais gerais — detecção de bordas, reconhecimento de texturas e compreensão de formas — a partir de milhões de imagens. O aprendizado por transferência por meio do ajuste fino reutiliza esse conhecimento e ensina ao modelo apenas a aparência das novas classes, por isso ele converge mais rápido e exige menos dados. O treinamento do zero descarta todo esse conhecimento e obriga o modelo a aprender tudo a partir de padrões no nível dos pixels, o que exige muito mais recursos. Consulte o Guia de configuração do YAML do modelo para saber como os arquivos .yaml, que contêm apenas a arquitetura, diferem dos checkpoints.

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

Quando um modelo pré-treinado é ajustado com um conjunto de dados que tem um número diferente de classes (por exemplo, as 80 classes do COCO para 5 classes personalizadas), o Ultralytics transfere os pesos considerando as dimensões:

1. A transferência do backbone e do neck é completa — essas camadas extraem características visuais gerais, e suas dimensões são independentes do número de classes.
2. O cabeçalho de detecção é reinicializado parcialmente - somente a convolução final de cada ramo de classificação (cv3, one2one_cv3) tem uma forma vinculada à quantidade de classes (80 vs. 5); as camadas ocultas do ramo são transferidas quando ambos os modelos compartilham uma escala. As linhas compatíveis cujos nomes de classe coincidem são remapeadas antes de inicializar as linhas sem correspondência. As camadas de regressão de caixas (cv2, one2one_cv2) no cabeçalho têm formas fixas, independentemente da quantidade de classes, por isso são transferidas normalmente.
3. A grande maioria dos pesos é transferida quando se altera a quantidade de classes. Por exemplo, ao ajustar o YOLO26n do COCO (80 classes) para um conjunto de dados com 5 classes, são transferidos 696 dos 708 tensores de peso, além das linhas de classificação compatíveis que correspondam pelo nome.

Em conjuntos de dados com o mesmo número de classes que o modelo pré-treinado (por exemplo, ao ajustar pesos pré-treinados no COCO com outro conjunto de dados de 80 classes), 100% dos pesos são transferidos, incluindo os da cabeça de detecção.

Transferir classes com aliases de nome#

O Ultralytics transfere as linhas correspondentes da cabeça de classificação entre conjuntos de dados usando os nomes das classes, ignorando maiúsculas e minúsculas e espaços em branco no início e no fim. Quando classes equivalentes têm nomes diferentes, renomeie as classes do checkpoint de origem na memória antes de carregá-lo. Isso preserva os pesos de classificação pré-treinados dos conceitos compartilhados que, de outra forma, seriam considerados sem correspondência e inicializados aleatoriamente.

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

from ultralytics import YOLO

# Nome da classe de origem Objects365 v2 (em minúsculas) -> nome da classe de destino no COCO
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")
# Os nomes das classes de Objects365 usam maiúsculas iniciais em cada palavra, então compare-os em minúsculas
model.model.names = {i: ALIASES.get(name.lower(), name) for i, name in model.model.names.items()}
model.train(data="coco.yaml", epochs=100, imgsz=640)

A configuração cls_remap ativa essa transferência baseada nos nomes por padrão. Durante o treinamento, é exibido Remapped N/M cls head rows from pretrained weights by class name quando linhas compatíveis são copiadas; defina cls_remap=False para desativá-la.

Exemplo básico de ajuste fino#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # carregar modelo pré-treinado
model.train(data="custom.yaml", epochs=50, imgsz=640)

Como escolher 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 sobreajuste quando os dados de treinamento são limitados. Começar com um modelo menor (YOLO26n ou YOLO26s) e aumentar o tamanho apenas se as métricas de validação estabilizarem é 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 completa do modelo YOLO26 para ver os tamanhos disponíveis e os benchmarks de desempenho.

Seleção do otimizador e da 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:

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

Para a maioria das tarefas de ajuste fino, a configuração padrão funciona bem sem ajustes manuais. Considere definir o otimizador explicitamente quando:

• O treinamento estiver instável (a perda oscila bruscamente ou diverge): experimente optimizer=AdamW, lr0=0.001 para obter uma convergência mais estável
• Você estiver ajustando um modelo grande em um conjunto de dados pequeno: um otimizador explícito com uma taxa de aprendizado menor, como optimizer=AdamW, lr0=0.001, pode ajudar a preservar as características pré-treinadas

Congelamento de camadas#

O congelamento impede que camadas específicas sejam atualizadas durante o treinamento. Isso acelera o treinamento e reduz o sobreajuste quando o conjunto de dados é 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 10 primeiras camadas (índices 0-9), que abrangem a maior parte do backbone do YOLO26. O backbone vai das camadas 0 a 10, portanto freeze=10 mantém treinável o bloco C2PSA final (camada 10); use freeze=11 para congelar todo o backbone. Uma lista pode conter índices de camadas, como freeze=[0, 3, 5], para congelar parcialmente o backbone, ou strings com nomes de módulos, como freeze=["23.cv2", "23.one2one_cv2"], para controlar com precisão ramos específicos de uma camada (neste caso, os dois ramos de regressão de caixas da cabeça de detecção).

from ultralytics import YOLO

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

A profundidade de congelamento adequada depende da semelhança entre o domínio de destino e os dados de pré-treinamento, bem como da quantidade de dados de treinamento disponível:

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 forma prática de encontrar a melhor configuração para um conjunto de dados específico.

Principais hiperparâmetros para ajuste fino#

Em geral, o ajuste fino exige menos alterações de hiperparâmetros do que o treinamento do zero. Os parâmetros mais importantes são:

• epochs: O ajuste fino converge mais rapidamente do que o treinamento do zero. Comece com um valor moderado e use patience para interromper o treinamento antecipadamente quando as métricas de validação estabilizarem.
• patience: O valor padrão de 100 foi projetado para execuções longas de treinamento. Reduzi-lo para 10-20 evita perder tempo com execuções que já convergiram.
• warmup_epochs: O aquecimento aumenta gradualmente a taxa de aprendizado até o valor definido pelo agendamento durante as primeiras épocas, reduzindo a probabilidade de os lotes iniciais perturbarem os recursos pré-treinados. Mantenha-o diferente de zero durante o ajuste fino, mas não é necessário usar o padrão completo de 3 épocas: a busca evolutiva por trás do ajuste fino oficial do YOLO26 no COCO — uma continuação de várias épocas a partir dos pesos do Objects365 — chegou a cerca de uma época para cada tamanho de modelo.

Para ver a lista completa de parâmetros de treinamento, consulte a referência de configuração de treinamento. Para controlar comportamentos que os parâmetros não oferecem — taxas de aprendizado por camada, recorte de gradiente ou métricas de validação personalizadas — crie uma subclasse do treinador.

Ajuste fino em duas etapas#

O ajuste fino em duas etapas divide o treinamento em duas fases. Na primeira etapa, o backbone é congelado e somente o neck e a cabeça são treinados, permitindo que as camadas de detecção se adaptem às novas classes sem perturbar os recursos pré-treinados. Na segunda etapa, todas as camadas são descongeladas e o modelo completo é treinado com uma taxa de aprendizado menor para refinar o backbone para o domínio de destino.

Essa abordagem é especialmente útil quando o domínio de destino difere significativamente do COCO (imagens médicas, imagens aéreas, microscopia), casos em que talvez seja necessário adaptar o backbone, mas treinar tudo de uma vez causa instabilidade. Para descongelar automaticamente usando uma abordagem baseada em callbacks, consulte Congelamento e descongelamento do backbone.

from ultralytics import YOLO

# Etapa 1: congelar o backbone, treinar a cabeça e o neck
model = YOLO("yolo26n.pt")
model.train(data="custom.yaml", epochs=20, freeze=10, name="stage1", exist_ok=True)

# Etapa 2: descongelar tudo e fazer o ajuste fino com uma taxa de aprendizado menor
model = YOLO("runs/detect/stage1/weights/best.pt")
model.train(data="custom.yaml", epochs=30, optimizer="AdamW", lr0=0.001, name="stage2", exist_ok=True)

Problemas comuns#

O modelo não gera previsões#

• Dados de treinamento insuficientes: treinar com pouquíssimas amostras é a causa mais comum — o modelo não consegue aprender nem generalizar com tão poucos dados. Garanta que haja exemplos diversificados suficientes por classe antes de investigar outras causas.

• Verifique os caminhos do conjunto de dados: caminhos de imagens inválidos geram um erro no conjunto de dados. Arquivos de rótulos individuais ausentes ou vazios são tratados como imagens de fundo e relatados durante a verificação; uma divisão de treinamento sem rótulos gera um erro. Valide o conjunto de dados antes do treinamento:

  yolo detect val model=yolo26n.pt data=custom.yaml

• Reduza o limiar de confiança: se houver previsões, mas elas forem filtradas, tente conf=0.1 durante a inferência.

• Verifique o número de classes: confirme que nc em data.yaml corresponde ao número real de classes nos arquivos de rótulos.

O mAP de validação estabiliza cedo#

• Adicione mais dados: o ajuste fino se beneficia muito de dados de treinamento adicionais, especialmente de exemplos diversificados com ângulos, iluminação e planos de fundo variados.
• Verifique o equilíbrio entre classes: classes sub-representadas terão AP baixo. Adicione mais exemplos ou ajuste cls_pw usando o conjunto de validação.
• Reduza o aumento de dados: em conjuntos de dados muito pequenos, aumentos de dados intensos 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 os detalhes.

O desempenho nas classes originais piora após o ajuste fino#

Isso é conhecido como esquecimento catastrófico: o modelo perde conhecimentos aprendidos anteriormente quando o ajuste fino é feito exclusivamente com dados novos. Em geral, não é possível evitar o esquecimento sem incluir imagens do conjunto de dados original junto com os dados novos. Para atenuá-lo:

• Una os conjuntos de dados: inclua exemplos das classes originais junto com as novas durante o ajuste fino. Essa é a única forma confiável de evitar o esquecimento.
• Congele o backbone e o neck: congelar o backbone e o neck para que somente a cabeça de detecção seja treinada ajuda em execuções curtas de ajuste fino com uma taxa de aprendizado muito baixa.
• Treine por menos épocas: quanto mais tempo o modelo for treinado exclusivamente com dados novos, maior será o esquecimento.

Perguntas frequentes#