Reflection 发布 501B 开源模型 Beam，Apache 2.0 许可

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

Beam 专注于编程和智能体用例。它面向那些希望在自己的硬件、基础设施或云上运行前沿规模模型，并希望针对自身用例进行定制的团队。Beam 自带专用的开源 Rust 基础框架，可让模型发挥最佳性能。

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

TL;DR

• 501B 参数的 MoE 大语言模型，每 token 激活 23B。52 层，每个 MoE 层 256 个专家，每 token 路由 8 个。
• 文本输入、文本输出，具有100 万 token 的上下文窗口。
• 检查点格式：BF16、FP8、以及NVFP4
• 推理内容可跨轮次保留在上下文中（preserve_thinking），通过专用语法进行工具调用。该模型支持五种推理值："low"、"medium"（默认）、"high"、"xhigh" 和 "max"。
• 分词器中内置响应模板。
• 基于 DFlash2 的投机解码草稿模型
• 首日支持的库：transformers、SGLang、vLLM。使用 Miles 进行全参数 RL。
• 自带基于 Rust 的自定义框架。
• 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 是一个纯文本模型，专为长上下文（100 万上下文长度）推理和智能体工作而构建。它是一个稀疏 MoE 模型，每个 token 只由网络的一小部分计算，因此它以远小于其规模的模型的速度运行，同时保持大模型的容量。

注意力

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

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

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

注意力使用分组查询注意力，有 48 个 query 头和 8 个 key-value 头，并对 query 和 key 使用 RMSNorm。一个由层输入计算出的可学习 sigmoid 门控，在输出投影之前对每个头的每个通道进行缩放。

专家混合

前 3 层使用稠密的 SwiGLU MLP。其余 49 层将其替换为包含 256 个专家的专家混合块，每个专家是一个中间维度为 2,560、约 3900 万参数的 SwiGLU MLP。这些专家占据了模型 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、查询缩放和 softcap。

长上下文

混合注意力在长上下文下表现良好。每层为每个 token 缓存 2 x 8 个 KV 头 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，但 H200 等早于 Blackwell 的 GPU 不支持。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 流水线：

from transformers import pipeline

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

messages = [
    {"role": "user", "content": "写一首关于 Python 异常的打油诗。"}
]
output = pipe(messages, max_new_tokens=2000)
output[0]["generated_text"][-1]

流水线返回整个对话。最后一条消息是 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"
)

Chat

messages = [
    {"role": "system", "content": "你只能用一个数字回答。"},
    {"role": "user", "content": "17 * 23 等于多少？"},
]

inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    reasoning_effort="medium" # 默认情况下
).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"):
    """
获取某个城市的当前天气。

参数：
city：要查询的城市。
unit：温度单位，"celsius" 或 "fahrenheit"。
"""
    ...

tools = [get_weather]
messages = [
    {"role": "user", "content": "我今晚到巴黎。我需要带外套吗？"}
]

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")

Passtools给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。这样每块 GPU 持有 78 GB 权重。若用 8 块 GPU，每块将持有 139 GB，这在 141 GB 的 H200 上不留任何空间。设备数量必须能整除专家数量 256。

vLLM

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

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

为了加快生成速度，可以加入 DFlash2 投机解码。一个小型草稿模型最多提前提出 15 个 token，Beam 在一次前向传播中全部校验，因此每一步可以接受多个 token。代价是草稿模型需要额外占用一点内存：

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 配方。

SGLang

Beam 在 SGLang 中也提供 day-0 支持。我们建议使用 DFlash2 投机解码来服务它，下面两条命令都会开启该功能。在 Blackwell 上，NVFP4 检查点可以放在 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 检查点。只有三个标志需要更改：检查点、张量并行大小（8 而不是 4）以及注意力后端（fa3 而不是需要 Blackwell 的 trtllm_mha）：

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

推理提供商

Beam 已在 HF Mirror Inference Providers 上提供，由 Baseten、Fireworks 和 Together 提供支持，后续还会有更多。

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://router.hf-mirror.com/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)

推理端点

我们为你准备了一个 Beam 配方，可在 Inference Endpoints 中从目录一键部署FP8或NVFP4，或者用hfcli 这样安装：

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 用量、任务夹具、评分器和对话轨迹都在这个公开的 HF Mirror 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 训练后，Beam 在 16 个留出提示中的 16 个上都用所要求的语言进行推理，而基础模型仅为 16 个中的 3 个。这项小型评估衡量的是语言遵循度，而非推理本身的正确性。

在 open-r1/Mixture-of-Thought 的一个推理子集上单独运行 500 步时的训练损失（左）和平均 token 准确率（右），使用一个 8 卡 B300 节点。这些训练指标来自官方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 服务。

评分：将 boxed 答案与标签进行核对，对接近长度限制的响应施加软惩罚。

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

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

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

评估：每五次 rollout 评估一次 AIME25，每个问题八个样本。每二十次保存一个 checkpoint。

下一次 rollout 在当前这次训练时生成，因此响应会落后一个更新。添加--resume以从上一个检查点继续。execute-colocate在八个节点上运行相同的配方，每个 GPU 轮流进行训练和推理服务。

使用 LoRA 训练

你也可以在四个 8× H200 节点上使用 LoRA 运行 GRPO：16 个 GPU 用于训练，16 个用于 rollout。该配方在 Beam 的注意力层、稠密 MLP 层和专家层上训练 rank-16 适配器，同时保持基础权重冻结。只有适配器权重会与 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 应用程序！

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

我们让 Beam 构建一个原生 MacOS 应用程序，将语音转换为文本，并方便地将其放到你的光标处。我们希望使用 MLX 来充分利用 Mac Metal，并使用 Parakeet 模型来实现出色的语音转文本。

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 HF Mirror 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 编码工具构建了最初的 native macOS 菜单栏应用，用 MLX 运行 Parakeet。保存的运行记录包含后续提示；最终源码还包含后来的 Codex 修复。上面的提示是构建需求的精简版本。

你可以在以下位置查看 Beam 如何在 pi 中构建此应用的智能体轨迹此轨迹。如果你想试用该演示，请下载源代码或阅读设置说明。

嘿 Beam，你如何在多个智能体上扩展？

我们想看看 Beam 能否通过将编程任务拆分到多个智能体上来取得更快的进展。我们将 Beam 与开源 Pi 编码智能体配对，并比较了三种设置：1. 一个智能体单独工作，2. 五个持久对等体通过共享 Git 仓库协作，3. 一个主智能体将工作委派给异步子智能体。该工具在 HF Mirror jobs 上运行，推理通过 Reflection 的平台 API 进行。

For the tasks, we used ProgramBench: agents must recreate a program from its compiled executable and documentation, without seeing its source code or the evaluator’s tests. Each setup had the same 8M API-token ceiling and two-hour solver limit per task, shared across its agents. We saved implementation snapshots and evaluated them against fixed hidden-test suites from theProgramBench-Tests dataset.

Ourscore-versus-latency plotshows the average fraction of tests passed. The time axis uses fixed reference rates for model tokens plus measured tool time, rather than elapsed wall time. We initially ran five tasks. The current figure shows a post-hoc subset of jq, xsv, FIGlet, and hexyl; ripgrep was excluded across all three setups because grading its saved artifacts was too slow. The published results retain all 15 original episodes.

You can inspect the runs in theTrackio dashboard, explore thepublished result data, and reuse thestudy harness.

Hey Beam, finetune a decision model for my code base!

Decision models are all the rage at the moment because they’re super fast and practical for many use cases. We started with Beam in Pi after Beam’s quota ran out to train and evaluate a custom decision model for developer incident triage.

We wanted to see whether a coding agent could turn an incident-triage policy into a small, fast decision model. The task was to read a developer incident and choose the responsible team, its severity, and whether someone should be pinged immediately. Using Unsloth, we fine-tuned Qwen3.5-0.8B to score these choices directly.

First, the workflow built a synthetic dataset containing 2.3k incidents split by incident cluster for training, calibration, and testing. We trained a LoRA adapter and decision head for three epochs, with a 4-bit backbone, on one H100 80GB on the Science Slurm cluster.

作为基线，我们用完整的分诊策略和工单提示未适配的模型，不提供示例，并要求它以 JSON 格式生成三个决策。在同样的 320 张合成测试工单上，微调后的决策模型在 76.25% 的情况下三个答案全部正确，而提示式零样本仅为 4.69%。平均工单延迟从 1218.06 ms 降至 102.58 ms，加速 11.9 倍。

如果你想亲自尝试这个实验，请查看artifact bucket其中包含数据、代码、检查点和结果。

总结

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