欢迎认识 Muse Spark Open：Meta 推出的开源权重前沿多模态混合专家模型

来源：https://huggingface.co/blog/meta-muse-spark-open

Muse Spark Open 是 Meta 推出的一款开源权重模型。这个混合专家（Mixture of Experts）模型将文本、图像、音频和视频整合到一个拥有约 8160 亿参数的模型中，每个 token 激活约 420 亿参数，上下文窗口最高可达 100 万 token。它以文本输出，为开发者提供了一个统一的接口，用于对不同类型的输入进行提问。

继 Muse Glimmer 之后，Muse Spark Open 在更大规模上引入了混合专家架构，是迄今为止美国最强大的开源权重模型。Meta 针对代理式编程（agentic coding）场景训练了 Muse Spark Open：阅读代码库、编写和调试代码，以及调用工具。它还能接受图像、音频和视频输入，因此同一个模型可以在处理你的代码时阅读截图、听语音备忘或观看屏幕录制。

本文将展示如何运行它、如何微调它，以及我们用它构建了什么。所有模型请前往此处查看。

总体能力与架构

Meta 将 Muse Spark Open 描述为一个面向编码优化的模型，在真实的开发者工作流上进行了训练，例如多文件重构和长时间的调试会话。Muse Spark Open 是一个以代理能力为核心的模型，能够在长时间任务中进行规划、执行、观察和自我纠正，包括使用图像浏览网页。

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

模型架构图

Muse Spark Open 是 Muse 系列模型的完整尺寸版本。Meta 于八月发布的 Muse Glimmer 是同一系列中的小型稠密模型，适合本地运行。两个模型使用相同的分词器和词表。聊天模板遵循 Muse Glimmer 的模板，并为新增模态添加了扩展。在 Muse Spark Open 中，输入嵌入和输出层是两个独立的矩阵，每个约 16.6 亿参数。

混合专家

语言模型有 62 层，隐藏维度为 8192。每层有 128 个查询头和 16 个键值头（分组查询注意力，Grouped-Query Attention）。每个头有 64 个维度。注意力块包含一个输出门控和一个输出归一化层。模型还对查询和键进行归一化（QK-norm）。每个块通过一个可学习的残差门控将输入和输出结合，而非简单相加。

Muse Glimmer 在每层使用一个稠密前馈网络。Muse Spark Open 用混合专家（MoE）块替代了这个稠密网络。每个 MoE 块有 256 个专家，路由器为每个 token 选择 8 个专家。每个专家是一个前馈网络，先从 8192 维投影到 4096 维，再投影回 8192 维，然后对其输出应用自己的归一化。专家持有约 97% 的总模型参数。每个 token 只运行 8 个专家，因此模型以约 420 亿参数计算每个 token。所有 256 个专家都保存在内存中，因此部署需要 8160 亿参数模型的内存，但运行速度接近 420 亿参数模型。

BF16 检查点以 safetensors 格式约 1.5 TB。NVFP4 检查点以 4 位精度存储参数，精度损失可忽略不计，专为 NVIDIA Blackwell GPU 设计。在 transformers 中，BF16 检查点需要跨 4 个节点、共 32 张 H200 GPU（张量并行 TP=32）运行，NVFP4 则可在单个 B200 节点上运行。如果你想部署 Muse Spark Open，请查看下方的 llama.cpp、vLLM 和 SGLang 部署方案。

感知编码器

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

图像处理流水线图

Muse Glimmer 30B 使用了相同架构的编码器。设计遵循 Meta 的 Perception Encoder 工作。视频输入与图像走相同的编码器。

音频编码器

音频处理图

Muse Spark Open 通过其音频编码器接受音频输入。音频分词器将音频转换为 token，聊天模板用 <|audio|> token 标记音频位置。编码器每 80 毫秒输出一个音频 token，即每秒 12.5 个 token。因此，如果你有一段 10 秒的音频，输入的音频 token 数量为 125 个。

编码器本身是一个卷积金字塔，每个阶段由一个不同图块大小的 patch embedder 和 2 个 1D 卷积块（卷积核大小为 7，步幅为 1）组成。这些阶段按图块大小 [16, 6, 5, 4] 重复。在最后一个阶段的末尾，时间帧被送入一个由 RMSNorm → 线性投影 → RMSNorm 组成的最终块。

长上下文

推理时上下文窗口为 100 万 token。配置将 max_position_embeddings 设为 1,048,576。这包括与文本在同一窗口中的图像、视频和音频 token。

分组查询注意力使得如此规模的模型 KV 缓存保持较小。每个 token 向缓存添加 2 × 16 个头 × 64 维 × 62 层 = 126,976 个值。在 BF16 下，每个 token 约 250 KB，完整的 100 万 token 上下文约 266 GB。

推理支持

Transformers

Muse Spark Open 实现提供了 MuseSparkForConditionalGeneration 用于从多模态输入进行文本生成，以及 MuseSparkProcessor 用于准备对话。处理器组合了分词器、图像和视频处理器、音频特征提取器和聊天模板。

使用 DistributedConfig 配置并行设置。tp_size 是稠密层分片的设备数量，ep_size 是专家分布的设备数量。

你可以这样初始化模型和处理器：

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",  # 默认: xhigh，可选: 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)

纯文本推理

准备对话，然后将消息传递给 processor.apply_chat_template，启用 add_generation_prompt=True、tokenize=True、return_dict=True 和 return_tensors="pt"。将处理器输出传递给 model.generate，解码新生成的 token，排除输入前缀。

处理器提供了一个推理强度的调节开关，将符号级别（low/medium/high/xhigh）映射为模型本身接受的整数（16、64、256、512）。

请注意，Muse Spark Open 无法关闭推理模式，因此如果想在较简单的任务上减少 token 消耗，可以将推理强度设为 “low”。你也可以在系统提示中加入类似 Reasoning strength: 1 的行来设置数值强度。

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",  # 可选: 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 处理器将每个图像标记展开为处理后图像所需的 patch token 数量，并用图像边界 token 包裹。这种展开确保了文本位置与传递给模型的视觉特征对齐。处理器还支持在单个提示中包含多张图像。

image_url = (
    "https://huggingface.co/datasets/merve/vl-test-suite/"
    "resolve/main/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 FPS 采样，最多 96 帧。你可以通过设置视频处理器的 fps 来修改：

processor.video_processor.fps = 4.0

一般经验是：视频是按时间顺序排列的帧，下采样越多，就会丢失特定事件之间的更多帧，因此如果需要更精确的生成，应保持较高的 fps。但这存在权衡，因为你会需要更多内存并增加预填充的延迟。

帧与包含时间戳的文本输入交错排列（例如 “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": "https://huggingface.co/datasets/merve/vlm_test_images/resolve/main/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": "https://huggingface.co/buckets/huggingface/audio-samples/resolve/bbaudio_question_39.mp3",
            },
            {
                "type": "text",
                "text": "Answer the question.",
            },
        ],
    },
]

# 下载音频、解码为单声道、重采样到 24 kHz、填充、创建 input_values_mask 并展开音频占位符。
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,
    )

# 仅解码新生成的 token
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"

# 加载模型
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": "https://huggingface.co/datasets/merve/vl-test-suite/resolve/main/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)