Knowledge Distillation

A destilação de conhecimento é uma técnica de compressão de modelos em que uma rede neural pequena, o "aluno", é treinada para reproduzir o comportamento de um modelo "professor" maior e mais preciso. O aluno aprende com as probabilidades de saída ou as características internas do professor, além dos rótulos de referência ou em vez deles; esses alvos mais ricos permitem que ele alcance maior precisão do que a mesma arquitetura treinada apenas com rótulos. O resultado é um modelo rápido e pequeno o bastante para celulares, placas embarcadas e outros dispositivos de IA de borda, mantendo boa parte da qualidade do professor. Buciluǎ, Caruana e Niculescu-Mizil mostraram em 2006 que era possível comprimir o conhecimento de um ensemble em um único modelo; em 2015, Hinton, Vinyals e Dean deram à abordagem o nome de destilação de conhecimento e introduziram os alvos suavizados por temperatura que a maioria dos métodos ainda usa.

Como funciona a destilação de conhecimento#

Um rótulo informa apenas que uma imagem mostra um lobo. A saída softmax de um professor treinado informa mais: a imagem se parece um pouco com um husky, um pouco com um gato e nada com um carro. Essas probabilidades relativas das classes incorretas, muitas vezes chamadas de conhecimento obscuro, chegam ao aluno como alvos suaves. Dividir os logits por uma temperatura T maior que 1 antes do softmax achata a distribuição, fazendo com que as probabilidades pequenas tenham peso suficiente para o aprendizado. A função de perda de destilação é a divergência de Kullback-Leibler entre as distribuições suavizadas do professor e do aluno, multiplicada por T² para que seus gradientes permaneçam de tamanho comparável aos da função de perda comum dos rótulos:

import torch
import torch.nn.functional as F

# Logits for one wolf photo over the classes [wolf, husky, cat, car]
teacher_logits = torch.tensor([[6.0, 4.0, 1.0, -2.0]])
student_logits = torch.tensor([[4.0, 1.0, 1.5, 0.0]])

# Dividing logits by a temperature T > 1 softens the teacher's distribution
for T in (1.0, 4.0):
    probs = F.softmax(teacher_logits / T, dim=1)
    print(f"T={T}: teacher probabilities {[round(p, 3) for p in probs[0].tolist()]}")

# Distillation loss: KL divergence between the softened distributions, scaled by T^2
T = 4.0
soft_targets = F.softmax(teacher_logits / T, dim=1)
student_log_probs = F.log_softmax(student_logits / T, dim=1)
loss = F.kl_div(student_log_probs, soft_targets, reduction="batchmean") * T**2
print(f"Distillation loss at T={T}: {loss.item():.3f}")

Com T=1, o professor atribui à classe lobo a probabilidade 0.875 e deixa apenas 0.006 para gato e 0.0 para carro. Com T=4, os mesmos logits se tornam 0.493, 0.299, 0.141 e 0.067, indicando ao aluno que um lobo se parece mais com um husky do que com um gato, e mais com um gato do que com um carro. O aluno minimiza essa função de perda, que aqui é 1.244, geralmente como uma soma ponderada com a função de perda da tarefa nos rótulos de referência. O professor permanece congelado durante todo o processo e executa apenas passagens para a frente:

Tipos de destilação#

• Baseada em respostas: O aluno corresponde às saídas finais do professor, como no método de alvos suaves acima, e não precisa de nada do professor além dos logits. DistilBERT combinou esse método com funções de perda de modelagem de linguagem e de estados ocultos durante o pré-treinamento, tornando o BERT 40% menor e 60% mais rápido, mantendo 97% da compreensão de linguagem.
• Baseada em características: O aluno corresponde aos mapas de características intermediários do professor, com um pequeno projetor aprendido que faz a ponte entre eventuais diferenças no número de canais. O FitNets introduziu essas "dicas" e treinou um aluno com cerca de 10.4 vezes menos parâmetros que o professor, mas que teve desempenho superior no CIFAR-10.
• No nível de sequência: Um professor de modelo de linguagem gera texto, e o aluno é ajustado com esses resultados. A DeepSeek ajustou seus modelos destilados R1, baseados em Qwen2.5 e Llama 3, com 800,000 amostras selecionadas com o DeepSeek-R1.

A destilação baseada em características é adequada para detectores, cujas saídas são milhares de caixas e pontuações, em vez de uma única distribuição de classes. O Ultralytics YOLO usa essa abordagem quando o treinamento recebe um professor distill_model: um modelo YOLO26 maior e congelado fornece os três mapas de características do pescoço que alimentam sua cabeça de detecção, e o aluno os reproduz por meio de projetores de convolução 1×1, com uma função de perda L2 ponderada pela confiança do professor e escalada por dis (6.0 por padrão). No COCO val2017, o modelo nano YOLO26 destilado atinge 41.5 mAP_50-95, em comparação com 40.9 para o mesmo modelo treinado sem professor, com custo de inferência idêntico.

from ultralytics import YOLO

# Aluno: o modelo compacto YOLO26 nano que será implantado
model = YOLO("yolo26n.pt")

# Professor: um checkpoint YOLO26 maior que orienta o treinamento e é descartado depois
results = model.train(data="coco8.yaml", epochs=5, distill_model="yolo26s.pt")

Destilação vs. termos relacionados#

• Aprendizado por transferência: Reutiliza os próprios pesos de um modelo como ponto de partida para uma nova tarefa. A destilação treina uma arquitetura diferente, geralmente menor, para imitar um modelo na mesma tarefa.
• Poda de modelos: Remove pesos, canais ou camadas de uma rede treinada. Muitas vezes, os modelos podados são ajustados com destilação a partir do original para recuperar a precisão.
• Quantização de modelos: Armazena pesos e ativações com precisão inferior, como INT8. Ela reduz o tamanho da mesma arquitetura e pode ser combinada com a destilação, que escolhe uma arquitetura menor.
• Ensemble de modelos: Calcula a média das saídas de vários modelos durante a inferência. Destilar um ensemble em um único aluno foi a motivação original da técnica.
• Destilação de conjuntos de dados: apesar da semelhança no nome, ela comprime um conjunto de dados, não um modelo. Wang et al. comprimiram as 60.000 imagens de treinamento do MNIST em 10 imagens sintéticas, uma por classe, que aproximam uma rede de sua precisão original em poucos passos de gradiente, com uma inicialização fixa.