TRL documentation
Distillation asynchrone
Distillation asynchrone
Ce formateur nécessite
vllm,transformers>=5.2.0etkernels(l’entraînement charge FlashAttention depuis le Hub via ce dernier). Pour l’entraînement distribué, seul FSDP2 est pris en charge (DeepSpeed ZeRO ne l’est pas).Actuellement,
vllmettransformersont des contraintes de dépendances conflictuelles. Pour contourner ce problème, installez d’abord vLLM, puis forcez l’installation de transformers, puis ajoutezkernelsvia l’extra de TRL, qui fixe la version acceptée par transformers :pip install vllm pip install 'transformers>=5.2.0' --no-deps pip install 'trl[kernels]'
Aperçu
experimental.async_distillation.AsyncDistillationTrainer est l’équivalent asynchrone de DistillationTrainer, conçu à l’image de AsyncGRPOTrainer : un travailleur de rollout en arrière-plan génère les complétions on-policy de l’étudiant et les évalue par rapport à un enseignant, tandis que l’entraînement se déroule de manière concurrente au lieu d’alterner entre génération et mises à jour des gradients. Contrairement à l’entraîneur synchrone, l’enseignant n’est jamais chargé localement — seule une URL de serveur vLLM est requise, ce qui permet à l’enseignant de s’exécuter sur un matériel entièrement distinct de celui de l’étudiant et de l’entraîneur, ou même d’être un modèle beaucoup plus volumineux que ce qui ne pourrait autrement tenir à côté de l’étudiant.
compute_loss minimise une divergence de Jensen-Shannon généralisée entre les distributions de jetons par position de l’étudiant et de l’enseignant (beta=0.0 correspond à la KL avant, beta=1.0 à la KL arrière, les valeurs intermédiaires interpolent), le même objectif que celui utilisé par DistillationTrainer et ServerDistillationTrainer. L’entraînement est toujours on-policy : l’étudiant génère chaque complétion sur laquelle il s’entraîne.
Distillation sur politique multi-enseignants (MOPD)
MOPD ne fait pas partie de l’article 2306.13649 sur lequel repose l’objectif principal de ce formateur (qui décrit un contexte synchrone à un seul enseignant) ; il s’agit d’une méthode distincte, décrite dans MOPD: Multi-Teacher On-Policy Distillation for Capability Integration in LLM Post-Training. Dans cet article, MOPD est la troisième des trois étapes — SFT général, puis entraînement RL indépendant par domaine d’un expert par domaine, puis MOPD fusionne ces experts figés en un seul élève. AsyncDistillationTrainer implémente uniquement cette troisième étape de fusion : les enseignants experts par domaine doivent déjà exister (par exemple, entraînés séparément avec GRPOTrainer/RLOOTrainer) et être servis via HTTP avant de pointer teacher_server_urls vers eux. L’étape 3 de l’article utilise elle-même la KL inverse (beta=1.0), et non la valeur par défaut de ce formateur beta=0.0 (KL avant).
teacher_server_urls accepte plus d’une entrée. Avec une seule entrée, chaque échantillon est évalué par ce seul enseignant (distillation on-policy simple). Avec plusieurs entrées, la colonne teacher_id de chaque échantillon d’entraînement sélectionne l’enseignant qui l’évalue — par exemple, en acheminant les prompts de mathématiques vers un enseignant spécialisé en mathématiques et les prompts de code vers un enseignant spécialisé en code, chacun étant servi de manière indépendante. Chaque échantillon est acheminé vers son enseignant correspondant unique, sans jamais être moyenné ou combiné entre plusieurs enseignants. Un échantillon dont le teacher_id est manquant ou non mappé provoque une erreur plutôt que de basculer silencieusement vers le mauvais enseignant. Consultez examples/async_distillation_mopd/async_distillation_mopd.py pour un exemple exécutable qui fusionne les experts en mathématiques, en code et en suivi d’instructions publiés avec Open-MOPD dans leur point de contrôle SFT commun, et examples/async_distillation_mopd/launcher.py pour l’exécuter sur 4 GPU avec une seule commande Hugging Face Jobs.
Chaque enseignant doit partager le tokeniseur de l’élève. Les compléments sont transmis aux enseignants sous forme d’identifiants de jetons bruts, et les identifiants de candidats qu’un enseignant renvoie indexent directement le vocabulaire propre de l’élève dans
compute_loss. Les enseignants issus de la même famille de modèles que l’élève (comme dans l’exemple MOPD, où un élève SmolLM3 est fusionné à partir d’experts SmolLM3 entraînés à partir du même point de contrôle) satisfont cette condition ; un enseignant doté d’un vocabulaire différent entraîne l’élève sur les mauvais jetons, de manière silencieuse, sauf si son vocabulaire est plus grand que celui de l’élève.
Point de contrôle et reprise : ignore_data_skip est défini sur True par défaut ; la boucle de saut et de rejouage du Trainer de base ne s’applique pas à une file de déroulement en direct. En revanche, l’indice du premier prompt sur lequel l’entraînement n’a pas encore été effectué est enregistré dans rollout_state.json avec chaque point de contrôle et restauré lors de la reprise, de sorte que le travailleur avance rapidement jusqu’à ce prompt sans rejouer les échantillons. Il s’agit de la position entraînée, et non de celle du générateur : le travailleur court en tête de l’entraînement de la profondeur de la file de déroulement, et ces échantillons mis en mémoire tampon sont perdus lorsque l’exécution se termine, si bien que reprendre depuis la position du générateur sauterait des prompts qui ont été générés mais jamais entraînés. Les jeux de données en flux (IterableDataset) ne peuvent pas être repositionnés ; leur travailleur redémarre depuis le prompt 0 lors de la reprise. Sous FSDP avec bf16=True (par défaut) ou fp16=True, model.safetensors est écrit dans ce type de données, même si les poids maîtres sont en fp32, de sorte qu’un point de contrôle poussé a la taille du modèle servi, et non le double ; les poids maîtres en fp32 et l’état de l’optimiseur vont toujours dans les fichiers de reprise (pytorch_model_fsdp.bin, optimizer.bin), qui sont ceux que lit une reprise, si bien que la reprise n’est pas affectée. Sans FSDP, le point de contrôle est également le fichier de reprise, il conserve donc le type de données maître.
En quoi cela diffère de DistillationTrainer
Dans DistillationTrainer, l’enseignant est un modèle chargé localement : la génération, le passage avant de l’enseignant et la mise à jour des gradients se déroulent de manière séquentielle dans le même processus. experimental.async_distillation.AsyncDistillationTrainer sépare ces préoccupations de la même manière que AsyncGRPOTrainer sépare le déroulement (rollout) de GRPO de sa mise à jour :
- Travailleur de déroulement (processus en arrière-plan) — génère des complétions à partir du serveur vLLM de l’étudiant, renvoie la séquence complète au
/v1/completionsde l’enseignant résolu avecprompt_logprobspour un score forcé par l’enseignant (aucun nouveau jeton généré par l’enseignant) et pousse les échantillons prêts à l’entraînement dans une file d’attente. - Boucle d’entraînement (processus principal) — extrait des échantillons de la file d’attente, calcule la perte JSD généralisée et met à jour les poids de l’étudiant.
Comme l’enseignant est évalué via HTTP plutôt que par un passage avant local, seule une portion creuse, top-k, de sa distribution est transmise (teacher_top_k), et non le vocabulaire complet — consultez la documentation de beta et teacher_top_k de experimental.async_distillation.AsyncDistillationConfig pour savoir exactement quels candidats le protocole de transmission garantit un logprob d’enseignant pour, à chaque régime beta.
Toutes les weight_sync_steps étapes d’entraînement, les poids mis à jour de l’étudiant sont transférés vers son serveur vLLM via NCCL. Comme avec AsyncGRPOTrainer, la génération avance sur l’entraînement, de sorte que les échantillons peuvent refléter une politique légèrement obsolète ; max_staleness contrôle le nombre de mises à jour de poids qu’un échantillon peut retarder avant d’être écarté.
Démarrage rapide
# train_async_distillation.py
from datasets import load_dataset
from trl.experimental.async_distillation import AsyncDistillationTrainer
if __name__ == "__main__": # the rollout worker is a spawned process that re-imports this script
dataset = load_dataset("trl-lib/DeepMath-103K", split="train")
trainer = AsyncDistillationTrainer(
model="Qwen/Qwen2.5-0.5B-Instruct",
train_dataset=dataset,
)
trainer.train()Le serveur enseignant, le serveur vLLM de l’élève et le formateur doivent s’exécuter sur des GPU distincts. Il s’agit dans les deux cas d’instances simples de vllm serve, mais elles nécessitent des drapeaux différents : l’enseignant ne sert qu’à évaluer (--logprobs-mode processed_logprobs afin que teacher_temperature s’applique aux logprobs renvoyés, et --max-logprobs -1 afin que teacher_top_k puisse dépasser la limite par défaut de 20 de vLLM), tandis que l’élève ne sert qu’à générer et nécessite l’activation du transfert de poids NCCL pour que le formateur puisse y pousser les poids mis à jour. L’évaluation envoie la séquence complète de l’élève et demande à l’enseignant un token supplémentaire, de sorte que la valeur de --max-model-len de l’enseignant (ou sa valeur par défaut) doit être supérieure à celle de l’élève :
# Terminal 1: teacher server on GPU 0 (static, never updated)
CUDA_VISIBLE_DEVICES=0 vllm serve Qwen/Qwen2.5-1.5B-Instruct \
--port 8001 \
--logprobs-mode processed_logprobs \
--max-logprobs -1# Terminal 2: student's vLLM server on GPU 1 (dev mode + NCCL weight transfer are required)
CUDA_VISIBLE_DEVICES=1 VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen2.5-0.5B-Instruct \
--port 8000 \
--weight-transfer-config '{"backend":"nccl"}'# Terminal 3: training on GPU 2
CUDA_VISIBLE_DEVICES=2 python train_async_distillation.pyLoRA
Passez un peft_config pour entraîner un adaptateur LoRA sur l'étudiant plutôt que sur le modèle complet :
from peft import LoraConfig
trainer = AsyncDistillationTrainer(
model="Qwen/Qwen2.5-0.5B-Instruct",
train_dataset=dataset,
peft_config=LoraConfig(r=32, lora_alpha=64, target_modules="all-linear"),
)Chaque synchronisation des poids doit transmettre l’étudiant mis à jour à son serveur. Par défaut, l’entraîneur fusionne l’adaptateur dans le modèle de base et envoie les poids fusionnés complets, soit environ 15 Go pour un modèle de 7B à chaque synchronisation. Démarrez le serveur vLLM de l’étudiant avec --enable-lora et il n’enverra que l’adaptateur, soit environ 160 Mo à r=32 :
CUDA_VISIBLE_DEVICES=1 VLLM_SERVER_DEV_MODE=1 VLLM_ALLOW_RUNTIME_LORA_UPDATING=1 vllm serve Qwen/Qwen2.5-0.5B-Instruct \
--port 8000 \
--weight-transfer-config '{"backend":"nccl"}' \
--enable-lora \
--max-lora-rank 32 \
--max-loras 6VLLM_ALLOW_RUNTIME_LORA_UPDATING=1 expose l’endpoint vers lequel l’entraîneur envoie chaque nouvel adaptateur. Ajoutez VLLM_WORKER_MULTIPROC_METHOD=spawn si vous servez en parallélisme de tenseurs, et conservez --weight-transfer-config dans tous les cas : l’entraîneur ne choisit un mode de synchronisation qu’au démarrage, à un moment où le serveur est déjà actif, et la synchronisation fusionnée est le mode de repli. Le serveur enseignant n’est pas affecté : il n’est jamais mis à jour.
--max-lora-rank doit être l’un des éléments de 1, 8, 16, 32, 64, 128, 256, 320, 512. Il définit le rang maximal que le serveur peut servir, et non le rang qu’il servira effectivement, de sorte qu’un adaptateur r=4 fonctionne parfaitement sous 8. --max-loras doit être au moins égal à max_staleness + 2 : l’entraîneur conserve max_staleness + 1 versions d’adaptateurs enregistrées afin qu’un déroulement ayant démarré sous une politique plus ancienne puisse se terminer sous celle-ci, plutôt que de changer de politique en cours de génération, et chaque synchronisation charge la version suivante avant de décharger la plus ancienne. L’entraîneur vérifie les deux valeurs au démarrage et vous indique avec quelles valeurs relancer le serveur.
vLLM charge les adaptateurs depuis le disque plutôt que via le réseau, le formateur écrit donc chaque version sous <output_dir>/.vllm_lora/ et transmet le chemin au serveur. Si le serveur s’exécute sur une machine différente, ce répertoire doit se trouver sur un système de fichiers accessible aux deux.
<output_dir>/.vllm_lora/est un cache de service, et non l’endroit où votre adaptateur entraîné est conservé. Il ne contient que les versions les plus récentes, et chacune est supprimée peu après avoir quitté la fenêtre de fraîcheur. Les points de contrôle sont ce qui préserve l’adaptateur que vous avez entraîné, il ne faut donc pas les désactiver : avecsave_strategy="no", une exécution de plusieurs heures se termine sans laisser aucune trace.output_dirdoit également être lisible par le serveur et doit survivre à la tâche, de sorte qu’un espace de travail local au nœud ne fonctionnera pas, même s’il permettrait d’éviter les synchronisations sur un système de fichiers partagé lent.
La synchronisation d’adaptateurs n’est pas toujours plus rapide. vLLM génère environ 1,33 à 1,39 fois plus lentement par jeton lorsqu’il sert un adaptateur LoRA par rapport à des poids fusionnés, et la génération est généralement ce qui domine le temps réel. En contrepartie, vous obtenez une pause beaucoup plus courte à chaque synchronisation et environ 1 % de la bande passante de synchronisation. Si le débit de génération est votre goulot d’étranglement, la synchronisation fusionnée reste souvent le meilleur choix.
Métriques journalisées
Un déroulement traverse plusieurs étapes avant de devenir un gradient. Examinons d’abord les différentes étapes, depuis un prompt jusqu’à la composition finale de notre lot :
Dataset row = PROMPT (message list + optional `teacher_id`)
└─ ROLLOUT (1 prompt -> 1 student completion -> 1 teacher scoring call)
├─ generate (student's vLLM /v1/completions, sampled)
└─ score (the routed teacher's /v1/completions with `prompt_logprobs`, teacher-forced)
└─ SAMPLE (prompt + completion + the teacher's sparse per-position distribution)
════════════ Trainer process boundary: `rollout_buffer` (mp.Queue) ════════════
└─ SAMPLE (Pulled 1 at a time; dropped if staleness > `max_staleness`)
└─ ROW (Planner assigns it to one of `dp` rows, Σ Lᵢ²-balanced)
└─ MICRO-BATCH (`dp` rows, one per rank)
└─ PACKED ROW (1 concat sequence, `position_ids` reset per sample)
└─ FORWARD (`compute_loss`, bs=1, inter-rank padding stripped)
└─ OPTIMIZER STEP (from `grad_accum` micro-batches)En le lisant de haut en bas :
- un rollout correspond à un prompt généré une seule fois et évalué une seule fois. Il n'y a pas de groupe : la distillation ne dispose d'aucune ligne de base d'avantage à calculer entre les générations, si bien qu'un prompt n'est pas répété et qu'un seul rollout produit exactement un seul échantillon d'entraînement.
- un échantillon est constitué de cette complétion ainsi que des
teacher_top_kmeilleurs candidats du modèle enseignant pour chaque position de la complétion. C'est ce qui traverse la frontière de processus. - au-delà de la limite, le formateur répartit les échantillons en lignes (une par rang DP), regroupe chaque ligne en une seule séquence concaténée et accumule
grad_accummicro-lots en une seule étape d'optimiseur.
Nous divisons donc nos métriques en fonction de l'étape (ou de l'entité) qu'elles concernent :
| namespace | entité qu'il compte |
|---|---|
rollout/ | un aller-retour de génération et de notation : la durée et la distance parcourue |
completions/ | ce que l'étudiant (vLLM) a généré pour un prompt |
sample/ | représente un échantillon d'entraînement, tel qu'il arrive dans la file d'attente |
batch/ | un micro-lot ou une étape d'optimiseur (construit à partir d'un ou de plusieurs échantillons) |
perf/ | secondes mesurées et FLOPs |
Tout ce que la perte elle-même mesure est consigné sans préfixe (jsd, entropy, teacher_entropy), avec un détail teacher/<teacher_id>/* sous MOPD — voir la divergence ci-dessous.
Définissons également quelques termes pour rendre les métriques de jetons non ambiguës :
- Les jetons generated sont ceux produits par l'élève (
completions/*). - Les jetons forwarded sont tous les jetons traités par le passage forward : le prompt et les jetons générés.
- Les jetons trained constituent le sous-ensemble sur lequel la perte est calculée, là où
completion_mask == 1. Trained ≠ generated : une position de complétion pour laquelle l’enseignant n’a pas noté de candidat est masquée de la divergence, mais reste transmise.
Les métriques sont journalisées une fois par fenêtre de journalisation : tout ce qui a été enregistré depuis le dernier journal, couvrant les logging_steps dernières étapes d’optimiseur. Sur la fenêtre :
- Une moyenne mesurée par déroulement, échantillon ou appel, comme
rollout/duration_setrollout/score_s, est moyennée sur l’ensemble des déroulements, échantillons ou appels de la fenêtre. Un taux commerollout/generated_tokens_per_sest le nombre total de jetons divisé par le nombre total de secondes. - Sinon, un nom dont la dernière partie contient le mot
countest additionné :sample/dropped_stale_countest le nombre d’échantillons abandonnés depuis le dernier journal, et non depuis le début de l’entraînement. - Un nom dont la dernière partie contient le mot
maxoumin, commesample/staleness_maxoucompletions/max_length, conserve la valeur la plus grande ou la plus petite. - Toute autre métrique est la moyenne des valeurs enregistrées dans la fenêtre.
Unités :
_s: secondes.tokens_per_s: jetons par seconde._frac: fraction comprise entre 0 et 1._per_step: quantité par pas d'optimiseur, moyenne des pas de la fenêtre.
Les métriques que GRPOTrainer enregistre également conservent leurs noms GRPO (completions/mean_length, completions/clipped_ratio).
Comment les numéros de lot se composent
Une ligne est ce qu'un rang DP transmet dans un micro-lot : plusieurs échantillons concaténés en une seule séquence, avec position_ids qui repartent à zéro à chaque frontière d'échantillon. Le planificateur décide dans quelle ligne se trouvent quels échantillons (en équilibrant Σ Lᵢ² pour qu'aucun rang ne soit en retard), et un collateur de données effectue la concaténation.
Dans toutes nos métriques, un « step » désigne toujours un pas d’optimiseur COMPLET, jamais un micro-lot. gradient_accumulation_steps micro-lots constituent un pas, et toute métrique nommée _per_step est exprimée par pas d’optimiseur, conformément à global_step, logging_steps et au reste du vocabulaire de Trainer. Lorsqu’une métrique est exprimée par micro-lot, c’est indiqué (batch/microbatches_per_step) ou il s’agit d’une quantité par ligne (batch/row_*, batch/samples_per_row).
Une étape contient donc un nombre fixe de row-slots :
row-slots per step = gradient_accumulation_steps x world_sizece qui permet de composer les métriques par lot en une échelle que vous pouvez vérifier les unes par rapport aux autres :
sample sample/forwarded_tokens_mean
└─ packed into a ROW batch/samples_per_row, batch/row_tokens_mean
└─ one row per DP rank = one micro-batch
└─ gradient_accumulation_steps micro-batches = one STEP
batch/samples_per_step, batch/forwarded_tokens_per_stepAinsi, batch/samples_per_step ≈ row-slots x batch/samples_per_row, et de même pour les jetons. Les deux côtés ne concordent que jusqu’à la variation entre les micro-lots au sein de l’étape — les métriques par étape sont des sommes, celles par ligne sont des moyennes — il faut donc s’attendre à une différence de l’ordre du pour cent, et non à une correspondance exacte.
batch/row_fill_frac est l’indicateur à surveiller lorsque les échantillons sont longs : un échantillon de 10 k jetons remplit mal un budget de 32 k (trois tiennent, quatre ne tiennent jamais, de sorte que l’empaqueur n’en obtient souvent que deux et que la ligne est remplie à environ 77 %), tandis que des échantillons de 1 k jetons le remplissent presque parfaitement. Il s’agit d’un effet de quantification, pas d’un bug, et token_budget est le levier à actionner — en gardant à l’esprit que l’attention est en O(L²) par séquence, si bien qu’une ligne plus remplie de séquences longues n’entraîne pas une augmentation linéaire de la mémoire.
La file d'attente de déploiement
Le worker pousse les échantillons notés dans une file d’attente et le trainer en tire. Quatre métriques décrivent cette file d’attente unique et répondent à des questions différentes :
| métrique | question |
|---|---|
rollout/queue_size | combien d'échantillons sont en attente en ce moment |
sample/time_in_queue_s | le temps pendant lequel un échantillon unique est resté là avant d'être utilisé pour l'entraînement — la moitié en secondes de son caractère hors politique |
perf/rollout_wait_s | la durée pendant laquelle l'entraînement est resté bloqué parce que la file d'attente était vide |
rollout/backpressure_s | durée d'attente de la génération (le worker) car elle était en avance de max_staleness étapes sur l'entraînement |
Les deux dernières métriques (perf/rollout_wait_s et rollout/backpressure_s) sont des images miroir. Les lire ensemble avec la taille de la file vous indique quel côté est le goulot d'étranglement :
- File d'attente presque vide,
perf/rollout_wait_sélevé → limité par la génération. Le formateur est en manque de données ; examinezrollout/generated_tokens_per_s,rollout/concurrencyetrollout/score_s. - file d’attente contenant environ
max_stalenessétapes de jetons,rollout/backpressure_sélevé → limité par l’entraîneur. La génération est freinée etsample/staleness_meanse situe près de sa limite. - les deux sont élevés → la limite
max_stalenesselle-même est trop stricte : les rollouts en cours remplissent cette limite avant que leurs échantillons n’atteignent la file d’attente, si bien que l’entraîneur attend tandis que la génération est freinée. Augmentezmax_staleness. - les deux proches de zéro → équilibré !
Complétions
Un completion est ce que le serveur vLLM de l’étudiant a généré pour un prompt.
| métrique | signification |
|---|---|
completions/mean_length | jetons générés par déroulement |
completions/min_length, completions/max_length | complétion la plus courte et la plus longue dans la fenêtre |
completions/clipped_ratio | fraction des complétions qui ne se sont pas terminées sur EOS, c'est-à-dire qui ont été coupées par max_completion_length |
completions/mean_terminated_length, completions/min_terminated_length, completions/max_terminated_length | les mêmes longueurs, sur les complétions qui se sont terminées par EOS |
Rollouts
Un rollout est un prompt traité de bout en bout : généré par l’étudiant, puis soumis à son enseignant en mode teacher-forcing. Comme l’appel à l’enseignant se trouve sur le chemin critique de chaque rollout (contrairement à GRPO, où la notation est une boucle distincte sur des groupes terminés), un enseignant lent se traduit directement par rollout/duration_s.
| métrique | signification |
|---|---|
rollout/duration_s | temps réel d'un rollout, de la distribution à un échantillon noté : génération et appel au teacher |
rollout/score_s | de cela, le temps que la requête /v1/completions de l’enseignant a pris |
teacher/<id>/score_s | MOPD uniquement : idem, par enseignant. Un expert lent ne ralentit que les déroulements qui lui sont routés, ce que la moyenne mélangée masque |
rollout/generated_tokens_per_s | débit de génération sur la dernière fenêtre (fenêtré), de sorte qu'un blocage se manifeste |
rollout/concurrency | rollouts en cours, c'est-à-dire en cours de génération ou d'évaluation |
rollout/vllm_retry_count | requêtes vLLM réessayées, soit vers le serveur de l’étudiant, soit vers celui d’un enseignant. Un serveur dégradé se manifeste sinon par une lenteur inexpliquée. Il se trouve ici plutôt que dans completions/ car il compte les requêtes envoyées à un serveur, et non le texte généré |
rollout/backpressure_s | durée d'attente de la génération car elle était en avance de max_staleness étapes. Voir la file d'attente de déroulement |
rollout/queue_size | échantillons notés en attente dans la file de rollout, mesurés au point où le formateur les récupère. Voir la file de rollout |
Échantillons arrivant depuis la file d'attente
Chaque échantillon est un RolloutSample : un prompt, la complétion de l’étudiant et le scoreage creux du professeur. Le worker les pousse dans rollout_buffer ; tout ce qui suit est mesuré côté formateur, au moment où il les récupère pour l’entraînement.
| métrique | signification |
|---|---|
sample/forwarded_tokens_mean, sample/forwarded_tokens_max | jetons dans un échantillon : invite + générés. Le packing est une préoccupation au niveau de la ligne, voir batch/row_* |
sample/trained_tokens_mean | parmi ceux-ci, combien sont pris en compte dans la perte |
sample/time_in_queue_s | le temps que cet exemple a passé dans cette file d'attente avant d'être utilisé pour l'entraînement. Ce n'est pas la même chose que perf/rollout_wait_s — voir la file d'attente de rollout |
sample/staleness_mean, sample/staleness_max | de combien de versions de politique la donnée est en retard. jsd montre l'effet du caractère hors-politique sur la perte ; cela montre la cause |
sample/dropped_stale_count | échantillons supprimés pour dépassement de max_staleness |
Lots
Un micro-lot correspond à world_size lignes (rappelons que le packing aplatit en une seule séquence), soit un par rang DP, de sorte que le rang i effectue le forward de la ligne i. gradient_accumulation_steps de ces micro-lots constituent une étape d’optimiseur. Une étape couvre donc au total gradient_accumulation_steps × world_size lignes. Chaque métrique _per_step ci-dessous est une somme sur l’ensemble de l’étape et sur tous les rangs ; les métriques batch/row_* sont des moyennes sur les lignes.
| métrique | signification |
|---|---|
batch/forwarded_tokens_per_step, batch/trained_tokens_per_step | jetons dans une étape d'optimiseur, respectivement en avant et en entraînement |
batch/samples_per_step | échantillons d'entraînement par étape d'optimiseur |
batch/microbatches_per_step | comptés, non lus dans la configuration |
batch/masked_token_frac | jetons transmis avec completion_mask == 0 — la part du calcul avant qui ne génère aucun gradient |
batch/samples_per_row, batch/row_tokens_mean, batch/row_tokens_max | la densité avec laquelle le planificateur a rempli la ligne de chaque rang |
batch/row_fill_frac | jetons de ligne par rapport à token_budget. Une valeur faible indique que le budget n'est pas utilisé |
batch/row_imbalance | max Σ Lᵢ² / mean Σ Lᵢ² sur les lignes. L'attention est en O(L²), ce qui permet de prédire quel rang bloque l'all-reduce des gradients. 1,0 est parfait |
batch/pad_frac | remplissage inter-rang. Coûte uniquement des octets de diffusion ; il est retiré avant le calcul en avant |
batch/dropped_oversize_count | échantillons supprimés pour dépassement de token_budget |
La divergence
Ce que la fonction objectif mesure elle-même, en moyenne sur les jetons entraînés de la fenêtre. Ce sont les chiffres à surveiller pour l'apprentissage, par opposition à ceux du débit.
| métrique | signification |
|---|---|
jsd | la JSD généralisée que la perte minimise, avec le beta configuré. Une baisse indique que la distribution de l’élève converge vers celle de l’enseignant |
entropy | l’entropie prédictive propre à l’élève. Un effondrement ici, accompagné d’une baisse de jsd, indique que l’élève se resserre plutôt qu’il n’apprend |
teacher_entropy | l’entropie de l’enseignant sur les candidats qu’il a signalés. Inférieure à la valeur réelle, car seuls teacher_top_k candidats sont transmis |
teacher/<id>/jsd | MOPD uniquement : jsd restreint aux jetons évalués par l'enseignant. Les enseignants de différents domaines peuvent diverger à des taux très différents, ce que le jsd mélangé confond |
teacher/<id>/entropy | MOPD uniquement : le même décompte de teacher_entropy |
teacher/<id>/token_frac | MOPD uniquement : la part de jetons évalués que l’enseignant a pris. Le déséquilibre de routage reste autrement invisible : un enseignant privé de lignes signale toujours un teacher/<id>/jsd sain. |
aux_loss | perte d’équilibrage de charge du routeur MoE par micro-lot, moyenne sur les rangs, enregistrée lorsque le modèle renvoie les logits du routeur et que router_aux_loss_coef n’est pas 0. Contrairement aux lignes ci-dessus, ce n’est pas une moyenne par jeton |
Il n’existe pas d’entropy par enseignant : l’entropie de l’élève est une propriété de sa propre politique, et non de l’enseignant qui a évalué l’échantillon, de sorte que la métrique combinée la couvre déjà.
Performance
Le débit mesure le nombre de jetons que le formateur traite par seconde. Model FLOPs Utilization (MFU) estime le pourcentage de la capacité de calcul théorique des appareils d’entraînement utilisé pour les passes avant et arrière du modèle. La capacité utilisée pour cette estimation dépend du matériel et de la précision de l’entraînement.
Le débit et le MFU sont rapportés sur deux bases temporelles :
fwd_bwd_mesure les performances lors des passes avant et arrière.wall_clock_mesure les performances sur l'ensemble de l'étape d'optimiseur, y compris les mises à jour de l'optimiseur, la synchronisation des poids et le temps passé en attente des déroulements.
Cette différence permet de distinguer les performances de calcul du coût lié à l’attente et à la coordination. Les deux métriques MFU décrivent uniquement les appareils d’entraînement : elles n’incluent ni le calcul ni la capacité matérielle des serveurs de rollout ou d’enseignant externes. Le MFU wall-clock reflète le temps que le formateur passe à attendre ces services, et non l’utilisation de ces services eux-mêmes.
MFU est signalé uniquement lorsque la capacité de calcul de pointe est connue pour le périphérique d’entraînement local à la précision sélectionnée, et lorsque l’estimation des FLOPs prend en charge l’architecture du modèle (telle que Llama, Qwen2, Qwen3, Qwen3-MoE ou Qwen3-VL). Sinon, MFU est omis ; l’entraînement se poursuit et les métriques de débit et de chronométrage restent disponibles.
| métrique | signification |
|---|---|
perf/step_s | temps réel entre les étapes de l'optimiseur : calcul, optimiseur, synchronisation des poids et temps d'attente dans la file d'attente inclus |
perf/fwd_bwd_s | forward + backward, additionné sur les micro-lots de l'étape. C'est le dénominateur de chaque métrique fwd_bwd_ ci-dessous |
perf/fwd_s | la partie avant. fwd_s / fwd_bwd_s proche de 1/3 est le ratio habituel ; une valeur plus élevée signifie que le calcul inverse est peu coûteux ou que le recalcul est payé sur le calcul avant |
perf/optimizer_s | optimizer.step() |
perf/rollout_wait_s | la durée pendant laquelle le formateur est resté bloqué car la file d'attente était vide. Voir la file d'attente de déroulement |
perf/weight_sync_s | un synchronisation complète, plus _pause_s (attente de vLLM), _barrier_s (déséquilibre des rangs) et _transfer_s (les octets) |
perf/fwd_bwd_forwarded_tokens_per_s, perf/wall_clock_forwarded_tokens_per_s | jetons transmis par seconde sur chaque base |
perf/wall_clock_trained_tokens_per_s | identique, en ne comptant que les jetons vus par la perte |
perf/fwd_bwd_mfu, perf/wall_clock_mfu | utilisation des FLOPs du modèle sur chaque base |
Philosophie de conception
Ce formateur est volontairement maintenu au minimum et n’est pas conçu pour devenir une solution à usage général. Si vous avez besoin d’une fonctionnalité non prise en charge, nous vous recommandons de cloner le dépôt et d’adapter le formateur directement à vos besoins. De nouvelles fonctionnalités ne seront prises en compte que s’il existe une demande significative de la part de la communauté.
AsyncDistillationConfig
classe trl.experimental.async_distillation.AsyncDistillationConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 1logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Truerestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonedtype: str = 'float32'trust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonemax_completion_length: int = 2048temperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonerepetition_penalty: float = 1.0chat_template_kwargs: dict | str | None = Nonevllm_server_base_url: str = 'http://localhost:8000'vllm_server_timeout: float = 1800.0teacher_server_urls: dict[str, str] | str | None = Nonebeta: float = 0.0teacher_temperature: float = 1.0teacher_top_k: int = 8add_tail_bucket: bool = Truetoken_budget: int | None = Nonemax_concurrent_rollouts: int = 512max_staleness: int = 4weight_sync_steps: int = 1rollout_worker_timeout: float = 300.0log_completions: bool = Falselog_completions_steps: int = 100num_completions_to_print: int | None = None )
Paramètres qui contrôlent le modèle
- model_init_kwargs (
dict[str, Any]oustr, facultatif) — Arguments par mot-clé pour from_pretrained, utilisés lors de l’instanciation du modèle élève à partir d’un chemin. La valeur derevisionest également utilisée lors du chargement de la classe de traitement. - dtype (
str, facultatif, par défaut"float32") — Type de données pour charger le modèle élève, l'un des"auto","bfloat16","float16"ou"float32". Il est défini par défaut sur"float32"car le décalage entre l'entraînement et l'inférence, auquel les entraîneurs asynchrones sont comparés (Defeating the Training-Inference Mismatch via FP16) ) est sensible à la précision de l'entraîneur lui-même. Pour combler cet écart de bout en bout, il faut également servir le serveur vLLM de l'élève avec le même type de données (vllm serve --dtype). Adtypedansmodel_init_kwargsa la priorité. Les serveurs enseignants ne sont pas affectés : ils ne sont jamais mis à jour.Cela ne définit que le dtype dans lequel les poids sont chargés. Sous FSDP avec précision mixte (
bf16=Trueest la valeur par défaut), accelerate convertit chaque paramètre entraînable en fp32 avant le sharding, de sorte que les poids maîtres et l'état de l'optimiseur sont en fp32, indépendamment de la valeur dedtype, tandis que les passes avant et arrière s'exécutent en bf16 ou fp16. Les points de contrôle sont ensuite écrits dans ce dtype de précision mixte, et non en fp32. Sans FSDP, aucune conversion ascendante n'est effectuée :dtype="bfloat16"avecbf16=Trueconserve les poids et les états de l'optimiseur en bf16, ce qui correspond à un entraînement en bf16 pur. - trust_remote_code (
bool, facultatif, valeur par défautFalse) — Indique s'il faut autoriser le chargement de modèles et de tokenizers qui incluent du code Python personnalisé depuis le Hub. Transmis à from_pretrained et from_pretrained. - router_aux_loss_coef (
float, facultatif) — Coefficient de la perte auxiliaire d’équilibrage de charge pour les modèles Mixture-of-Experts (MoE), ajoutée à la perte d’entraînement avec ce poids. Si non défini, la valeur déclarée par la configuration du modèle est utilisée. Définissez-le à0.0pour le désactiver. Échoue s’il est utilisé avec un modèle non-MoE.
Paramètres qui contrôlent la génération
- max_completion_length (
int, facultatif, par défaut2048) — Nombre maximal de jetons à générer par complétion. - temperature (
float, facultatif, par défaut1.0) — Température pour l'échantillonnage des complétions on-policy de l'étudiant. - top_p (
float, facultatif, valeur par défaut1.0) — Paramètre d'échantillonnage Top-p (noyau) pour la génération on-policy. - top_k (
int, facultatif, valeur par défaut0) — Paramètre d'échantillonnage top-k pour la génération on-policy.0désactive le filtrage top-k. - min_p (
float, facultatif) — Probabilité minimale du jeton, qui sera mise à l'échelle par la probabilité du jeton le plus probable. Elle doit être une valeur comprise entre0.0et1.0. Les valeurs typiques se situent dans la plage0.01-0.2. - repetition_penalty (
float, facultatif, par défaut1.0) — Flottant qui pénalise les nouveaux jetons en fonction de leur présence dans le prompt et dans le texte généré jusqu’à présent. Les valeurs >1.0encouragent le modèle à utiliser de nouveaux jetons, tandis que les valeurs <1.0encouragent le modèle à répéter les jetons. - chat_template_kwargs (
dict[str, Any], facultatif) — Arguments supplémentaires à passer à la fonctionapply_chat_templatelors de la génération des complétions.
Paramètres qui contrôlent les serveurs vLLM
- vllm_server_base_url (
str, facultatif, par défaut"http --//localhost:8000") : URL de base du serveur vLLM de l’étudiant, utilisée à la fois pour la génération et pour le streaming des mises à jour des poids. - vllm_server_timeout (
float, facultatif, valeur par défaut1800.0) — Délai d’attente en secondes pour les appels aux serveurs vLLM : attente de la disponibilité du serveur de l’étudiant au démarrage, chaque requête de génération ou de notation, et chaque appel de synchronisation des poids. L’attente du serveur et les appels de synchronisation des poids lèvent une exception en cas d’expiration ; une requête de génération ou de notation expirée est réessayée. - teacher_server_urls (
dict[str, str], facultatif, par défaut{"default" -- "http://localhost:8001"}) : Serveur(s) vLLM enseignant(s), chacun démarré avecvllm serve <teacher-model> --logprobs-mode processed_logprobs --max-logprobs -1. Chaque enseignant est statique : cet entraîneur n’envoie jamais de mises à jour de poids à aucun d’entre eux, de sorte qu’un enseignant n’a besoin ni deVLLM_SERVER_DEV_MODEni d’un backend de transfert de poids, seulement de ces deux drapeaux, qui rendent son scoring exact (voirteacher_temperatureetteacher_top_k). Chaque enseignant doit partager le tokeniseur de l’étudiant : les complétions sont envoyées sous forme d’identifiants de jetons bruts, et les identifiants rapportés par un enseignant sont utilisés directement pour indexer le vocabulaire propre à l’étudiant danscompute_loss. Un enseignant avec un vocabulaire différent s’entraîne contre les mauvais jetons, silencieusement si son vocabulaire n’est pas plus grand que celui de l’étudiant. Le scoring est une requête teacher-forced contre les jetons de complétion propres à l’étudiant (max_tokens=1,prompt_logprobs=teacher_top_k,temperature=teacher_temperature), la même requête que celle émise parget_sequence_logprobs()pour les entraîneurs synchrones avec enseignant serveur. En raison de ce jeton jetable, un enseignant a besoin d’un--max-model-lenplus grand que celui de l’étudiant, sinon les complétions les plus longues ne peuvent pas être scorées. Une seule entrée score tous les échantillons (distillation on-policy à enseignant unique simple, par défaut). Plusieurs entrées activent MOPD (distillation on-policy multi-enseignants, voir MOPD) : la colonneteacher_idde chaque ligne d’entraînement sélectionne quelle entrée la score, par exemple{"math": "http://localhost:8002", "code": "http://localhost:8003"}avec unteacher_idde"math"ou"code"par ligne.
Paramètres qui contrôlent la perte de distillation
- beta (
float, facultatif, valeur par défaut0.0) — Coefficient d’interpolation pour la divergence de Jensen-Shannon généralisée.0.0correspond à la KL avant (recherche de la moyenne),1.0à la KL arrière (recherche du mode), et les valeurs intermédiaires effectuent une interpolation, conformément à la même formulation de JSD généralisée que DistillationTrainer calcule en interne. Le support sur lequel la divergence est calculée varie selon le régime, à l’image deServerDistillationTrainer: pourbeta=0.0, le support complet de largeurteacher_top_ksignalé par l’enseignant (plus le seau de la queue) est utilisé, car le pondération de la KL avant est exactement ce que ce support fournit. Pourbeta != 0.0, le support est restreint à seulement deux candidats — le jeton top-1 de l’enseignant et le jeton réel/observé de la complétion — car ce sont les seuls deux jetons pour lesquels le protocole de communication garantit un logprob de l’enseignant sans transmettre un vocabulaire plus large (ou complet) ; tout support plus large ne serait qu’une approximation probabiliste de la couverture des jetons probables de l’étudiant, et non une garantie. - teacher_temperature (
float, facultatif, valeur par défaut1.0) — Température du softmax de la divergence, appliquée aux deux côtés : envoyée au teacher afin que vLLM calcule ses logprobs à cette température côté serveur (exact, et non une rééchelonnage côté client), et appliquée aux logits du student danscompute_loss, reflétant latemperatureunique deServerDistillationTrainer. Sans rapport avectemperature, qui ne contrôle que la manière dont le student échantillonne ses complétions. Le serveur du teacher doit être exécuté avec--logprobs-mode processed_logprobspour que cela atteigne les logprobs qu’il renvoie ; sans cela, le teacher signale silencieusement des logprobs bruts et ce paramètre n’affecte que le côté du student. - teacher_top_k (
int, facultatif, valeur par défaut8) — Nombre de jetons candidats par position demandés au modèle enseignant viaprompt_logprobs. Seuls ces candidats (ainsi que le jeton réalisé, que vLLM signale toujours même s’il se situe en dehors du top-k, ainsi qu’un seau de queue capturant la masse de probabilité restante, voiradd_tail_bucket) sont utilisés pour approximer la distribution de l’enseignant ; le vocabulaire complet n’est jamais transmis via HTTP. Le côté étudiant de la divergence est exact (calculé localement, non approximé), car l’étudiant est le modèle en cours d’entraînement et ses logits complets sont déjà disponibles danscompute_loss.8est une valeur par défaut légère destinée aux tests de fumée ; les configurations de distillation on-policy en production dans les frameworks RL adjacents utilisent un support d’enseignant creux dans une fourchette approximativement similaire (miles utilise16par défaut, EasyOPD utilise64), il est donc raisonnable d’augmenter cette valeur vers16–64dès que l’entraînement est réel. Toute valeur supérieure à20exige que le serveur de l’enseignant ait été démarré avec--max-logprobs -1, ce qui lève la limite par défaut de vLLM sur les logprobs par jeton. - add_tail_bucket (
bool, facultatif, valeur par défautTrue) — Indique s'il faut ajouter un seau de fin représentant la masse de probabilité restante en dehors deteacher_top_k, afin d'éviter une divergence trivialement faible lorsqueteacher_top_kest petit. - token_budget (
int, facultatif) — Nombre maximal de jetons réels regroupés dans une seule ligne (un avant d’un rang DP). UnTokenBudgetBatcherforme des micro-lots équilibrés selon Σ Lᵢ² dont chaque ligne reste dans cette limite, bornant ainsi la mémoire de pointe indépendamment du nombre d’échantillons (le nombre d’échantillons par ligne devient dynamique). SiNone(par défaut), il est fixé à la valeurmax_model_lendu serveur vLLM de l’étudiant (interrogée au démarrage de l’entraînement) — la limite de longueur prompt + complétion — de sorte qu’aucun échantillon de déroulement ne puisse dépasser le budget. Un échantillon plus long quetoken_budgetne tient dans aucune ligne et est écarté avec un avertissement, comptabilisé dansbatch/dropped_oversize_count.
Paramètres qui contrôlent le pipeline de déploiement asynchrone
- max_concurrent_rollouts (
int, facultatif, valeur par défaut512) — Nombre maximal de rollouts en cours d’exécution simultanément auprès des serveurs vLLM de l’étudiant et des enseignants, en cours de génération ou d’évaluation. - max_staleness (
int, facultatif, valeur par défaut4) — Nombre maximal d'étapes de mise à jour des poids qu'un échantillon de rollout peut retarder par rapport à la version actuelle du modèle avant d'être écarté. La génération est limitée en conséquence : un rollout ne démarre que si les tokens en file d'attente et en cours de traitement tiennent dans ce que le formateur consomme enmax(max_staleness, 1)étapes. - weight_sync_steps (
int, facultatif, valeur par défaut1) — Nombre d'étapes d'entraînement entre les synchronisations de poids vers le serveur vLLM de l'élève. - rollout_worker_timeout (
float, facultatif, valeur par défaut300.0) — Nombre de secondes écoulées depuis le dernier battement de cœur du worker de rollout après lesquelles le formateur le considère comme bloqué et interrompt le processus.
Paramètres qui contrôlent la journalisation
- log_completions (
bool, facultatif, par défautFalse) — Indique s'il faut consigner un échantillon de paires (prompt, completion) toutes leslog_completions_stepsévaluations. - log_completions_steps (
int, facultatif, valeur par défaut100) — Nombre d'échantillons notés entre les enregistrements des complétions. Utilisé uniquement silog_completionsestTrue. Compté en échantillons que le worker de rollout a notés, et non en étapes d'optimiseur : le worker s'exécute dans un processus séparé de celui de l'entraîneur et n'a pas accès àself.state.global_step. - num_completions_to_print (
int, facultatif) — Nombre de complétions à afficher avecrich. SiNone, toutes les complétions sont journalisées.
Classe de configuration pour experimental.async_distillation.AsyncDistillationTrainer.
Cette classe ne contient que les paramètres spécifiques à la distillation asynchrone on-policy. Pour la liste complète des arguments d’entraînement, veuillez consulter la documentation de TrainingArguments. Notez que les valeurs par défaut de cette classe peuvent différer de celles de TrainingArguments. Sa structure est identique à celle de AsyncGRPOConfig (pipeline asynchrone, serveur vLLM, champs de journalisation identiques), avec les champs de clipping/groupe de GRPO remplacés par les champs de perte de distillation par l’enseignant ci-dessous.
Ces paramètres ont des valeurs par défaut différentes de TrainingArguments :
logging_steps: la valeur par défaut est1au lieu de500.gradient_checkpointing: la valeur par défaut estTrueau lieu deFalse.bf16: passe àTruepar défaut sifp16n’est pas défini, au lieu deFalse.learning_rate: la valeur par défaut est1e-6au lieu de5e-5.ignore_data_skip: la valeur par défaut estTrueau lieu deFalse; la boucle de saut et de rejouage du Trainer de base ne s’applique pas à la file d’attente de déroulement asynchrone.
AsyncDistillationTrainer
classe trl.experimental.async_distillation.AsyncDistillationTrainer
< source >( model: str | PreTrainedModelargs: trl.experimental.async_distillation.async_distillation_config.AsyncDistillationConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)peft_config: PeftConfig | None = None )
Paramètres
- model (
strou PreTrainedModel) — Modèle élève à entraîner. Peut être soit :- Une chaîne de caractères, correspondant à l'identifiant du modèle d'un modèle pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co, ou à un chemin vers un dossier contenant les poids du modèle enregistrés à l'aide de save_pretrained. Chargé avec from_pretrained.
- Un objet PreTrainedModel. Son implémentation d’attention est basculée sur le backend FlashAttention de l’entraîneur pour une formation sans bourrage.
Le nom du modèle issu de la configuration est utilisé pour identifier le modèle étudiant sur son serveur vLLM.
- args (experimental.async_distillation.AsyncDistillationConfig, facultatif) —
Configuration de ce formateur. Si
None, une configuration par défaut est utilisée. - train_dataset (Dataset ou IterableDataset) —
Jeu de données à utiliser pour l’entraînement. Doit inclure une colonne
"prompt"(format conversational). Toute colonne supplémentaire est ignorée. - processing_class (PreTrainedTokenizerBase, facultatif) —
Classe de traitement utilisée pour traiter les données. Si
None, elle est chargée à partir du nom du modèle avec from_pretrained. S’il n’a pas de jeton de bourrage,tokenizer.eos_tokenest utilisé. - callbacks (liste de TrainerCallback, facultatif) — Liste de callbacks pour personnaliser la boucle d'entraînement, ajoutée aux callbacks par défaut (voir ici).
- optimizers (
tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], facultatif, par défaut(None, None)) — Un tuple contenant l'optimiseur et le planificateur à utiliser. Par défaut,AdamWet un planificateur linéaire contrôlé parargs. - peft_config (
PeftConfig, facultatif) — Configuration PEFT utilisée pour envelopper le modèle. SiNone, le modèle n’est pas enveloppé. Lorsque le serveur vLLM de l’étudiant a été démarré avec--enable-lora, un adaptateur LoRA y est synchronisé en tant qu’adaptateur plutôt qu’en tant que poids fusionnés ; voir la section LoRA de la documentation AsyncDistillation.
Contrepartie asynchrone de DistillationTrainer, conçue exactement comme AsyncGRPOTrainer : un travailleur de rollout en arrière-plan génère les complétions on-policy de l’étudiant et les évalue par rapport à un serveur enseignant, tandis que l’entraînement se déroule de manière concurrente, découplant le rollout de la boucle de mise à jour des gradients. Là où la perte de gradient de politique tronquée de GRPO lit un avantage relatif au groupe, la fonction compute_loss de ce formateur lit une distribution d’enseignant par position, creuse, et minimise une JSD généralisée par rapport à celle-ci (voir AsyncDistillationConfig.beta), toujours on-policy : l’étudiant génère chaque complétion sur laquelle il s’entraîne.
Contrairement au DistillationTrainer synchrone, ce formateur ne prend en charge que la notation par rapport à un enseignant servi via HTTP (un serveur vLLM externe). Un passage avant local (in-process, GPU) de l’enseignant ne peut pas s’exécuter dans le processus enfant généré avec CUDA désactivé du travailleur de rollout, de la même manière que les fonctions de récompense de GRPO, et devrait au contraire s’exécuter dans le processus principal d’entraînement ; ce chemin n’est pas encore implémenté.
Exemple :
>>> from trl.experimental.async_distillation import AsyncDistillationTrainer
>>> from datasets import load_dataset
>>> dataset = load_dataset("trl-lib/DeepMath-103K", split="train")
>>> trainer = AsyncDistillationTrainer(
... model="Qwen/Qwen2.5-0.5B-Instruct",
... train_dataset=dataset,
... )
>>> trainer.train()