Hermes agent

Fine Tuning With Trl

TRL: SFT, DPO, PPO, GRPO, обучение модели наград для RLHF.

Метаданные навыка

ИсточникОпциональный — установить командой hermes skills install official/mlops/trl-fine-tuning
Путьoptional-skills/mlops/training/trl-fine-tuning
Версия1.0.0
АвторOrchestra Research
ЛицензияMIT
Зависимостиtrl, transformers, datasets, peft, accelerate, torch
Платформыlinux, macos, windows
ТегиPost-Training, TRL, Reinforcement Learning, Fine-Tuning, SFT, DPO, PPO, GRPO, RLHF, Preference Alignment, HuggingFace

Справочник: полный SKILL.md

инфо

Ниже приведено полное определение навыка, которое Hermes Agent загружает при его активации. Именно это агент видит как инструкции в момент работы навыка.

TRL - Transformer Reinforcement Learning

Быстрый старт

TRL предоставляет методы post-training для согласования языковых моделей с предпочтениями людей.

Установка:

pip install trl transformers datasets peft accelerate

Supervised Fine-Tuning (обучение следованию инструкциям):

from trl import SFTTrainer

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B",
    train_dataset=dataset,  # Prompt-completion pairs
)
trainer.train()

DPO (выравнивание по предпочтениям):

from trl import DPOTrainer, DPOConfig

config = DPOConfig(output_dir="model-dpo", beta=0.1)
trainer = DPOTrainer(
    model=model,
    args=config,
    train_dataset=preference_dataset,  # chosen/rejected pairs
    processing_class=tokenizer
)
trainer.train()

Типовые рабочие процессы

Рабочий процесс 1: Полный RLHF-пайплайн (SFT → Reward Model → PPO)

Полный путь от базовой модели до модели, выровненной по предпочтениям людей.

Чеклист для копирования:

RLHF Training:
- [ ] Step 1: Supervised fine-tuning (SFT)
- [ ] Step 2: Train reward model
- [ ] Step 3: PPO reinforcement learning
- [ ] Step 4: Evaluate aligned model

Шаг 1: Supervised fine-tuning

Обучаем базовую модель на данных с инструкциями:

from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

# Загружаем модель
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B")

# Загружаем датасет с инструкциями
dataset = load_dataset("trl-lib/Capybara", split="train")

# Настраиваем обучение
training_args = SFTConfig(
    output_dir="Qwen2.5-0.5B-SFT",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=2e-5,
    logging_steps=10,
    save_strategy="epoch"
)

# Обучаем
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer
)
trainer.train()
trainer.save_model()

Шаг 2: Обучение модели наград

Учим модель предсказывать предпочтения людей:

from transformers import AutoModelForSequenceClassification
from trl import RewardTrainer, RewardConfig

# Берём SFT-модель за основу
model = AutoModelForSequenceClassification.from_pretrained(
    "Qwen2.5-0.5B-SFT",
    num_labels=1  # Single reward score
)
tokenizer = AutoTokenizer.from_pretrained("Qwen2.5-0.5B-SFT")

# Загружаем данные предпочтений (пары chosen/rejected)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

# Настраиваем обучение
training_args = RewardConfig(
    output_dir="Qwen2.5-0.5B-Reward",
    per_device_train_batch_size=2,
    num_train_epochs=1,
    learning_rate=1e-5
)

# Обучаем модель наград
trainer = RewardTrainer(
    model=model,
    args=training_args,
    processing_class=tokenizer,
    train_dataset=dataset
)
trainer.train()
trainer.save_model()

Шаг 3: PPO — обучение с подкреплением

Оптимизируем политику с помощью модели наград:

python -m trl.scripts.ppo \
    --model_name_or_path Qwen2.5-0.5B-SFT \
    --reward_model_path Qwen2.5-0.5B-Reward \
    --dataset_name trl-internal-testing/descriptiveness-sentiment-trl-style \
    --output_dir Qwen2.5-0.5B-PPO \
    --learning_rate 3e-6 \
    --per_device_train_batch_size 64 \
    --total_episodes 10000

Шаг 4: Оценка

from transformers import pipeline

# Загружаем выровненную модель
generator = pipeline("text-generation", model="Qwen2.5-0.5B-PPO")

# Тест
prompt = "Explain quantum computing to a 10-year-old"
output = generator(prompt, max_length=200)[0]["generated_text"]
print(output)

Рабочий процесс 2: Простое выравнивание по предпочтениям через DPO

Выравниваем модель по предпочтениям без отдельной модели наград.

Чеклист для копирования:

DPO Training:
- [ ] Step 1: Prepare preference dataset
- [ ] Step 2: Configure DPO
- [ ] Step 3: Train with DPOTrainer
- [ ] Step 4: Evaluate alignment

Шаг 1: Подготовка датасета с предпочтениями

Формат данных:

{
  "prompt": "What is the capital of France?",
  "chosen": "The capital of France is Paris.",
  "rejected": "I don't know."
}

Загружаем датасет:

from datasets import load_dataset

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
# Или загружаем свой
# dataset = load_dataset("json", data_files="preferences.json")

Шаг 2: Конфигурация DPO

from trl import DPOConfig

config = DPOConfig(
    output_dir="Qwen2.5-0.5B-DPO",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=5e-7,
    beta=0.1,  # KL penalty strength
    max_prompt_length=512,
    max_length=1024,
    logging_steps=10
)

Шаг 3: Обучение через DPOTrainer

from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOTrainer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")

trainer = DPOTrainer(
    model=model,
    args=config,
    train_dataset=dataset,
    processing_class=tokenizer
)

trainer.train()
trainer.save_model()

Альтернатива через CLI:

trl dpo \
    --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
    --dataset_name argilla/Capybara-Preferences \
    --output_dir Qwen2.5-0.5B-DPO \
    --per_device_train_batch_size 4 \
    --learning_rate 5e-7 \
    --beta 0.1

Рабочий процесс 3: Экономичное онлайн-RL с GRPO

Обучение с подкреплением при минимальном потреблении памяти.

Подробное руководство по GRPO — проектирование функции наград, важные особенности обучения (поведение функции потерь, mode collapse, тюнинг) и продвинутые многоэтапные схемы — в файле references/grpo-training.md. Готовый к продакшену скрипт обучения — в templates/basic_grpo_training.py.

Чеклист для копирования:

GRPO Training:
- [ ] Step 1: Define reward function
- [ ] Step 2: Configure GRPO
- [ ] Step 3: Train with GRPOTrainer

Шаг 1: Определяем функцию наград

def reward_function(completions, **kwargs):
    """
    Вычисляем награды для сгенерированных текстов.

    Args:
        completions: List of generated texts

    Returns:
        List of reward scores (floats)
    """
    rewards = []
    for completion in completions:
        # Пример: награда за длину и уникальность слов
        score = len(completion.split())  # Favor longer responses
        score += len(set(completion.lower().split()))  # Reward unique words
        rewards.append(score)
    return rewards

Или используем модель наград:

from transformers import pipeline

reward_model = pipeline("text-classification", model="reward-model-path")

def reward_from_model(completions, prompts, **kwargs):
    # Склеиваем prompt + completion
    full_texts = [p + c for p, c in zip(prompts, completions)]
    # Получаем оценки
    results = reward_model(full_texts)
    return [r["score"] for r in results]

Шаг 2: Конфигурация GRPO

from trl import GRPOConfig

config = GRPOConfig(
    output_dir="Qwen2-GRPO",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=1e-5,
    num_generations=4,  # Generate 4 completions per prompt
    max_new_tokens=128
)

Шаг 3: Обучение через GRPOTrainer

from datasets import load_dataset
from trl import GRPOTrainer

# Загружаем датасет только с промптами
dataset = load_dataset("trl-lib/tldr", split="train")

trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=reward_function,  # Your reward function
    args=config,
    train_dataset=dataset
)

trainer.train()

CLI:

trl grpo \
    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/tldr \
    --output_dir Qwen2-GRPO \
    --num_generations 4

Когда использовать и альтернативы

Используйте TRL, когда:

  • Нужно выровнять модель по предпочтениям людей
  • Есть данные предпочтений (пары chosen/rejected)
  • Планируете обучение с подкреплением (PPO, GRPO)
  • Нужно обучить модель наград
  • Реализуете полный RLHF-пайплайн

Выбор метода:

  • SFT: есть пары prompt-completion, нужно базовое следование инструкциям
  • DPO: есть данные предпочтений, хотите простое выравнивание (без отдельной модели наград)
  • PPO: есть модель наград, нужен максимальный контроль над RL
  • GRPO: ограничена память, нужно онлайн-RL
  • Reward Model: строите RLHF-пайплайн, нужно оценивать сгенерированные тексты

Когда лучше взять альтернативу:

  • HuggingFace Trainer: базовый файн-тюнинг без RL
  • Axolotl: конфигурация обучения через YAML
  • LitGPT: учебный минималистичный файн-тюнинг
  • Unsloth: быстрое LoRA-обучение

Типичные проблемы

Проблема: OOM при DPO-обучении

Уменьшаем размер батча и длину последовательности:

config = DPOConfig(
    per_device_train_batch_size=1,  # Reduce from 4
    max_length=512,  # Reduce from 1024
    gradient_accumulation_steps=8  # Maintain effective batch
)

Или включаем gradient checkpointing:

model.gradient_checkpointing_enable()

Проблема: Низкое качество выравнивания

Подбираем параметр beta:

# Higher beta = more conservative (stays closer to reference)
config = DPOConfig(beta=0.5)  # Default 0.1

# Lower beta = more aggressive alignment
config = DPOConfig(beta=0.01)

Проблема: Модель наград не обучается

Проверяем тип функции потерь и learning rate:

config = RewardConfig(
    learning_rate=1e-5,  # Try different LR
    num_train_epochs=3  # Train longer
)

Убеждаемся, что в датасете предпочтений есть явные победители:

# Verify dataset
print(dataset[0])
# Should have clear chosen > rejected

Проблема: Нестабильное PPO-обучение

Регулируем KL-коэффициент:

config = PPOConfig(
    kl_coef=0.1,  # Increase from 0.05
    cliprange=0.1  # Reduce from 0.2
)

Дополнительные темы

Руководство по SFT: форматы датасетов, шаблоны чата, стратегии packing и многоGPU-обучение — в references/sft-training.md.

Варианты DPO: IPO, cDPO, RPO и другие функции потерь с рекомендуемыми гиперпараметрами — в references/dpo-variants.md.

Модели наград: outcome vs process rewards, Bradley-Terry loss, оценка модели наград — в references/reward-modeling.md.

Онлайн-методы RL: PPO, GRPO, RLOO и OnlineDPO с детальными конфигурациями — в references/online-rl.md.

Углублённый разбор GRPO: философия проектирования функций наград, особенности обучения (почему растёт функция потерь, детектирование mode collapse), подбор гиперпараметров, многоэтапное обучение и отладка — в references/grpo-training.md. Готовый шаблон — в templates/basic_grpo_training.py.

Требования к железу

  • GPU: NVIDIA (требуется CUDA)
  • VRAM: зависит от модели и метода
    • SFT 7B: 16 ГБ (с LoRA)
    • DPO 7B: 24 ГБ (хранит reference-модель)
    • PPO 7B: 40 ГБ (политика + модель наград)
    • GRPO 7B: 24 ГБ (экономичнее по памяти)
  • Multi-GPU: поддерживается через accelerate
  • Смешанная точность: рекомендуется BF16 (A100/H100)

Оптимизация памяти:

  • Используйте LoRA/QLoRA для всех методов
  • Включайте gradient checkpointing
  • Уменьшайте размер батча с gradient accumulation

Ресурсы

⌕ ESC