import torch
import torch.nn.practical as F
class DPOTrainer:
def __init__(self, mannequin, ref_model, beta=0.1, lr=1e-5):
self.mannequin = mannequin
self.ref_model = ref_model
self.beta = beta
self.optimizer = torch.optim.AdamW(self.mannequin.parameters(), lr=lr)
def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
"""
pi_logps: coverage logprobs, form (B,)
ref_logps: reference mannequin logprobs, form (B,)
yw_idxs: most well-liked completion indices in (0, B-1), form (T,)
yl_idxs: dispreferred completion indices in (0, B-1), form (T,)
beta: temperature controlling power of KL penalty
Every pair of (yw_idxs(i), yl_idxs(i)) represents the indices of a single desire pair.
"""
# Extract log chances for the popular and dispreferred completions
pi_yw_logps, pi_yl_logps = pi_logps(yw_idxs), pi_logps(yl_idxs)
ref_yw_logps, ref_yl_logps = ref_logps(yw_idxs), ref_logps(yl_idxs)
# Calculate log-ratios
pi_logratios = pi_yw_logps - pi_yl_logps
ref_logratios = ref_yw_logps - ref_yl_logps
# Compute DPO loss
losses = -F.logsigmoid(self.beta * (pi_logratios - ref_logratios))
rewards = self.beta * (pi_logps - ref_logps).detach()
return losses.imply(), rewards
def train_step(self, batch):
x, yw_idxs, yl_idxs = batch
self.optimizer.zero_grad()
# Compute log chances for the mannequin and the reference mannequin
pi_logps = self.mannequin(x).log_softmax(-1)
ref_logps = self.ref_model(x).log_softmax(-1)
# Compute the loss
loss, _ = self.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
loss.backward()
self.optimizer.step()
return loss.merchandise()
# Utilization
mannequin = YourLanguageModel() # Initialize your mannequin
ref_model = YourLanguageModel() # Load pre-trained reference mannequin
coach = DPOTrainer(mannequin, ref_model)
for batch in dataloader:
loss = coach.train_step(batch)
print(f"Loss: {loss}")
Desafios e Direções Futuras
Embora o DPO ofereça vantagens significativas sobre as abordagens tradicionais de RLHF, ainda há desafios e áreas para pesquisas futuras:
a) Escalabilidade para modelos maiores:
À medida que os modelos de linguagem continuam a crescer em tamanho, aplicar DPO de forma eficiente a modelos com centenas de bilhões de parâmetros continua sendo um desafio aberto. Os pesquisadores estão explorando técnicas como:
- Métodos de ajuste fino eficientes (por exemplo, LoRA, ajuste de prefixo)
- Otimizações de treinamento distribuído
- Pontos de verificação de gradiente e treinamento de precisão mista
Exemplo de uso de LoRA com DPO:
from peft import LoraConfig, get_peft_model
class DPOTrainerWithLoRA(DPOTrainer):
def __init__(self, mannequin, ref_model, beta=0.1, lr=1e-5, lora_rank=8):
lora_config = LoraConfig(
r=lora_rank,
lora_alpha=32,
target_modules=("q_proj", "v_proj"),
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM"
)
self.mannequin = get_peft_model(mannequin, lora_config)
self.ref_model = ref_model
self.beta = beta
self.optimizer = torch.optim.AdamW(self.mannequin.parameters(), lr=lr)
# Utilization
base_model = YourLargeLanguageModel()
dpo_trainer = DPOTrainerWithLoRA(base_model, ref_model)
b) Adaptação multitarefa e poucos disparos:
Desenvolver técnicas de DPO que possam se adaptar eficientemente a novas tarefas ou domínios com dados de preferência limitados é uma área ativa de pesquisa. As abordagens que estão sendo exploradas incluem:
- Estruturas de meta-aprendizagem para adaptação rápida
- Ajuste fino baseado em immediate para DPO
- Transferir a aprendizagem de modelos de preferência geral para domínios específicos
c) Tratamento de preferências ambíguas ou conflitantes:
Dados de preferência do mundo actual frequentemente contêm ambiguidades ou conflitos. Melhorar a robustez do DPO para tais dados é essential. Soluções potenciais incluem:
- Modelagem de preferência probabilística
- Aprendizagem ativa para resolver ambiguidades
- Agregação de preferências multiagente
Exemplo de modelagem de preferência probabilística:
class ProbabilisticDPOTrainer(DPOTrainer):
def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob):
# Compute log ratios
pi_yw_logps, pi_yl_logps = pi_logps(yw_idxs), pi_logps(yl_idxs)
ref_yw_logps, ref_yl_logps = ref_logps(yw_idxs), ref_logps(yl_idxs)
log_ratio_diff = pi_yw_logps.sum(-1) - pi_yl_logps.sum(-1)
loss = -(preference_prob * F.logsigmoid(self.beta * log_ratio_diff) +
(1 - preference_prob) * F.logsigmoid(-self.beta * log_ratio_diff))
return loss.imply()
# Utilization
coach = ProbabilisticDPOTrainer(mannequin, ref_model)
loss = coach.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob=0.8) # 80% confidence in desire
d) Combinando DPO com outras técnicas de alinhamento:
A integração do DPO com outras abordagens de alinhamento pode levar a sistemas mais robustos e capazes:
- Princípios constitucionais da IA para satisfação de restrições explícitas
- Debate e modelagem de recompensa recursiva para obtenção de preferências complexas
- Aprendizagem por reforço inverso para inferir funções de recompensa subjacentes
Exemplo de combinação de DPO com IA constitucional:
class ConstitutionalDPOTrainer(DPOTrainer):
def __init__(self, mannequin, ref_model, beta=0.1, lr=1e-5, constraints=None):
tremendous().__init__(mannequin, ref_model, beta, lr)
self.constraints = constraints or ()
def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
base_loss = tremendous().compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
constraint_loss = 0
for constraint in self.constraints:
constraint_loss += constraint(self.mannequin, pi_logps, ref_logps, yw_idxs, yl_idxs)
return base_loss + constraint_loss
# Utilization
def safety_constraint(mannequin, pi_logps, ref_logps, yw_idxs, yl_idxs):
# Implement security checking logic
unsafe_score = compute_unsafe_score(mannequin, pi_logps, ref_logps)
return torch.relu(unsafe_score - 0.5) # Penalize if unsafe rating > 0.5
constraints = (safety_constraint)
coach = ConstitutionalDPOTrainer(mannequin, ref_model, constraints=constraints)
Considerações práticas e melhores práticas
Ao implementar o DPO para aplicações do mundo actual, considere as seguintes dicas:
um) Qualidade de dados: A qualidade dos seus dados de preferência é essential. Garanta que seu conjunto de dados:
- Abrange uma gama diversificada de entradas e comportamentos desejados
- Possui anotações de preferência consistentes e confiáveis
- Equilibra diferentes tipos de preferências (por exemplo, factualidade, segurança, estilo)
b) Ajuste de hiperparâmetros:Embora o DPO tenha menos hiperparâmetros que o RLHF, o ajuste ainda é importante:
- β (beta): Controla o trade-off entre a satisfação da preferência e a divergência do modelo de referência. Comece com valores em torno de 0,1-0,5.
- Taxa de aprendizagem: use uma taxa de aprendizagem menor do que o ajuste fino padrão, normalmente na faixa de 1e-6 a 1e-5.
- Tamanho do lote: tamanhos de lote maiores (32-128) geralmente funcionam bem para aprendizagem de preferências.
c) Refinamento Iterativo: O DPO pode ser aplicado iterativamente:
- Treine um modelo inicial usando DPO
- Gerar novas respostas usando o modelo treinado
- Colete novos dados de preferência sobre essas respostas
- Retreinar usando o conjunto de dados expandido
Desempenho de otimização de preferência direta
Esta imagem se aprofunda no desempenho de LLMs como GPT-4 em comparação com julgamentos humanos em várias técnicas de treinamento, incluindo Direct Choice Optimization (DPO), Supervised High-quality-Tuning (SFT) e Proximal Coverage Optimization (PPO). A tabela revela que as saídas do GPT-4 estão cada vez mais alinhadas com as preferências humanas, especialmente em tarefas de sumarização. O nível de concordância entre o GPT-4 e os revisores humanos demonstra a capacidade do modelo de gerar conteúdo que ressoa com avaliadores humanos, quase tão próximo quanto o conteúdo gerado por humanos.
Estudos de caso e aplicações
Para ilustrar a eficácia do DPO, vejamos algumas aplicações do mundo actual e algumas de suas variantes:
- DPO iterativo: Desenvolvida por Snorkel (2023), esta variante combina amostragem de rejeição com DPO, permitindo um processo de seleção mais refinado para dados de treinamento. Ao iterar em várias rodadas de amostragem de preferência, o modelo é mais capaz de generalizar e evitar overfitting para preferências ruidosas ou tendenciosas.
- IPO (Otimização de Preferência Iterativa): Introduzido por Azar et al. (2023), o IPO adiciona um termo de regularização para evitar overfitting, que é um problema comum na otimização baseada em preferências. Essa extensão permite que os modelos mantenham um equilíbrio entre aderir às preferências e preservar as capacidades de generalização.
- KTO (Otimização da Transferência de Conhecimento): Uma variante mais recente de Ethayarajh et al. (2023), KTO dispensa completamente as preferências binárias. Em vez disso, ele se concentra em transferir conhecimento de um modelo de referência para o modelo de política, otimizando para um alinhamento mais suave e consistente com os valores humanos.
- DPO multimodal para aprendizagem entre domínios por Xu et al. (2024): Uma abordagem em que o DPO é aplicado em diferentes modalidades — texto, imagem e áudio — demonstrando sua versatilidade em alinhar modelos com preferências humanas em diversos tipos de dados. Esta pesquisa destaca o potencial do DPO na criação de sistemas de IA mais abrangentes, capazes de lidar com tarefas complexas e multimodais.
Conclusão
Direct Choice Optimization representa um avanço significativo no alinhamento de modelos de linguagem com preferências humanas. Sua simplicidade, eficiência e eficácia fazem dela uma ferramenta poderosa para pesquisadores e profissionais.
Ao aproveitar o poder da Otimização de Preferência Direta e manter esses princípios em mente, você pode criar modelos de linguagem que não apenas exibem capacidades impressionantes, mas também se alinham estreitamente com valores e intenções humanas.
