Reflection 在 Hugging Face 发布 501B 开源模型 Beam

Beam by Reflection 已在 Hugging Face 上线！它是美国新实验室 Reflection 的首个模型，并且是开放的！它是一个混合专家（MoEs）模型，拥有 501B 参数（每个 token 激活 23B），支持文本输入，具有 1M tokens 的上下文窗口，并以 Apache 2.0 许可证发布。

Beam 专注于 编程 和 智能体 用例。它面向希望在自有硬件、基础设施或云上运行前沿规模模型，并希望按自身用例进行定制的团队。Beam 附带专用的开源 Rust harness，以发挥该模型的最佳性能。

Beam 拥有原生 transformers 实现，以及 vLLM 和 SGLang 等下游库。我们与 Reflection 团队合作，为你带来推理、SFT（监督微调）和 RL（强化学习）配方，供你按自身需求基于该模型进行构建。在 transformers、SGLang 和 vLLM 的首日支持之外，本文还将展示如何运行它、如何进行后训练，以及我们用它构建了什么。

太长不看

• 501B 参数的 MoEs LLM，每个 token 激活 23B。52 层，每个 MoE 层 256 个专家，每个 token 路由 8 个。
• 文本输入、文本输出，上下文窗口为 1M tokens。
• 检查点格式：BF16、FP8、以及 NVFP4
• 可在多轮中保持于上下文内的推理（preserve_thinking），以及带专用语法的工具调用。该模型支持五个推理值："low"、"medium"（默认）、"high"、"xhigh" 和 "max"。
• tokenizer 中的响应模板。
• 采用 DFlash2 的推测解码草稿模型
• 首日库：transformers、SGLang、vLLM。使用 Miles 进行全参数 RL。
• 附带 基于 Rust 的自定义 harness。
• Apache 2.0.

用 Beam 构建

Reflection 将向使用 Beam 的最佳项目发放 $10,000 的 Hub 积分。你只需做出一个东西，并在 Hub 上分享：

• 你可以制作一个在 Spaces 上使用 Beam 模型的演示
• 你可以针对自己喜欢的硬件对它进行量化
• 你可以为自己喜欢的问题生成一个合成数据集
• 你可以与 Beam 一起或为 Beam 构建一个 RL 环境
• 你可以对 Beam 进行基准测试并分享结果。
• 你也可以给我们一个惊喜！

如果你用 Beam 构建了什么，就把它分享到 Hub 上，即有机会赢得 $10,000。你只需构建 space、model 或 dataset 仓库，并在 模型的仓库页面 上分享。我们会收集所有链接，选出最佳作品，并将积分发放到你的 Hub 账户。

什么是 Beam？

Beam 是一个纯文本模型，专为长上下文（1M 上下文长度）推理和智能体工作而构建。它是一个稀疏 MoE 模型，每个 token 仅由网络的一小部分进行计算，因此能以小得多的模型的速度运行，同时保持大模型的容量。

注意力

解码器有 52 层，隐藏层大小为 5,120。大多数层对之前的 512 个 token 使用滑动窗口注意力；每第六层以及最后一层会关注完整上下文。因此共有 43 个滑动窗口层和 9 个全局层。

注意力块内部（两种层类型）

这两类层对位置的处理方式不同。滑动窗口层使用 RoPE，因为相对位置在短窗口内最为重要。全局层不使用位置编码。取而代之的是，每个 query 会乘以一个随可见 token 数量缓慢增长的缩放系数，(1 + (pos + 1) / 2048) ** 0.1。它起到温度的作用：随着上下文变长，softmax 仍能保持精度，而不会趋于平坦。该实现将此称为 scalable-softmax query scaling。

注意力采用分组查询注意力（grouped-query attention），包含 48 个 query head 和 8 个 key-value head，并对 query 和 key 使用 RMSNorm。一个由层输入计算得到的可学习 sigmoid 门，会在输出投影之前缩放每个 head 的每个通道。

混合专家

前 3 层使用稠密 SwiGLU MLP。其余 49 层将其替换为由 256 个专家组成的混合专家（Mixture-of-Experts）模块，每个专家都是中间维度为 2,560 的 SwiGLU MLP，约 39M 参数。这些专家占模型参数的 98.4%。

路由器遵循 DeepSeek-V3 的分组受限方案。它用 sigmoid 为全部 256 个专家打分，将它们分成 8 组、每组 32 个，保留最好的 4 组（按每组前两名得分之和排序），然后在其中选出得分最高的 8 个专家。Beam 使用与 DeepSeek-V3 相同的组大小，但没有共享专家。专家输出以归一化后的路由器权重进行组合，并乘以 2.5。

每个 token 只运行 8 个专家，因此模型计算每个 token 时大约使用 23B 参数。全部 256 个专家都保留在内存中，因此部署需要 501B 模型的显存，但运行速度相当于 23B 模型。BF16 检查点以 safetensors 格式约为 1 TB。NVFP4 检查点将大部分参数以 4 位精度存储，面向 NVIDIA Blackwell GPU，为了保证精度，部分参数保留为 BF16。Hub 上还有 FP8 检查点，适合 Hopper 和 Ampere 系列芯片。

如果想自行部署 Beam，请查看下方的 vLLM 或 SGLang 方案。

残差流

残差连接是最有特色的部分。标准 transformer 以权重 1 将每个子层输出加到流中，因此该流会随深度增长。

Beam 将输入嵌入计为第 1 步。在第 k 步，它以权重 1/sqrt(k) 加入子层输出，并以权重 sqrt((k-1)/k) 保留已有的流。两个权重的平方和为 1，因此从第一层到最后一层，流都保持恒定尺度。在全部 104 次相加之后，每个子层输出与输入嵌入在最终隐藏状态中所占权重相同。

每个子层在前后也会做归一化，最终 logits 会经过 ±30 的 tanh softcap，并以 FP32 计算。实现中固定了以 FP32 计算的位置：路由器、SwiGLU 乘积、归一化、RoPE、query 缩放以及 softcap。

长上下文

混合注意力很适合长上下文。每一层为每个 token 缓存 2 x 8 个 KV head x 128 维 = 2,048 个值。如果全部 52 层都保留每个 token，缓存将以每个 token 208 KiB 的速度增长。只有 9 个全局层会保留完整序列。43 个滑动窗口层各自只持有固定的 512 token 窗口，不再增长。因此缓存以每个 token 36 KiB 的速度增长，大约是朴素速率的六分之一。

这些数字针对每条序列，采用 BF16，并使用 transformers 动态缓存。

基准测试结果

以下是 Reflection 团队提供的不同精度级别的基准测试结果。

硬件要求

部署该模型最实用的方式是使用 NVFP4 检查点，它保留了 bf16 检查点的大部分质量。 NVFP4 将部分权重以 4 位存储，从而将 BF16 下的 501B 参数从 1 TB 缩减到约 280 GB。Blackwell GPU 可原生运行 NVFP4，但比 Blackwell 更早的 GPU（如 H200）则不行。FP8 检查点适用于比 Blackwell 更早的 GPU。

一块 B200 拥有 180 GB 的 HBM3e，因此两块（360 GB）可以容纳 Beam 的权重，但留给激活值和 KV 缓存的空间所剩无几。建议按四块 B200（720 GB）来规划，这样能为长上下文和并发请求留出充足空间。你也可以在完整的 8xB200 节点上部署它，或在两块各 288 GB 的 B300 上部署，甚至使用 8xRTX Pro 6000。如果你没有 Blackwell 硬件，可使用 Inference Providers（无服务器）来测试 Reflection。

推理支持

Beam 在 transformers、SGLang 和 vLLM 中提供首日支持。

Transformers

安装最新版本的 transformers。

pip install -U "transformers>=5.20.1"

运行 Beam 最简单的方式是 text-generation pipeline：

from transformers import pipeline

pipe = pipeline(
    "text-generation", model="reflection/Beam-1.0-501B-A23B", device_map="auto"
)

messages = [
    {"role": "user", "content": "Write a limerick about Python exceptions."}
]
output = pipe(messages, max_new_tokens=2000)
output[0]["generated_text"][-1]

该 pipeline 会返回完整对话。最后一条消息是 Beam 的回复，已由响应模板解析。

再深入一层，使用 AutoModelForCausalLM 和 AutoTokenizer。

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "reflection/Beam-1.0-501B-A23B"
tokenizer = AutoTokenizer.from_pretrained(model_id)

model = AutoModelForCausalLM.from_pretrained(
    model_id, dtype="auto", device_map="auto"
)

对话

messages = [
    {"role": "system", "content": "You should only answer with a number."},
    {"role": "user", "content": "What is 17 * 23?"},
]

inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    reasoning_effort="medium" # by default
).to(model.device)

input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=2000)

tokenizer.parse_response(
    outputs[0][input_len:], prefix=inputs["input_ids"][0]
)

Beam 的分词器带有响应模板。parse_response 会读取它，并将原始输出转换为消息字典，推理、答案以及任何工具调用分别位于不同字段。这样就避免了通常用来把推理、答案和工具调用拆分开的正则表达式。而且这些规则随分词器一同提供，因此解析后的结构与 Beam 训练时要生成的内容一致。聊天模板可以预先写入助手回合的一部分，解析器需要看到这部分。

工具调用

完整的工具调用示例

def get_weather(city: str, unit: str = "celsius"):
    """
    Get the current weather for a city.

    Args:
        city: The city to look up.
        unit: Temperature unit, "celsius" or "fahrenheit".
    """
    ...

tools = [get_weather]
messages = [
    {"role": "user", "content": "I land in Paris tonight. Do I need a coat?"}
]

inputs = tokenizer.apply_chat_template(
    messages,
    tools=tools,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=1000)

message = tokenizer.parse_response(
    outputs[0][input_len:], prefix=inputs["input_ids"][0], tools=tools
)
message.get("tool_calls")

也要把 tools 传给 parse_response。Beam 以内联方式、用其自身的 XML 风格语法写入工具调用参数，因此单独的 7 可能是数字或字符串。有了工具 schema，解析器会将每个参数转换为其所声明的类型。

多 GPU 与多节点

Beam 的配置定义了专家并行方案。专家并行将每个专家放在一台设备上。注意力、稠密层、嵌入和 LM head 会在每台设备上复制。这是 8B 参数，即 BF16 下的 16 GB。使用 DistributedConfig 加载模型：

import os

from transformers import AutoModelForCausalLM
from transformers.distributed import DistributedConfig

model = AutoModelForCausalLM.from_pretrained(
    "reflection/Beam-1.0-501B-A23B",
    distributed_config=DistributedConfig(
        tp_size=int(os.environ["WORLD_SIZE"]), ep_size=int(os.environ["WORLD_SIZE"]), tp_plan={}
    ),
)

使用 torchrun 在 16 块 H200 GPU 上启动该脚本。这样每块承载 78 GB 的权重。若使用 8 块 GPU，每块将承载 139 GB，在 141 GB 的 H200 上就没有剩余空间。设备数量必须能整除专家数量 256。

vLLM

Beam 在 vLLM 中提供首日支持。下面的命令以张量并行方式在 16 块 GPU（两个 8x H200 节点）上部署 BF16 检查点，并暴露兼容 OpenAI 的 API：

vllm serve reflection/Beam-1.0-501B-A23B --tensor-parallel-size 16 --served-model-name beam

为了更快生成，加入 DFlash2 推测解码。小型 drafter 模型最多提前提议 15 个 token，Beam 在一次前向传播中全部检查，因此每一步可以接受多个 token。代价是 drafter 会多占用一点内存：

vllm serve reflection/Beam-1.0-501B-A23B \
  --tensor-parallel-size 16 \
  --speculative-config '{ "method": "dflash", "model": "reflection/dflash2-drafter-preview", "num_speculative_tokens": 15 }'

两条命令都会启动一个兼容 OpenAI 的服务器，因此你可以将任意 OpenAI 客户端指向 http://localhost:8000/v1。更多服务配置请参见 为 vLLM 提议的 Beam recipe。

SGLang

Beam 在 SGLang 中也有 day-0 支持。我们建议使用 DFlash2 推测解码来服务它，下面两条命令都会开启该功能。在 Blackwell 上，NVFP4 checkpoint 可放入 4 张 B300：

python -m sglang.launch_server \
--model-path reflection/Beam-1.0-501B-A23B-NVFP4 \
--served-model-name beam \
--tp 4 \
--attention-backend trtllm_mha \
--page-size 64 \
--context-length 1048576 \
--mem-fraction-static 0.85 \
--enable-unified-memory \
--speculative-algorithm DFLASH \
--speculative-draft-model-path reflection/Beam-1.0-501B-A23B-DFlash2 \
--speculative-dflash-block-size 8 \
--tool-call-parser beam --reasoning-parser beam \
--host 0.0.0.0 --port 30000

在 Hopper GPU 上，请改在 8 张 H200 上使用 FP8 checkpoint。只有三个 flag 会变：checkpoint、张量并行大小（8 而非 4），以及注意力后端（fa3 而非 trtllm_mha，后者需要 Blackwell）：

python -m sglang.launch_server \
--model-path reflection/Beam-1.0-501B-A23B-FP8 \
--served-model-name beam \
--tp 8 \
--attention-backend fa3 \
--page-size 64 \
--context-length 1048576 \
--mem-fraction-static 0.85 \
--enable-unified-memory \
--speculative-algorithm DFLASH \
--speculative-draft-model-path reflection/Beam-1.0-501B-A23B-DFlash2 \
--speculative-dflash-block-size 8 \
--tool-call-parser beam --reasoning-parser beam \
--host 0.0.0.0 --port 30000

Inference Providers

Beam 已可在 Hugging Face Inference Providers 上使用，由 Baseten、Fireworks 和 Together 提供支持，很快还会有更多。

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://router.huggingface.co/v1",
    api_key=os.environ["HF_TOKEN"],
)

completion = client.chat.completions.create(
    model="reflection/Beam-1.0-501B-A23B:auto",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

print(completion.choices[0].message)

Inference Endpoints

我们已为你准备好一个 Beam recipe，可从目录中一键部署到 Inference Endpoints，选用 FP8 或 NVFP4，也可以用 hf cli 按如下方式安装：

hf endpoints catalog deploy --repo reflection/Beam-1.0-501B-A23B --name beam

我们测试了什么

我们分享了 Reflection Beam-501B-A23B 在五项任务上的一些 vibe eval，每项任务都通过 Reflection 平台以低推理力度和高推理力度各运行一次。这些是 vibe eval，不是基准测试。如果你打算使用 Beam，这是上手试用、了解它在具体用例中如何表现的好办法，更重要的是看清它赢在哪里、输在哪里。

下面概述了我们运行的提示词，以及来自 hub 的输出轨迹。完整的输入、输出、API 用量、任务 fixture、评分器和对话轨迹见 这个公开的 Hugging Face bucket。

* Low 的长上下文回答在所有代码行为以及全部六个源引用上都正确。然而，该回答与解析器格式不符，因此这部分是提示歧义所致。

† Low 返回了正确答案，但省略了所要求的论证。High 提供了一个正确的单位根证明，并经过独立审阅。

不必只听我们的。深入查看 bucket，针对你的用例或项目改写，并把 Beam 推向极限。

后训练 Beam

你可以为自己的用例微调 Beam。这里我们分享一些 TRL 和 Miles 中的示例，帮助你入门监督微调与强化学习。

用 TRL 进行 SFT

将 Beam 适配到你自己的数据的最快方式，是使用 TRL 的 SFTTrainer 进行监督微调。为了控制显存占用，我们用 PEFT 训练 LoRA 适配器，而不是更新全部 501B 参数： 我们使用 TRL 的 SFTTrainer 将 Beam 适配到一个简单目标：让其推理保持在用户所要求的语言中。我们在 Multilingual-Thinking 上用 LoRA 进行微调，只训练一小部分适配器权重，同时保持基础模型冻结。

该配置结合了加载时的模型分片、专家并行、FlashAttention 4 和序列打包。LoRA SFT 可在配备 8 块 B300 GPU 的单节点上运行，吞吐约达每秒 19,000 个 token。对应的 H100 配置使用四个节点。

在 Multilingual-Thinking 上训练一个 epoch 后，Beam 在 16 个留出提示中的全部 16 个上都以所要求的语言进行推理，而基础模型仅为 16 个中的 3 个。这项小规模评估衡量的是语言遵循情况，而非推理本身的正确性。

在 open-r1/Mixture-of-Thought 的推理子集上、使用一个 8 GPU B300 节点进行的另一次 500 步训练中的训练损失（左）和平均 token 准确率（右）。这些训练指标来自官方 TRL 示例 PR。

使用 Miles 进行 GRPO

Reflection 和 RadixArk 构建了一套配方，在 Miles 中以 BF16 用 GRPO 训练模型。你可以更新完整模型，或使用 LoRA 训练适配器并保持基础权重冻结。Megatron 负责训练，SGLang 生成 rollout，Miles 在每次更新后将新权重发布到 rollout 引擎。我们审阅了该配方。

该配方在 DAPO-Math-17K 上运行 GRPO，并在 AIME25 上评估。构建镜像、下载数据，并将作业提交到由十二个 8x H200 节点组成的 Ray 集群：

docker build -f docker/Dockerfile.beam -t miles-beam .

python scripts/run_beam.py prepare \
  --model-id reflection/Beam-1.0-501B-A23B \
  --model-dir /root/models/Beam \
  --data-dir /data/datasets

export MASTER_ADDR=10.0.0.1
export RAY_ADDRESS=http://${MASTER_ADDR}:8265

python scripts/run_beam.py execute \
  --model-dir /root/models/Beam \
  --data-dir /data/datasets \
  --output-dir /root/shared_data/beam-run \
  --num-rollout 100

rollout 中会发生什么：

采样： 将 32 条提示传入模型，每条生成 8 个回复。两个 SGLang 引擎各自在 16 块 GPU 上提供 rollout 服务。

评分： 将方框内的答案与标签核对，并对接近长度上限的回复施加软惩罚。

更新： 对全部 256 个样本执行一步优化器更新。使用组相对优势和截断重要性采样，不使用 KL 或熵惩罚。

并行训练： 张量并行 8、专家并行 8、数据并行 8，并启用序列并行和完全重计算。

优化器： Adam，恒定学习率 1e-6。梯度为 BF16，主权重为 FP32，矩为 BF16。优化器状态通过节点本地 NVMe 流式传输，因此每个训练节点需要 2 TB 暂存空间。

评估： 每五次 rollout 在 AIME25 上评估一次，每道题八个样本。每二十次保存一个检查点。

当前 rollout 训练时会生成下一次 rollout，因此回复会落后一次更新。添加 --resume 即可从最近的检查点继续。execute-colocate 在八个节点上运行同一配方，每块 GPU 轮流进行训练和服务。

使用 LoRA 训练

你也可以在四台 8× H200 节点上用 LoRA 运行 GRPO：16 块 GPU 用于训练，16 块用于 rollout。该方案在 Beam 的 attention、dense MLP 和 expert 层上训练 rank-16 adapter，同时保持基础权重冻结。只有 adapter 权重会与 SGLang 同步，优化器状态保留在 GPU 显存中，从而无需将优化器卸载到 NVMe。

python scripts/run_beam_lora.py execute \
  --model-dir /root/models/Beam \
  --data-dir /data/datasets \
  --output-dir /root/shared_data/beam-run \
  --num-rollout 100

用 Beam 构建：演示

如果你用 Beam 构建了什么，就把它分享到 Hub，就有机会赢得 $10,000。你只需构建一个 space、model 或 dataset 仓库，并在 模型的仓库页面 上分享。为了给你一些灵感，下面是我们构建的几个例子。

嘿 Beam，构建一个原生的本地 MacOS 应用！

在 Hugging Face，我们喜欢能在其硬件上原生运行的开放本地模型，但在 Mac 上构建原生应用可能会很难！让我们看看 Beam 能否帮上忙。

我们让 Beam 构建一个原生 MacOS 应用，将语音转为文字，并方便地放到光标处。我们希望使用 MLX 充分发挥 Mac Metal 的性能，并使用 Parakeet Model 实现出色的语音转文字。

Build BeamSpeak, a native macOS menu bar dictation app with a compact recording pill and no main window or account.

Use ⌘⇧Space to start and stop microphone recording, showing elapsed time, microphone level, and transcription status. Run speech recognition entirely locally using a Hugging Face model, preferably Parakeet v3 through MLX, and keep the model loaded between recordings. Paste the transcript into the original app if it remains focused and Accessibility permission is granted; otherwise copy it to the clipboard, preserving newer clipboard changes and never pressing Enter. Handle permissions, cancellation, silence, errors, a two-minute recording limit, and temporary audio cleanup. Deliver source code, a runnable BeamSpeak.app, setup instructions, and verification of offline transcription, the physical shortcut, microphone capture, and text delivery.

我们使用 Beam 与 Pi coding harness 构建了最初的原生 macOS 菜单栏应用，用 MLX 运行 Parakeet。保存的运行包含后续 prompt；最终源码还包含后来的 Codex 修复。上面的 prompt 是构建要求的精简版。

你可以在 这条 trace 中查看 Beam 如何在 pi 中构建它的 agent trace。如果想试用这个 demo，请下载 源代码，或阅读 设置说明。

嘿 Beam，你如何在多个 agent 上扩展？

我们想看看 Beam 能否通过将编程任务拆分到多个 agent 来更快取得进展。我们将 Beam 与开源的 Pi coding agent 搭配，比较了三种设置：1. 一个 agent 单独工作，2. 五个持久 peer 通过共享的 Git 仓库协作，以及 3. 一个主导 agent 将工作委派给异步 subagent。该 harness 运行在 Hugging Face jobs 上，推理通过 Reflection 的平台 API 进行。

在任务方面，我们使用了 ProgramBench：agent 必须根据其编译后的可执行文件和文档重建程序，而不能看到其源代码或评估器的测试。每种设置对每个任务都有相同的 8M API-token 上限和两小时 solver 时限，由其各个 agent 共享。我们保存了实现快照，并根据 ProgramBench-Tests 数据集 中固定的隐藏测试套件对它们进行评估。

我们的 分数与延迟关系图 显示了通过测试的平均比例。时间轴使用模型 token 的固定参考速率加上测得的工具时间，而不是经过的墙钟时间。我们最初运行了五个任务。当前图显示的是事后子集 jq、xsv、FIGlet 和 hexyl；ripgrep 在全部三种设置中都被排除，因为对其保存的产物进行评分太慢。已发布的结果保留了全部 15 个原始 episode。

你可以在 Trackio 仪表板 中查看这些运行，探索 已发布的结果数据，并复用 研究 harness。

嘿 Beam，为我的代码库微调一个决策模型！

决策模型眼下正风靡一时，因为它们速度极快，而且对许多用例都很实用。我们从 Beam 开始，在 Beam 的配额用完后，又在 Pi 中继续使用 GLM-5.3，以训练并评估一个用于开发者事件分诊的定制决策模型。

我们想看看编程智能体能否把事件分诊策略转化为一个小型、快速的决策模型。任务是阅读开发者事件，并选择负责团队、其严重程度，以及是否应立即通知某人。我们使用 Unsloth 微调了 Qwen3.5-0.8B，以直接对这些选择打分。

首先，该工作流构建了一个包含 2.3k 条事件的合成数据集，按事件簇划分，用于训练、校准和测试。我们在 Science Slurm 集群上的一块 H100 80GB 上，以 4-bit 主干训练了 LoRA 适配器和决策头，共三个 epoch。

作为基线，我们在不提供示例的情况下，用完整的分诊策略和工单向未适配模型发出提示，并要求它以 JSON 生成这三项决策。在相同的 320 条合成测试工单上，微调后的决策模型三项全部答对的比例为 76.25%，而提示式零样本为 4.69%。平均工单延迟从 1,218.06 ms 降至 102.58 ms，加速 11.9×。

如果你想亲自尝试这个实验，请查看包含数据、代码、检查点和结果的 产物存储桶。

结语

Beam 是一个 501B 开放模型，你可以在自己的硬件上运行并修改。从 BF16 检查点开始，或尝试其中一种量化版本 FP8、 NVFP4。如果你用 Beam 做了些东西，请在 讨论标签页中分享。