TRL (обучение RLHF/DPO)

TRL (Transformer Reinforcement Learning) — официальная библиотека HuggingFace для обучения языковых моделей с помощью методов обучения с подкреплением. Имея более 10 тыс. звёзд на GitHub, она предоставляет передовые реализации RLHF, DPO, PPO, GRPO и других алгоритмов выравнивания для LLM.

Все примеры можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI.

---

Что такое TRL?

TRL — это библиотека, лежащая в основе многих лучших по выравниванию языковых моделей современности. Она предоставляет:

• SFT (супервизированное дообучение) — стандартное дообучение по инструкциям в формате ChatML

• RLHF/PPO — классическая оптимизация проксимальной политики с моделью вознаграждения

• DPO — Direct Preference Optimization (модель вознаграждения не нужна!)

• GRPO — Group Relative Policy Optimization (метод DeepSeek-R1)

• KTO — Kahneman-Tversky Optimization (работает с непарными предпочтениями)

• Reward Modeling — обучите модель вознаграждения на данных человеческих предпочтений

• IterativeSFT — онлайн-обучение с подкреплением с более простой схемой

• ORPO — Odds Ratio Preference Optimization

TRL нативно интегрируется с экосистемой HuggingFace: transformers, peft, datasets, accelerate, и bitsandbytes.

Какой алгоритм следует использовать?

• DPO — самый простой и стабильный. Используйте, когда у вас есть парные данные предпочтений (выбранный/отклонённый).

• PPO — самый мощный, но и самый сложный. Используйте, когда у вас есть модель вознаграждения или функция оценки.

• GRPO — отлично подходит для задач рассуждения и математики. Метод обучения DeepSeek-R1.

• SFT — всегда начинайте с этого перед применением любого RL-метода.

---

Требования к серверу

Компонент	Минимум	Рекомендуется
GPU	RTX 3090 (24 GB)	A100 80 GB / H100
VRAM	16 GB (SFT/DPO 7B + LoRA)	80 GB (полное дообучение 7B)
ОЗУ	32 ГБ	64 GB+
CPU	8 ядер	16+ ядер
Хранилище	100 ГБ	300+ GB
ОС	Ubuntu 20.04+	Ubuntu 22.04
Python	3.9+	3.11
CUDA	12.8+	12.8+

VRAM по задаче

Задача	Модель	Метод	VRAM
SFT	Llama 3 8B	QLoRA 4-bit	~8 ГБ
DPO	Llama 3 8B	LoRA	~20 GB
PPO	Llama 3 8B	Полное	~80 GB (2×A100)
GRPO	Qwen 7B	LoRA	~24 GB
SFT	Llama 3 70B	QLoRA 4-bit	~48 GB
DPO	Llama 3 70B	LoRA	~80 GB

---

Порты

Порт	Сервис	Примечания
22	SSH	Доступ к терминалу, передача файлов, мониторинг

TRL — это библиотека для обучения; она запускается как CLI- или Python-скрипт, веб-сервер не требуется.

---

Установка на Clore.ai

Шаг 1 — Арендуйте сервер

1. Перейдите на Маркетплейс Clore.ai

2. Фильтруйте по VRAM ≥ 24 GB (RTX 3090, A100 или H100)

3. Выберите PyTorch или CUDA 12.8 базовый образ

4. Выберите Хранилище ≥ 200 GB для моделей и датасетов

5. Откройте порт 22 для доступа по SSH

Шаг 2 — Подключитесь по SSH

ssh root@<server-ip> -p <ssh-port>

Шаг 3 — Установите TRL

# Создайте виртуальное Python-окружение
python3 -m venv /opt/trl
source /opt/trl/bin/activate

# Установите TRL со всеми зависимостями
pip install trl

# Установите дополнительные зависимости для полных рабочих процессов
pip install \
    transformers \
    datasets \
    peft \
    accelerate \
    bitsandbytes \
    wandb \
    scipy \
    sentencepiece \
    protobuf

# Проверьте поддержку GPU
python3 -c "import torch; print(f'CUDA: {torch.cuda.is_available()}, GPU: {torch.cuda.get_device_name(0)}')"

Шаг 4 — Аутентификация HuggingFace

# Войдите, чтобы получить доступ к ограниченным моделям (Llama, Gemma)
huggingface-cli login
# Введите ваш токен HF с https://huggingface.co/settings/tokens

# Или задайте переменную окружения
export HF_TOKEN=hf_your-token-here

Шаг 5 — Опционально: отслеживание в Weights & Biases

# Настройте отслеживание экспериментов (крайне рекомендуется)
pip install wandb
wandb login  # Введите ваш API-ключ W&B с https://wandb.ai/settings

# Или отключите W&B
export WANDB_DISABLED=true

---

Супервизированное дообучение (SFT)

SFT всегда является первым шагом перед любой техникой RL.

Подготовьте свой датасет

# Формат: библиотека datasets с колонкой 'messages' или 'text'
# Формат ChatML (рекомендуется)
from datasets import Dataset

data = [
    {
        "messages": [
            {"role": "system", "content": "Вы полезный ассистент облака GPU."},
            {"role": "user", "content": "Как арендовать GPU на Clore.ai?"},
            {"role": "assistant", "content": "Посетите clore.ai/marketplace, отфильтруйте по характеристикам GPU, выберите сервер и нажмите «Арендовать». Доступ по SSH предоставляется сразу после оплаты."}
        ]
    },
    # ... больше примеров
]

dataset = Dataset.from_list(data)
dataset.save_to_disk("data/sft_dataset")
dataset.push_to_hub("your-username/my-sft-dataset")  # опционально

Скрипт обучения SFT

# sft_train.py
from trl import SFTTrainer, SFTConfig
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
from datasets import load_dataset
import torch

# Конфигурация модели
model_name = "meta-llama/Llama-3.2-8B-Instruct"

# QLoRA: конфигурация 4-битной квантизации
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

# Загрузить модель
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

# Загрузить токенизатор
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# Конфигурация LoRA
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

# Загрузить датасет
dataset = load_dataset("trl-lib/ultrachat_200k", split="train_sft[:10%]")

# Конфигурация обучения
training_config = SFTConfig(
    output_dir="./sft_output",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    warmup_ratio=0.05,
    lr_scheduler_type="cosine",
    fp16=False,
    bf16=True,
    max_seq_length=2048,
    dataset_text_field="messages",
    logging_steps=10,
    save_steps=100,
    save_total_limit=3,
    push_to_hub=False,
    report_to="wandb",  # или "none"
)

# Инициализировать тренер
trainer = SFTTrainer(
    model=model,
    args=training_config,
    train_dataset=dataset,
    peft_config=lora_config,
    tokenizer=tokenizer,
)

# Обучение
trainer.train()
trainer.save_model("./sft_final")

# Запустить обучение
python3 sft_train.py

---

DPO (Direct Preference Optimization)

DPO — самый популярный метод выравнивания: модель вознаграждения не нужна, только пары предпочтений.

Подготовьте DPO-датасет

# Формат: у каждого примера есть 'prompt', 'chosen', 'rejected'
from datasets import Dataset

data = [
    {
        "prompt": "Объясните, как оптимизировать использование GPU",
        "chosen": "Чтобы оптимизировать использование GPU: 1) используйте большие размеры батча, чтобы максимизировать загрузку, 2) включите смешанную точность (bf16/fp16), 3) профилируйте с помощью nvidia-smi, чтобы выявить узкие места, 4) используйте потоки CUDA для параллельных операций.",
        "rejected": "Просто используйте больше GPU."
    },
    # ... больше пар предпочтений
]

dataset = Dataset.from_list(data)

Скрипт обучения DPO

# dpo_train.py
from trl import DPOTrainer, DPOConfig
from transformers import AutoTokenizer, AutoModelForCausalLM
from datasets import load_dataset
import torch

model_name = "./sft_final"  # Начните со своей SFT-модели!

# Загрузите SFT-модель (политику, которую нужно выровнять)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Референсная модель (замороженная копия SFT-модели)
ref_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# Загрузить датасет предпочтений
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train[:5%]")

# Конфигурация DPO
dpo_config = DPOConfig(
    output_dir="./dpo_output",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=5e-7,           # Значительно ниже, чем у SFT
    beta=0.1,                     # Коэффициент штрафа KL
    loss_type="sigmoid",          # Стандартная функция потерь DPO
    max_length=2048,
    max_prompt_length=512,
    bf16=True,
    logging_steps=10,
    save_steps=50,
    report_to="wandb",
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=dpo_config,
    train_dataset=dataset,
    tokenizer=tokenizer,
)

trainer.train()
trainer.save_model("./dpo_final")

---

PPO (Proximal Policy Optimization)

PPO — классический подход RLHF: используйте его, когда у вас есть сигнал вознаграждения:

# ppo_train.py
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer, pipeline
from datasets import load_dataset
import torch

model_name = "./sft_final"

# Модель политики (с value head для PPO)
model = AutoModelForCausalLMWithValueHead.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# Модель вознаграждения (может быть любой функцией оценки)
sentiment_pipe = pipeline(
    "sentiment-analysis",
    model="distilbert/distilbert-base-uncased-finetuned-sst-2-english",
    device=0,
)

def reward_fn(texts):
    """Оцените каждый ответ. Верните список тензоров вознаграждения."""
    results = sentiment_pipe(texts)
    rewards = []
    for result in results:
        score = result["score"] if result["label"] == "POSITIVE" else -result["score"]
        rewards.append(torch.tensor(score))
    return rewards

ppo_config = PPOConfig(
    output_dir="./ppo_output",
    learning_rate=1.41e-5,
    mini_batch_size=1,
    batch_size=4,
    gradient_accumulation_steps=4,
    kl_penalty="kl",
    target_kl=6.0,
    cliprange=0.2,
    vf_coef=0.1,
)

trainer = PPOTrainer(
    config=ppo_config,
    model=model,
    ref_model=None,  # Автоматически копирует начальную модель как референс
    tokenizer=tokenizer,
)

# Цикл обучения
dataset = load_dataset("imdb", split="train[:1000]")
for epoch in range(3):
    for batch in trainer.dataloader:
        queries = batch["input_ids"]
        
        # Сгенерировать ответы
        responses = trainer.generate(queries, max_new_tokens=100)
        
        # Оценить ответы
        texts = tokenizer.batch_decode(responses, skip_special_tokens=True)
        rewards = reward_fn(texts)
        
        # Обновление PPO
        stats = trainer.step(queries, responses, rewards)
        trainer.log_stats(stats, batch, rewards)

---

GRPO (Group Relative Policy Optimization)

GRPO используется в DeepSeek-R1 для обучения рассуждению:

# grpo_train.py
from trl import GRPOTrainer, GRPOConfig
from transformers import AutoTokenizer, AutoModelForCausalLM
from datasets import Dataset
import re, torch

model_name = "Qwen/Qwen2.5-7B-Instruct"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Математический датасет
def make_math_dataset():
    examples = [
        {"prompt": "Сколько будет 2+2?", "answer": "4"},
        {"prompt": "Сколько будет 15 * 7?", "answer": "105"},
        # ... больше математических задач
    ]
    return Dataset.from_list(examples)

dataset = make_math_dataset()

def correctness_reward(completions, answer, **kwargs):
    """Вознаграждайте 1.0, если ответ верный, и 0.0 в противном случае."""
    rewards = []
    for completion in completions:
        # Извлеките последнее число из завершения
        numbers = re.findall(r'\d+', completion[-1]["content"])
        if numbers and numbers[-1] == answer:
            rewards.append(1.0)
        else:
            rewards.append(0.0)
    return rewards

grpo_config = GRPOConfig(
    output_dir="./grpo_output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    num_generations=8,       # GRPO генерирует G ответов на каждый запрос
    learning_rate=5e-7,
    bf16=True,
    logging_steps=10,
)

trainer = GRPOTrainer(
    model=model,
    args=grpo_config,
    train_dataset=dataset,
    reward_funcs=correctness_reward,
    tokenizer=tokenizer,
)

trainer.train()

---

Многопроцессорное обучение на нескольких GPU

Используйте accelerate для распределённого обучения:

# Настройте accelerate для работы с несколькими GPU
accelerate config

# Пример конфигурации для 4 GPU:
# - compute_environment: LOCAL_MACHINE
# - distributed_type: MULTI_GPU
# - num_processes: 4
# - mixed_precision: bf16

# Запустите обучение на всех GPU
accelerate launch sft_train.py
accelerate launch dpo_train.py

# Или явно указать GPU
CUDA_VISIBLE_DEVICES=0,1,2,3 accelerate launch \
  --num_processes 4 \
  --mixed_precision bf16 \
  sft_train.py

---

Использование CLI TRL

TRL предоставляет удобные команды CLI:

# SFT через CLI
trl sft \
  --model_name_or_path meta-llama/Llama-3.2-8B-Instruct \
  --dataset_name trl-lib/ultrachat_200k \
  --dataset_text_field messages \
  --output_dir ./cli_sft_output \
  --num_train_epochs 3 \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 2e-4 \
  --bf16 \
  --use_peft \
  --lora_r 16 \
  --lora_alpha 32

# DPO через CLI
trl dpo \
  --model_name_or_path ./cli_sft_output \
  --dataset_name trl-lib/ultrafeedback_binarized \
  --output_dir ./cli_dpo_output \
  --num_train_epochs 1 \
  --beta 0.1 \
  --bf16

---

Мониторинг обучения

# Следите за загрузкой GPU
watch -n 1 nvidia-smi

# Мониторьте loss обучения (если используете W&B)
# Откройте https://wandb.ai/your-username в браузере

# Проверьте каталог вывода на наличие чекпойнтов
ls -lh sft_output/checkpoint-*/

# Возобновить из чекпойнта
python3 sft_train.py --resume_from_checkpoint sft_output/checkpoint-500/

---

Рекомендации по GPU для Clore.ai

Многопроцессорные конфигурации с GPU класса 80GB не представлены на маркетплейсе Clore.ai. Самые крупные доступные сейчас машины — это 4× RTX PRO 6000 Blackwell (по 96GB, всего 380GB) и 8–11× RTX 5090 (по 32GB). Ёмкость A100 / H200 / B200 продаётся как голое железо по запросу. Проверьте Цены и доступность GPU перед выбором размера развёртывания.

Обучение TRL — одна из самых требовательных к VRAM задач. Выбирайте GPU в зависимости от размера модели и метода:

Задача	GPU	Примечания
SFT / DPO для 7–8B (QLoRA)	RTX 3090 24 ГБ	~8 ГБ для QLoRA 4-bit; удобно помещается; $0.07–0.21/час на Clore.ai
SFT / DPO для 7–8B (LoRA bf16)	RTX 4090 24 ГБ	Та же VRAM, что и у 3090, но на 30% быстрее вычисления; отлично подходит для быстрой итерации
Полный SFT для 7B или DPO для 13B	A100 40 ГБ	40 ГБ хватает для полноточного обучения 7B; память ECC предотвращает скрытые ошибки
PPO / полное дообучение 7B или любой 70B QLoRA	A100 80 ГБ	PPO требует в VRAM 2× policy+ref model; 80 ГБ позволяет запустить оба без OOM

Практический совет: Начните с RTX 3090 и QLoRA для экспериментов — обучите Llama 3 8B примерно за 2 часа на 10 тыс. примеров. После проверки пайплайна переходите на A100 80GB для полноточных запусков или моделей 70B.

Показатели скорости (Llama 3 8B SFT, QLoRA, batch=4, seq=2048):

• RTX 3090: ~1,100 токенов/с пропускная способность обучения

• RTX 4090: ~1,450 токенов/с

• A100 80GB: ~2,800 токенов/с (полный bf16, без квантования)

---

Устранение неполадок

Недостаточно памяти CUDA

# Уменьшите размер батча
per_device_train_batch_size=1
gradient_accumulation_steps=16  # Сохраните тот же эффективный размер батча

# Используйте 4-битную квантование (QLoRA)
# Добавьте BitsAndBytesConfig с load_in_4bit=True

# Включите checkpointing градиентов
gradient_checkpointing=True

# Уменьшите длину последовательности
max_seq_length=1024  # вместо 2048+

# Проверьте память GPU
nvidia-smi --query-gpu=memory.used,memory.total --format=csv

Loss — NaN

# Частая причина: слишком высокий learning rate
learning_rate=1e-5  # Попробуйте ниже

# Частая причина: плохие данные (пустые строки, значения None)
# Проверьте датасет:
python3 -c "
from datasets import load_from_disk
ds = load_from_disk('data/sft_dataset')
print(ds[0])
print(f'Length: {len(ds)}')
# Проверить None
none_count = sum(1 for x in ds if x.get('messages') is None)
print(f'None count: {none_count}')
"

# Включите bf16 вместо fp16 (более стабильно)
bf16=True
fp16=False

DPO: chosen_rewards > rejected_rewards ложно

# Это означает, что модель предпочитает отвергнутые ответы — переобучение или плохие данные
# Решения:
# 1. Проверьте качество датасета
# 2. Уменьшите beta (меньше штраф KL)
# 3. Уменьшите learning rate
# 4. Добавьте больше SFT-обучения перед DPO
beta=0.05  # Попробуйте меньшие значения

Обучение очень медленное

# Включите Flash Attention 2
pip install flash-attn --no-build-isolation

# В вашем коде:
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    attn_implementation="flash_attention_2",
    torch_dtype=torch.bfloat16,
)

# Используйте bf16 вместо fp16 на GPU Ampere+ (A100, RTX 3000+)
bf16=True

# Увеличьте число workers DataLoader
dataloader_num_workers=4

# Проверьте, что GPU действительно используется
nvidia-smi  # Должно показывать высокую загрузку GPU

tokenizer.pad_token предупреждение

# Стандартное исправление для токенизаторов Llama/Mistral
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"  # Важно для стабильности обучения

Отказано в доступе / HuggingFace 401

# Войдите заново
huggingface-cli login

# Задайте токен в окружении
export HF_TOKEN=hf_your-token

# Для приватных моделей/датасетов убедитесь, что у вас есть доступ:
# Перейдите на https://huggingface.co/meta-llama/Llama-3.2-8B-Instruct
# Нажмите "Request access" и примите лицензию

---

Сохранение и публикация вашей модели

# Объедините веса LoRA с базовой моделью
python3 << 'EOF'
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-8B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
model = PeftModel.from_pretrained(base_model, "./sft_final")
merged = model.merge_and_unload()
merged.save_pretrained("./merged_model")

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-8B-Instruct")
tokenizer.save_pretrained("./merged_model")
print("Объединённая модель сохранена!")
EOF

# Отправить в HuggingFace
huggingface-cli upload your-username/my-trl-model ./merged_model

---

Полезные ссылки

• GitHub: https://github.com/huggingface/trl ⭐ 10K+

• Документация: https://huggingface.co/docs/trl

• Статья по DPO: https://arxiv.org/abs/2305.18290

• GRPO / DeepSeek-R1: https://arxiv.org/abs/2501.12599

• Статья по PPO (RLHF): https://arxiv.org/abs/2203.02155

• PEFT от HuggingFace: https://github.com/huggingface/peft

• Weights & Biases: https://wandb.ai

• Flash Attention: https://github.com/Dao-AILab/flash-attention

• Маркетплейс Clore.ai: https://clore.ai/marketplace