Slime RL Training

Предоставляет руководство по пост-тренировке LLM с подкреплением (RL) с использованием slime, фреймворка на основе Megatron+SGLang. Используйте при обучении моделей GLM, реализации пользовательских рабочих процессов генерации данных или при необходимости тесной интеграции с Megatron-LM для масштабирования RL.

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

Источник	Опционально — установка через vibeos skills install official/mlops/slime
Путь	optional-skills/mlops/slime
Версия	1.0.0
Автор	Orchestra Research
Лицензия	MIT
Зависимости	sglang-router>=0.2.3, ray, torch>=2.0.0, transformers>=4.40.0
Платформы	linux, macos
Теги	Reinforcement Learning, Megatron-LM, SGLang, GRPO, Post-Training, GLM

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

к сведению

Ниже приведено полное определение навыка, которое VibeOS загружает при его активации. Это инструкции, которые видит агент, когда навык активен.

slime: Фреймворк пост-тренировки LLM для масштабирования RL

slime — это фреймворк пост-тренировки LLM от команды THUDM из Университета Цинхуа, обеспечивающий работу GLM-4.5, GLM-4.6 и GLM-4.7. Он связывает Megatron-LM для обучения с SGLang для высокопроизводительной генерации прогонов (rollout).

Когда использовать slime

Выбирайте slime, если вам нужно:

• Нативное обучение Megatron-LM с инференсом SGLang
• Пользовательские рабочие процессы генерации данных с гибкими буферами данных
• Обучение моделей GLM, Qwen3, DeepSeek V3 или Llama 3
• Исследовательский фреймворк с производственной поддержкой (Z.ai)

Рассмотрите альтернативы, если:

• Вам нужны функции стабильности корпоративного уровня → используйте miles
• Вам нужна гибкая смена бэкендов → используйте verl
• Вам нужны абстракции на основе PyTorch → используйте torchforge

Ключевые особенности

• Обучение: Megatron-LM с полной поддержкой параллелизма (TP, PP, DP, SP)
• Прогон (Rollout): Высокопроизводительная генерация на основе SGLang с маршрутизатором
• Буфер данных: Гибкое управление промптами и хранение сэмплов
• Модели: GLM-4.x, Qwen3, DeepSeek V3/R1, Llama 3

Обзор архитектуры

┌─────────────────────────────────────────────────────────┐
│                    Буфер данных                         │
│ - Инициализация и управление промптами                  │
│ - Пользовательская генерация и фильтрация данных        │
│ - Хранение сэмплов прогонов                             │
└─────────────┬───────────────────────────┬───────────────┘
              │                           │
┌─────────────▼───────────┐ ┌─────────────▼───────────────┐
│ Обучение (Megatron-LM)  │ │ Прогон (SGLang + Router)    │
│ - Обучение модели-актора│ │ - Генерация ответов         │
│ - Критик (опционально)  │ │ - Вывод награды/верификатора│
│ - Синхронизация весов   │ │ - Поддержка нескольких      │
│   с прогоном            │ │   витков (multi-turn)       │
└─────────────────────────┘ └─────────────────────────────┘

Установка

# Рекомендуется: Docker
docker pull slimerl/slime:latest
docker run --rm --gpus all --ipc=host --shm-size=16g \
  -it slimerl/slime:latest /bin/bash

# Внутри контейнера
cd /root/slime && pip install -e . --no-deps

Из исходного кода

git clone https://github.com/THUDM/slime.git
cd slime
pip install -r requirements.txt
pip install -e .

Быстрый старт: обучение GRPO

# Конфигурация исходной модели
source scripts/models/qwen3-4B.sh

# Запуск обучения
python train.py \
    --actor-num-nodes 1 \
    --actor-num-gpus-per-node 4 \
    --rollout-num-gpus 4 \
    --advantage-estimator grpo \
    --use-kl-loss --kl-loss-coef 0.001 \
    --rollout-batch-size 32 \
    --n-samples-per-prompt 8 \
    --global-batch-size 256 \
    --num-rollout 3000 \
    --prompt-data /path/to/data.jsonl \
    ${MODEL_ARGS[@]} ${CKPT_ARGS[@]}

---

Рабочий процесс 1: Стандартное обучение GRPO

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

Контрольный список предварительных требований

• Окружение Docker или установленные Megatron-LM + SGLang
• Контрольная точка модели (формат HuggingFace или Megatron)
• Обучающие данные в формате JSONL

Шаг 1: Подготовка данных

# Формат data.jsonl
{"prompt": "Сколько будет 2 + 2?", "label": "4"}
{"prompt": "Решите: 3x = 12", "label": "x = 4"}

Или в чат-формате:

{
    "prompt": [
        {"role": "system", "content": "Вы — репетитор по математике."},
        {"role": "user", "content": "Сколько будет 15 + 27?"}
    ],
    "label": "42"
}

Шаг 2: Настройка модели

Выберите предварительно настроенный скрипт модели:

# Список доступных моделей
ls scripts/models/
# glm4-9B.sh, qwen3-4B.sh, qwen3-30B-A3B.sh, deepseek-v3.sh, llama3-8B.sh, ...

# Загрузите вашу модель
source scripts/models/qwen3-4B.sh

Шаг 3: Запуск обучения

python train.py \
    --actor-num-nodes 1 \
    --actor-num-gpus-per-node 8 \
    --rollout-num-gpus 8 \
    --advantage-estimator grpo \
    --use-kl-loss \
    --kl-loss-coef 0.001 \
    --prompt-data /path/to/train.jsonl \
    --input-key prompt \
    --label-key label \
    --apply-chat-template \
    --rollout-batch-size 32 \
    --n-samples-per-prompt 8 \
    --global-batch-size 256 \
    --num-rollout 3000 \
    --save-interval 100 \
    --eval-interval 50 \
    ${MODEL_ARGS[@]}

Шаг 4: Мониторинг обучения

• Проверьте TensorBoard: tensorboard --logdir outputs/
• Убедитесь, что кривые награды растут
• Отслеживайте загрузку GPU на всех узлах

---

Рабочий процесс 2: Асинхронное обучение

Используйте асинхронный режим для повышения пропускной способности за счет перекрытия прогона и обучения.

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

• Большие модели с длительным временем генерации
• Высокое время простоя GPU в синхронном режиме
• Достаточный объем памяти для буферизации

Запуск асинхронного обучения

python train_async.py \
    --actor-num-nodes 1 \
    --actor-num-gpus-per-node 8 \
    --rollout-num-gpus 8 \
    --advantage-estimator grpo \
    --async-buffer-size 4 \
    --prompt-data /path/to/train.jsonl \
    ${MODEL_ARGS[@]}

Специфические параметры асинхронного режима

--async-buffer-size 4        # Количество прогонов для буферизации
--update-weights-interval 2  # Синхронизация весов каждые N прогонов

---

Рабочий процесс 3: Многовитковое агентное обучение

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

Предварительные требования

• Пользовательская функция генерации для многовитковой логики
• Интерфейс инструмента/окружения

Шаг 1: Определение пользовательской функции генерации

# custom_generate.py
async def custom_generate(args, samples, evaluation=False):
    """Многовитковая генерация с вызовом инструментов."""
    for sample in samples:
        conversation = sample.prompt

        for turn in range(args.max_turns):
            # Генерация ответа
            response = await generate_single(conversation)

            # Проверка на вызов инструмента
            tool_call = extract_tool_call(response)
            if tool_call:
                tool_result = execute_tool(tool_call)
                conversation.append({"role": "assistant", "content": response})
                conversation.append({"role": "tool", "content": tool_result})
            else:
                break

        sample.response = response
        sample.reward = compute_reward(sample)

    return samples

Шаг 2: Запуск с пользовательской функцией

python train.py \
    --custom-generate-function-path custom_generate.py \
    --max-turns 5 \
    --prompt-data /path/to/agent_data.jsonl \
    ${MODEL_ARGS[@]}

Полный пример многовиткового поиска см. в examples/search-r1/.

---

Справочник по конфигурации

Три категории аргументов

slime использует три типа аргументов:

1. Аргументы Megatron (передаются напрямую):

--tensor-model-parallel-size 2
--pipeline-model-parallel-size 1
--num-layers 32
--hidden-size 4096

2. Аргументы SGLang (с префиксом --sglang-):

--sglang-mem-fraction-static 0.8
--sglang-context-length 8192
--sglang-log-level INFO

3. Аргументы slime:

# Выделение ресурсов
--actor-num-nodes 1
--actor-num-gpus-per-node 8
--rollout-num-gpus 8
--colocate  # Совместное использование GPU для обучения/инференса

# Данные
--prompt-data /path/to/data.jsonl
--input-key prompt
--label-key label

# Цикл обучения
--num-rollout 3000
--rollout-batch-size 32
--n-samples-per-prompt 8
--global-batch-size 256

# Алгоритм
--advantage-estimator grpo  # или: gspo, ppo, reinforce_plus_plus
--use-kl-loss
--kl-loss-coef 0.001

Ключевые ограничения

rollout_batch_size × n_samples_per_prompt = global_batch_size × num_steps_per_rollout

Пример: 32 × 8 = 256 × 1

---

Система буфера данных

Буфер данных slime обеспечивает гибкое управление данными:

Базовый источник данных

class RolloutDataSource:
    def get_samples(self, num_samples):
        """Получение промптов из набора данных."""
        return self.dataset.sample(num_samples)

    def add_samples(self, samples):
        """Вызывается после генерации (по умолчанию ничего не делает)."""
        pass

Буферизованный источник данных (Off-Policy)

class RolloutDataSourceWithBuffer(RolloutDataSource):
    def __init__(self):
        self.buffer = []

    def add_samples(self, samples):
        """Сохранение сгенерированных сэмплов для повторного использования."""
        self.buffer.extend(samples)

    def buffer_filter(self, args, buffer, num_samples):
        """Пользовательская логика выбора (приоритетная, стратифицированная и т.д.)."""
        return select_best(buffer, num_samples)

---

Часто встречающиеся проблемы и их решения

Проблема: Сбой движка SGLang

Симптомы: Движок инференса падает в середине обучения

Решения:

# Включение отказоустойчивости
--use-fault-tolerance

# Увеличение выделения памяти
--sglang-mem-fraction-static 0.85

# Уменьшение размера пакета
--rollout-batch-size 16

Проблема: Тайм-аут синхронизации весов

Симптомы: Обучение зависает после прогона

Решения:

# Увеличение интервала синхронизации
--update-weights-interval 5

# Использование совмещенного режима (без сетевой передачи)
--colocate

Проблема: OOM во время обучения

Симптомы: CUDA OOM при обратном проходе

Решения:

# Включение градиентной контрольной точки
--recompute-activations

# Уменьшение размера микро-пакета
--micro-batch-size 1

# Включение последовательного параллелизма
--sequence-parallel

Проблема: Медленная загрузка данных

Симптомы: GPU простаивает во время выборки данных

Решения:

# Увеличение количества рабочих процессов для данных
--num-data-workers 4

# Использование потокового набора данных
--streaming-data

---

Поддерживаемые модели

Семейство моделей	Конфигурации
GLM	GLM-4.5, GLM-4.6, GLM-4.7, GLM-Z1-9B
Qwen	Qwen3 (4B, 8B, 30B-A3B), Qwen3-MoE, Qwen2.5
DeepSeek	V3, V3.1, R1
Llama	Llama 3 (8B, 70B)
Другие	Kimi K2, Moonlight-16B

Для каждой модели есть предварительно настроенные скрипты в scripts/models/.

---

Продвинутые темы

Режим совместного размещения (Co-location)

Совместное использование GPU между обучением и инференсом для уменьшения потребления памяти:

python train.py \
    --colocate \
    --actor-num-gpus-per-node 8 \
    --sglang-mem-fraction-static 0.4 \
    ${MODEL_ARGS[@]}

Пользовательская модель награды

# custom_rm.py
class CustomRewardModel:
    def __init__(self, model_path):
        self.model = load_model(model_path)

    def compute_reward(self, prompts, responses):
        inputs = self.tokenize(prompts, responses)
        scores = self.model(inputs)
        return scores.tolist()

--custom-rm-path custom_rm.py

Многозадачная оценка

--eval-prompt-data aime /path/to/aime.jsonl \
--eval-prompt-data gsm8k /path/to/gsm8k.jsonl \
--n-samples-per-eval-prompt 16

---

Ресурсы

• Документация: https://thudm.github.io/slime/
• GitHub: https://github.com/THUDM/slime
• Блог: https://lmsys.org/blog/2025-07-09-slime/
• Примеры: Смотрите каталог examples/ для 14+ проработанных примеров