TRL documentation
Treinador de Destilação de Conhecimento Generalizada
Treinador de Destilação de Conhecimento Generalizada
Visão geral
O Generalized Knowledge Distillation (GKD) foi proposto em On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes por Rishabh Agarwal, Nino Vieillard, Yongchao Zhou, Piotr Stanczyk, Sabela Ramos, Matthieu Geist e Olivier Bachem.
O resumo do artigo é o seguinte:
A destilação de conhecimento (KD) é amplamente utilizada para comprimir um modelo professor, reduzindo seu custo de inferência e sua pegada de memória, por meio do treinamento de um modelo aluno menor. No entanto, os métodos atuais de KD para modelos de sequência auto-regressivos sofrem com o desalinhamento de distribuição entre as sequências de saída vistas durante o treinamento e aquelas geradas pelo aluno durante a inferência. Para abordar essa questão, introduzimos a Destilação de Conhecimento Generalizada (GKD). Em vez de depender exclusivamente de um conjunto fixo de sequências de saída, o GKD treina o aluno em suas próprias sequências de saída auto-geradas, aproveitando o feedback do professor sobre tais sequências. Diferente das abordagens de KD supervisionadas, o GKD também oferece a flexibilidade de empregar funções de perda alternativas entre o aluno e o professor, o que pode ser útil quando o aluno carece da expressividade para imitar a distribuição do professor. Além disso, o GKD facilita a integração sem emendas da destilação com o ajuste fino por RL (RLHF). Demonstramos a eficácia do GKD para destilar modelos de linguagem auto-regressivos em tarefas de sumarização, tradução e raciocínio aritmético, bem como para destilação agnóstica à tarefa para ajuste fino por instruções.
Os principais aspectos do GKD são:
- Ele aborda a incompatibilidade de distribuição entre treinamento e inferência em modelos de sequência auto-regressivos, treinando o modelo aluno em suas próprias sequências de saída geradas.
- O GKD permite flexibilidade na escolha de diferentes medidas de divergência entre os modelos de aluno e professor por meio da Divergência Generalizada de Jensen-Shannon (JSD), o que pode ser útil quando o aluno não tem capacidade suficiente para imitar completamente o professor.
Este método de pós-treinamento foi contribuído por Kashif Rasul e Lewis Tunstall.
Dicas de uso
O experimental.gkd.GKDTrainer é um wrapper em torno da classe SFTTrainer que recebe um argumento de modelo professor. Ele precisa que três parâmetros sejam definidos via experimental.gkd.GKDConfig, a saber:
lmbda: controla a fração de dados do aluno, ou seja, a proporção de saídas geradas pelo aluno em política. Quandolmbda=0.0, a perda se reduz a JSD supervisionada, onde o aluno é treinado com as probabilidades de nível de token do professor. Quandolmbda=1.0, a perda se reduz a JSD em política, onde o aluno gera sequências de saída e recebe feedback específico de token sobre essas sequências do professor. Para valores entre [0, 1], a escolha é aleatória entre as duas, com base no valor delmbdapara cada lote.seq_kd: controla se a KD de nível de sequência será executada (pode ser vista como FT supervisionado em saídas geradas pelo professor). Quandoseq_kd=Trueelmbda=0.0, a perda se reduz a JSD supervisionado, em que o professor gera sequências de saída e o aluno recebe feedback específico por token sobre essas sequências do professor.beta: controla a interpolação na Divergência Generalizada de Jensen-Shannon. Quandobeta=0.0, a perda aproxima a divergência KL direta, enquanto parabeta=1.0a perda aproxima a divergência KL reversa. Para valores entre [0, 1], ela interpola entre as duas.
Os autores constatam que os dados on-policy (alto lmbda) apresentam melhor desempenho e que o beta ótimo variava conforme a tarefa e o método de avaliação.
Certifique-se de que
attn_implementation="kernels-community/flash-attn2"ao treinar modelos Gemma. Caso contrário, você encontrará NaNs nos logits devido à técnica de soft capping adotada por essa arquitetura.
A API básica é a seguinte:
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 dataset esperado
O conjunto de dados deve ser formatado como uma lista de “mensagens”, em que cada mensagem é uma lista de dicionários com as seguintes chaves:
role: ousystem,assistantouusercontent: o conteúdo da mensagem
GKDTrainer
classe 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 ou
torch.nn.Moduleoustr, opcional) — Modelo a ser treinado, ou o identificador de string do modelo a ser instanciado a partir de um modelo pré-treinado. - teacher_model (PreTrainedModel ou
torch.nn.Moduleoustr, opcional) — Modelo de professor para destilação de conhecimento, ou o identificador de string do modelo a ser instanciado a partir de um modelo pré-treinado. - args (experimental.gkd.GKDConfig, opcional) — Argumentos de treinamento.
- data_collator (
DataCollator, opcional) — Data collator para agrupar amostras do dataset. O padrão é umexperimental.utils.DataCollatorForChatMLque usa oprocessing_class. - train_dataset (Dataset, opcional) — Conjunto de dados para treinamento.
- eval_dataset (Dataset ou
dictde Dataset, opcional) — Dataset para avaliação. - processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin ou ProcessorMixin, opcional) — Classe para processar os dados.
- compute_metrics (
Callable, opcional) — Função para calcular métricas na avaliação. Deve receber um EvalPrediction e retornar um dicionário de string para float. - callbacks (
listde TrainerCallback, opcional) — Callbacks a serem usados durante o treinamento. - optimizers (
tupledetorch.optim.Optimizeretorch.optim.lr_scheduler.LambdaLR, opcional, padrão(None, None)) — Tupla contendo o otimizador e o agendador de taxa de aprendizado a serem usados para o treinamento. - preprocess_logits_for_metrics (
Callable, opcional) — Função para pré-processar os logits antes de calcular as métricas. Deve receber oslogitse oslabelse retornar os logits a serem usados para o cálculo das métricas. - peft_config (
PeftConfig, opcional) — Configuração PEFT para usar PEFT no treinamento. SeNone, o PEFT não é usado. Se fornecida, omodelserá envolvido com o adaptador PEFT especificado. - formatting_func (
Callable, opcional) — Função para formatar o conjunto de dados. Deve receber um exemplo e retornar um exemplo.
Trainer para Generalized Knowledge Distillation (GKD) de modelos de linguagem.
Para mais detalhes sobre GKD, consulte o artigo: On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes.
treino
< 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 (
stroubool, opcional) — Se for umstr, caminho local para um checkpoint salvo por uma instância anterior deTrainer. Se for umboole for igual aTrue, carrega o último checkpoint em args.output_dir salvo por uma instância anterior deTrainer. Se presente, o treinamento será retomado a partir dos estados do modelo/otimizador/agendador carregados aqui. - trial (
optuna.Trialoudict[str, Any], opcional) — A execução do trial ou o dicionário de hiperparâmetros para a busca de hiperparâmetros. - ignore_keys_for_eval (
list[str], opcional) — Uma lista de chaves na saída do seu modelo (se for um dicionário) que devem ser ignoradas ao coletar previsões para avaliação durante o treinamento.
Retorna
~trainer_utils.TrainOutput
Objeto contendo a contagem de etapas globais, a perda de treinamento e as métricas.
Ponto de entrada principal do treinamento.
Salvará o modelo, para que você possa recarregá-lo usando from_pretrained().
Salvará apenas a partir do processo 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, padrão"End of training") — Mensagem a ser commitada durante o push. - blocking (
bool, opcional, padrãoTrue) — Se a função deve retornar apenas quando ogit pushtiver terminado. - token (
str, opcional, padrãoNone) — Token com permissão de escrita para sobrescrever os argumentos originais do Trainer. - revision (
str, opcional) — A revisão git de onde o commit será feito. O padrão é o topo do ramo “main”. - private (
bool, opcional) — Se o repositório deve ser privado quando for criado. O padrão éargs.hub_private_repo. Não tem efeito se o repositório já existir. - kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados para~Trainer.create_model_card.
Envie self.model e self.processing_class para o hub de modelos do 🤗 no repositório self.args.hub_model_id.
GKDConfig
classe 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, padrão0.9) — Temperatura para amostragem. Quanto maior a temperatura, mais aleatórias são as conclusões. - lmbda (
float, opcional, padrão0.5) — Parâmetro Lambda que controla a fração de dados do aluno (ou seja, a proporção de saídas geradas pelo aluno on-policy). - beta (
float, opcional, padrão0.5) — Coeficiente de interpolação entre0.0e1.0da perda de Divergência Generalizada de Jensen-Shannon. Quando beta é0.0, a perda é a divergência KL. Quando beta é1.0, a perda é a Divergência KL Inversa. - max_new_tokens (
int, opcional, padrão128) — Número máximo de tokens a serem gerados por conclusão. - teacher_model_name_or_path (
str, opcional) — Nome ou caminho do modelo teacher. SeNone, o modelo teacher será o mesmo que o modelo em treinamento. - teacher_model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave para passar aAutoModelForCausalLM.from_pretrainedao instanciar o modelo teacher a partir de uma string. - disable_dropout (
bool, opcional, padrãoTrue) — Se deve desabilitar o dropout no modelo. - seq_kd (
bool, opcional, padrãoFalse) — Parâmetro que controla se deve ser executado Sequence-Level KD (pode ser visto como FT supervisionado na saída gerada pelo teacher).
Classe de configuração para experimental.gkd.GKDTrainer.
Esta classe inclui apenas os parâmetros específicos para o treinamento GKD. Para a lista completa de argumentos de treinamento, consulte a documentação de TrainingArguments e SFTConfig.