TRL documentation

Formateur de distillation de logits en ligne généralisée (GOLD)

TRL

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.18.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Formateur de distillation de logits en ligne généralisée (GOLD)

Aperçu

General Online Logit Distillation (GOLD) est une extension de Universal Logit Distillation (ULD) qui prend en charge les paires élève/enseignant avec des tokenizers différents. Elle aligne les segments textuels produits par les deux tokenizers et fusionne les logits associés afin qu'aucun jeton de complétion ne soit omis. Cela permet la distillation de connaissances entre tokenizers, y compris pour des familles de modèles mixtes (par exemple, des élèves LLaMA avec des enseignants Qwen).

Fonctionnalités principales :

Alignement inter-tokeniseurs – GOLD décode de manière incrémentale les jetons de l'élève et de l'enseignant, regroupe les passages partageant le même texte visible et fusionne les probabilités au sein de chaque groupe. Cela garantit que les termes de perte sont calculés sur l'ensemble de la complétion, même lorsque les limites des jetons diffèrent.
Perte ULD hybride – lorsque uld_use_hybrid_loss est activé, GOLD compare directement les correspondances exactes du vocabulaire et utilise la perte ULD de probabilités triées d’origine pour les jetons non correspondants. Cela améliore la stabilité pour les élèves dont les vocabulaires ne chevauchent que partiellement celui de l’enseignant.
Intégration transparente avec GKD – GOLD reprend le planification on-policy vs. off-policy du experimental.gkd.GKDTrainer, ce qui vous permet de combiner la distillation KD au niveau de la séquence, le JSD généralisé et la distillation cross-tokenizer dans une seule exécution d'entraînement.

GOLD fait actuellement partie de l'espace de noms trl.experimental. Les API peuvent changer sans préavis pendant que la fonctionnalité est itérée.

Conseils d'utilisation

La classe experimental.gold.GOLDTrainer est une sous-classe de SFTTrainer et accepte les mêmes jeux de données que les autres formateurs TRL (listes de messages au format ChatML). Les drapeaux de configuration importants de experimental.gold.GOLDConfig incluent :

use_uld_loss – active la distillation universelle de logits. Définissez cette valeur sur True pour les configurations inter-tokeniseurs.
teacher_tokenizer_name_or_path – requis lorsque use_uld_loss=True ; GOLD utilise le tokenizer de l’enseignant pour aligner les jetons.
uld_use_hybrid_loss, uld_hybrid_matched_weight, uld_hybrid_unmatched_weight – active et pondère la perte hybride appariée/non appariée.
beta, lmbda, seq_kd – hérités de experimental.gkd.GKDConfig, contrôlant l'interpolation JSD généralisée et le ratio d'échantillonnage on-policy.
use_privileged_context, teacher_prompt_template, privileged_context_column – permet au teacher de voir un contexte supplémentaire par exemple, tandis que le prompt de l'étudiant reste inchangé. Cette fonctionnalité est actuellement limitée à l'entraînement texte, off-policy, standard-JSD.
num_generations, generation_batch_size – contrôlent la génération de rollout mise en tampon sur les fenêtres d’accumulation de gradients. generation_batch_size est le nombre de prompts uniques par travailleur et par étape d’optimiseur.

Un exemple minimal de bout en bout :

from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer

train_dataset = load_dataset(
    "HuggingFaceTB/OpenR1-Math-220k-default-verified",
    "all",
    split="train[:1024]",
)

trainer = GOLDTrainer(
    model="meta-llama/Llama-3.2-1B-Instruct",
    teacher_model="Qwen/Qwen2.5-0.5B-Instruct",
    args=GOLDConfig(output_dir="gold-model", use_uld_loss=True, teacher_tokenizer_name_or_path="Qwen/Qwen2.5-0.5B-Instruct"),
    train_dataset=train_dataset,
)
trainer.train()

Pour les workflows de démarrage rapide, vous pouvez vous fier aux identifiants sous forme de chaînes de caractères, comme indiqué ci-dessus — le formateur chargera le modèle et le tokeniseur pour vous. L'instantiation explicite de AutoModelForCausalLM, AutoTokenizer ou la population de GOLDConfig est recommandée uniquement pour les cas d'utilisation avancés où vous avez besoin d'un contrôle fin sur l'initialisation.

Un paramétrage plus explicite pourrait ressembler à ceci lorsque vous avez besoin de personnaliser le chargement du modèle, les paramètres du tokenizer ou les arguments d’entraînement :

from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

student_name = "meta-llama/Llama-3.2-1B-Instruct"
teacher_name = "Qwen/Qwen2.5-0.5B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(student_name)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(student_name)
teacher_model = AutoModelForCausalLM.from_pretrained(teacher_name)

train_dataset = load_dataset(
    "HuggingFaceTB/Countdown-Task-GOLD",
    "verified_Qwen2.5-0.5B-Instruct",
    split="train",
)

training_args = GOLDConfig(
    output_dir="gold-model",
    per_device_train_batch_size=1,
    teacher_model_name_or_path=teacher_name,
    teacher_tokenizer_name_or_path=teacher_name,
    use_uld_loss=True,
    uld_use_hybrid_loss=True,
)

trainer = GOLDTrainer(
    model=model,
    teacher_model=teacher_model,
    args=training_args,
    processing_class=tokenizer,
    train_dataset=train_dataset,
)
trainer.train()

GOLD met en mémoire tampon un lot de génération complet correspondant à une fenêtre d'optimiseur (per_device_train_batch_size * gradient_accumulation_steps) et le réutilise au fil des étapes d'accumulation. Si le dernier lot est de taille insuffisante, GOLD émet un avertissement et supprime ce dernier lot (Dropping last batch due to unexpected batch size). Définissez dataloader_drop_last=True pour éviter cet avertissement.

Type de jeu de données attendu

GOLD nécessite un jeu de données de conversation pour le modélisation du langage, par exemple :

{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}

GOLDTrainer conserve les messages bruts afin que le collateur ChatML puisse construire les prompts et les complétions avec les bonnes limites.

Contexte privilégié

La distillation en contexte privilégié fournit au modèle enseignant des informations supplémentaires qui ne sont pas disponibles pour le modèle élève au moment de l'inférence. Ajoutez une colonne de contexte à un jeu de données prompt/complétion standard, puis activez explicitement cette fonctionnalité :

from datasets import Dataset

dataset = Dataset.from_list(
    [
        {
            "prompt": [{"role": "user", "content": "What caused the outage?"}],
            "completion": [{"role": "assistant", "content": "A timeout change caused the outage."}],
            "privileged_context": "The deployment changed the timeout immediately before errors began.",
        }
    ]
)

args = GOLDConfig(
    output_dir="gold-model",
    lmbda=0.0,
    use_privileged_context=True,
)

L’étudiant est entraîné sur le prompt et la complétion d’origine. Par défaut, l’enseignant reçoit un prompt distinct construit à partir de "{prompt}\n\n{privileged_context}", puis évalue exactement la même complétion. Pour les données conversationnelles, GOLD ne réécrit que le dernier tour utilisateur avant de réappliquer le modèle de chat ; les tours système, outil et assistant restent inchangés. Définissez teacher_prompt_template pour personnaliser ce prompt, et privileged_context_column pour utiliser une colonne autre que "privileged_context".

Le prompt de l’enseignant n’est jamais tronqué, veillez donc à ce qu’il tienne dans la fenêtre de contexte du modèle enseignant. Cette prise en charge initiale est volontairement limitée au texte et à la distillation JSD standard hors politique : lmbda doit être 0, et seq_kd=True, use_uld_loss=True, le KD X-Token (xtoken_loss_type autre que "none"), le packing, les VLM et Liger Kernel ne sont pas pris en charge avec un contexte privilégié.

Comment le regroupement de jetons fonctionne

Lorsque l’élève et l’enseignant utilisent des tokenizers différents, le même texte peut être découpé différemment :

Étudiant : "Hugging Face" → 1 jeton
Enseignant : "Hugging", " Face" → 2 jetons

GOLD aligne ces séquences et fusionne les probabilités multi-tokens de l’enseignant en une seule distribution qui peut être comparée à la distribution mono-token de l’étudiant.

Fusion de probabilités

Pour une séquence d’enseignants de jetons [token₀, token₁, ..., tokenₖ] qui correspond à un seul jeton d’élève, GOLD calcule :

P_merged(y) = P(y | context) × P(token₁ | token₀, context) × ... × P(tokenₖ | ..., context)

où :

P(y | context) est la distribution de probabilité marginale sur tous les jetons du vocabulaire à la première position
P(tokenᵢ | ..., context) sont des probabilités conditionnelles scalaires des jetons réellement générés

Point clé : seules les probabilités conditionnelles des jetons de continuation réels sont extraites sous forme de scalaires. La distribution marginale complète à la première position est ensuite mise à l'échelle en multipliant par ces probabilités scalaires.

Cela garantit :

Probabilité conjointe correcte de la séquence réellement générée (par la règle de la chaîne)
Approximation raisonnable pour les jetons contrefactuels (mis à l'échelle par la même probabilité de continuation)
Distributions non normalisées qui préservent les probabilités relatives correctes pour le calcul de la perte ULD

Exemple

Données :

P(x₀):         ["HF": 0.6,  "is": 0.3,  "cool": 0.1]
P(x₁ | "HF"):  ["HF": 0.05, "is": 0.9,  "cool": 0.05]

Si les jetons 0 et 1 sont fusionnés et que la séquence réelle était ["HF", "is"] :

P_merged("HF")   = 0.6 × 0.9 = 0.54  ✓ (correct joint probability)
P_merged("is")   = 0.3 × 0.9 = 0.27
P_merged("cool") = 0.1 × 0.9 = 0.09

La distribution fusionnée est non normalisée (somme à 0,81), mais c'est intentionnel et correct pour le calcul de la perte ULD, qui utilise le tri et la distance L1.

Exemple de script

Utilisez examples/gold_chatbot_arena/gold_chatbot_arena.py pour lancer l’entraînement GOLD depuis la ligne de commande. Le script prend en charge l’entraînement complet et LoRA via les drapeaux standard de ModelConfig.

python examples/gold_chatbot_arena/gold_chatbot_arena.py \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
    --dataset_name trl-lib/chatbot_arena_completions \
    --learning_rate 2e-5 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 8 \
    --output_dir gold-model \
    --num_train_epochs 1 \
    --push_to_hub

Entraînement des modèles de vision et de langage

experimental.gold.GOLDTrainer prend en charge la distillation VLM-vers-VLM. L’étudiant comme l’enseignant doivent être des modèles vision-langage. Pour entraîner un VLM, fournissez un jeu de données comportant soit une colonne image (une seule image par exemple), soit une colonne images (liste d’images par exemple). Pour plus d’informations sur la structure attendue du jeu de données, consultez la section Format du jeu de données — Jeux de données vision.

Lorsque l’élève et l’enseignant partagent la même architecture et le même tokenizer (par exemple Qwen3-VL-8B vers Qwen3-VL-2B), la perte JSD généralisée standard s’applique directement. S’ils ont des model_type différents (par exemple Qwen3-VL vers LFM2.5-VL), définissez use_uld_loss=True pour activer l’alignement inter-tokenizers via Universal Logit Distillation. Les images sont traitées séparément par le processeur de chaque modèle.

from datasets import load_dataset
import torch
from transformers import AutoModelForImageTextToText, AutoProcessor
from trl.experimental.gold import GOLDConfig, GOLDTrainer

student_name = "Qwen/Qwen3-VL-2B-Instruct"
teacher_name = "Qwen/Qwen3-VL-8B-Instruct"

processor = AutoProcessor.from_pretrained(student_name, padding_side="left")
student_model = AutoModelForImageTextToText.from_pretrained(student_name, dtype=torch.bfloat16)
teacher_model = AutoModelForImageTextToText.from_pretrained(teacher_name, dtype=torch.bfloat16)

train_dataset = load_dataset("trl-lib/llava-instruct-mix", split="train")

trainer = GOLDTrainer(
    model=student_model,
    teacher_model=teacher_model,
    args=GOLDConfig(
        output_dir="gold-vlm-model",
        max_length=None,
        teacher_model_name_or_path=teacher_name,
        use_uld_loss=False,
    ),
    train_dataset=train_dataset,
    processing_class=processor,
)
trainer.train()

Pour la distillation inter-familles, définissez use_uld_loss=True et teacher_tokenizer_name_or_path sur le nom du modèle enseignant.

Utilisez examples/gold_qwen3_vl/gold_qwen3_vl.py pour lancer l’entraînement de GOLD VLM depuis la ligne de commande :

# Same-family distillation (JSD loss, vLLM enabled)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name Qwen/Qwen3-VL-2B-Instruct \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct

# Cross-family distillation (ULD loss, local generation)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name LiquidAI/LFM2.5-VL-1.6B \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct \
    --use_uld_loss \
    --no-use_vllm

Pour les VLM, truncation_mode='keep_end' n'est pas pris en charge car les jetons d'image se trouvent dans la partie invite de la séquence et peuvent être supprimés silencieusement. Utilisez truncation_mode='keep_start' (par défaut) ou définissez max_length=None dans experimental.gold.GOLDConfig. Cela permet au modèle de traiter la longueur complète de la séquence sans tronquer les jetons d'image.
GOLDConfig(max_length=None, ...)
N’utilisez max_length que si vous avez vérifié que la troncature ne supprimera pas les jetons d’image pour l’ensemble du jeu de données.

La distillation de VLM entre architectures différentes nécessite use_uld_loss=True. Le formateur lèvera une erreur si vous tentez une distillation entre architectures différentes sans perte ULD.

GOLDTrainer

classe trl.experimental.gold.GOLDTrainer

< source >

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = Noneteacher_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str] = Noneargs: trl.experimental.gold.gold_config.GOLDConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | dict[str, datasets.arrow_dataset.Dataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None)preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonepeft_config: typing.Optional[ForwardRef('PeftConfig')] = None )

train

< source >

Paramètres

resume_from_checkpoint (str ou bool, facultatif) — Si c'est une str, chemin local d'un point de contrôle enregistré par une instance précédente de Trainer. Si c'est un bool et vaut True, charge le dernier point de contrôle dans args.output_dir enregistré par une instance précédente de Trainer. S'il est présent, l'entraînement reprendra à partir des états du modèle/optimiseur/planificateur chargés ici.
trial (optuna.Trial ou dict[str, Any], facultatif) — L’exécution de l’essai ou le dictionnaire d’hyperparamètres pour la recherche d’hyperparamètres.
ignore_keys_for_eval (list[str], facultatif) — Une liste de clés dans la sortie de votre modèle (s’il s’agit d’un dictionnaire) qui doivent être ignorées lors de la collecte des prédictions pour l’évaluation pendant l’entraînement.

Retourne

~trainer_utils.TrainOutput

Objet contenant le nombre d'étapes globales, la perte d'entraînement et les métriques.

Point d'entrée principal de l'entraînement.

generate_on_policy_outputs

< source >

( modelinputsgeneration_config )

save_model

< source >

( output_dir: str | None = None_internal_call: bool = False )

Enregistrera le modèle, ce qui vous permettra de le recharger à l'aide de from_pretrained().

N'enregistrera que depuis le processus principal.

push_to_hub

< source >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Paramètres

commit_message (str, facultatif, par défaut "End of training") — Message à committer lors de la poussée.
blocking (bool, facultatif, par défaut True) — Indique si la fonction doit ne renvoyer que lorsque le git push est terminé.
token (str, facultatif, par défaut None) — Jeton avec permission d’écriture pour écraser les arguments originaux du Trainer.
revision (str, facultatif) — La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche « main ».
private (bool, facultatif) — Indique s'il faut rendre le dépôt privé lors de sa création. La valeur par défaut est args.hub_private_repo. N'a aucun effet si le dépôt existe déjà.
kwargs (dict[str, Any], facultatif) — Arguments supplémentaires passés à ~Trainer.create_model_card.

Téléchargez self.model et self.processing_class sur le hub de modèles 🤗 dans le dépôt self.args.hub_model_id.

GOLDConfig

classe trl.experimental.gold.GOLDConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-07lr_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 = 10logging_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 = Falserestore_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 = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonechat_template_path: str | None = Nonedataset_text_field: str = 'text'dataset_kwargs: dict[str, typing.Any] | str | None = Nonedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'shuffle_dataset: bool = Falsepacking: bool = Falsepacking_strategy: str = 'bfd'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'eval_packing: bool | None = Nonecompletion_only_loss: bool | None = Noneassistant_only_loss: bool = Falseloss_type: str = 'nll'activation_offloading: bool = Falsepad_token: str | None = Nonetemperature: float = 0.9top_p: float = 0.95top_k: int = 0lmbda: float = 0.5beta: float = 0.5max_completion_length: int = 128teacher_model_name_or_path: str | None = Noneteacher_model_revision: str | None = Noneteacher_model_init_kwargs: dict[str, typing.Any] | str | None = Noneteacher_tokenizer_name_or_path: str | None = Nonedisable_dropout: bool = Trueseq_kd: bool = Falseuse_privileged_context: bool = Falseteacher_prompt_template: str | None = Noneprivileged_context_column: str = 'privileged_context'num_generations: int = 1generation_batch_size: int | None = Noneuse_uld_loss: bool = Falseuld_token_merge_strategy: str = 'observed'use_extended_uld: bool = Trueuld_use_hybrid_loss: bool = Falseuld_hybrid_matched_weight: float | None = Noneuld_hybrid_unmatched_weight: float | None = Noneuld_crossentropy_weight: float = 0.0uld_distillation_weight: float = 1.0uld_student_temperature: float = 1.0uld_teacher_temperature: float = 1.0uld_skip_student_eos: bool = Trueuld_skip_teacher_eos: bool = Truextoken_loss_type: str = 'none'xtoken_projection_matrix_path: str | None = Nonextoken_temperature: float = 1.0xtoken_dynamic_scaling: bool = Truextoken_uncommon_topk: int = 8192xtoken_vocab_topk: int = 8192xtoken_kl_weight: float = 1.0xtoken_ce_scale: float = 0.1use_vllm: bool = Falsevllm_mode: str = 'colocate'vllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8001vllm_server_timeout: float = 240.0vllm_group_port: int = 51216vllm_gpu_memory_utilization: float = 0.9vllm_tensor_parallel_size: int = 1vllm_max_model_length: int | None = Nonevllm_model_impl: str = 'vllm'vllm_structured_outputs_regex: str | None = Nonevllm_sync_frequency: int = 1vllm_enable_sleep_mode: bool = Falselog_completions: bool = Falselog_completions_steps: int = 100num_completions_to_print: int | None = Nonewandb_log_unique_prompts: bool = Truecallbacks: list[str] = <factory> )

Paramètres qui contrôlent la génération et la boucle d'entraînement

temperature (float, facultatif, par défaut 0.9) — Température pour l'échantillonnage. Plus la température est élevée, plus les complétions sont aléatoires.
top_p (float, facultatif, valeur par défaut 0.95) — Si défini sur un float < 1, seul l’ensemble minimal de jetons les plus probables dont les probabilités cumulées atteignent top_p ou plus est conservé pour la génération.
top_k (int, facultatif, par défaut 0) — Nombre de jetons du vocabulaire ayant la plus haute probabilité à conserver pour le filtrage top-k. Si la valeur est 0, le filtrage top-k est désactivé et tous les jetons sont pris en compte.
lmbda (float, facultatif, valeur par défaut 0.5) — Paramètre Lambda qui contrôle la fraction de données étudiantes (c’est-à-dire la proportion de sorties générées par l’étudiant selon sa propre politique).
beta (float, facultatif, par défaut 0.5) — Coefficient d'interpolation entre 0.0 et 1.0 de la perte de divergence de Jensen-Shannon généralisée. Lorsque beta vaut 0.0, la perte est la divergence KL. Lorsque beta vaut 1.0, la perte est la divergence KL inverse.
max_completion_length (int, facultatif, par défaut 128) — Nombre maximal de jetons à générer par complétion.
teacher_model_name_or_path (str, facultatif) — Nom ou chemin du modèle enseignant. Si None, le modèle enseignant sera identique au modèle en cours d’entraînement.
teacher_model_revision (str ou None, facultatif, par défaut None) — Révision du modèle enseignant (par exemple, nom de branche, tag ou hachage de commit). Si None, la révision par défaut est utilisée.
teacher_model_init_kwargs (dict[str, Any], facultatif) — Arguments par mot-clé à passer à AutoModelForCausalLM.from_pretrained lors de l’instanciation du modèle enseignant à partir d’une chaîne de caractères. La valeur de revision est également utilisée lors du chargement de la classe de traitement de l’enseignant.
teacher_tokenizer_name_or_path (str, facultatif) — Nom ou chemin du tokenizer pour le modèle enseignant. Si None lors de l'utilisation de la perte ULD, le même tokenizer que celui du modèle étudiant sera utilisé (non recommandé pour la distillation inter-tokenizers).
disable_dropout (bool, facultatif, valeur par défaut True) — Indique s'il faut désactiver le dropout dans le modèle.
seq_kd (bool, facultatif, valeur par défaut False) — Paramètre qui contrôle l’exécution du KD au niveau de la séquence (peut être considéré comme un FT supervisé sur la sortie générée par l’enseignant).
use_privileged_context (bool, facultatif, valeur par défaut False) — Indique s'il faut conditionner l'enseignant sur un contexte privilégié par exemple, tout en laissant le prompt de l'élève inchangé. Cette option n'est prise en charge que pour le texte et la distillation standard JSD hors politique.
teacher_prompt_template (str, facultatif) — Modèle utilisé pour construire le prompt de l’enseignant. Il doit contenir {prompt} et peut contenir {privileged_context}. Si None, la valeur par défaut est "{prompt}\n\n{privileged_context}".
privileged_context_column (str, facultatif, par défaut "privileged_context") — Colonne du jeu de données contenant le contexte privilégié par exemple utilisé pour construire le prompt de l’enseignant.
num_generations (int, facultatif, par défaut 1) — Nombre de générations par invite. Chaque invite est répétée ce nombre de fois dans le lot de génération.
generation_batch_size (int ou None, facultatif, par défaut None) — Nombre de prompts uniques par travailleur et par étape d’optimiseur. Si None, il est calculé à partir de (per_device_train_batch_size * gradient_accumulation_steps) // num_generations.

Paramètres qui contrôlent la perte ULD

use_uld_loss (bool, facultatif, par défaut False) — Indique s'il faut utiliser la perte Universal Logit Distillation (ULD) au lieu de la perte Generalized Jensen-Shannon Divergence.
use_extended_uld (bool, facultatif, valeur par défaut True) — Indique s’il faut activer l’alignement ULD étendu, qui utilise des tokenizers pour aligner et fusionner les probabilités de jetons entre les tokenizations de l’élève et de l’enseignant. Si True, l’entraîneur calcule les correspondances de jetons et fusionne les probabilités des jetons fractionnés ; si False, ULD utilise une simple troncature positionnelle, comme dans l’article original sur ULD. Définissez False pour les tokenizers qui ne sont ni ByteLevel ni BPE avec repli sur les octets (par ex. Llama 2).
uld_token_merge_strategy (str, facultatif, par défaut "observed") — Stratégie utilisée pour aligner les logits de réponse et fusionner les probabilités de jetons dans la perte ULD. Avec "observed", les logits de réponse sont extraits aux positions de la réponse et les jetons fractionnés (lorsque use_extended_uld=True) sont fusionnés en multipliant la distribution marginale à la première position par les probabilités conditionnelles scalaires des jetons ultérieurs effectifs. Avec "bayesian", l’extrait des logits de réponse est décalé d’une position en amont afin que probs[k] prédise token_ids[k] (règle de la chaîne), et les jetons fractionnés sont fusionnés en utilisant la distribution complète de la dernière position, conditionnée par les jetons du préfixe effectif, multipliée par les probabilités scalaires des jetons antérieurs. Le décalage d’alignement des logits s’applique que use_extended_uld soit activé ou non.
uld_use_hybrid_loss (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser une perte hybride combinant la perte ULD et la perte JSD. Si True, la perte finale est une combinaison de JSD pour les correspondances de jetons connues et de ULD pour les correspondances de jetons inconnues.
uld_hybrid_matched_weight (float ou None, facultatif) — Poids de la composante de perte des jetons appariés lors de l’utilisation de la perte hybride ULD + JSD. Ce poids ajuste la perte JSD calculée sur les jetons qui ont un mappage direct entre les tokenizations de l’élève et de l’enseignant. Si None, une pondération adaptative basée sur le chevauchement des vocabulaires est utilisée. Doit être défini conjointement avec uld_hybrid_unmatched_weight (les deux None ou les deux float).
uld_hybrid_unmatched_weight (float ou None, facultatif) — Poids pour la composante de perte des jetons non appariés lors de l’utilisation de la perte hybride ULD + JSD. Ce poids ajuste la perte ULD calculée sur les jetons qui ne disposent pas d’un mappage direct entre les tokenizations de l’élève et de l’enseignant. Si None, un pondération adaptative basée sur le chevauchement des vocabulaires est utilisée. Doit être défini conjointement avec uld_hybrid_matched_weight (les deux None ou les deux float).
uld_crossentropy_weight (float, facultatif, par défaut 0.0) — Poids de la composante de perte d'entropie croisée dans la perte ULD. Si la valeur est 0, seule la perte de distillation ULD est utilisée.
uld_distillation_weight (float, facultatif, valeur par défaut 1.0) — Poids de la composante de perte de distillation dans la perte ULD.
uld_student_temperature (float, facultatif, valeur par défaut 1.0) — Température des logits de l'étudiant dans le calcul de la perte ULD.
uld_teacher_temperature (float, facultatif, valeur par défaut 1.0) — Température des logits de l'enseignant pour le calcul de la perte ULD.
uld_skip_student_eos (bool, facultatif, valeur par défaut True) — Indique s'il faut ignorer le jeton EOS pour l'étudiant lors du calcul de la perte ULD.
uld_skip_teacher_eos (bool, facultatif, valeur par défaut True) — Indique s'il faut ignorer le jeton EOS pour l'enseignant lors du calcul de la perte ULD.

Paramètres pour la KD inter-tokenizer X-Token (https

xtoken_loss_type (str, facultatif, par défaut "none") — Variante KD inter-tokenizer : "none" (désactivé), "p_kl" (KL de projection) ou "h_kl" (KL hybride avec ensemble commun assoupli). Nécessite teacher_tokenizer_name_or_path et xtoken_projection_matrix_path.
xtoken_projection_matrix_path (str, facultatif) — Chemin vers un fichier de matrice de projection précalculée. Requis lorsque xtoken_loss_type != "none".
xtoken_temperature (float, facultatif, valeur par défaut 1.0) — Température T pour la perte KD X-Token ; la perte est multipliée par T² (Hinton 2015).
xtoken_dynamic_scaling (bool, facultatif, valeur par défaut True) — Échelle le KD par stop_gradient(abs(CE) / abs(KD)) pour chaque microbatch afin d'équilibrer les ordres de grandeur des pertes (équation 7 du papier).
xtoken_uncommon_topk (int, facultatif, valeur par défaut 8192) — H-KL : limite la comparaison non courante L1 triée aux k premiers jetons de chaque côté.
xtoken_vocab_topk (int, facultatif, valeur par défaut 8192) — P-KL : restreint la divergence KL aux k meilleurs jetons globaux de l’enseignant, classés par logit maximal. Interagit avec la matrice de projection --top-k : les jetons de l’enseignant hors de portée de la matrice reçoivent une masse projetée de l’étudiant quasi nulle et dominent la divergence KL, de sorte que des valeurs plus petites concentrent la perte sur les jetons que l’étudiant peut reproduire.
xtoken_kl_weight (float, facultatif, valeur par défaut 1.0) — Poids du terme KD X-Token lorsque xtoken_dynamic_scaling=False.
xtoken_ce_scale (float, facultatif, valeur par défaut 0.1) — Facteur d'échelle du terme CE dans la perte X-Token lorsque xtoken_dynamic_scaling=False.

Paramètres qui contrôlent l'intégration de vLLM

use_vllm (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser vLLM pour générer des complétions à partir du modèle étudiant. Nécessite l'installation de vllm.
vllm_mode (str, facultatif, par défaut "colocate") — Mode d'intégration de vLLM pour l'étudiant. Soit "server" (connexion à un serveur vLLM en cours d'exécution), soit "colocate" (exécution de vLLM dans le même processus).
vllm_server_host (str, facultatif, par défaut "0.0.0.0") — Hôte du serveur vLLM pour le modèle étudiant (si vllm_mode="server").
vllm_server_port (int, facultatif, par défaut 8001) — Port du serveur vLLM pour le modèle étudiant (si vllm_mode="server").
vllm_server_timeout (float, facultatif, par défaut 240.0) — Délai d'attente pour la connexion au serveur vLLM de l'élève (si vllm_mode="server").
vllm_gpu_memory_utilization (float, facultatif, valeur par défaut 0.9) — Taux d'utilisation de la mémoire GPU pour le moteur vLLM étudiant colocalisé (si vllm_mode="colocate"). Il est recommandé de définir cette valeur sur un nombre faible si les modèles étudiant et enseignant partagent le même GPU.
vllm_tensor_parallel_size (int, facultatif, valeur par défaut 1) — Taille du parallélisme tensoriel pour le moteur vLLM étudiant co-localisé (si vllm_mode="colocate").
vllm_structured_outputs_regex (str, facultatif) — Expression régulière pour les sorties structurées de vLLM du modèle étudiant.
vllm_server_base_url (str, facultatif) — URL de base du serveur vLLM (par exemple, "http://localhost:8001"). Si fournie, vllm_server_host et vllm_server_port sont ignorés.
vllm_group_port (int, facultatif, valeur par défaut 51216) — Port du groupe de mise à jour des poids vLLM (communicateur NCCL). Sauf si le port est occupé, il n'est pas nécessaire de le modifier.
vllm_max_model_length (int, facultatif) — Longueur maximale de séquence du modèle pour le moteur vLLM co-localisé lorsque vllm_mode="colocate". Par défaut, la longueur de contexte maximale du modèle.
vllm_model_impl (str, facultatif, par défaut "vllm") — Backend d’implémentation du modèle à utiliser dans vLLM. Utilisez "vllm" (par défaut) ou "transformers".
vllm_sync_frequency (int, facultatif, valeur par défaut 1) — Fréquence (en nombre d'étapes d'entraînement) à laquelle synchroniser les poids du modèle étudiant vers le moteur vLLM. Définir à 1 pour synchroniser après chaque étape.
vllm_enable_sleep_mode (bool, facultatif, valeur par défaut False) — Active le mode veille de vLLM pour décharger les poids et le cache de l’étudiant pendant l’étape d’optimisation. Cela maintient l’utilisation de la mémoire GPU au plus bas, mais le réveil du moteur ajoute une latence de transfert hôte–appareil.

Paramètres qui contrôlent la journalisation

log_completions (bool, facultatif, par défaut False) — Indique s'il faut journaliser un échantillon de paires (prompt, completion) toutes les logging_steps étapes. Si rich est installé, l'échantillon est affiché. Si la journalisation wandb est activée, il est envoyé à wandb.
log_completions_steps (int, facultatif, par défaut 100) — Nombre d'étapes entre l'enregistrement des paires (prompt, completion). Utilisé uniquement si log_completions est défini sur True.
num_completions_to_print (int ou None, facultatif) — Nombre de complétions à afficher avec rich. Si None, toutes les complétions sont journalisées.
wandb_log_unique_prompts (bool, facultatif, valeur par défaut True) — Indique s'il faut journaliser les prompts uniques dans wandb. Cela crée une nouvelle exécution pour chaque prompt unique.
callbacks (list[str], facultatif, par défaut []) — Les callbacks à exécuter pendant l'entraînement.

Classe de configuration pour experimental.gold.GOLDTrainer.

Cette classe ne contient que les paramètres spécifiques à l’entraînement GOLD. Pour la liste complète des arguments d’entraînement, veuillez consulter la documentation de TrainingArguments et SFTConfig.

Ces paramètres ont des valeurs par défaut différentes de TrainingArguments :

learning_rate : passe par défaut à 1e-7 au lieu de 5e-5.

Update on GitHub

←GMPO IW-OPD→