TRL documentation
Entrenador de destilación de conocimiento generalizado
Entrenador de destilación de conocimiento generalizado
Resumen
La destilación de conocimiento generalizada (GKD) fue propuesta en On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes por Rishabh Agarwal, Nino Vieillard, Yongchao Zhou, Piotr Stanczyk, Sabela Ramos, Matthieu Geist y Olivier Bachem.
El resumen del artículo es el siguiente:
La destilación de conocimiento (KD) se utiliza ampliamente para comprimir un modelo maestro y reducir su costo de inferencia y su huella de memoria, mediante el entrenamiento de un modelo estudiante más pequeño. Sin embargo, los métodos actuales de KD para modelos de secuencia auto-regresivos sufren de un desajuste de distribución entre las secuencias de salida vistas durante el entrenamiento y las generadas por el estudiante durante la inferencia. Para abordar este problema, introducimos la Destilación de Conocimiento Generalizada (GKD). En lugar de depender únicamente de un conjunto fijo de secuencias de salida, GKD entrena al estudiante en sus propias secuencias de salida auto-generadas, aprovechando la retroalimentación del maestro sobre dichas secuencias. A diferencia de los enfoques de KD supervisados, GKD también ofrece la flexibilidad de emplear funciones de pérdida alternativas entre el estudiante y el maestro, lo cual puede ser útil cuando el estudiante carece de la expresividad para imitar la distribución del maestro. Además, GKD facilita la integración sin problemas de la destilación con el ajuste fino mediante RL (RLHF). Demostramos la eficacia de GKD para destilar modelos de lenguaje auto-regresivos en tareas de resumen, traducción y razonamiento aritmético, así como para la destilación agnóstica a la tarea para el ajuste de instrucciones.
Los aspectos clave de GKD son:
- Aborda la discrepancia de distribución entre el entrenamiento y la inferencia en los modelos de secuencia auto-regresivos entrenando el modelo estudiante en sus propias secuencias de salida generadas.
- GKD permite flexibilidad a la hora de elegir diferentes medidas de divergencia entre los modelos de estudiante y de maestro mediante la Divergencia Generalizada de Jensen-Shannon (JSD), lo cual puede ser útil cuando el estudiante carece de la capacidad para imitar por completo al maestro.
Este método de post-entrenamiento fue aportado por Kashif Rasul y Lewis Tunstall.
Consejos de uso
El experimental.gkd.GKDTrainer es un envoltorio de la clase SFTTrainer que acepta un argumento de modelo maestro. Requiere que se establezcan tres parámetros a través de experimental.gkd.GKDConfig, a saber:
lmbda: controla la fracción de datos del estudiante, es decir, la proporción de salidas generadas por el estudiante en la política. Cuandolmbda=0.0, la pérdida se reduce a JSD supervisado, donde el estudiante se entrena con las probabilidades a nivel de token del maestro. Cuandolmbda=1.0, la pérdida se reduce a JSD en la política, donde el estudiante genera secuencias de salida y recibe retroalimentación específica de token sobre estas secuencias del maestro. Para valores intermedios en [0, 1], es aleatorio entre los dos basándose en el valor delmbdapara cada lote.seq_kd: controla si se realiza KD a nivel de secuencia (puede verse como FT supervisado sobre la salida generada por el teacher). Cuandoseq_kd=Trueylmbda=0.0, la pérdida se reduce a JSD supervisado, donde el teacher genera secuencias de salida y el student recibe retroalimentación específica por token sobre estas secuencias del teacher.beta: controla la interpolación en la divergencia generalizada de Jensen-Shannon. Cuandobeta=0.0, la pérdida aproxima la divergencia KL hacia adelante, mientras que parabeta=1.0la pérdida aproxima la divergencia KL hacia atrás. Para valores intermedios en [0, 1], interpola entre ambas.
Los autores encuentran que los datos on-policy (alto lmbda) rinden mejor y que el beta óptimo variaba según la tarea y el método de evaluación.
Asegúrate de que
attn_implementation="kernels-community/flash-attn2"al entrenar modelos Gemma. De lo contrario, te encontrarás con NaNs en los logits debido a la técnica de soft capping adoptada por esta arquitectura.
La API básica es la siguiente:
from datasets import Dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl.experimental.gkd import GKDConfig, GKDTrainer
NUM_DUMMY_SAMPLES = 100
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
# The model to optimise
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
# The teacher model to calculate the KL divergence against
teacher_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-1.5B-Instruct")
train_dataset = Dataset.from_dict(
{
"messages": [
[
{"role": "user", "content": "Hi, how are you?"},
{"role": "assistant", "content": "I'm great thanks"},
]
]
* NUM_DUMMY_SAMPLES
}
)
eval_dataset = Dataset.from_dict(
{
"messages": [
[
{"role": "user", "content": "What colour is the sky?"},
{"role": "assistant", "content": "The sky is blue"},
]
]
* NUM_DUMMY_SAMPLES
}
)
training_args = GKDConfig(output_dir="gkd-model", per_device_train_batch_size=1)
trainer = GKDTrainer(
model=model,
teacher_model=teacher_model,
args=training_args,
processing_class=tokenizer,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
)
trainer.train()Tipo de conjunto de datos esperado
El conjunto de datos debe estar formateado como una lista de “mensajes” donde cada mensaje es una lista de diccionarios con las siguientes claves:
role: ya seasystem,assistantousercontent: el contenido del mensaje
GKDTrainer
clase trl.experimental.gkd.GKDTrainer
< 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.gkd.gkd_config.GKDConfig | 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: PeftConfig | None = Noneformatting_func: collections.abc.Callable | None = None )
Parámetros
- model (PreTrainedModel o
torch.nn.Moduleostr, opcional) — Modelo que se va a entrenar, o el identificador de cadena del modelo que se va a instanciar a partir de un modelo preentrenado. - teacher_model (PreTrainedModel o
torch.nn.Moduleostr, opcional) — Modelo maestro para la destilación de conocimiento, o el identificador de cadena del modelo que se instanciará a partir de un modelo preentrenado. - args (experimental.gkd.GKDConfig, opcional) — Argumentos de entrenamiento.
- data_collator (
DataCollator, opcional) — Collator de datos para agrupar muestras del conjunto de datos. Por defecto, se utiliza unexperimental.utils.DataCollatorForChatMLque emplea elprocessing_class. - train_dataset (Dataset, opcional) — Conjunto de datos para el entrenamiento.
- eval_dataset (Dataset o
dictde Dataset, opcional) — Conjunto de datos para la evaluación. - processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin o ProcessorMixin, opcional) — Clase para procesar los datos.
- compute_metrics (
Callable, opcional) — Función para calcular métricas durante la evaluación. Debe recibir un EvalPrediction y devolver un diccionario de cadenas a flotantes. - callbacks (
listde TrainerCallback, opcional) — Callbacks para usar durante el entrenamiento. - optimizers (
tupledetorch.optim.Optimizerytorch.optim.lr_scheduler.LambdaLR, opcional, valor predeterminado(None, None)) — Tupla que contiene el optimizador y el programador de tasa de aprendizaje a utilizar para el entrenamiento. - preprocess_logits_for_metrics (
Callable, opcional) — Función para preprocesar los logits antes de calcular las métricas. Debe recibir loslogitsy laslabelsy devolver los logits que se usarán para el cálculo de las métricas. - peft_config (
PeftConfig, opcional) — Configuración de PEFT para usar PEFT en el entrenamiento. Si esNone, no se usa PEFT. Si se proporciona, elmodelse envolverá con el adaptador PEFT especificado. - formatting_func (
Callable, opcional) — Función para formatear el conjunto de datos. Debe recibir un ejemplo y devolver un ejemplo.
Trainer para la Destilación de Conocimiento Generalizada (GKD) de modelos de lenguaje.
Para más detalles sobre GKD, consulte el artículo: On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes.
entrenar
< source >( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput
Parámetros
- resume_from_checkpoint (
strobool, opcional) — Si es unastr, ruta local a un punto de control guardado por una instancia anterior deTrainer. Si es unbooly es igual aTrue, carga el último punto de control en args.output_dir guardado por una instancia anterior deTrainer. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí. - trial (
optuna.Trialodict[str, Any], opcional) — La ejecución del ensayo o el diccionario de hiperparámetros para la búsqueda de hiperparámetros. - ignore_keys_for_eval (
list[str], opcional) — Una lista de claves en la salida de tu modelo (si es un diccionario) que deben ignorarse al recopilar predicciones para la evaluación durante el entrenamiento.
Devuelve
~trainer_utils.TrainOutput
Objeto que contiene el número de pasos globales, la pérdida de entrenamiento y las métricas.
Punto de entrada principal del entrenamiento.
Guardará el modelo, por lo que podrás recargarlo usando from_pretrained().
Solo se guardará desde el proceso 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 )
Parámetros
- commit_message (
str, opcional, valor predeterminado"End of training") — Mensaje para el commit al hacer push. - blocking (
bool, opcional, valor predeterminadoTrue) — Si la función debe devolver el control solo cuando elgit pushhaya terminado. - token (
str, opcional, valor predeterminadoNone) — Token con permiso de escritura para sobrescribir los argumentos originales de Trainer. - revision (
str, opcional) — La revisión de git desde la que se realizará el commit. Por defecto, es la cabecera de la rama “main”. - private (
bool, opcional) — Si se debe hacer el repositorio privado cuando se crea. El valor predeterminado esargs.hub_private_repo. No tiene efecto si el repositorio ya existe. - kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan a~Trainer.create_model_card.
Sube self.model y self.processing_class al hub de modelos de 🤗 en el repositorio self.args.hub_model_id.
GKDConfig
clase trl.experimental.gkd.GKDConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 2e-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 = 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.9lmbda: float = 0.5beta: float = 0.5max_new_tokens: int = 128teacher_model_name_or_path: str | None = Noneteacher_model_init_kwargs: dict[str, typing.Any] | str | None = Nonedisable_dropout: bool = Trueseq_kd: bool = False )
Parámetros
- temperature (
float, opcional, valor predeterminado0.9) — Temperatura para el muestreo. A mayor temperatura, más aleatorias son las finalizaciones. - lmbda (
float, opcional, valor predeterminado0.5) — Parámetro lambda que controla la fracción de datos del estudiante (es decir, la proporción de salidas generadas por el estudiante en la política). - beta (
float, opcional, valor predeterminado0.5) — Coeficiente de interpolación entre0.0y1.0de la pérdida de Divergencia Generalizada de Jensen-Shannon. Cuando beta es0.0, la pérdida es la divergencia KL. Cuando beta es1.0, la pérdida es la Divergencia KL Inversa. - max_new_tokens (
int, opcional, valor predeterminado128) — Número máximo de tokens que se generarán por cada finalización. - teacher_model_name_or_path (
str, opcional) — Nombre o ruta del modelo de maestro. Si esNone, el modelo de maestro será el mismo que el modelo que se está entrenando. - teacher_model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palabra clave para pasar aAutoModelForCausalLM.from_pretrainedal instanciar el modelo teacher desde una cadena. - disable_dropout (
bool, opcional, valor predeterminadoTrue) — Si se debe deshabilitar el dropout en el modelo. - seq_kd (
bool, opcional, valor predeterminadoFalse) — Parámetro que controla si se debe realizar KD a nivel de secuencia (puede considerarse como FT supervisado sobre la salida generada por el teacher).
Clase de configuración para experimental.gkd.GKDTrainer.
Esta clase incluye solo los parámetros específicos para el entrenamiento con GKD. Para obtener la lista completa de argumentos de entrenamiento, consulte la documentación de TrainingArguments y SFTConfig.