# Entrenador de destilación de conocimiento generalizado

[![model badge](https://img.shields.io/badge/All_models-GKD-blue)](https://huggingface.co/models?other=gkd,trl)

## Resumen

La destilación de conocimiento generalizada (GKD) fue propuesta en [On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes](https://huggingface.co/papers/2306.13649) 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 Generalizada de Conocimiento (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:

1. 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.
2. 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](https://huggingface.co/kashif) y [Lewis Tunstall](https://huggingface.co/lewtun).

## Consejos de uso

El [experimental.gkd.GKDTrainer](/docs/trl/v1.18.2/es/gkd_trainer#trl.experimental.gkd.GKDTrainer) es un envoltorio de la clase [SFTTrainer](/docs/trl/v1.18.2/es/sft_trainer#trl.SFTTrainer) que acepta un argumento de modelo maestro. Requiere que se establezcan tres parámetros a través de [experimental.gkd.GKDConfig](/docs/trl/v1.18.2/es/gkd_trainer#trl.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. Cuando `lmbda=0.0`, la pérdida se reduce a JSD supervisado, donde el estudiante se entrena con las probabilidades a nivel de token del maestro. Cuando `lmbda=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 de `lmbda` para 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). Cuando `seq_kd=True` y `lmbda=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. Cuando `beta=0.0`, la pérdida aproxima la divergencia KL hacia adelante, mientras que para `beta=1.0` la 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.

> [!WARNING]
> Asegúrate de que `attn_implementation="kernels-community/flash-attn2"` al entrenar [modelos Gemma](https://huggingface.co/models?other=gemma2). De lo contrario, te encontrarás con NaNs en los logits debido a la [técnica de soft capping](https://huggingface.co/blog/gemma2#soft-capping-and-attention-implementations) adoptada por esta arquitectura.

La API básica es la siguiente:

```python
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 "messages" donde cada mensaje es una lista de diccionarios con las siguientes claves:

* `role`: ya sea `system`, `assistant` o `user`
* `content`: el contenido del mensaje

## GKDTrainer[[trl.experimental.gkd.GKDTrainer]]

#### trl.experimental.gkd.GKDTrainer[[trl.experimental.gkd.GKDTrainer]]

```python
trl.experimental.gkd.GKDTrainer(model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = None, teacher_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str] = None, args: trl.experimental.gkd.gkd_config.GKDConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | dict[str, datasets.arrow_dataset.Dataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: 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 = None, peft_config: PeftConfig | None = None, formatting_func: collections.abc.Callable | None = None)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.2/trl/experimental/gkd/gkd_trainer.py#L54)

**Parámetros:**

model ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) o `torch.nn.Module` o `str`, *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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) o `torch.nn.Module` o `str`, *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](/docs/trl/v1.18.2/es/gkd_trainer#trl.experimental.gkd.GKDConfig), *opcional*) : Argumentos de entrenamiento.

data_collator (`DataCollator`, *opcional*) : Data collator para agrupar muestras del conjunto de datos. Por defecto, se utiliza un `experimental.utils.DataCollatorForChatML` que emplea `processing_class`.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), *opcional*) : Dataset para el entrenamiento.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) o `dict` de [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), *opcional*) : Dataset para la evaluación.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), [BaseImageProcessor](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/image_processor#transformers.BaseImageProcessor), [FeatureExtractionMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/feature_extractor#transformers.FeatureExtractionMixin) o [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.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](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.EvalPrediction) y devolver un diccionario de cadenas a flotantes.

callbacks (`list` de [TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback), *opcional*) : Callbacks para usar durante el entrenamiento.

optimizers (`tuple` de `torch.optim.Optimizer` y `torch.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 los `logits` y las `labels` y devolver los logits que se usarán para el cálculo de las métricas.

peft_config ([PeftConfig](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/config#peft.PeftConfig), *opcional*) : Configuración de PEFT para usar PEFT en el entrenamiento. Si es `None`, no se usa PEFT. Si se proporciona, el `model` se 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](https://huggingface.co/papers/2306.13649).

#### train[[trl.experimental.gkd.GKDTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L1450)

**Parámetros:**

resume_from_checkpoint (`str` o `bool`, *opcional*) : Si es un `str`, ruta local a un punto de control guardado por una instancia anterior de `Trainer`. Si es un `bool` y es igual a `True`, carga el último punto de control en *args.output_dir* guardado por una instancia anterior de `Trainer`. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí.

trial (`optuna.Trial` o `dict[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 su 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.

#### save_model[[trl.experimental.gkd.GKDTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4077)

Guardará el modelo, por lo que podrás recargarlo usando `from_pretrained()`.

Solo se guardará desde el proceso principal.

#### push_to_hub[[trl.experimental.gkd.GKDTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4337)

**Parámetros:**

commit_message (`str`, *opcional*, por defecto `"End of training"`) : Mensaje para el commit al hacer push.

blocking (`bool`, *opcional*, valor predeterminado `True`) : Si la función debe devolver el control solo cuando el `git push` haya terminado.

token (`str`, *opcional*, valor predeterminado `None`) : 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 privada la repositorio cuando se crea. El valor predeterminado es `args.hub_private_repo`. No tiene efecto si la repositorio ya existe.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan a `~Trainer.create_model_card`.

**Devuelve:**

La URL del repositorio donde se subió el modelo si `blocking=False`, o un objeto `Future` que rastrea el progreso del commit si `blocking=True`.

Sube `self.model` y `self.processing_class` al hub de modelos de 🤗 en el repositorio `self.args.hub_model_id`.

## GKDConfig[[trl.experimental.gkd.GKDConfig]]

#### trl.experimental.gkd.GKDConfig[[trl.experimental.gkd.GKDConfig]]

```python
trl.experimental.gkd.GKDConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 2e-05, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, chat_template_path: str | None = None, dataset_text_field: str = 'text', dataset_kwargs: dict[str, typing.Any] | str | None = None, dataset_num_proc: int | None = None, eos_token: str | None = None, max_length: int | None = 1024, truncation_mode: str = 'keep_start', shuffle_dataset: bool = False, packing: bool = False, packing_strategy: str = 'bfd', padding_free: bool = False, pad_to_multiple_of: int | str | None = 'auto', eval_packing: bool | None = None, completion_only_loss: bool | None = None, assistant_only_loss: bool = False, loss_type: str = 'nll', activation_offloading: bool = False, pad_token: str | None = None, temperature: float = 0.9, lmbda: float = 0.5, beta: float = 0.5, max_new_tokens: int = 128, teacher_model_name_or_path: str | None = None, teacher_model_init_kwargs: dict[str, typing.Any] | str | None = None, disable_dropout: bool = True, seq_kd: bool = False)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.2/trl/experimental/gkd/gkd_config.py#L22)

**Parámetros:**

temperature (`float`, *opcional*, valor predeterminado `0.9`) : Temperatura para el muestreo. A mayor temperatura, más aleatorias son las completaciones.

lmbda (`float`, *opcional*, valor predeterminado `0.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 predeterminado `0.5`) : Coeficiente de interpolación entre `0.0` y `1.0` de la pérdida de Divergencia Generalizada de Jensen-Shannon. Cuando beta es `0.0`, la pérdida es la divergencia KL. Cuando beta es `1.0`, la pérdida es la Divergencia KL Inversa.

max_new_tokens (`int`, *opcional*, valor predeterminado `128`) : Número máximo de tokens a generar por completado.

teacher_model_name_or_path (`str`, *opcional*) : Nombre o ruta del modelo maestro. Si es `None`, el modelo 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 a `AutoModelForCausalLM.from_pretrained` al instanciar el modelo maestro desde una cadena.

disable_dropout (`bool`, *opcional*, valor predeterminado `True`) : Si se debe desactivar el dropout en el modelo.

seq_kd (`bool`, *opcional*, valor predeterminado `False`) : Parámetro de Seq_kd que controla si se realiza KD a nivel de secuencia (se puede ver como FT supervisado sobre la salida generada por el maestro).

Clase de configuración para [experimental.gkd.GKDTrainer](/docs/trl/v1.18.2/es/gkd_trainer#trl.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) y [SFTConfig](/docs/trl/v1.18.2/es/sft_trainer#trl.SFTConfig).

