Meta 开源 Muse-Spark-Open： 816B 参数激活 42B，1M 上下文，支持全模态输入

魔搭ModelScope社区

7人浏览 · 2026-10-19 17:20:37

魔搭ModelScope社区 · 2026-10-19 17:20:37 发布

Muse Spark Open 是 Meta 推出的一款开放权重模型。这款混合专家模型将文本、图像、音频和视频整合到同一个模型中，总参数量约为 816B，每个 Token 激活约 42B 参数，上下文窗口最多可容纳 100 万个 Token。它生成文本输出，为开发者提供了一个统一接口，用于针对不同类型的输入提出问题。

继 Muse Glimmer 之后，Muse Spark Open 引入了规模大得多的混合专家架构，针对智能体编程训练了 Muse Spark Open，涵盖阅读代码库、编写和调试代码以及调用工具。它还支持图像、音频和视频输入，因此，同一个模型可以在处理你的代码时阅读截图、听取语音备忘录，或观看屏幕录制视频。

开源地址：

模型权重：Muse-Spark-Open-816B-A42B - ModelScope 魔搭社区
NVFP4 版本：Muse-Spark-Open-816B-A42B-NVFP4 - ModelScope 魔搭社区

应用场景案例

编码协作：从代码编写到审查与交付

Muse Spark Open 覆盖代码编写、审查与交付环节，以更少的操作步骤和更低的延迟支持开发任务。比如，开发者可以用它构建编码智能体，也可以将其作为日常开发伙伴，协助推进功能实现与代码审查。

多模态开发：以截图、视频和文档作为输入

Muse Spark Open 原生支持视频、图像和文档感知，视觉推理在真实执行环境中完成，而非依赖预设的脚本步骤。比如，开发者可以提供一张截图或一段视频，让模型结合视觉信息开展开发，将输入素材转化为功能实现的依据。

多智能体工作流：用一个模型构建与编排

Muse Spark Open 支持使用同一个模型构建和编排多智能体工作流，帮助开发者从想法推进到功能实现，将更多精力投入测试、验证与开发，而非工作流配置。独立的 commentary 通道允许模型在执行前说明行动意图，让开发者了解它接下来要做什么，以及为什么这样做。

整体能力与架构

Meta 将 Muse Spark Open 描述为一款针对编程优化的模型，其训练围绕真实的开发者工作流展开，例如多文件重构和长时间调试。Muse Spark Open 侧重智能体能力，能够在长任务中进行规划、执行、观察和自我纠正，包括借助图像浏览网页。

特性	Muse Spark Open
模型规模	总参数约 816B；每个 token 激活约 42B 参数
专家路由	每个 MoE 层有 256 个专家；每个 token 选择 8 个专家
输入	文本、图像、音频和视频
输出	文本
上下文窗口	最多 1M 个 token
检查点格式	BF16 和 NVFP4

检查点仓库分别为 Muse-Spark-Open-816B-A42B 和 Muse-Spark-Open-816B-A42B-NVFP4。

Muse Spark Open 是 Muse 模型系列中的全尺寸模型。Meta 于 8 月发布的 Muse Glimmer 则是同系列中的小型稠密模型，非常适合在本地运行。两个模型使用相同的 tokenizer 和词表。聊天模板沿用了 Muse Glimmer 的模板，并增加了对新模态的支持。在 Muse Spark Open 中，输入嵌入和输出层是两个独立的矩阵，每个矩阵的参数量约为 16.6 亿。

混合专家

语言模型共有 62 层，隐藏维度为 8192。每层包含 128 个查询头和 16 个键值头，采用分组查询注意力。每个注意力头的维度为 64。注意力模块包含一个输出门和一个输出归一化层。模型还对查询和键进行归一化，即 QK-norm。每个模块通过一个可学习的残差门将输入与输出结合，而不是直接相加。

Muse Glimmer 在每层使用一个稠密前馈网络。Muse Spark Open 则用混合专家（MoE）模块替换了这个稠密网络。每个 MoE 模块包含 256 个专家，路由器为每个 token 选择 8 个专家。每个专家都是一个前馈网络，将维度从 8192 投影到 4096，再投影回 8192，随后对自身的输出进行归一化。专家部分占模型总参数量的约 97%。

每个 token 只运行 8 个专家，因此模型在计算每个 token 时使用约 42 参数。全部 256 个专家仍然驻留在内存中，因此部署时需要容纳一个 816B 参数模型的内存，但运行速度则接近快得多的 42 参数模型。BF16 检查点采用 safetensors 格式，大小约为 1.5 TB。NVFP4 检查点以 4 位精度存储参数，精度损失可忽略不计，专门面向 NVIDIA Blackwell GPU。在 Transformers 中，BF16 检查点通过张量并行（TP=32）运行在 4 个节点上，每个节点配备 8 张 H200 GPU；NVFP4 则运行在单个 B200 节点上。

感知编码器

与 Muse Glimmer 一样，感知编码器将图像和视频帧转换为语言模型使用的 token。该编码器拥有 18 亿参数、50 层，隐藏维度为 1536，包含 16 个注意力头。它将每张图像切分成 14×14 的图像块，并生成 4096 维特征。位置信息来自可学习的绝对位置嵌入和二维 RoPE。每层的前馈网络使用 LayerNorm 和 GELU。每隔四层以及最后一层使用全注意力，其余层使用稀疏注意力。

Muse Glimmer 30B 使用架构相同的编码器。这一设计沿用了 Meta 的 Perception Encoder 研究。视频输入使用与图像相同的编码器。

音频编码器

Muse Spark Open 通过音频编码器接收音频输入。音频 tokenizer 将音频转换成 token，聊天模板则使用 <|audio|> token 标记音频位置。编码器每 80 毫秒输出一个音频 token，相当于每秒 12.5 个 token。因此，假设你有一段 10 秒的音频，输入的音频 token 数量就是 125。编码器本身采用卷积金字塔结构，每个阶段都包含一个使用不同分块大小的块嵌入器，以及两个一维卷积模块，卷积核大小为 7、步幅为 1。各阶段依次采用 [16, 6, 5, 4] 的块大小重复这一结构。在最后一个阶段结束后，时间帧被送入最终模块：RMSNorm → 线性投影 → RMSNorm。

长上下文

推理时的上下文窗口为 1M 个 token。配置将 max_position_embeddings 设为 1,048,576。图像、视频和音频 token 与文本共享同一个窗口。

对于这样规模的模型，分组查询注意力能够控制 KV 缓存的大小。每个 token 向缓存添加 2 × 16 个头 × 64 维 × 62 层 = 126,976 个数值。在 BF16 下，这约等于每个 token 250 KB；完整的 1M token 上下文约需 266 GB。

本地部署与推理

模型下载：

modelscope download --model meta-models/Muse-Spark-Open-816B-A42B --local_dir meta-models/Muse-Spark-Open-816B-A42B
modelscope download --model meta-models/Muse-Spark-Open-816B-A42B-NVFP4 --local_dir meta-models/Muse-Spark-Open-816B-A42B-NVFP4

Transformers 推理

推理脚本：

import os

from transformers import AutoModelForMultimodalLM, AutoTokenizer, DistributedConfig

distributed_config = DistributedConfig(
    tp_size=int(os.environ["WORLD_SIZE"]),
    ep_size=int(os.environ["WORLD_SIZE"]),
)

tokenizer = AutoTokenizer.from_pretrained("meta-models/Muse-Spark-Open-816B-A42B
")
model = AutoModelForMultimodalLM.from_pretrained(
    "meta-models/Muse-Spark-Open-816B-A42B",
    distributed_config=distributed_config,
)

messages = [
    {"role": "user", "content": "Explain in one sentence why the sky is usually blue."},
]
inputs = tokenizer.apply_chat_template(
    messages,
    reasoning_effort="medium",  # default: xhigh, options: low/medium/high/xhigh
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device).to(model.dtype)

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

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

纯文本推理：

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

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    reasoning_effort="high", # options:low/medium/high/xhigh
).to(model.device).to(model.dtype)

output = model.generate(**inputs, max_new_tokens=2000)
generated_tokens = output[0][inputs["input_ids"].shape[1] :]
print(processor.decode(generated_tokens, skip_special_tokens=False))

图像与文本推理：

Muse Spark Open 处理器会将每个图像标记展开为处理后图像所需数量的图像块 token，并在两侧加上图像边界 token。这种展开方式能够使文本位置与传给模型的视觉特征保持对齐。处理器还支持在单个提示词中处理多张图像。

image_url = (
    "pills.jpg"
)
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": image_url,
            },
            {
                "type": "text",
                "text": "Do any of the components in this supplement interact?",
            },
        ],
    },
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    reasoning_effort="medium",
    return_dict=True,
    return_tensors="pt",
).to(model.device).to(model.dtype)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=2000)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)

processor.parse_response(response)

视频推理：

视频提示词不仅包含视觉内容，还包含帧的时间信息。处理器能够处理带音频的视频；得益于音频编码器，这是相较 Muse Glimmer 的一项升级。处理器会对视频帧和音频进行下采样，使它们相互对齐。默认情况下，视频按每秒 2 帧采样，最多 96 帧。你可以通过设置视频处理器的 fps 来修改这一行为：

processor.video_processor.fps = 4.0

一般来说，视频就是按时间顺序排列的帧。下采样程度越高，特定事件之间丢失的帧就越多，因此，若想获得更准确的生成结果，就需要保持较高的 fps。但这里存在取舍：更高的采样率会需要更多内存，并增加预填充（prefill）的延迟。视频帧与标明时间戳的文本输入交错排列，例如 Time: 3.5s。要传入带音频的视频，请向 apply_chat_template 传入 load_audio_from_video=True。

准备输入时，使用 return_metadata=True 保留视频元数据，使处理器能够指定正确的帧率。

import torch

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": (
                    "Describe what happens in this video. "
                    "Use timestamps and include relevant speech or sounds."
                ),
            },
            {
                "type": "video",
                "url": "ramen.mp4"
            },
        ],
    }
]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    load_audio_from_video=True,
    return_metadata=True,
).to(model.device).to(model.dtype)

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        max_new_tokens=256,
        do_sample=False,
    )

generated_ids = output_ids[:, inputs["input_ids"].shape[1] :]
response = processor.batch_decode(
    generated_ids,
    skip_special_tokens=True,
)[0]

print(response)

音频推理：

Muse Spark Open 的音频分支接收原始波形。处理器要求输入为 24 kHz 的单声道音频，并将波形补齐到 1,920 个采样点的整数倍，对应每 80 毫秒一个音频嵌入。如果直接向处理器提供其他采样率的音频，必须先重采样。你可以使用 Transformers 的 load_audio 工具来完成这一步。load_audio 使用 torchcodec、librosa 或 torchaudio 后端，因此，请确保在运行推理前，已在本地安装其中之一。

不过，如果你只是将消息传给 apply_chat_template，这些处理都会在内部自动完成：

import torch
from transformers import AutoProcessor, AutoModelForMultimodalLM

model_id = "meta-models/Muse-Spark-Open-816B-A42B"
processor = AutoProcessor.from_pretrained(model_id)

model = AutoModelForMultimodalLM.from_pretrained(model_id).eval()

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "audio",
                "url": "39.mp3",
            },
            {
                "type": "text",
                "text": "Answer the question.",
            },
        ],
    }
]

# Downloads the audio, decodes it as mono, resamples it to 24 kHz, pads it, creates input_values_mask, and expands the audio placeholders.
inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    load_audio_backend="auto",
).to(model.device).to(model.dtype)

with torch.inference_mode():
    output_ids = model.generate(
        **inputs,
        max_new_tokens=128,
        do_sample=False,
    )

# Decode only newly generated tokens
prompt_length = inputs["input_ids"].shape[1]
generated_text = processor.batch_decode(
    output_ids[:, prompt_length:],
    skip_special_tokens=True,
)

print(generated_text[0])

处理器会在音频边界标记之间插入数量匹配的音频 token。它还会返回一个标识真实采样点的掩码，使模型能够排除填充部分的音频嵌入。

工具调用：

Muse Spark Open 支持纯文本和多模态工具调用。你可以按以下方式让模型调用工具。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Spark-Open-816B-A42B"

# Load model
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "weather.get",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                },
                "required": ["city"],
            },
        },
    }
]


messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": "SF.png"},
            {"type": "text", "text": "I'm going to the city in this picture. What clothes should I wear?"},
        ],
    },
]

inputs = processor.apply_chat_template(
    messages,
    tools=tools,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="high"
).to(model.device).to(model.dtype)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs)
response = processor.parse_response(
      completion,
      prefix=inputs["input_ids"][0],
      tools=tools,
  )
print(response)

Muse Spark Open 使用基于通道的聊天模板 Harmony，这种模板最早由 gpt-oss 引入。下面是一个输入消息示例：

<|begin_of_text|>
  <|start|>system<|message|>
  You are a helpful AI assistant.
  Knowledge cutoff: 2026-01-04.
  Current date: ...
  ...
  <|eot|>
  <|start|>user<|message|>...
  <|eot|>
  <|start|>assistant

<|start|>assistant 被有意留在未结束的状态，由模型通过 to= 选择接收方。模型有不同的接收方，例如，self 会让模型进行推理：

to=self<|message|>the model reasons here<|eom|> # reasoning
<|start|>assistant to=user<|message|>final answer<|eot|> # final answer

self 用于推理，commentary 是在工具调用之前和之间向最终用户展示的说明，user 则是最终回复。工具调用的路由按如下方式解析，前提是你已将工具传给 apply_chat_template：

<|start|>assistant to=weather.get<|message|>
  <atem:function_calls>
  <atem:invoke name="weather.get">
  <atem:parameter name="city">San Francisco</atem:parameter>
  </atem:invoke>
  </atem:function_calls>
  <|eot|>

SGLang

Muse Spark Open 的 SGLang 集成支持文本、图像、音频和视频输入。NVFP4 参考配置运行在四张 GB300 GPU 上。

在 SGLang 集成环境中，启动服务器：

export MODEL_ID=meta-models/Muse-Spark-Open-816B-A42B-NVFP4

SGLANG_FLASHINFER_NVFP4_PER_TOKEN_ACTIVATION=1 \
uv run sglang_meta serve \
  --model-path meta-models/Muse-Spark-Open-816B-A42B-NVFP4 \
  --served-model-name "$MODEL_ID" \
  --quantization modelopt_fp4 \
  --moe-runner-backend flashinfer_trtllm \
  --tp-size 4 \
  --ep-size 4 \
  --port 30000

通过兼容 OpenAI 的 API 发送请求：

curl http://localhost:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-models/Muse-Spark-Open-816B-A42B-NVFP4",
    "messages": [{
      "role": "user",
      "content": "Explain how a mixture-of-experts model works."
    }],
    "max_tokens": 2048
  }'

响应将推理轨迹与最终答案分开，分别放在 reasoning_content 和 content 中。

vLLM

Muse Spark Open 的 vLLM 参考集成使用 NVFP4 检查点，支持文本和图像输入，需要 Blackwell 系列 GPU。

安装参考插件及其依赖后，启动服务器：

export MODEL_ID=meta-models/Muse-Spark-Open-816B-A42B-NVFP4

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 \
VLLM_PLUGINS=musespark1x_models,ptq_nvfp4 \
vllm serve meta-models/Muse-Spark-Open-816B-A42B-NVFP4 \
  --served-model-name "$MODEL_ID" \
  --tokenizer-mode musespark1x \
  --config-format auto \
  --load-format internal_safetensor \
  --tensor-parallel-size 4 \
  --enable-expert-parallel \
  --max-model-len 131072 \
  --gpu-memory-utilization 0.92 \
  --reasoning-parser musespark1x \
  --tool-call-parser musespark1x \
  --enable-auto-tool-choice \
  --port 8000

这一配置将服务端上下文设为 128K 个 token。插件提供模型实现、检查点加载器以及推理和工具调用解析器。

使用同一个服务名称发送请求：

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-models/Muse-Spark-Open-816B-A42B-NVFP4",
    "messages": [{
      "role": "user",
      "content": "Explain how a mixture-of-experts model works."
    }],
    "max_tokens": 2048
  }'