Прямая оптимизация предпочтений: полное руководство

import torch
import torch.nn.functional as F

class DPOTrainer:
    def __init__(self, model, ref_model, beta=0.1, lr=1e-5):
        self.model = model
        self.ref_model = ref_model
        self.beta = beta
        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)
    
    def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
        """
        pi_logps: policy logprobs, shape (B,)
        ref_logps: reference model logprobs, shape (B,)
        yw_idxs: preferred completion indices in [0, B-1], shape (T,)
        yl_idxs: dispreferred completion indices in [0, B-1], shape (T,)
        beta: temperature controlling strength of KL penalty

        Each pair of (yw_idxs[i], yl_idxs[i]) represents the indices of a single preference pair.
        """

        # Extract log probabilities for the preferred 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.mean(), rewards

    def train_step(self, batch):
        x, yw_idxs, yl_idxs = batch
        self.optimizer.zero_grad()

        # Compute log probabilities for the model and the reference model
        pi_logps = self.model(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.item()

# Usage
model = YourLanguageModel()  # Initialize your model
ref_model = YourLanguageModel()  # Load pre-trained reference model
trainer = DPOTrainer(model, ref_model)

for batch in dataloader:
    loss = trainer.train_step(batch)
    print(f"Loss: {loss}")

Проблемы и будущие направления

Хотя DPO предлагает значительные преимущества по сравнению с традиционными подходами RLHF, все еще существуют проблемы и области для дальнейших исследований:

а) Масштабируемость до более крупных моделей:

Поскольку языковые модели продолжают расти в размерах, эффективное применение DPO к моделям с сотнями миллиардов параметров остается открытой проблемой. Исследователи изучают такие методы, как:

• Эффективные методы тонкой настройки (например, LoRA, настройка префикса)
• Оптимизация распределенного обучения
• Градиентная контрольная точка и обучение смешанной точности

Пример использования LoRA с DPO:

from peft import LoraConfig, get_peft_model

class DPOTrainerWithLoRA(DPOTrainer):
    def __init__(self, model, 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.model = get_peft_model(model, lora_config)
        self.ref_model = ref_model
        self.beta = beta
        self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)

# Usage
base_model = YourLargeLanguageModel()
dpo_trainer = DPOTrainerWithLoRA(base_model, ref_model)

б) Многозадачность и адаптация к небольшому количеству кадров:

Разработка методов DPO, которые могут эффективно адаптироваться к новым задачам или областям с ограниченными данными о предпочтениях, является активной областью исследований. Изучаемые подходы включают:

• Рамки метаобучения для быстрой адаптации
• Оперативная точная настройка для DPO
• Перенос обучения из моделей общих предпочтений в конкретные области

в) Обработка неоднозначных или противоречивых предпочтений:

Реальные данные о предпочтениях часто содержат неопределенности или противоречия. Повышение устойчивости DPO к таким данным имеет решающее значение. Возможные решения включают:

• Вероятностное моделирование предпочтений
• Активное обучение разрешению двусмысленностей
• Мультиагентная агрегация предпочтений

Пример вероятностного моделирования предпочтений:

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.mean()

# Usage
trainer = ProbabilisticDPOTrainer(model, ref_model)
loss = trainer.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob=0.8)  # 80% confidence in preference

г) Сочетание DPO с другими методами выравнивания:

Интеграция DPO с другими подходами к согласованию может привести к созданию более надежных и функциональных систем:

• Конституционные принципы ИИ для явного удовлетворения ограничений
• Моделирование дебатов и рекурсивного вознаграждения для выявления сложных предпочтений
• Обучение с обратным подкреплением для определения основных функций вознаграждения

Пример сочетания ДПО с конституциональным ИИ:

class ConstitutionalDPOTrainer(DPOTrainer):
    def __init__(self, model, ref_model, beta=0.1, lr=1e-5, constraints=None):
        super().__init__(model, ref_model, beta, lr)
        self.constraints = constraints or []

    def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
        base_loss = super().compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
        
        constraint_loss = 0
        for constraint in self.constraints:
            constraint_loss += constraint(self.model, pi_logps, ref_logps, yw_idxs, yl_idxs)
        
        return base_loss + constraint_loss

# Usage
def safety_constraint(model, pi_logps, ref_logps, yw_idxs, yl_idxs):
    # Implement safety checking logic
    unsafe_score = compute_unsafe_score(model, pi_logps, ref_logps)
    return torch.relu(unsafe_score - 0.5)  # Penalize if unsafe score > 0.5

constraints = [safety_constraint]
trainer = ConstitutionalDPOTrainer(model, ref_model, constraints=constraints)

Практические соображения и лучшие практики

При реализации DPO для реальных приложений примите во внимание следующие советы:

a) Качество данных: качество данных о ваших предпочтениях имеет решающее значение. Убедитесь, что ваш набор данных:

• Охватывает широкий спектр входных данных и желаемого поведения.
• Имеет последовательные и надежные аннотации предпочтений.
• Уравновешивает различные типы предпочтений (например, фактичность, безопасность, стиль)

b) Настройка гиперпараметра: Хотя у DPO меньше гиперпараметров, чем у RLHF, настройка все равно важна:

• β (бета): контролирует компромисс между удовлетворением предпочтений и отклонением от эталонной модели. Начните с ценностей вокруг 0.1-0.5.
• Скорость обучения. Используйте более низкую скорость обучения, чем при стандартной точной настройке, обычно в диапазоне от 1e-6 до 1e-5.
• Размер партии: Большие размеры партии (32-128) часто хорошо работают для обучения предпочтениям.

c) Итеративное уточнение: DPO можно применять итеративно:

1. Обучите исходную модель с помощью DPO
2. Генерируйте новые ответы, используя обученную модель
3. Соберите новые данные о предпочтениях по этим ответам.
4. Повторное обучение с использованием расширенного набора данных

 

Производительность оптимизации прямых предпочтений

На этом изображении показана эффективность моделей LLM, таких как GPT-4, в сравнении с человеческими суждениями при использовании различных методов обучения, включая прямую оптимизацию предпочтений (DPO), контролируемую тонкую настройку (SFT) и оптимизацию проксимальной политики (PPO). Таблица показывает, что результаты GPT-4 всё больше соответствуют человеческим предпочтениям, особенно в задачах реферирования. Уровень согласованности между GPT-4 и рецензентами-людьми демонстрирует способность модели генерировать контент, который резонирует с рецензентами-людьми, почти так же близко, как и контент, созданный человеком.

Тематические исследования и приложения

Чтобы проиллюстрировать эффективность DPO, давайте рассмотрим некоторые реальные приложения и некоторые его варианты:

• Итеративный DPO: этот вариант, разработанный Snorkel (2023), сочетает в себе отбраковочную выборку и DPO, что позволяет более усовершенствовать процесс отбора обучающих данных. Путем повторения нескольких раундов выборки предпочтений модель может лучше обобщать и избегать переобучения к шумным или предвзятым предпочтениям.
• IPO (Итеративная оптимизация предпочтений): Представлено Азаром и др. (2023), IPO добавляет термин регуляризации, чтобы предотвратить переоснащение, что является распространенной проблемой при оптимизации на основе предпочтений. Это расширение позволяет моделям поддерживать баланс между соблюдением предпочтений и сохранением возможностей обобщения.
• КТО (Оптимизация передачи знаний): более поздний вариант от Ethayarajh et al. (2023), KTO вообще отказывается от бинарных предпочтений. Вместо этого он фокусируется на переносе знаний из эталонной модели в политическую модель, оптимизируя ее для более плавного и последовательного соответствия человеческим ценностям.
• Мультимодальный DPO для междоменного обучения Сюй и др. (2024): подход, в котором DPO применяется к различным модальностям — тексту, изображению и аудио — демонстрируя свою универсальность в согласовании моделей с предпочтениями человека в различных типах данных. Это исследование подчеркивает потенциал DPO в создании более комплексных систем искусственного интеллекта, способных решать сложные мультимодальные задачи.

Заключение

Прямая оптимизация предпочтений представляет собой значительный прогресс в согласовании языковых моделей с предпочтениями человека. Его простота, эффективность и результативность делают его мощным инструментом как для исследователей, так и для практиков.

Используя возможности оптимизации прямых предпочтений и помня об этих принципах, вы можете создавать языковые модели, которые не только демонстрируют впечатляющие возможности, но и тесно соответствуют человеческим ценностям и намерениям.