TRL documentation

Treinador de Destilação de Conhecimento Generalizada

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Treinador de Destilação de Conhecimento Generalizada

model badge

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:

  1. 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.
  2. 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. Quando lmbda=0.0, a perda se reduz a JSD supervisionada, onde o aluno é treinado com as probabilidades de nível de token do professor. Quando lmbda=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 de lmbda para 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). Quando seq_kd=True e lmbda=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. Quando beta=0.0, a perda aproxima a divergência KL direta, enquanto para beta=1.0 a 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: ou system, assistant ou user
  • content: o conteúdo da mensagem

GKDTrainer

classe trl.experimental.gkd.GKDTrainer

< >

( 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.Module ou str, 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.Module ou str, 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 é um experimental.utils.DataCollatorForChatML que usa o processing_class.
  • train_dataset (Dataset, opcional) — Conjunto de dados para treinamento.
  • eval_dataset (Dataset ou dict de 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 (list de TrainerCallback, opcional) — Callbacks a serem usados durante o treinamento.
  • optimizers (tuple de torch.optim.Optimizer e torch.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 os logits e os labels e 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. Se None, o PEFT não é usado. Se fornecida, o model será 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

< >

( 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 (str ou bool, opcional) — Se for um str, caminho local para um checkpoint salvo por uma instância anterior de Trainer. Se for um bool e for igual a True, carrega o último checkpoint em args.output_dir salvo por uma instância anterior de Trainer. Se presente, o treinamento será retomado a partir dos estados do modelo/otimizador/agendador carregados aqui.
  • trial (optuna.Trial ou dict[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.

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

Salvará o modelo, para que você possa recarregá-lo usando from_pretrained().

Salvará apenas a partir do processo principal.

push_to_hub

< >

( 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ão True) — Se a função deve retornar apenas quando o git push tiver terminado.
  • token (str, opcional, padrão None) — 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

< >

( 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ão 0.9) — Temperatura para amostragem. Quanto maior a temperatura, mais aleatórias são as conclusões.
  • lmbda (float, opcional, padrão 0.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ão 0.5) — Coeficiente de interpolação entre 0.0 e 1.0 da 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ão 128) — 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. Se None, 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 a AutoModelForCausalLM.from_pretrained ao instanciar o modelo teacher a partir de uma string.
  • disable_dropout (bool, opcional, padrão True) — Se deve desabilitar o dropout no modelo.
  • seq_kd (bool, opcional, padrão False) — 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.

Update on GitHub