Beam：501B 开源 MoE 模型，可拥有、定制与扩展

文本生成 • 501B • 已更新 • 440 • 106

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

Beam 拥有原生 transformers 实现，以及 vLLM 和 SGLang 等下游库。我们与 Reflection 团队合作，为您带来推理、SFT（监督微调）和 RL（强化学习）配方，以便您根据需求使用此模型进行构建。除了在 transformers、SGLang 和 vLLM 中的第 0 天支持外，本文还展示了如何运行它、如何进行后训练，以及我们用它构建了什么。

TL;DR

• 501B 参数的 MoE LLM，每个 token 激活 23B。52 层，每个 MoE 层 256 个专家，每个 token 路由 8 个。
• 文本输入，文本输出，上下文窗口为 1M token。
• 检查点格式：

BF16，以及[FP8]，NVFP4

• 推理可以在多轮对话中保持在上下文中（

preserve_thinking

），使用专用语法进行工具调用。模型支持五种推理值："low"、"medium"（默认）、"high"、"xhigh" 和 "max"。

• 分词器中的响应模板。
• 使用 DFlash2 的推测解码草稿模型
• 第 0 天库：transformers、SGLang、vLLM。使用 Miles 进行全参数 RL。
• 附带一个 [基于 Rust 的自定义框架。]
• Apache 2.0。

Reflection 将向使用 Beam 的最佳项目提供 10,000 美元的 Hub 积分。您只需制作一个东西，并在 Hub 上分享：

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

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

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

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

两种层处理位置的方式不同。滑动窗口层使用 RoPE，因为在短窗口内相对位置最重要。全局层不使用位置编码。相反，每个查询乘以一个随可见 token 数量缓慢增长的缩放器，(1 + (pos + 1) / 2048) ** 0.1

。它起到温度的作用：随着上下文变长，softmax 保持其精度而不是变得平坦。实现将此称为可扩展 softmax 查询缩放。

注意力使用分组查询注意力，具有 48 个查询头和 8 个键值头，并在查询和键上使用 RMSNorm。一个从层输入计算的学习 sigmoid 门在输出投影之前缩放每个头的每个通道。

前 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 个专家，因此模型用约 23B 参数计算每个 token。全部 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 团队提供的不同精度级别的基准测试结果。

Beam (BF16) |

Beam (FP8) |

服务该模型最实用的方式是使用 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 中提供第 0 天支持。

安装最新版本的 transformers。

pip install -U "transformers>=5.20.1"

运行 Beam 最简单的方式是使用文本生成流水线：

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]

该流水线返回整个聊天记录。最后一条消息是 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，解析器会把每个参数转换为它所声明的类型。

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。

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，因此每一步可以接受多个 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 配方。

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 而不是 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

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)

我们已为你准备好一个 Beam 配方，可从目录中一键部署到 Inference Endpoints，支持 FP8 或 NVFP4，或使用 hf

cli 进行安装，如下所示：

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

我们分享一些 Reflection Beam-501B-A23B 在五个任务上的 vibe evals，每个任务分别以低推理强度和高推理强度通过 Reflection 平台各运行一次。这些是 vibe evals，不是基准测试。如果你打算使用 Beam，这是一个很好的试驾方式，可以看看它在特定用例上的表现，更重要的是，看看它在哪些地方胜出、哪些地方失利。

以下是我们在 hub 上运行的提示词和输出轨迹的概览。完整的输入、输出、API 使用情况、任务夹具、评分器和对话轨迹都在这个公开的 Hugging Face bucket中。

** Low 的长上下文响应把所有代码行为和全部六处来源引用都做对了。然而，该响应不符合解析器的格式，所以这部分是提示词歧义造成的。*

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

不要只听我们的一面之词。深入这个 bucket，针对你的用例或项目重写，把 Beam 推到极限。

你可以针对自己的用例微调 Beam。这里，我们分享一些 TRL 和 Miles 中的示例，帮助你开始进行监督微调和强化学习。

让 Beam 适应你自己数据的最快方式是使用 TRL 的 SFTTrainer 进行监督微调。为了控制内存，我们使用 PEFT 训练 LoRA 适配器，而不是更新全部 501B 参数：

我们使用了 TRL 的 SFTTrainer

来让 Beam 适应一个简单的目标：将其推理保持在用户所要求的语言中。我们使用 LoRA 在 Multilingual-Thinking 上进行了微调，这训练一小组适配器权重，同时保持基础模型冻结。

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

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

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

Reflection 和 RadixArk 构建了一个配方，在 Miles 中用 GRPO 以 BF16 训练模型。你可以更新完整模型，或使用 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 轮流进行训练和服务。

你也可以在四个 8× H200 节点上使用 LoRA 运行 GRPO：16 块 GPU 用于训练，16 块用于 rollout。该配方在 Beam 的注意力、稠密 MLP 和专家层上训练秩为 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 构建了作品，那就把它分享到 Hub 上，有机会赢取 10,000 美元。你只需构建一个 space、model 或 dataset 仓库，并将其分享到模型仓库页面。为了给你一些灵感，这里是我们构建的一些东西。

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

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

构建 BeamSpeak，一个原生 macOS 菜单栏听写应用，具有紧凑的录音胶囊界面，没有主窗口或账户。
使用 ⌘⇧Space 开始和停止麦克风录音，显示已用时间、麦克风电平和转录状态。完全在本地运行语音识别，使用 Hugging Face 模型，最好是通过 MLX 使用 Parakeet v3，并在录音之间保持模型加载。如果原始应用仍保持焦点且已授予辅助功能权限，则将转录文本粘贴到原始应用中；否则将其复制到剪贴板，保留较新的剪贴板更改，并且绝不按 Enter 键。处理权限、取消、静音、错误、两分钟录音限制以及临时音频清理。交付源代码、可运行的 BeamSpeak.app、设置说明，以及离线转录、物理快捷键、麦克风捕获和文本传递的验证。

我们使用 Beam 搭配 Pi 编码工具框架构建了最初的 macOS 原生菜单栏应用，并通过 MLX 运行 Parakeet。保存的运行记录包含后续提示；最终源码还包含后来 Codex 的修复。上面的提示是构建需求的精简版本。

你可以在这份追踪记录中查看 Beam 如何在 pi 中构建此项目的智能体轨迹。如果你想试用这个演示，请下载源代码或阅读安装说明。

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

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

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

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

决策模型目前风靡一时，因为它们速度极快，并且在许多用例中非常实用。在 Beam 的配额用完后，我们从 Pi 中的 Beam 开始，训练并评估一个用于开发者事件分诊的自定义决策模型。

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

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

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

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

Beam 是一个 501B 的开放模型，你可以在自己的硬件上运行并修改它。从 BF16 检查点开始，或尝试其中一种量化版本

显示可下载数据的交互式基准测试结果

那么，你为什么不构建一些可以在消费级 GPU 上运行的东西，例如使用 strata 的 Qwen 3.8 Flash Next？