SDFT

Le Fine-Tuning par auto-distillation (SDFT) est décrit dans l'article Self-Distillation Enables Continual Learning d'Idan Shenfeld, Mehul Damani, Jonas Hübotter et Pulkit Agrawal.

L’apprentissage continu, qui permet aux modèles d’acquérir de nouvelles compétences et connaissances sans dégrader leurs capacités existantes, reste un défi fondamental pour les modèles de base. Bien que l’apprentissage par renforcement on-policy puisse réduire l’oubli, il nécessite des fonctions de récompense explicites, souvent indisponibles. L’apprentissage à partir de démonstrations d’experts, l’alternative principale, est dominé par le fine-tuning supervisé (SFT), qui est intrinsèquement off-policy. Nous introduisons le Self-Distillation Fine-Tuning (SDFT), une méthode simple qui permet un apprentissage on-policy directement à partir de démonstrations. SDFT exploite l’apprentissage in-context en utilisant un modèle conditionné par une démonstration comme son propre enseignant, générant des signaux d’entraînement on-policy qui préservent les capacités antérieures tout en acquérant de nouvelles compétences. Sur des tâches d’apprentissage de compétences et d’acquisition de connaissances, SDFT surpasse systématiquement le SFT, atteignant une précision supérieure sur les nouvelles tâches tout en réduisant considérablement l’oubli catastrophique. Dans des expériences d’apprentissage séquentiel, SDFT permet à un modèle unique d’accumuler plusieurs compétences au fil du temps sans régression de performance, établissant la distillation on-policy comme une voie pratique vers l’apprentissage continu à partir de démonstrations.

Fonctionnement

Le fine-tuning supervisé classique entraîne le modèle hors politique sur le texte de démonstration, ce qui a tendance à écraser les capacités antérieures. SDFT apprend en revanche en politique : l’étudiant génère à partir du prompt brut, un enseignant — le même modèle auquel on montre le prompt ainsi que le privileged_context de l’exemple — réévalue ces jetons, et sa distribution conditionnée par la démonstration est distillée dans l’étudiant. L’enseignant et l’étudiant sont un seul réseau qui ne diffère que par ce qu’il voit, créant une boucle d’auto-distillation self.

Choisir le modèle enseignant

teacher_model_kind sélectionne quelle copie du modèle agit en tant que professeur. "base" (par défaut) fige les poids initiaux comme référence fixe, conformément à l’article ; "live" réutilise l’étudiant actuel pour un auto-professeur sans latence ; "ema" maintient une moyenne mobile exponentielle, resynchronisée toutes les teacher_sync_steps étapes avec un taux de teacher_update_rate. Sous PEFT, "base" est obtenu en désactivant l’adaptateur pendant la passe avant du professeur pour récupérer les poids de base, et "ema" avec un entraînement purement LoRA conserve la moyenne mobile dans un adaptateur dédié "teacher" plutôt que dans une seconde copie du modèle. "ema" avec un modèle PEFT non purement LoRA (par ex. modules_to_save ou bias) n’est pas pris en charge, car une copie EMA distincte ne peut pas être alignée paramètre par paramètre avec l’étudiant.

Par défaut, l’étudiant génère à partir du prompt brut ; définissez generate_from_teacher=True pour échantillonner à partir du prompt conditionné par la démonstration, en échangeant la fidélité on-policy contre des rollouts de meilleure qualité. L’objectif de distillation est défini par distillation_mode ("topk_logits" par défaut, avec les alternatives "full_logits" et "sampled_token"), distillation_alpha et distillation_topk ; num_loss_tokens_to_skip exclut les jetons de complétion initiaux de la perte. L’entraînement est uniquement textuel ; la génération s’exécute par défaut via transformers, ou via vLLM (mode colocate ou serveur) lorsque use_vllm=True.

Utilisation

from datasets import Dataset

from trl.experimental.sdft import SDFTConfig, SDFTTrainer

dataset = Dataset.from_dict(
    {
        "prompt": [[{"role": "user", "content": "Solve 2+2."}]],
        "privileged_context": ["Example answer: 4."],
    }
)

training_args = SDFTConfig(
    output_dir="sdft-model",
    distillation_alpha=0.5,
    distillation_mode="topk_logits",
    distillation_topk=5,
    max_completion_length=64,
)

trainer = SDFTTrainer(
    model="Qwen/Qwen2.5-1.5B-Instruct",
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

Pour générer à partir du prompt conditionné par l'enseignant plutôt que du prompt de l'élève, définissez generate_from_teacher=True. Pour personnaliser la construction du prompt de l'enseignant, définissez teacher_prompt_template sur experimental.sdft.SDFTConfig.

Servir le modèle enseignant depuis le serveur vLLM

Avec teacher_model_kind="live", l’enseignant est l’étudiant actuel, dont les poids sont déjà détenus par le serveur vLLM (ils sont synchronisés à chaque étape pour la génération). Définissez use_teacher_server=True pour évaluer les log-probabilités de l’enseignant sur ce même serveur plutôt que d’exécuter un passage avant local séparé de l’enseignant, ce qui supprime l’enseignant de l’étape d’entraînement :

training_args = SDFTConfig(
    output_dir="sdft-model",
    use_vllm=True,
    vllm_mode="server",
    teacher_model_kind="live",
    use_teacher_server=True,
    distillation_mode="sampled_token",
)

Lors de l'utilisation du serveur enseignant :

use_vllm=True et vllm_mode="server" sont requis
teacher_model_kind doit être "live" (le serveur détient les poids actuels de l'étudiant)
distillation_mode doit être "sampled_token" (KL inverse sur le token réalisé) ou "topk_logits". Le serveur renvoie les log-probs top-k du teacher, de sorte que topk_logits distille sur le support top-k du teacher (il ne peut pas utiliser celui de l’étudiant, contrairement à l’objectif local) ; avec un teacher "live", les deux supports coïncident presque. full_logits n’est pas disponible.

Colonnes de jeu de données attendues

Chaque exemple doit fournir :

prompt : le prompt destiné à l'étudiant
privileged_context : uniquement les informations supplémentaires réservées à l'enseignant, telles qu'une démonstration, un indice ou un retour d'information privilégié

Les prompts textuels standards et les prompts conversationnels sont tous deux pris en charge par la gestion des prompts de l'entraîneur.

Callbacks

Le formateur émet un petit ensemble de points d’ancrage de rappel (callback hooks) utiles pour le débogage, l’observabilité et les tests. Ces points d’ancrage sont conçus comme des points d’intégration pratiques pour les flux de travail expérimentaux d’auto-distillation.

Crochets d'auto-distillation partagés :

on_self_distillation_batch_prepared : déclenché lorsqu'un lot d'auto-distillation est prêt. La charge utile inclut prompt_ids, completion_ids et old_per_token_logps lorsque les entrées de rognage par échantillonnage d'importance sont disponibles.
on_generation_batch_built : déclenché lorsqu'un nouveau lot de génération tamponné est créé. La charge utile inclut generate_every et steps_per_generation.

Accroche spécifique à SDFT :

on_generation_prompts_selected : déclenché lorsque SDFT choisit la source des prompts pour la génération on-policy. La charge utile inclut les generation_prompts sélectionnés et le generation_prompt_text correspondant.

Exemple de script

Utilisez examples/sdft_privileged_context/sdft_privileged_context.py pour lancer l’entraînement SDFT depuis la ligne de commande. Le script prend en charge n’importe quel LM causal du Hub, des jeux de données locaux personnalisés via --dataset_path, ainsi que PEFT/LoRA via les drapeaux standard de ModelConfig.

python examples/sdft_privileged_context/sdft_privileged_context.py \
    --model_name_or_path Qwen/Qwen3.5-0.8B \
    --dataset_name your-org/your-dataset \
    --output_dir outputs/sdft-qwen3.5-0.8b \
    --per_device_train_batch_size 1 \
    --gradient_accumulation_steps 16 \
    --learning_rate 2e-5 \
    --max_prompt_length 1024 \
    --max_completion_length 512 \
    --generate_from_teacher \
    --teacher_model_kind ema \
    --teacher_sync_steps 1 \
    --teacher_update_rate 0.05 \
    --eval_strategy steps \
    --eval_steps 50 \
    --report_to wandb

L'implémentation originale est disponible sur idanshen/Self-Distillation.

SDFTConfig

classe trl.experimental.sdft.SDFTConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 5e-05lr_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 = Falselabel_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] | None = Nonetrust_remote_code: bool = Falsedisable_dropout: bool = Truemax_prompt_length: int | None = 512num_generations: int = 8num_generations_eval: int | None = Nonemax_completion_length: int | None = 256ds3_gather_for_generation: bool = Trueshuffle_dataset: bool = Truegeneration_batch_size: int | None = Nonesteps_per_generation: int | None = Nonetemperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict[str, typing.Any] | None = Nonechat_template_kwargs: dict[str, typing.Any] | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falseuse_teacher_server: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_group_port: int = 51216vllm_server_timeout: float = 240.0vllm_tensor_parallel_size: int = 1vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonenum_iterations: int = 1teacher_model_kind: str = 'base'teacher_update_rate: float = 0.05teacher_sync_steps: int = 1distillation_alpha: float = 0.5distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'topk_logits'distillation_topk: int | None = 100distillation_is_clip: float | None = 2.0distillation_add_tail: bool = Falsegenerate_from_teacher: bool = Falseteacher_prompt_template: str = '{prompt}\n\n{privileged_context}'num_loss_tokens_to_skip: int = 0 )

Paramètres qui contrôlent la perte SDFT

distillation_alpha (float, facultatif, valeur par défaut 0.5) — Coefficient d'interpolation de divergence pour la distillation des logits top-k de SDFT.
distillation_mode (Literal["sampled_token", "full_logits", "topk_logits"], facultatif, par défaut "topk_logits") — Mode de l'objectif de distillation. SDFT utilise par défaut la distillation des logits top-k.
distillation_topk (int, facultatif, valeur par défaut 100) — Nombre de jetons supérieurs utilisés par l'objectif logit top-k par défaut de SDFT.
distillation_is_clip (float, facultatif, valeur par défaut 2.0) — Coefficient de rognage pour l'échantillonnage d'importance dans l'auto-distillation. None désactive la rognage.
distillation_add_tail (bool, facultatif, valeur par défaut False) — Indique s'il faut ajouter un seau de queue pour la masse de probabilité non-top-k.
num_loss_tokens_to_skip (int, facultatif, valeur par défaut 0) — Nombre de jetons de complétion initiaux à exclure de la perte de distillation.

Paramètres qui contrôlent l'enseignant

teacher_model_kind (str, facultatif, par défaut "base") — Choix sémantique de l’enseignant pour SDFT. base utilise l’étudiant initial, live utilise l’étudiant actuel et ema utilise un enseignant moyenné exponentiellement.
teacher_update_rate (float, facultatif, valeur par défaut 0.05) — Taux de mise à jour EMA utilisé lorsque teacher_model_kind="ema". Une valeur de 1.0 réduit la mise à jour à un écrasement direct, resynchronisant périodiquement le modèle enseignant avec les poids actuels du modèle élève.
teacher_sync_steps (int, facultatif, par défaut 1) — Nombre d'étapes d'optimiseur entre les mises à jour de l'enseignant.

Paramètres qui contrôlent la génération conditionnée par l'enseignant

generate_from_teacher (bool, facultatif, par défaut False) — Indique si la génération on-policy doit utiliser le prompt conditionné par l'enseignant au lieu du prompt de l'élève.
teacher_prompt_template (str, facultatif, par défaut "{prompt}\n\n{privileged_context}") — Modèle utilisé pour combiner le prompt de l’étudiant et le contexte privilégié afin de former le prompt de l’enseignant.

Paramètres qui contrôlent le modèle

model_init_kwargs (dict[str, Any], facultatif) — Arguments par mot-clé pour transformers.AutoModelForCausalLM.from_pretrained, utilisés lorsque l’argument model du SDFTTrainer est fourni sous forme de chaîne de caractères. La valeur de revision est également utilisée lors du chargement de la classe de traitement.
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, pour l'étudiant comme pour l'enseignant.
disable_dropout (bool, facultatif, valeur par défaut True) — Indique s'il faut désactiver le dropout dans les modèles étudiant et enseignant.

Paramètres qui contrôlent la prétraitement des données

remove_unused_columns (bool, facultatif, valeur par défaut False) — Indique s'il faut ne conserver que les colonnes requises par le formateur dans le jeu de données. Laissez cette valeur à False si vous fournissez des colonnes supplémentaires (telles que privileged_context) dont le formateur a besoin.
max_prompt_length (int, facultatif, par défaut 512) — Longueur maximale du prompt. Les prompts plus longs sont tronqués à gauche.
shuffle_dataset (bool, facultatif, par défaut True) — Indique s'il faut mélanger le jeu de données d'entraînement.

Paramètres qui contrôlent la génération

num_generations (int, facultatif, par défaut 8) — Nombre de générations à échantillonner. La taille de lot effective (num_processes per_device_batch_size gradient_accumulation_steps) doit être divisible par cette valeur.
num_generations_eval (int, facultatif) — Nombre de générations à échantillonner lors de l'évaluation. Cela permet d'utiliser moins de générations pendant l'évaluation afin d'économiser des calculs. Si None, utilise la valeur de num_generations.
max_completion_length (int, facultatif, par défaut 256) — Longueur maximale de la complétion générée.
temperature (float, facultatif, par défaut 1.0) — Température pour l'échantillonnage. Plus la température est élevée, plus les complétions sont aléatoires.
top_p (float, facultatif, par défaut 1.0) — Flottant qui contrôle la probabilité cumulée des jetons de tête à prendre en compte. Doit être compris dans (0, 1]. Définissez-le à 1.0 pour prendre en compte tous les jetons.
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.
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, valeur 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.
cache_implementation (str, facultatif) — Implémentation de la méthode de cache pour une génération plus rapide lorsque use_vllm est défini sur False.
generation_kwargs (dict[str, Any], facultatif) — Arguments supplémentaires à passer à GenerationConfig (si vous utilisez transformers) ou à SamplingParams (si vous utilisez vLLM) lors de l’échantillonnage des complétions. Cela permet de personnaliser davantage le comportement de génération, par exemple en définissant suppress_tokens, num_beams, etc. S’il contient des clés qui entrent en conflit avec les autres paramètres de génération (comme min_p, top_p, etc.), ils les remplaceront.
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.
ds3_gather_for_generation (bool, facultatif, valeur par défaut True) — Ce paramètre s’applique à DeepSpeed ZeRO-3. S’il est activé, les poids du modèle de politique sont regroupés pour la génération, ce qui améliore la vitesse de génération. Toutefois, désactiver cette option permet d’entraîner des modèles dont la taille dépasse la capacité VRAM d’une seule GPU, au prix d’une génération plus lente. La désactivation de cette option n’est pas compatible avec la génération vLLM.

Paramètres qui contrôlent l'accélération de la génération propulsée par vLLM

use_vllm (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser vLLM pour générer des complétions. Si défini sur True, l'entraîneur utilisera vLLM pour la génération au lieu de model.generate() par défaut. Nécessite l'installation de vllm.
use_teacher_server (bool, facultatif, valeur par défaut False) — Calcule les logprobs de l’enseignant à partir du serveur de génération vLLM en cours d’exécution plutôt que d’un passage avant local de l’enseignant. Uniquement pris en charge pour teacher_model_kind='live' avec use_vllm=True et vllm_mode='server', et distillation_mode dans {‘sampled_token’, ‘topk_logits’} (le serveur renvoie les logprobs top-k de l’enseignant, et non le vocabulaire complet ; topk_logits distille sur le support top-k propre à l’enseignant).
vllm_mode (str, facultatif, par défaut "colocate") — Mode à utiliser pour l’intégration vLLM lorsque use_vllm est défini sur True. Doit être l’un des 'server' ou 'colocate'. 'server' : l’entraîneur enverra les requêtes de génération à un serveur vLLM distinct. Assurez-vous qu’un serveur vLLM est en cours d’exécution (à démarrer avec vllm serve). 'colocate' : vLLM s’exécutera dans le même processus et partagera les GPU d’entraînement. Cela évite le besoin d’un serveur distinct, mais peut provoquer une concurrence pour les ressources avec l’entraînement.
vllm_model_impl (str, facultatif, par défaut "vllm") — Implémentation du modèle à utiliser pour vLLM. Doit être transformers ou vllm. transformers : utiliser le backend transformers pour l’implémentation du modèle. vllm : utiliser la bibliothèque vllm pour l’implémentation du modèle.
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 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.
vllm_server_base_url (str, facultatif) — URL de base du serveur vLLM (par exemple, ‘http://localhost:8000’). Si fournie, vllm_server_host et vllm_server_port sont ignorés.
vllm_server_host (str, facultatif, par défaut "0.0.0.0") — Hôte du serveur vLLM auquel se connecter. Ignoré si vllm_server_base_url est fourni.
vllm_server_port (int, facultatif, par défaut 8000) — Port du serveur vLLM auquel se connecter. Ignoré si vllm_server_base_url est fourni.
vllm_group_port (int, facultatif, valeur par défaut 51216) — Numéro de port du groupe de mise à jour des poids. Il est utilisé pour communiquer avec le serveur vLLM. Sauf si le port est occupé, il n'est pas nécessaire de le modifier.
vllm_server_timeout (float, facultatif, valeur par défaut 240.0) — Durée totale de temporisation, en secondes, à attendre pour que le serveur vLLM soit opérationnel. Si le serveur n'est pas opérationnel après le dépassement de ce délai, une ConnectionError est levée.
vllm_tensor_parallel_size (int, facultatif, valeur par défaut 1) — Contrôle la taille du parallélisme de tenseurs pour vLLM. Ce paramètre ne s’applique que lorsque vllm_mode est défini sur 'colocate'. Si vous utilisez vllm_mode='server', ce paramètre doit être transmis séparément lors du démarrage du serveur vLLM via le drapeau --vllm_tensor_parallel_size.
vllm_gpu_memory_utilization (float, facultatif, valeur par défaut 0.3) — Contrôle l'utilisation de la mémoire GPU pour vLLM. Ce paramètre ne s'applique que lorsque vllm_mode est défini sur 'colocate'. Si vous utilisez vllm_mode='server', ce paramètre doit être transmis séparément lors du démarrage du serveur vLLM via le drapeau --vllm_gpu_memory_utilization.
vllm_max_model_length (int, facultatif) — Fenêtre de contexte pour vLLM. Réglez-la sur au moins la longueur maximale des prompts dans le jeu de données plus max_completion_length ; si elle est omise, elle est déduite de la configuration du modèle.

Paramètres qui contrôlent l'entraînement

num_iterations (int, facultatif, par défaut 1) — Nombre d'itérations par lot (noté μ dans l'algorithme).
generation_batch_size (int, facultatif) — Taille de lot à utiliser pour la génération. Si None, la valeur par défaut est la taille de lot effective d'entraînement : per_device_train_batch_size * num_processes * steps_per_generation.
steps_per_generation (int, facultatif) — Nombre d'étapes par génération. Si None, la valeur par défaut est gradient_accumulation_steps.

Classe de configuration pour le experimental.sdft.SDFTTrainer.

SDFTTrainer

classe trl.experimental.sdft.SDFTTrainer

< source >

( model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module]args: trl.experimental.sdft.sdft_config.SDFTConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | 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 )

Trainer pour l'auto-distillation on-policy de type SDFT avec des prompts explicites pour l'enseignant.

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.

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.

Update on GitHub

TRL

SDFT

Fonctionnement

Choisir le modèle enseignant

Utilisation

Servir le modèle enseignant depuis le serveur vLLM

Colonnes de jeu de données attendues

Callbacks

Exemple de script

SDFTConfig

classe trl.experimental.sdft.SDFTConfig

SDFTTrainer

classe trl.experimental.sdft.SDFTTrainer

train

save_model

push_to_hub