Reflection 发布 501B 开源 MoE 模型 Beam，主打编码与 Agent 场景

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

Beam 专注于编程和智能体用例。它面向那些想在自己的硬件、基础设施或云端使用前沿规模模型，并希望针对自己的用例进行定制的团队。Beam 附带了专属的开源 Rust harness，可从模型中交付最佳性能。

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 的自定义 harness。
• Apache 2.0 许可证。

用 Beam 构建

Reflection 将向使用 Beam 的最佳项目发放 10,000 美元的 Hub 额度。你要做的只是做出一个作品，并分享到 Hub 上：

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

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

Beam 是什么？

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

注意力

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

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

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

注意力采用分组查询注意力(grouped-query attention),包含 48 个 query 头和 8 个 key-value 头,并对 query 和 key 应用 RMSNorm。一个由层输入计算得到的可学习 sigmoid 门控,在输出投影之前对每个头的每个通道进行缩放。

混合专家(Mixture of Experts)

前 3 层使用稠密的 SwiGLU MLP。其余 49 层则将其替换为一个包含 256 个专家的混合专家(Mixture-of-Experts)模块,每个专家是一个中间维度为 2,560 的 SwiGLU MLP,约有 3900 万参数。专家占据了模型参数的 98.4%。

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

每个 token 只运行 8 个专家,因此模型对每个 token 的计算约使用 230 亿参数。全部 256 个专家都保留在内存中,因此部署需要 5010 亿参数模型的内存,但能以 230 亿参数模型的速度运行。BF16 检查点以 safetensors 格式存储,大小约为 1 TB。NVFP4 检查点针对 NVIDIA Blackwell GPU 将大部分参数以 4 位精度存储,部分参数为保持精度而保留为 BF16。Hub 上还有适合 Hopper 和 Ampere 系列芯片的 FP8 检查点。

如果你想自己部署 Beam,请查看下方的 vLLM 或 SGLang 使用指南。

残差流(Residual Stream)

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

Beam 将输入嵌入视为第 1 步。在第 k 步,它以权重 1/sqrt(k) 加上子层输出,并以权重 sqrt((k-1)/k) 保留现有流。两个权重的平方和为一,因此流从第一层到最后一层保持恒定尺度。经过全部 104 次加法后,每个子层输出和输入嵌入在最终隐藏状态中 carrying 相同的权重。

每个子层在前后都进行归一化,最终的 logits 经过 ±30 的 tanh softcap,以 FP32 计算。实现明确规定了在何处使用 FP32 计算:路由器、SwiGLU 乘积、归一化、RoPE、query 缩放和 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，但比 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="reflectionai/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 = "reflectionai/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 训练时生成的格式一致。对话模板可以预先写入 assistant 回合的一部分，解析器需要看到这部分内容。

工具调用

完整的工具调用示例

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"]), enable_expert_parallel=True
    ),
)

在 16 块 H200 GPU 上用 torchrun 启动脚本。这样每块 GPU 上存放 78 GB 权重。如果用 8 块 GPU，每块则需存放 139 GB，在 141 GB 的 H200 上就没有剩余空间了。设备数量必须能整除专家数量 256。

vLLM

Beam 在 vLLM 中获得首日支持。以下命令以 16 卡张量并行（两台 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，因此每一步可以接受多个 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 建议方案。

SGLang

Beam 在 SGLang 中也有第 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

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 方案，你可以在 Inference Endpoints 中通过目录一键部署 FP8 或 NVFP4 版本，或使用 hf cli 按如下方式安装：

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

我们的测试内容

我们正在分享 Reflection Beam-501B-A23B 在五个任务上的一些 vibe 评测，每个任务分别以低和高推理力度通过 Reflection 平台各运行一次。这些是 vibe 评测，而非基准测试。如果你计划使用 Beam，这是很好的试用方式，可以了解它在特定用例上的表现，尤其是它在哪些方面胜出、哪些方面不足。

下面是我们运行的提示词概览以及来自 hub 的输出轨迹。完整的输入、输出、API 用量、任务夹具、评分器和对话轨迹都在这个公开的 Hugging Face 存储桶中。

* 低推理力度的长上下文回答在所有代码行为和全部六处源码引用上都是正确的。但该回答不符合解析器的格式，因此这部分属于提示词的歧义。

† 低推理力度返回了正确答案，但省略了所要求的证明。高推理力度给出了正确的单位根证明，并经过独立审阅。

不要只听我们的一面之词。深入研究这个存储桶，针对你的用例或项目进行改写，把 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 个以要求的语言进行推理，而基础模型只有 3/16。这个小型评估衡量的是语言遵循度，而不是推理本身的正确性。

在 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 的注意力层、稠密 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、模型或数据集仓库,并将其分享到模型仓库页面。为了给你一些启发,这里是我们构建的几个示例。

Hey Beam,构建一个原生本地 MacOS 应用!

在 Hugging Face,我们热爱那些原生运行于自身硬件的开放本地模型,但在 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 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 编码框架构建了最初的 macOS 原生菜单栏应用,通过 MLX 运行 Parakeet。保存的运行记录包含后续提示;最终源代码还包含后来的 Codex 修复。上述提示是构建需求的一个精简版本。

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

Hey Beam,你如何在多个智能体上扩展?

我们想看看 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 仪表板中查看这些运行,浏览已发布的结果数据,并复用这个研究框架。

Hey 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% 的情况下三项答案全部正确，而提示的 zero-shot 仅为 4.69%。单张工单的平均延迟从 1,218.06 ms 降至 102.58 ms，实现了 11.9× 的加速。

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

结语

Beam 是一个 501B 的开放模型，你可以在自己的硬件上运行并修改它。可以从 BF16 检查点开始，或者尝试量化版本 FP8, NVFP4。如果你用 Beam 构建了什么，欢迎在讨论区分享。