IA Générative

Distillation de LLM : transférer les capacités d'un grand modèle vers un petit

Les meilleurs modèles de langage comptent des centaines de milliards de paramètres, et chacune de leurs réponses mobilise des GPU coûteux. Pourtant, les modèles compacts qui sortent aujourd'hui rivalisent avec des géants d'il y a deux ans sur de nombreuses tâches. Comment un modèle de quelques milliards de paramètres peut-il hériter d'une partie des capacités d'un modèle cent fois plus gros ? La réponse tient en grande partie à une technique : la distillation de connaissances.

Équipe Blent

Publié le · 14 min de lecture

Dans cet article

Les meilleurs modèles de langage comptent des centaines de milliards de paramètres, et chacune de leurs réponses mobilise des GPU coûteux. Pourtant, les modèles compacts qui sortent aujourd'hui rivalisent avec des géants d'il y a deux ans sur de nombreuses tâches. Comment un modèle de quelques milliards de paramètres peut-il hériter d'une partie des capacités d'un modèle cent fois plus gros ? La réponse tient en grande partie à une technique : la distillation de connaissances.

Formalisée en 2015 par Geoffrey Hinton, Oriol Vinyals et Jeff Dean, la distillation consiste à entraîner un petit modèle (l'élève) à reproduire le comportement d'un grand modèle (l'enseignant). Elle est aujourd'hui omniprésente : les petites versions de Gemma, les Llama 3.2 de 1 et 3 milliards de paramètres, ou encore les versions compactes de DeepSeek-R1 en sont issues. Elle sert aussi bien à fabriquer des modèles généralistes qu'à spécialiser un modèle sur une tâche d'entreprise.

Pour un AI Engineer ou un data scientist, comprendre la distillation permet de choisir la bonne technique de compression et de savoir ce que l'on peut attendre d'un modèle distillé. Dans cet article, nous allons expliquer le principe enseignant/élève, détailler les deux grandes familles de méthodes (sur logits et sur données synthétiques), comparer la distillation à la quantization et au fine-tuning, puis voir les outils pratiques et les limites, notamment juridiques.

Le principe enseignant/élève

Un LLM est entraîné à prédire le token suivant. Lors d'un pré-entraînement classique, la cible est binaire : le token présent dans le texte vaut 1, tous les autres valent 0. L'information apprise à chaque étape est donc très pauvre, puisque le modèle ne sait pas que d'autres continuations étaient presque aussi plausibles.

Avec la distillation, la cible devient la distribution de probabilités complète produite par l'enseignant sur tout le vocabulaire. Si l'enseignant attribue 60 % au mot « voiture », 25 % à « automobile » et 5 % à « camion », l'élève apprend ces proportions, c'est-à-dire la structure sémantique que l'enseignant a acquise. Hinton parle de dark knowledge (connaissance cachée) pour désigner cette information contenue dans les probabilités faibles, que le simple token correct ne transmet pas.

Le cycle se déroule en trois temps :

  • Choix de l'enseignant : un grand modèle performant, ouvert ou accessible par API, qui joue le rôle de référence
  • Génération des signaux : l'enseignant produit, pour chaque exemple, soit ses distributions de probabilités (les logits), soit des textes complets (réponses, raisonnements)
  • Entraînement de l'élève : le petit modèle est optimisé pour rapprocher sa sortie de celle de l'enseignant, avec une fonction de perte adaptée

L'intérêt économique est direct. Le coût de l'enseignant est payé une fois, au moment de la distillation, alors que le coût d'inférence de l'élève se répète à chaque requête. C'est l'une des briques qui expliquent la progression des Small Language Models, dont la distillation est l'un des leviers de qualité.

Les deux grandes familles de distillation

On distingue deux approches selon le type de signal que l'élève reçoit. Elles diffèrent par leurs prérequis techniques, leur richesse d'information et leur coût.

La distillation sur logits (white-box)

Dans cette approche, l'élève accède aux logits de l'enseignant, les scores bruts calculés avant la fonction softmax. Il faut donc disposer des poids du modèle enseignant, et en général d'un vocabulaire (tokenizer) commun aux deux modèles. En contrepartie, le signal est le plus riche possible : une distribution complète pour chaque position de chaque séquence.

La perte combine souvent deux termes. Le premier est l'entropie croisée classique sur les vrais tokens, le second est la divergence de Kullback-Leibler (KL) entre les distributions de l'enseignant et de l'élève, adoucies par une température TT qui rend les probabilités faibles plus visibles :

L=α LCE+(1−α) T2 KL(penseignant(T) ∥ peˊleˋve(T))\mathcal{L} = \alpha \, \mathcal{L}_{CE} + (1 - \alpha) \, T^2 \, \mathrm{KL}\left(p_{\text{enseignant}}^{(T)} \,\|\, p_{\text{élève}}^{(T)}\right)

Le facteur T2T^2 compense la réduction des gradients induite par la température, et α\alpha pondère les deux termes. Voici une implémentation minimale de cette perte en PyTorch.

python
import torch
import torch.nn.functional as F


def perte_distillation(logits_eleve, logits_enseignant, labels, T=2.0, alpha=0.5):
    """Combine entropie croisée et divergence KL entre enseignant et élève."""
    # Entropie croisée classique sur les vrais tokens (-100 = positions ignorées)
    ce = F.cross_entropy(
        logits_eleve.view(-1, logits_eleve.size(-1)),
        labels.view(-1),
        ignore_index=-100,
    )

    # Distributions adoucies par la température
    log_p_eleve = F.log_softmax(logits_eleve / T, dim=-1)
    p_enseignant = F.softmax(logits_enseignant / T, dim=-1)

    # Divergence KL moyenne par token, multipliée par T^2
    kl = F.kl_div(
        log_p_eleve.view(-1, log_p_eleve.size(-1)),
        p_enseignant.view(-1, p_enseignant.size(-1)),
        reduction="batchmean",
    ) * (T ** 2)

    return alpha * ce + (1 - alpha) * kl

Cette fonction suppose que les deux modèles partagent le même vocabulaire et que les logits de l'enseignant ont été calculés sans gradient (torch.no_grad()). Dans la pratique, on charge l'enseignant en lecture seule, parfois quantifié pour tenir en mémoire, et on l'interroge sur chaque lot d'entraînement.

Cette méthode est celle de la distillation « de pré-entraînement » : Google indique avoir entraîné les petits modèles de Gemma 2 (2 et 9 milliards de paramètres) en distillant un modèle plus grand, et Meta a utilisé les logits de Llama 3.1 8B et 70B comme cibles pour les Llama 3.2 de 1 et 3 milliards de paramètres, après élagage. NVIDIA a suivi une logique voisine avec ses modèles Minitron, obtenus en combinant pruning et distillation.

La distillation sur données synthétiques (black-box)

La seconde approche ne nécessite pas l'accès aux logits. L'enseignant, souvent un modèle propriétaire servi par API, génère des textes : réponses à des instructions, explications détaillées, chaînes de raisonnement. L'élève est ensuite fine-tuné de façon supervisée (SFT) sur ces textes, comme sur n'importe quel jeu de données.

C'est la voie qu'a ouverte le projet Alpaca de Stanford en 2023 : 52 000 instructions générées par un modèle d'OpenAI ont suffi pour donner à un petit modèle Llama un comportement conversationnel convaincant. Plus récemment, DeepSeek a publié des modèles dérivés de Qwen et de Llama (de 1,5 à 70 milliards de paramètres), fine-tunés sur environ 800 000 exemples produits par DeepSeek-R1, dont de longues chaînes de pensée. Le signal est ici un texte, pas une distribution : l'élève imite les trajectoires de raisonnement de l'enseignant, ce qui s'inscrit directement dans la logique des modèles de raisonnement et du chain-of-thought.

Le tableau suivant compare les deux familles.

CritèreDistillation sur logitsDistillation sur données synthétiques
Accès à l'enseignantPoids du modèle requisAPI suffisante
Signal transmisDistribution complète par tokenTexte généré (un seul échantillon)
Contrainte de tokenizerVocabulaire commun en généralAucune
Coût de mise en œuvreCalcul élevé (enseignant en mémoire)Coût de génération, puis SFT standard
Usage typiquePré-entraînement de modèles généralistesTransfert d'un comportement ou d'un raisonnement

La distillation sur logits est plus efficace par exemple d'entraînement, car chaque token apporte beaucoup d'information. La version sur données synthétiques est plus accessible et plus souple, mais l'élève ne voit qu'un échantillon par prompt : la qualité de la génération et la diversité des prompts deviennent déterminantes.

À lire : découvrez notre formation LLM Engineering

Distillation, quantization et fine-tuning : ne pas confondre

Ces trois techniques servent souvent le même objectif (un modèle moins cher à servir) mais agissent à des niveaux différents. Les confondre conduit à de mauvais choix d'architecture.

  • La quantization réduit la précision numérique des poids (de 16 bits à 8 ou 4 bits) sans changer l'architecture ni les paramètres appris. Elle divise l'empreinte mémoire sans nouvel entraînement ou presque.
  • Le fine-tuning adapte un modèle existant à une tâche ou à un style à partir de données annotées, avec la même taille de modèle avant et après.
  • La distillation transfère les capacités d'un modèle vers un autre, d'architecture et de taille différentes, en utilisant l'enseignant comme source de supervision.
TechniqueCe qui changeTaille du modèleEntraînement nécessaireCas d'usage
QuantizationPrécision des poidsIdentique en paramètres, moins de mémoireAucun ou calibrationRéduire la mémoire et accélérer l'inférence
Fine-tuningPoids du modèle (ou adaptateurs)IdentiqueOui, sur données annotéesSpécialiser un modèle sur un domaine
DistillationModèle plus petit entraîné à imiter un grandRéduite (architecture différente)Oui, lourdObtenir un modèle compact de bonne qualité

Ces techniques se combinent. Une chaîne courante consiste à distiller un grand modèle vers un modèle de 7 milliards de paramètres, à le fine-tuner sur les données de l'entreprise avec LoRA, puis à le quantifier en 4 bits pour le déployer sur un seul GPU avec un serveur comme vLLM. La distillation est la seule des trois qui change réellement le rapport entre taille et capacités de départ ; la quantization et le fine-tuning optimisent ensuite le déploiement et l'adaptation.

Un cas particulier mérite d'être cité : la distillation sert aussi à spécialiser. Un grand modèle sert d'enseignant sur une tâche étroite (extraction d'entités dans des contrats, classification de tickets), génère quelques dizaines de milliers d'exemples annotés, et un petit modèle est entraîné dessus. Il reproduit alors la qualité de l'enseignant sur ce périmètre, pour un coût d'inférence sans commune mesure.

Mettre en œuvre la distillation avec les outils actuels

L'écosystème offre aujourd'hui plusieurs briques pour distiller sans tout recoder. Le choix dépend de l'approche retenue.

Générer des données avec l'enseignant

Pour la voie sur données synthétiques, la première étape est la génération d'un jeu d'exemples de qualité. Il faut partir de prompts représentatifs de l'usage visé, interroger l'enseignant, puis filtrer : suppression des doublons, rejet des réponses incorrectes ou mal formées, et vérification automatique quand c'est possible (code exécuté, réponse mathématique comparée à une référence, sortie validée par un schéma, voir les sorties structurées). Pour les tâches à réponse ouverte, un LLM utilisé comme juge permet de noter et de trier les générations.

Des bibliothèques comme distilabel (Argilla, aujourd'hui dans l'écosystème Hugging Face) structurent ce travail sous forme de pipelines de génération et de filtrage. Le jeu de données obtenu s'utilise ensuite avec un entraîneur SFT classique de la bibliothèque TRL, présentée dans notre article sur Hugging Face.

Distiller sur logits avec TRL

Pour la distillation sur logits, la bibliothèque TRL propose le GKDTrainer, qui implémente la Generalized Knowledge Distillation (GKD). Cette méthode apporte une idée importante : au lieu de n'entraîner l'élève que sur des textes fixes, elle le fait aussi apprendre sur ses propres générations (entraînement on-policy), que l'enseignant corrige token par token. Cela réduit l'écart entre ce que l'élève voit à l'entraînement et ce qu'il produit à l'inférence.

python
from datasets import load_dataset
from transformers import AutoTokenizer
from trl import GKDConfig, GKDTrainer

# Enseignant et élève doivent partager le même tokenizer
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")

# Jeu de données au format conversationnel (colonne "messages")
dataset = load_dataset("json", data_files="conversations.jsonl", split="train")

args = GKDConfig(
    output_dir="eleve-distille",
    lmbda=0.5,   # part de séquences générées par l'élève (on-policy)
    beta=0.5,    # interpolation entre KL directe (0) et KL inverse (1)
    per_device_train_batch_size=2,
    num_train_epochs=1,
)

trainer = GKDTrainer(
    model="Qwen/Qwen3-0.6B",          # élève
    teacher_model="Qwen/Qwen3-8B",    # enseignant
    args=args,
    train_dataset=dataset,
    processing_class=tokenizer,
)
trainer.train()

Les paramètres lmbda et beta contrôlent respectivement la proportion de données générées par l'élève et la forme de la divergence entre les deux distributions. Selon la version de TRL installée, le trainer peut être importé depuis trl ou depuis un sous-module expérimental : il faut donc vérifier la documentation de la version utilisée. Dans les deux cas, le principal facteur limitant reste la mémoire GPU, puisque l'enseignant et l'élève cohabitent pendant l'entraînement.

D'autres frameworks proposent des recettes de distillation, comme torchtune (recette de distillation de connaissances en KL) ou NeMo de NVIDIA pour la combinaison pruning et distillation. Pour évaluer le résultat, il faut comparer l'élève à l'enseignant sur un jeu de test représentatif, avec les métriques adaptées à la tâche, et pas seulement sur des benchmarks généraux.

À découvrir : notre formation LLM Engineering

Limites et points de vigilance

La distillation n'est pas une compression sans perte. Plusieurs écueils techniques et juridiques doivent être anticipés avant de lancer un projet.

Perte de capacités et plafond de l'enseignant

L'élève ne dépasse pas son enseignant sur la tâche distillée : il hérite aussi de ses erreurs et de ses biais. Plus l'écart de taille est grand, plus la perte est marquée sur les capacités les plus exigeantes. Les connaissances factuelles, qui dépendent du nombre de paramètres, se transfèrent mal, alors que le style, le format de sortie et certaines méthodes de raisonnement se transfèrent bien.

Les modèles de raisonnement distillés illustrent cet effet : ils reproduisent les chaînes de pensée de l'enseignant et progressent nettement en mathématiques et en code, mais restent en retrait sur les problèmes très éloignés des exemples vus. Il faut aussi surveiller l'effondrement de la diversité : un élève entraîné sur un seul échantillon par prompt tend à produire des réponses plus uniformes que l'enseignant.

Le tableau ci-dessous résume les risques les plus courants et les réponses à y apporter.

RisqueCauseParade
Perte de connaissances factuellesCapacité limitée de l'élèveCoupler avec un RAG, viser une tâche étroite
Héritage des erreursDonnées générées non vérifiéesFiltrage, vérification automatique, juge
Manque de diversitéUn seul échantillon par promptPlusieurs générations, températures variées
Dérive de distributionPrompts peu représentatifs de l'usageConstruire les prompts à partir de logs réels

Licences et conditions d'utilisation

Le volet juridique est souvent sous-estimé. Les conditions d'utilisation de plusieurs fournisseurs d'API interdisent d'utiliser les sorties de leurs modèles pour développer des modèles concurrents. Distiller un modèle propriétaire pour déployer un produit commercial peut donc violer ces conditions, même si la technique est simple à mettre en œuvre.

Côté modèles ouverts, les licences varient : certaines, comme Apache 2.0 ou MIT, autorisent la distillation sans restriction notable, d'autres imposent des conditions (attribution, mention du modèle d'origine dans le nom du modèle dérivé, limites d'usage). Un modèle distillé hérite également de la question des données d'entraînement de l'enseignant. Avant tout projet commercial, il convient de relire la licence de l'enseignant et celle de l'élève, et de documenter la provenance des données générées. Ces enjeux rejoignent ceux de la sécurité des LLM : un modèle distillé peut aussi hériter des vulnérabilités et des comportements indésirables de son enseignant.

Enfin, la distillation n'est pas toujours la bonne réponse. Pour un besoin ponctuel, utiliser un modèle compact existant, éventuellement fine-tuné avec LoRA, coûte bien moins cher que distiller soi-même. La distillation devient rentable quand le volume d'inférence est élevé, que la tâche est stable et que les gains de latence ou de coût justifient la complexité de la chaîne d'entraînement.

Conclusion

La distillation de connaissances est l'un des mécanismes qui permettent aux modèles compacts de rattraper les grands. En faisant apprendre à l'élève les distributions de probabilités de l'enseignant, ou ses réponses et ses raisonnements, elle transmet bien plus d'information qu'un entraînement classique sur du texte brut. Les deux voies, sur logits et sur données synthétiques, répondent à des contraintes différentes : accès aux poids de l'enseignant d'un côté, simplicité et souplesse de l'autre.

Il reste essentiel de la distinguer de la quantization, qui compresse les poids d'un même modèle, et du fine-tuning, qui l'adapte sans changer sa taille. Ces techniques sont complémentaires, et les chaînes de production les plus efficaces les enchaînent. Le bon réflexe consiste à définir la tâche, à mesurer l'enseignant sur un jeu d'évaluation, puis à vérifier que l'élève conserve l'essentiel de la qualité, tout en s'assurant que les licences autorisent l'usage prévu.

À mesure que les modèles de pointe progressent, la distillation permettra de diffuser leurs capacités vers des modèles que l'on peut héberger, auditer et adapter soi-même. Savoir concevoir ce transfert, de la génération des données à l'évaluation, devient une compétence différenciante pour les équipes qui industrialisent l'IA Générative.

Pour aller plus loin

D'autres articles IA Générative

Approfondir le sujet

Formation LLM Engineering

Apprenez à construire, évaluer et préparer des applications LLM pour la production.

  • RAG
  • Fine-tuning
  • Évaluation
  • Mise en production