# Тренер обобщенной дистилляции знаний

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

## Обзор

Обобщённая дистилляция знаний (GKD) была предложена в работе [On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes](https://huggingface.co/papers/2306.13649) Р. Агарвалом, Н. Вийярдом, Ю. Чжоу, П. Станччиком, С. Рамосом, М. Гейстом и О. Бахемом.

Аннотация из статьи следующая:

> Метод дистилляции знаний (KD) широко применяется для сжатия модели-учителя с целью снижения затрат на инференс и потребления памяти путём обучения более компактной модели-ученика. Однако существующие методы KD для авто-регрессионных последовательных моделей страдают от рассогласования распределений между выходными последовательностями, на которых обучается модель, и теми, которые генерирует ученик во время инференса. Для решения этой проблемы мы предлагаем Generalized Knowledge Distillation (GKD). Вместо того чтобы полагаться исключительно на фиксированный набор выходных последовательностей, GKD обучает ученика на его собственных сгенерированных выходных последовательностях, используя обратную связь от учителя по таким последовательностям. В отличие от методов KD с учителем, GKD также обеспечивает гибкость в использовании альтернативных функций потерь между учеником и учителем, что может быть полезно, когда ученик не обладает достаточной выразительностью для имитации распределения учителя. Кроме того, GKD позволяет бесшовно интегрировать дистилляцию с дообучением с подкреплением (RLHF). Мы демонстрируем эффективность GKD для дистилляции авто-регрессионных языковых моделей на задачах суммаризации, перевода и арифметического рассуждения, а также для дистилляции, не зависящей от конкретной задачи, в контексте instruction-tuning.

Ключевые аспекты GKD:

1. Он устраняет рассогласование распределений между этапами обучения и инференса в авто-регрессионных последовательных моделях, обучая модель-ученика на последовательностях, сгенерированных ею самой.
2. GKD обеспечивает гибкость при выборе различных мер расхождения между моделями-учениками и моделями-наставниками с помощью обобщённого расхождения Йенсена–Шаннона (JSD), что может быть полезно, когда модель-ученик не обладает достаточной ёмкостью для полного копирования модели-наставника.

Этот метод постобучения был предложен [Kashif Rasul](https://huggingface.co/kashif) и [Lewis Tunstall](https://huggingface.co/lewtun).

## Советы по использованию

Класс [experimental.gkd.GKDTrainer](/docs/trl/main/ru/gkd_trainer#trl.experimental.gkd.GKDTrainer) является обёрткой над классом [SFTTrainer](/docs/trl/main/ru/sft_trainer#trl.SFTTrainer) и принимает в качестве аргумента модель-учителя. Для его работы необходимо задать три параметра через [experimental.gkd.GKDConfig](/docs/trl/main/ru/gkd_trainer#trl.experimental.gkd.GKDConfig), а именно:

* `lmbda`:  управляет долей данных студента, то есть пропорцией выходов, сгенерированных студентом по его собственной политике. При `lmbda=0.0` функция потерь сводится к надзорному JSD, где студент обучается на токенных вероятностях учителя. При `lmbda=1.0` функция потерь сводится к on-policy JSD, где студент генерирует последовательности выходов, а учитель предоставляет токенную обратную связь по этим последовательностям. Для значений в диапазоне [0, 1] выбор между этими двумя режимами происходит случайно для каждой партии в соответствии со значением `lmbda`.
* `seq_kd`: управляет выполнением Sequence-Level KD (можно рассматривать как supervised FT на выходе, сгенерированном учителем). При `seq_kd=True` и `lmbda=0.0` функция потерь сводится к supervised JSD, где учитель генерирует выходные последовательности, а ученик получает токен-специфичную обратную связь от учителя по этим последовательностям.
* `beta`: управляет интерполяцией в обобщённой дивергенции Дженсена–Шаннона. При `beta=0.0` функция потерь приближает прямую дивергенцию КЛ, а при `beta=1.0` — обратную дивергенцию КЛ. Для значений в диапазоне [0, 1] происходит интерполяция между ними.

Авторы выяснили, что данные on-policy (высокое значение `lmbda`) показывают лучшие результаты, а оптимальное значение `beta` варьировалось в зависимости от задачи и метода оценки.

> [!WARNING]
> Убедитесь, что при обучении [моделей Gemma](https://huggingface.co/models?other=gemma2) используется `attn_implementation="kernels-community/flash-attn2"`. В противном случае в логитах возникнут значения NaN из-за [техники мягкого ограничения](https://huggingface.co/blog/gemma2#soft-capping-and-attention-implementations), применяемой в этой архитектуре.

Базовый API выглядит следующим образом:

```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()
```

### Ожидаемый тип набора данных

Набор данных должен быть оформлен в виде списка «сообщений», где каждое сообщение представляет собой список словарей со следующими ключами:

* `role`: одно из значений `system`, `assistant` или `user`
* `content`: содержимое сообщения

## 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)
```

[Источник](https://github.com/huggingface/trl/blob/main/trl/experimental/gkd/gkd_trainer.py#L54)

**Параметры:**

model ([PreTrainedModel](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel) или `torch.nn.Module` или `str`, *optional*) : Модель, подлежащая обучению, или строковый идентификатор модели, которая будет создана из предобученной модели.

teacher_model ([PreTrainedModel](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel) или `torch.nn.Module` или `str`, *optional*) : Модель-учитель для дистилляции знаний или строковый идентификатор модели, которая будет создана из предобученной модели.

args ([experimental.gkd.GKDConfig](/docs/trl/main/ru/gkd_trainer#trl.experimental.gkd.GKDConfig), *необязательный*) : Аргументы обучения.

data_collator (`DataCollator`, *необязательный*) : Собирает образцы из набора данных в батчи. По умолчанию используется `experimental.utils.DataCollatorForChatML` с `processing_class`.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset), *необязательный*) : Набор данных для обучения.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset) или `dict` из [Dataset](https://huggingface.co/docs/datasets/main/en/package_reference/main_classes#datasets.Dataset), *optional*) : Набор данных для оценки.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), [BaseImageProcessor](https://huggingface.co/docs/transformers/main/en/main_classes/image_processor#transformers.BaseImageProcessor), [FeatureExtractionMixin](https://huggingface.co/docs/transformers/main/en/main_classes/feature_extractor#transformers.FeatureExtractionMixin) или [ProcessorMixin](https://huggingface.co/docs/transformers/main/en/main_classes/processors#transformers.ProcessorMixin), *необязательный*) : Класс для обработки данных.

compute_metrics (`Callable`, *необязательный*) : функция для вычисления метрик при оценке. Должна принимать [EvalPrediction](https://huggingface.co/docs/transformers/main/en/internal/trainer_utils#transformers.EvalPrediction) и возвращать словарь, сопоставляющий строки с числами с плавающей точкой.

callbacks (`list` из [TrainerCallback](https://huggingface.co/docs/transformers/main/en/main_classes/callback#transformers.TrainerCallback), *optional*) : Колбэки, используемые во время обучения.

optimizers (`tuple` из `torch.optim.Optimizer` и `torch.optim.lr_scheduler.LambdaLR`, *необязательный*, по умолчанию `(None, None)`) : Кортеж, содержащий оптимизатор и планировщик скорости обучения, используемые для обучения.

preprocess_logits_for_metrics (`Callable`, *необязательный*) : Функция для предобработки logits перед вычислением метрик. Должна принимать `logits` и `labels` и возвращать logits, которые будут использоваться для вычисления метрик.

peft_config ([PeftConfig](https://huggingface.co/docs/peft/main/en/package_reference/config#peft.PeftConfig), *необязательный*) : конфигурация PEFT для использования PEFT при обучении. Если `None`, PEFT не используется. Если указано, `model` будет обернута с помощью указанного адаптера PEFT.

formatting_func (`Callable`, *необязательный*) : Функция для форматирования набора данных. Должна принимать пример и возвращать пример.

Trainer для обобщённой дистилляции знаний (GKD) языковых моделей.

Подробнее о GKD см. в статье: [Дистилляция языковых моделей в соответствии с политикой: обучение на собственных ошибках](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)
```

[Источник](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L1450)

**Параметры:**

resume_from_checkpoint (`str` или `bool`, *необязательный*) : Если передано значение типа `str`, это локальный путь к сохранённой контрольной точке, созданной предыдущим экземпляром `Trainer`. Если передано значение типа `bool` и оно равно `True`, загружается последняя контрольная точка из *args.output_dir*, сохранённая предыдущим экземпляром `Trainer`. Если параметр указан, обучение возобновляется из состояний модели/оптимизатора/планировщика, загруженных отсюда.

trial (`optuna.Trial` или `dict[str, Any]`, *необязательный*) : Запуск испытания или словарь гиперпараметров для поиска гиперпараметров.

ignore_keys_for_eval (`list[str]`, *необязательный*) : Список ключей в выводе вашей модели (если он является словарём), которые следует игнорировать при сборе предсказаний для оценки во время обучения.

**Возвращает:** `~trainer_utils.TrainOutput`

Объект, содержащий количество глобальных шагов, потерю обучения и метрики.

Основная точка входа для обучения.

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

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

[Источник](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L4077)

Сохранит модель, чтобы вы могли загрузить её снова с помощью `from_pretrained()`.

Сохранение будет выполняться только из основного процесса.

#### 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)
```

[Источник](https://github.com/huggingface/trl/blob/main/transformers/trainer.py#L4337)

**Параметры:**

commit_message (`str`, *необязательный*, по умолчанию `"End of training"`) : Сообщение для коммита при отправке.

blocking (`bool`, *необязательный*, по умолчанию `True`) : Указывает, должна ли функция возвращаться только после завершения `git push`.

token (`str`, *необязательный*, по умолчанию `None`) : Токен с правом записи для перезаписи исходных аргументов Trainer.

revision (`str`, *необязательный*) : git-ревизия, от которой выполняется коммит. По умолчанию используется head ветки "main".

private (`bool`, *необязательный*) : Указывает, следует ли сделать репозиторий приватным при его создании. По умолчанию используется значение `args.hub_private_repo`. Не имеет эффекта, если репозиторий уже существует.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в `~Trainer.create_model_card`.

**Возвращает:**

URL репозитория, в который была загружена модель, если `blocking=False`, или объект `Future`, отслеживающий ход коммита, если `blocking=True`.

Загрузите `self.model` и `self.processing_class` в модельный хаб 🤗 в репозиторий `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)
```

[Источник](https://github.com/huggingface/trl/blob/main/trl/experimental/gkd/gkd_config.py#L22)

**Параметры:**

temperature (`float`, *необязательный*, по умолчанию `0.9`) : Температура для выборки. Чем выше температура, тем более случайными будут завершения.

lmbda (`float`, *необязательный*, по умолчанию `0.5`) : Параметр Lambda, управляющий долей данных студента (т. е. пропорцией выходов, сгенерированных студентом по его собственной политике).

beta (`float`, *optional*, по умолчанию `0.5`) : Коэффициент интерполяции между `0.0` и `1.0` для функции потерь обобщённого расхождения Дженсена–Шаннона. Если beta равно `0.0`, функция потерь представляет собой расхождение KL. Если beta равно `1.0`, функция потерь представляет собой обратное расхождение KL.

max_new_tokens (`int`, *необязательный*, по умолчанию `128`) : Максимальное количество токенов для генерации в каждом завершении.

teacher_model_name_or_path (`str`, *необязательный*) : Имя модели или путь к учителю. Если `None`, модель-учитель будет такой же, как и обучаемая модель.

teacher_model_init_kwargs (`dict[str, Any]`, *необязательный*) : Ключевые аргументы, передаваемые в `AutoModelForCausalLM.from_pretrained` при создании модели-учителя из строки.

disable_dropout (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли отключить dropout в модели.

seq_kd (`bool`, *необязательный*, по умолчанию `False`) : Параметр Seq_kd, управляющий выполнением Sequence-Level KD (можно рассматривать как supervised FT на выходе, сгенерированном учителем).

Класс конфигурации для [experimental.gkd.GKDTrainer](/docs/trl/main/ru/gkd_trainer#trl.experimental.gkd.GKDTrainer).

Этот класс содержит только параметры, специфичные для обучения GKD. Полный список аргументов обучения см. в документации [TrainingArguments](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments) и [SFTConfig](/docs/trl/main/ru/sft_trainer#trl.SFTConfig).

