TRL documentation

Distillation asynchrone

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Distillation asynchrone

Ce formateur nécessite vllm, transformers>=5.2.0 et kernels (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, vllm et transformers ont des contraintes de dépendances conflictuelles. Pour contourner ce problème, installez d’abord vLLM, puis forcez l’installation de transformers, puis ajoutez kernels via 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/completions de l’enseignant résolu avec prompt_logprobs pour 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.py

LoRA

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 6

VLLM_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 : avec save_strategy="no", une exécution de plusieurs heures se termine sans laisser aucune trace. output_dir doit é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_k meilleurs 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_accum micro-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 :

namespaceentité 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_s et rollout/score_s, est moyennée sur l’ensemble des déroulements, échantillons ou appels de la fenêtre. Un taux comme rollout/generated_tokens_per_s est le nombre total de jetons divisé par le nombre total de secondes.
  • Sinon, un nom dont la dernière partie contient le mot count est additionné : sample/dropped_stale_count est 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 max ou min, comme sample/staleness_max ou completions/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_size

ce 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_step

Ainsi, 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étriquequestion
rollout/queue_sizecombien d'échantillons sont en attente en ce moment
sample/time_in_queue_sle 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_sla durée pendant laquelle l'entraînement est resté bloqué parce que la file d'attente était vide
rollout/backpressure_sduré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 ; examinez rollout/generated_tokens_per_s, rollout/concurrency et rollout/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 et sample/staleness_mean se situe près de sa limite.
  • les deux sont élevés → la limite max_staleness elle-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. Augmentez max_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étriquesignification
completions/mean_lengthjetons générés par déroulement
completions/min_length, completions/max_lengthcomplétion la plus courte et la plus longue dans la fenêtre
completions/clipped_ratiofraction 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_lengthles 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étriquesignification
rollout/duration_stemps réel d'un rollout, de la distribution à un échantillon noté : génération et appel au teacher
rollout/score_sde cela, le temps que la requête /v1/completions de l’enseignant a pris
teacher/<id>/score_sMOPD 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_sdébit de génération sur la dernière fenêtre (fenêtré), de sorte qu'un blocage se manifeste
rollout/concurrencyrollouts en cours, c'est-à-dire en cours de génération ou d'évaluation
rollout/vllm_retry_countrequê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_sduré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étriquesignification
sample/forwarded_tokens_mean, sample/forwarded_tokens_maxjetons 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_meanparmi ceux-ci, combien sont pris en compte dans la perte
sample/time_in_queue_sle 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_maxde 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étriquesignification
batch/forwarded_tokens_per_step, batch/trained_tokens_per_stepjetons 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_stepcomptés, non lus dans la configuration
batch/masked_token_fracjetons 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_maxla densité avec laquelle le planificateur a rempli la ligne de chaque rang
batch/row_fill_fracjetons de ligne par rapport à token_budget. Une valeur faible indique que le budget n'est pas utilisé
batch/row_imbalancemax Σ 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_fracremplissage 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étriquesignification
jsdla 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
entropyl’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_entropyl’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>/jsdMOPD 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>/entropyMOPD uniquement : le même décompte de teacher_entropy
teacher/<id>/token_fracMOPD 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_lossperte 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étriquesignification
perf/step_stemps 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_sforward + backward, additionné sur les micro-lots de l'étape. C'est le dénominateur de chaque métrique fwd_bwd_ ci-dessous
perf/fwd_sla 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_soptimizer.step()
perf/rollout_wait_sla 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_sun 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_sjetons transmis par seconde sur chaque base
perf/wall_clock_trained_tokens_per_sidentique, en ne comptant que les jetons vus par la perte
perf/fwd_bwd_mfu, perf/wall_clock_mfuutilisation 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

< >

( 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] ou str, 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 de revision est é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). A dtype dans model_init_kwargs a 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=True est 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 de dtype, 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" avec bf16=True conserve 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éfaut False) — 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.0 pour 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éfaut 2048) — Nombre maximal de jetons à générer par complétion.
  • temperature (float, facultatif, par défaut 1.0) — Température pour l'échantillonnage des complétions on-policy de l'étudiant.
  • top_p (float, facultatif, valeur par défaut 1.0) — Paramètre d'échantillonnage Top-p (noyau) pour la génération on-policy.
  • top_k (int, facultatif, valeur par défaut 0) — Paramètre d'échantillonnage top-k pour la génération on-policy. 0 dé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 entre 0.0 et 1.0. Les valeurs typiques se situent dans la plage 0.01-0.2.
  • repetition_penalty (float, facultatif, par défaut 1.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.0 encouragent le modèle à utiliser de nouveaux jetons, tandis que les valeurs < 1.0 encouragent le modèle à répéter les jetons.
  • chat_template_kwargs (dict[str, Any], facultatif) — Arguments supplémentaires à passer à la fonction apply_chat_template lors 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éfaut 1800.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é avec vllm 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 de VLLM_SERVER_DEV_MODE ni d’un backend de transfert de poids, seulement de ces deux drapeaux, qui rendent son scoring exact (voir teacher_temperature et teacher_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 dans compute_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 par get_sequence_logprobs() pour les entraîneurs synchrones avec enseignant serveur. En raison de ce jeton jetable, un enseignant a besoin d’un --max-model-len plus 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 colonne teacher_id de chaque ligne d’entraînement sélectionne quelle entrée la score, par exemple {"math": "http://localhost:8002", "code": "http://localhost:8003"} avec un teacher_id de "math" ou "code" par ligne.

Paramètres qui contrôlent la perte de distillation

  • beta (float, facultatif, valeur par défaut 0.0) — Coefficient d’interpolation pour la divergence de Jensen-Shannon généralisée. 0.0 correspond à 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 de ServerDistillationTrainer : pour beta=0.0, le support complet de largeur teacher_top_k signalé 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. Pour beta != 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éfaut 1.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 dans compute_loss, reflétant la temperature unique de ServerDistillationTrainer. Sans rapport avec temperature, 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_logprobs pour 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éfaut 8) — Nombre de jetons candidats par position demandés au modèle enseignant via prompt_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, voir add_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 dans compute_loss. 8 est 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 utilise 16 par défaut, EasyOPD utilise 64), il est donc raisonnable d’augmenter cette valeur vers 16–64 dès que l’entraînement est réel. Toute valeur supérieure à 20 exige 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éfaut True) — Indique s'il faut ajouter un seau de fin représentant la masse de probabilité restante en dehors de teacher_top_k, afin d'éviter une divergence trivialement faible lorsque teacher_top_k est petit.
  • token_budget (int, facultatif) — Nombre maximal de jetons réels regroupés dans une seule ligne (un avant d’un rang DP). Un TokenBudgetBatcher forme 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). Si None (par défaut), il est fixé à la valeur max_model_len du 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 que token_budget ne tient dans aucune ligne et est écarté avec un avertissement, comptabilisé dans batch/dropped_oversize_count.

Paramètres qui contrôlent le pipeline de déploiement asynchrone

  • max_concurrent_rollouts (int, facultatif, valeur par défaut 512) — 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éfaut 4) — 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 en max(max_staleness, 1) étapes.
  • weight_sync_steps (int, facultatif, valeur par défaut 1) — 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éfaut 300.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éfaut False) — Indique s'il faut consigner un échantillon de paires (prompt, completion) toutes les log_completions_steps évaluations.
  • log_completions_steps (int, facultatif, valeur par défaut 100) — Nombre d'échantillons notés entre les enregistrements des complétions. Utilisé uniquement si log_completions est True. 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 avec rich. Si None, 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 est 1 au lieu de 500.
  • gradient_checkpointing : la valeur par défaut est True au lieu de False.
  • bf16 : passe à True par défaut si fp16 n’est pas défini, au lieu de False.
  • learning_rate : la valeur par défaut est 1e-6 au lieu de 5e-5.
  • ignore_data_skip : la valeur par défaut est True au lieu de False ; 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

< >

( 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 (str ou 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_token est 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, AdamW et un planificateur linéaire contrôlé par args.
  • peft_config (PeftConfig, facultatif) — Configuration PEFT utilisée pour envelopper le modèle. Si None, 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()
Update on GitHub