TRL documentation

BEMA para Modelo de Referência

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

BEMA para Modelo de Referência

Este recurso implementa o algoritmo BEMA para atualizar o modelo de referência durante o treinamento DPO.

Uso

from trl.experimental.bema_for_ref_model import BEMACallback, DPOTrainer
from datasets import load_dataset

dataset = load_dataset("trl-internal-testing/zen", "standard_preference", split="train")

bema_callback = BEMACallback(update_ref_model=True)

trainer = DPOTrainer(
    model="trl-internal-testing/tiny-Qwen2ForCausalLM-2.5",
    train_dataset=dataset,
    callbacks=[bema_callback],
)
trainer.train()

DPOTrainer

classe trl.DPOTrainer

< >

( *args**kwargs )

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.

BEMACallback

classe trl.BEMACallback

< >

( update_freq: int = 400ema_power: float = 0.5bias_power: float = 0.2lag: int = 10update_after: int = 0multiplier: float = 1.0min_ema_multiplier: float = 0.0device: str = 'cpu'update_ref_model: bool = Falseref_model_update_freq: int = 400ref_model_update_after: int = 0 )

Parâmetros

  • update_freq (int, opcional, padrão é 400) — Atualiza os pesos do BEMA a cada X passos. Denotado como {@html "ϕ \\phi ϕ"} in the paper.
  • ema_power (float, optional, defaults to 0.5) — Power for the EMA decay factor. Denoted {@html "κ \\kappa κ "} no artigo. Para desativar o EMA, defina este valor como 0.0.
  • bias_power (float, opcional, padrão é 0.2) — Potência para o fator de escala do BEMA. Denotado como {@html "η \\eta η"} no artigo. Um valor grande (por exemplo, 8.0) faz {@html "αt \\alpha_t αt​"} decair para 0, aproximando a correção de viés desativada; 0.0, por outro lado, fixa {@html "αt \\alpha_t αt​"} em 1 para cada etapa (correção máxima, sem decaimento). lag (int, opcional, padrão é 10) — Deslocamento inicial no agendamento de decaimento de peso que controla a suavidade nas etapas iniciais, atuando como uma idade inicial virtual para as atualizações. Denotado como {@html "ρ \\rho ρ "}η \\eta η"} in the paper. A large value (e.g. 8.0) makes {@html "αt \\alpha_t αt​"} decay to 0, approximating disabled bias-correction; 0.0 instead pins {@html "αt \\alpha_t αt​"} at 1 for every step (maximum, undecayed correction).
  • lag (int, optional, defaults to 10) — Initial offset in the weight decay schedule that controls early-stage smoothness by acting as a virtual starting age for the updates. Denoted as {@html "ρ \\rho ρ"} no artigo.
  • update_after (int, opcional, padrão é 0) — Tempo de aquecimento antes de começar a atualizar os pesos do BEMA. Denotado como {@html "τ \\tau τ"} no artigo. multiplier (float, opcional, padrão é 1.0) — Valor inicial para o fator de decaimento do EMA. Denotado como {@html "γ \\gamma γ "}τ \\tau τ"} in the paper.
  • multiplier (float, optional, defaults to 1.0) — Initial value for the EMA decay factor. Denoted as {@html "γ \\gamma γ"} no artigo.
  • min_ema_multiplier (float, opcional, padrão 0.0) — Valor mínimo para o fator de decaimento da EMA.
  • device (str, opcional, padrão "cpu") — Dispositivo a ser usado para os buffers BEMA, por exemplo, "cpu" ou "cuda". Observe que, na maioria dos casos, esse dispositivo DEVE SER DIFERENTE do dispositivo usado para o treinamento, a fim de evitar OOM.
  • update_ref_model (bool, opcional, padrão False) — Se deve atualizar o modelo de referência com os pesos do BEMA. Isso cria uma versão defasada e suavizada do modelo principal como modelo de referência.
  • ref_model_update_freq (int, opcional, padrão 400) — Atualiza o modelo de referência com os pesos BEMA a cada este número de etapas.
  • ref_model_update_after (int, opcional, padrão 0) — Número de etapas a aguardar antes de começar a atualizar o modelo de referência.

Uma TrainerCallback que implementa BEMA (Bias-Corrected Exponential Moving Average) de Adam Block e Cyril Zhang. Código de https://github.com/abblock/bema sob licença MIT.

O BEMA calcula pesos do modelo que são escalados da seguinte forma: θt′=αt⋅(θt−θ0)+EMAt \theta_t' = \alpha_t \cdot (\theta_t - \theta_0) + \text{EMA}_t

onde θt \theta_t são os pesos atuais do modelo, θ0 \theta_0 é um instantâneo dos pesos do modelo no primeiro update_after passo, EMAt \text{EMA}_t é a média móvel exponencial dos pesos do modelo, eαt \alpha_t é um fator de escala que decai com o número de passos t t como αt=(ρ+γ⋅t)−η. \alpha_t = (\rho + \gamma \cdot t)^{-\eta}.

O EMA é calculado como: EMAt=(1−βt)⋅EMAt−1+βt⋅θt \text{EMA}_t = (1 - \beta_t) \cdot \text{EMA}_{t-1} + \beta_t \cdot \theta_t

onde βt \beta_t é um fator de decaimento que decai com o número de passos t t como βt=(ρ+γ⋅t)−κ. \beta_t = (\rho + \gamma \cdot t)^{-\kappa}.

Exemplo:

>>> from trl import BEMACallback

>>> trainer = Trainer(..., callbacks=[BEMACallback()])
Update on GitHub