{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Đào tạo chất nhờn Rl

Cung cấp hướng dẫn về đào tạo sau LLM với RL bằng cách sử dụng slime, khung Megatron+SGLang. Sử dụng khi đào tạo các mô hình GLM, triển khai quy trình tạo dữ liệu tùy chỉnh hoặc cần tích hợp chặt chẽ Megatron-LM để mở rộng quy mô RL.

Siêu dữ liệu kỹ năng

Nguồn	Tùy chọn — cài đặt với
`Hermes skills install official/mlops/slime
`
Đường dẫn

optional-skills/mlops/slime ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

sglang-router>=0.2.3

, `ray

, `torch>=2.0.0

, transformers>=4.40.0 | | Nền tảng | Linux, macOS | | Thẻ |

Reinforcement Learning

, `Megatron-LM

, `SGLang

, `GRPO

, `Post-Training

, GLM |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

slime: Khung sau đào tạo LLM để mở rộng quy mô RL`slime là khung sau đào tạo LLM từ nhóm THUDM của Tsinghua, hỗ trợ GLM-4.5, GLM-4.6 và GLM-4.7. Nó kết nối Megatron-LM để đào tạo với SGLang nhằm tạo ra quá trình triển khai thông lượng cao.

Khi nào nên sử dụng chất nhờn`Chọn chất nhờn khi bạn cần:

• Đào tạo bản địa Megatron-LM với suy luận SGLang
• Quy trình tạo dữ liệu tùy chỉnh với bộ đệm dữ liệu linh hoạt
• Đào tạo các mô hình GLM, Qwen3, DeepSeek V3 hoặc Llama 3
• Khung cấp độ nghiên cứu có hỗ trợ sản xuất (Z.AI)

Cân nhắc các lựa chọn thay thế khi:

• Bạn cần các tính năng ổn định cấp doanh nghiệp → sử dụng dặm
• Bạn muốn hoán đổi backend linh hoạt → sử dụng verl
• Bạn cần các bản tóm tắt gốc PyTorch → sử dụng torchforge

Tính năng chính

• Đào tạo: Megatron-LM có hỗ trợ song song đầy đủ (TP, PP, DP, SP)
• Triển khai: Tạo thông lượng cao dựa trên SGLang với bộ định tuyến
• Bộ đệm dữ liệu: Quản lý lời nhắc và lưu trữ mẫu linh hoạt
• Mẫu: GLM-4.x, Qwen3, DeepSeek V3/R1, Llama 3

Tổng quan về kiến trúc`<!-- ascii-guard-ignore -->

`

┌─────────────────────────────────────────────────────────┐ │ Data Buffer │ │ - Prompt initialization and management │ │ - Custom data generation and filtering │ │ - Rollout sample storage │ └─────────────┬───────────────────────────┬───────────────┘ │ │ ┌─────────────▼───────────┐ ┌─────────────▼───────────────┐ │ Training (Megatron-LM) │ │ Rollout (SGLang + Router) │ │ - Actor model training │ │ - Response generation │ │ - Critic (optional) │ │ - Reward/verifier output │ │ - Weight sync to rollout│ │ - Multi-turn support │ └─────────────────────────┘ └─────────────────────────────┘

`

<!-- ascii-guard-ignore-end -->

Cài đặt

# Recommended: Docker
Docker pull slimerl/slime:latest
Docker run --rm --gpus all --ipc=host --shm-size=16g \
  -it slimerl/slime:latest /bin/bash

# Inside container
cd /root/slime && pip install -e . --no-deps

`

### Từ nguồn

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

`

## Bắt đầu nhanh: Đào tạo GRPO

`bash

# Source model configuration
source scripts/models/qwen3-4B.sh

# Launch training
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[@]}

`

---

## Quy trình 1: Đào tạo GRPO tiêu chuẩn

Sử dụng quy trình làm việc này để đào tạo các mô hình suy luận có lợi thế tương đối theo nhóm.

### Danh sách kiểm tra điều kiện tiên quyết
- [] Đã cài đặt môi trường Docker hoặc Megatron-LM + SGLang
- [ ] Điểm kiểm tra mô hình (định dạng HuggingFace hoặc Megatron)
- [] Dữ liệu huấn luyện ở định dạng JSONL

### Bước 1: Chuẩn bị dữ liệu

``` python

# data.JSONl format
\{"prompt": "What is 2 + 2?", "label": "4"}
\{"prompt": "Solve: 3x = 12", "label": "x = 4"}

`
``Hoặc với dạng trò chuyện:

`
``` python
{
    "prompt": [
        \{"role": "system", "content": "You are a math tutor."},
        \{"role": "user", "content": "What is 15 + 27?"}
    ],
    "label": "42"
}

`

### Bước 2: Cấu hình Model

Chọn tập lệnh mô hình được cấu hình sẵn:

`bash

# List available models
ls scripts/models/
# glm4-9B.sh, qwen3-4B.sh, qwen3-30B-A3B.sh, DeepSeek-v3.sh, Llama3-8B.sh, ...

# Source your model
source scripts/models/qwen3-4B.sh

`

### Bước 3: Khởi động đào tạo

``` bash
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[@]}

`

### Bước 4: Giám sát quá trình đào tạo
- [ ] Kiểm tra TensorBoard: 
`tensorboard --logdir outputs/

- [ ] Xác minh đường cong phần thưởng đang tăng lên
- [] Giám sát việc sử dụng GPU trên các nút

---

## Quy trình làm việc 2: Đào tạo không đồng bộ

Sử dụng chế độ không đồng bộ để có thông lượng cao hơn bằng cách triển khai và đào tạo chồng chéo.

### Khi nào nên sử dụng Async
- Mô hình lớn với thời gian thế hệ dài
- Thời gian rảnh GPU cao ở chế độ đồng bộ
- Đủ bộ nhớ để đệm

### Khởi chạy chương trình đào tạo không đồng bộ

``` bash
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[@]}

`

### Tham số cụ thể không đồng bộ

``` bash

--async-buffer-size 4        # Number of rollouts to buffer
--update-weights-interval 2  # Sync weights every N rollouts

`

---

## Workflow 3: Huấn luyện Agentic nhiều lượt

Sử dụng quy trình làm việc này để đào tạo nhân viên sử dụng công cụ hoặc lập luận nhiều bước.

### Điều kiện tiên quyết
- [] Chức năng tạo tùy chỉnh cho logic nhiều lượt
- [ ] Giao diện công cụ/môi trường

### Bước 1: Xác định hàm tạo tùy chỉnh

``` python

# custom_generate.py
async def custom_generate(args, samples, evaluation=False):
    """Multi-turn generation with tool calling."""
    for sample in samples:
        conversation = sample.prompt`for turn in range(args.max_turns):
            # Generate response
            response = await generate_single(conversation)

# Check for tool call
            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

`

### Bước 2: Khởi chạy với chức năng tùy chỉnh

``` bash
Python train.py \

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

`
``Xem 
`examples/search-r1/
` để biết ví dụ tìm kiếm nhiều lượt hoàn chỉnh.

---

## Tham khảo cấu hình

### Ba loại đối số`slime sử dụng ba loại đối số:

**1. Lập luận Megatron** (được truyền trực tiếp):

`
``` bash

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

`
``**2. Đối số SGLang** (có tiền tố là 

--sglang-

):

`
``` bash

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

`
``**3. Đối số chất nhờn**:

`
``` bash

# Resource allocation
--actor-num-nodes 1
--actor-num-gpus-per-node 8
--rollout-num-gpus 8
--colocate  # Share GPUs between training/inference

# Data
--prompt-data /path/to/data.JSONl
--input-key prompt
--label-key label

# Training loop
--num-rollout 3000
--rollout-batch-size 32
--n-samples-per-prompt 8
--global-batch-size 256

# Algorithm
--advantage-estimator grpo  # or: gspo, ppo, reinforce_plus_plus
--use-kl-loss
--kl-loss-coef 0.001

`

### Các ràng buộc chính

`
rollout_batch_size × n_samples_per_prompt = global_batch_size × num_steps_per_rollout

`
``Ví dụ: 32 × 8 = 256 × 1

---

## Hệ thống đệm dữ liệu

Bộ đệm dữ liệu của slime cho phép quản lý dữ liệu linh hoạt:

### Nguồn dữ liệu cơ bản

``` python
class RolloutDataSource:
    def get_samples(self, num_samples):
        """Fetch prompts from dataset."""
        return self.dataset.sample(num_samples)

def add_samples(self, samples):
        """Called after generation (no-op by default)."""
        pass

`

### Nguồn dữ liệu được đệm (Không chính sách)

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

def add_samples(self, samples):
        """Store generated samples for reuse."""
        self.buffer.extend(samples)

def buffer_filter(self, args, buffer, num_samples):
        """Custom selection logic (prioritiZed, stratified, etc.)."""
        return select_best(buffer, num_samples)

`

---

## Các vấn đề thường gặp và giải pháp

### Vấn đề: SGLang Engine Crash**Triệu chứng**: Công cụ suy luận ngừng hoạt động giữa quá trình đào tạo`**Giải pháp**:

`
`bash

# Enable fault tolerance
--use-fault-tolerance

# Increase memory allocation
--sglang-mem-fraction-static 0.85

# Reduce batch size
--rollout-batch-size 16

`

### Vấn đề: Hết thời gian đồng bộ hóa trọng lượng`**Triệu chứng**: Quá trình đào tạo bị treo sau khi triển khai`**Giải pháp**:

`
``` bash

# Increase sync interval
--update-weights-interval 5

# Use colocated mode (no network transfer)
--colocate

`

### Vấn đề: OOM trong quá trình đào tạo`**Triệu chứng**: CUDA OOM khi chuyền ngược`**Giải pháp**:

`
``` bash

# Enable gradient checkpointing
--recompute-activations

# Reduce micro-batch size
--micro-batch-size 1

# Enable sequence parallelism
--sequence-parallel

`

### Vấn đề: Tải dữ liệu chậm`**Triệu chứng**: GPU không hoạt động trong khi tìm nạp dữ liệu`**Giải pháp**:

`
``` bash

# Increase data workers
--num-data-workers 4

# Use streaming dataset
--streaming-data

`

---

## Model được hỗ trợ

| Gia đình kiểu mẫu | Cấu hình |
|--------------|-------|
| 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 | Lạc đà 3 (8B, 70B) |
| Khác | Kimi K2, Moonshot-16B |

Mỗi model đều có các tập lệnh được cấu hình sẵn trong 
`scripts/models/

.

---

## Chủ đề nâng cao

### Chế độ đồng vị trí

Chia sẻ GPU giữa đào tạo và suy luận để giảm bộ nhớ:

``` bash
Python train.py \

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

`

### Mô hình phần thưởng tùy chỉnh

``` python

# 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()

`

`
``` bash

--custom-rm-path custom_rm.py

`

### Đánh giá đa tác vụ

``` bash

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

`

---

## Tài nguyên
- **Tài liệu**: https://thudm.GitHub.io/slime/
- **GitHub**: https://GitHub.com/THUDM/slime
- **Blog**: https://lmsys.org/blog/2025-07-09-slime/
- **Ví dụ**: Xem thư mục 
`examples/
` để biết hơn 14 ví dụ đã hoạt động