open-r1

项目地址：https://github.com/huggingface/open-r1

由huggingface组建，目前刚上线2周，发布了最新进展open-r1/update-1，在MATH-500任务上接近deepseek的指标，可以在open-r1/open-r1-eval-leaderboard查看指标的排行榜。

mini-deepseek-r1

项目地址：https://github.com/philschmid/deep-learning-pytorch-huggingface/blob/main/training/mini-deepseek-r1-aha-grpo.ipynb

用 GRPO 和倒计时游戏复制出一个简单版本的 R1。

在大约 50 步时，模型学会了正确的格式，即…\n…;在 100 步时，解方程的成功率约为 25%，并且模型开始用文字进行 “推理”;在 200 步时，收敛变慢，成功率约为 40%。模型开始学习一种新的“格式”，它通过尝试不同的组合并检查结果来解方程，这种方式类似于编程解决问题的方式；在 450 步时，解方程的成功率为 50%，性能仍然在缓慢提升，并且模型保持了从 200 步开始的新格式。

open-thoughts

项目地址：https://github.com/open-thoughts/open-thoughts

该项目目标是策划一个推理数据集来训练最先进的小型推理模型，该模型在数学和代码推理基准上超越DeepSeek-R1-Distill-Qwen-32B和DeepSeek-R1-Distill-Qwen-7B 。

TinyZero

项目地址：https://github.com/Jiayi-Pan/TinyZero

干净、简约、易于访问的 DeepSeek R1-Zero 复制品

TinyZero 是DeepSeek R1 Zero在倒计时和乘法任务中的复刻版。我们以veRL为基础进行构建。通过强化学习，3B 基础 LM 可以自行开发自我验证和搜索能力只需不到 30 美元，就可以亲身体验 Ahah 时刻。

simpleRL-reason

项目地址：https://github.com/hkust-nlp/simpleRL-reason
这是 DeepSeek-R1-Zero 和 DeepSeek-R1 在数据有限的小模型上进行训练的复制品

这个 repo 包含一个简单的强化学习方法，用于提高模型的推理能力。它很简单，因为只使用了基于规则的奖励，该方法与DeepSeek-R1中使用的方法几乎相同，只是代码当前使用的是 PPO 而不是 GRPO。我们已经使用此代码在有限的数据（8K 示例）上训练小型模型（7B），取得了令人惊讶的强劲结果 - 例如，从 Qwen2.5-Math-7B（基础模型）开始，我们直接在其上执行 RL。没有 SFT，没有奖励模型，只有 8K MATH 示例用于验证，结果模型在 AIME 上实现 (pass@1) 33.3%、在 AMC 上实现 62.5%、在 MATH 上实现 77.2%，优于 Qwen2.5-math-7B-instruct，并且可与使用 >50 倍更多数据和更复杂组件的以前基线相媲美。

RAGEN

项目地址:https://github.com/ZihanWang314/RAGEN

RAGEN 是 DeepSeek-R1 在 AGENT 训练上的第一个开源复现版。

RAGEN 是用于训练智能体模型的 DeepSeek-R1 (-Zero) 方法的首次复现，主要在gym-sokoban（传统的推箱子游戏）任务上进行训练。

unsloth-Reasoning - GRPO

项目地址：https://docs.unsloth.ai/basics/reasoning-grpo
使用 GRPO（强化学习微调的一部分）通过 Unsloth 训练自己的 DeepSeek-R1 推理模型。

DeepSeek 的 GRPO（组相对策略优化）是一种无需价值函数模型的强化学习技术，能够高效优化响应并降低内存和计算成本。借助 Unsloth，仅需 7GB VRAM 即可在本地训练高达 15B 参数的推理模型（如 Llama 3.1、Phi-4、Mistral 或 Qwen2.5），而此前类似任务需要 2xA100 GPU（160GB VRAM）。GRPO 现已支持 QLoRA 和 LoRA，可将标准模型转化为成熟的推理模型。测试显示，仅训练 Phi-4 100 步，GRPO 模型已能生成思考 token 并给出正确答案，显著优于未使用 GRPO 的模型。

oat-zero

项目地址：https://github.com/sail-sg/oat-zero
DeepSeek-R1-Zero 的轻量级复制品，对自我反思行为进行了深入分析。

DeepSeek-R1-Zero 最鼓舞人心的结果之一是通过纯强化学习 (RL) 实现**“顿悟时刻”**。在顿悟时刻，模型会学习自我反思等新兴技能，这有助于它进行情境搜索来解决复杂的推理问题。

在 R1-Zero 发布后的短短几天内，多个项目在较小规模（例如 1B 到 7B）上独立“复现”了类似 R1-Zero 的训练，并且都观察到了 Aha 时刻，这通常通过模型响应长度的突然增加来衡量。按照他们的设置仔细检查了类似 R1-Zero 的训练过程，并分享了以下发现：

• 在类似 R1-Zero 的训练中，可能不存在顿悟时刻。相反，发现顿悟时刻（例如自我反思模式）出现在第 0 个时期，即基础模型中。
• 从基础模型的反应中发现了肤浅的自我反思（SSR），在这种情况下自我反思并不一定会导致正确的最终答案。
• 通过 RL 仔细研究了类似 R1-Zero 的训练，发现响应长度增加的现象不是由于自我反思的出现，而是 RL 优化精心设计的基于规则的奖励函数的结果。

deepscaler

项目地址：https://github.com/agentica-project/deepscaler

只用4500美元成本，就能成功复现DeepSeek？就在刚刚，UC伯克利团队只用简单的RL微调，就训出了DeepScaleR-1.5B-Preview，15亿参数模型直接吊打o1-preview，震撼业内。

第一步，研究人员会训练模来型进行短思考。他们使用DeepSeek的GRPO方法，设定了8k的上下文长度来训练模型，以鼓励高效思考。
经过1000步训练后，模型的token使用量减少了3倍，并比基础模型提升了5%。接下来，模型被训练进行长思考。强化学习训练扩展到16K和24K token，以解决更具挑战性、以前未解决的问题。随着响应长度增加，平均奖励也随之提高，24K的魔力，就让模型最终超越了o1-preview！

近日，来自UC伯克利的研究团队基于Deepseek-R1-Distilled-Qwen-1.5B，通过简单的强化学习（RL）微调，得到了全新的DeepScaleR-1.5B-Preview。在AIME2024基准中，模型的Pass@1准确率达高达43.1% ——不仅比基础模型提高了14.3%，而且在只有1.5B参数的情况下超越了OpenAI o1-preview！

grpo_demo

项目地址：https://gist.github.com/willccbb/4676755236bb08cab5f4e54a0475d6fb
原始的 grpo_demo.py 帖子

下面直接奉上源码：

# train_grpo.py
import re
import torch
from datasets import load_dataset, Dataset
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import LoraConfig
from trl import GRPOConfig, GRPOTrainer

# Load and prep dataset

SYSTEM_PROMPT = """
Respond in the following format:
<reasoning>
...
</reasoning>
<answer>
...
</answer>
"""

XML_COT_FORMAT = """\
<reasoning>
{reasoning}
</reasoning>
<answer>
{answer}
</answer>
"""

def extract_xml_answer(text: str) -> str:
    answer = text.split("<answer>")[-1]
    answer = answer.split("</answer>")[0]
    return answer.strip()

def extract_hash_answer(text: str) -> str | None:
    if "####" not in text:
        return None
    return text.split("####")[1].strip().replace(",", "").replace("$", "")

# uncomment middle messages for 1-shot prompting
def get_gsm8k_questions(split = "train") -> Dataset:
    data = load_dataset('openai/gsm8k', 'main')[split] # type: ignore
    data = data.map(lambda x: { # type: ignore
        'prompt': [
            {'role': 'system', 'content': SYSTEM_PROMPT},
            #{'role': 'user', 'content': 'What is the largest single-digit prime number?'},
            #{'role': 'assistant', 'content': XML_COT_FORMAT.format(
            #    reasoning="9 is divisble by 3 and 8 is divisible by 2, but 7 is prime.",
            #    answer="7"
            #)},
            {'role': 'user', 'content': x['question']}
        ],
        'answer': extract_hash_answer(x['answer'])
    }) # type: ignore
    return data # type: ignore

dataset = get_gsm8k_questions()

# Reward functions
def correctness_reward_func(prompts, completions, answer, **kwargs) -> list[float]:
    responses = [completion[0]['content'] for completion in completions]
    q = prompts[0][-1]['content']
    extracted_responses = [extract_xml_answer(r) for r in responses]
    print('-'*20, f"Question:\n{q}", f"\nAnswer:\n{answer[0]}", f"\nResponse:\n{responses[0]}", f"\nExtracted:\n{extracted_responses[0]}")
    return [2.0 if r == a else 0.0 for r, a in zip(extracted_responses, answer)]

def int_reward_func(completions, **kwargs) -> list[float]:
    responses = [completion[0]['content'] for completion in completions]
    extracted_responses = [extract_xml_answer(r) for r in responses]
    return [0.5 if r.isdigit() else 0.0 for r in extracted_responses]

def strict_format_reward_func(completions, **kwargs) -> list[float]:
    """Reward function that checks if the completion has a specific format."""
    pattern = r"^<reasoning>\n.*?\n</reasoning>\n<answer>\n.*?\n</answer>\n$"
    responses = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, r) for r in responses] 
    return [0.5 if match else 0.0 for match in matches]

def soft_format_reward_func(completions, **kwargs) -> list[float]:
    """Reward function that checks if the completion has a specific format."""
    pattern = r"<reasoning>.*?</reasoning>\s*<answer>.*?</answer>"
    responses = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, r) for r in responses] 
    return [0.5 if match else 0.0 for match in matches]

def count_xml(text) -> float:
    count = 0.0
    if text.count("<reasoning>\n") == 1:
        count += 0.125
    if text.count("\n</reasoning>\n") == 1:
        count += 0.125
    if text.count("\n<answer>\n") == 1:
        count += 0.125
        count -= len(text.split("\n</answer>\n")[-1])*0.001
    if text.count("\n</answer>") == 1:
        count += 0.125
        count -= (len(text.split("\n</answer>")[-1]) - 1)*0.001
    return count

def xmlcount_reward_func(completions, **kwargs) -> list[float]:
    contents = [completion[0]["content"] for completion in completions]
    return [count_xml(c) for c in contents]

#model_name = "meta-llama/Llama-3.2-1B-Instruct"
model_name = "Qwen/Qwen2.5-1.5B-Instruct"

if "Llama" in model_name:
    output_dir = "outputs/Llama-1B-GRPO"
    run_name = "Llama-1B-GRPO-gsm8k"
else:
    output_dir="outputs/Qwen-1.5B-GRPO"
    run_name="Qwen-1.5B-GRPO-gsm8k"
    
training_args = GRPOConfig(
    output_dir=output_dir,
    run_name=run_name,
    learning_rate=5e-6,
    adam_beta1 = 0.9,
    adam_beta2 = 0.99,
    weight_decay = 0.1,
    warmup_ratio = 0.1,
    lr_scheduler_type='cosine',
    logging_steps=1,
    bf16=True,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,
    num_generations=16,
    max_prompt_length=256,
    max_completion_length=786,
    num_train_epochs=1,
    save_steps=100,
    max_grad_norm=0.1,
    report_to="wandb",
    log_on_each_node=False,
)
peft_config = LoraConfig(
    r=16,
    lora_alpha=64,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "up_proj", "down_proj", "gate_proj"],
    task_type="CAUSAL_LM",
    lora_dropout=0.05,
)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    attn_implementation="flash_attention_2",
    device_map=None
).to("cuda")
        
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# use peft at your own risk; not working for me with multi-GPU training
trainer = GRPOTrainer(
    model=model,
    processing_class=tokenizer,
    reward_funcs=[
        xmlcount_reward_func,
        soft_format_reward_func,
        strict_format_reward_func,
        int_reward_func,
        correctness_reward_func],
    args=training_args,
    train_dataset=dataset,
    #peft_config=peft_config
)
trainer.train()

数据集

• open-r1/OpenR1-Math-220k:OpenR1-Math-220k 是一个大规模数学推理数据集，包含 220k 道数学题，每道题都有DeepSeek R1针对 NuminaMath 1.5 中的问题生成的 2 到 4 条推理痕迹。
• OpenThoughts-114k：拥有 114,000 个高质量示例，涵盖数学、科学、代码和谜题等。
• bespokelabs/Bespoke-Stratos-17k：对伯克利 Sky-T1 数据的复制，使用 DeepSeek-R1 创建了一个包含问题、推理过程和答案的数据集。
• R1-Distill-SFT：目前有 17000 个样本，目的是创建数据以支持 Open-R1 项目。
• cognitivecomputations/dolphin-r1：包含 80 万个样本的数据集，其中的数据来自 DeepSeek-R1 和 Gemini flash 的生成结果，同时还有来自 Dolphin chat 的 20 万个样本。
• GSM8K:GSM8K（小学数学 8K）是一个包含 8.5K 道高质量、语言多样化的小学数学应用题的数据集。该数据集的创建是为了支持需要多步推理的基本数学问题的问答任务。

参考资料

• Deepseek R1 最新复现进展
• deepseek-r1开源复现方法整理