欢迎 Muse Spark Open：Meta 的开放权重多模态 MoE 模型

Muse Spark Open 是 Meta 推出的一个开放权重模型。该混合专家模型将文本、图像、音频和视频整合到一个拥有约 8160 亿参数、每个 token 激活约 420 亿参数、上下文窗口高达 100 万 token 的模型中。它生成文本，为开发者提供了一个针对不同类型输入进行提问的通用接口。

继 Muse Glimmer 之后，Muse Spark Open 以更大的规模引入了混合专家架构，是目前美国能力最强的开放权重模型。

Meta 针对智能体编码训练了 Muse Spark Open：阅读代码库、编写和调试代码，以及调用工具。它还接受图像、音频和视频作为输入，因此同一个模型可以在处理你的代码时阅读截图、收听语音留言或观看屏幕录制。本文展示了如何运行它、如何微调它，以及我们用它构建了什么。你可以在这里找到所有模型。

整体能力与架构

Meta 将 Muse Spark Open 描述为一个针对编码优化的模型，基于真实开发者工作流（如多文件重构和长时间调试会话）进行训练。Muse Spark Open 是一个专注于智能体的模型，能够在长任务中进行规划、行动、观察和自我纠正，包括浏览带有图像的网页。

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

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

Muse Spark Open 是 Muse 系列模型的全尺寸版本。Meta 于 8 月发布的 Muse Glimmer 是同一系列中的小型稠密模型，适合本地运行。两个模型使用相同的分词器和词汇表。聊天模板遵循 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 个专家，因此模型使用约 42B 参数计算每个 token。所有 256 个专家都保留在内存中，因此部署需要 816B 参数模型的内存，但以 42B 模型的速度运行。BF16 检查点以 safetensors 格式存储，大小约为 1.5 TB。NVFP4 检查点以 4 位精度存储参数，精度损失可忽略不计，专为 NVIDIA Blackwell GPU 设计。在 transformers 中，BF16 检查点在 4 个节点（每个节点 8 个 H200 GPU）上运行，采用张量并行（TP=32）；NVFP4 则在单个 B200 节点上运行。如果您想部署 Muse Spark Open，请查看下方的 llama.cpp、vLLM 和 SGLang 配置方案。

感知编码器

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

Muse Glimmer 30B 使用具有相同架构的编码器。该设计遵循 Meta 的感知编码器工作。视频输入与图像通过相同的编码器处理。

音频编码器

Muse Spark Open 通过其音频编码器接受音频输入。音频分词器将音频转换为 token，聊天模板使用 <|audio|> token 标记音频位置。编码器每 80 毫秒输出一个音频 token，即每秒 12.5 个 token。因此，假设您有一段 10 秒的音频，输入音频 token 的数量将是 125。该编码器本身是一个卷积金字塔，每个阶段由不同块大小的块嵌入器和 2 个使用大小为 7、步长为 1 的一维卷积核的卷积块组成。这些阶段针对块大小 [16, 6, 5, 4] 重复进行。在最终阶段结束时，时间帧被送入一个由 RMSNorm → 线性投影 → RMSNorm 组成的最终块。

长上下文

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

分组查询注意力（Grouped-query attention）使该规模模型的 KV 缓存保持较小。每个 token 向缓存添加 2 × 16 个头 × 64 维 × 62 层 = 126,976 个值。在 BF16 下，这约为每个 token 250 KB，完整的 1M 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",  # 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)

纯文本推理

准备对话，然后将消息传递给 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", # 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 处理器将每个图像标记扩展为处理后的图像所需的 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”）的文本输入交错。要启用传递带音频的视频，请将 load_audio_from_video=True 传递给 apply_chat_template。

在使用 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.",
              },
          ],
      }
  ]

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

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 是最终响应。
工具调用路由解析如下（假设你已将 tools 传递给 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|>

Llama.cpp

Muse Spark 2-bit 在 Llama Server 上运行

Muse Spark Open 已集成到 llama.cpp 中，并包含在预编译二进制文件中。你可以使用以下命令安装：

curl -LsSf https://llama.app/install.sh | sh

你可以将量化后缀附加到模型 ID 后，按以下方式启动服务器：


llama serve -hf ggml-org/Muse-Spark-Open-816B-A42B-GGUF:Q2_K

包含量化版本的仓库在这里。服务器启动后，你可以访问 localhost:9931 与内置的 WebUI 进行聊天。从 Web UI 中，你可以添加音频和图像用于推理，并调整推理滑块。
请注意，在 Muse Spark Open 中无法关闭推理，因此如果你希望在解决较简单的任务时消耗更少的 token，请将模型推理保持在“低”级别。
我们在 Mac M3 Ultra (512GB) 上测试了量化版本。经过 imatrix 校准的 2-bit 量化版本运行速度为 18 tokens/s，KV 缓存仍有大量空闲空间（模型占用 304 GB）。

你也可以按以下方式查询服务器。欢迎查阅 API 参考了解多模态、工具调用等更多信息。


## text-only inference
curl http://localhost:8080/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Write a limerick about python exceptions"}
        ]
    }'

## image-text inference
curl -s http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" -H "Authorization: Bearer <your-key>" \
  -d '{"model":"muse-spark-open","messages":[{"role":"user","content":[
        {"type":"text","text":"What is in this image?"},
        {"type":"image_url","image_url":{"url":"data:image/png;base64,..."}}
      ]}],"temperature":0}'

## audio-text inference
curl -s http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" -H "Authorization: Bearer <your-key>" \
  -d '{"model":"muse-spark-open","messages":[{"role":"user","content":[
        {"type":"text","text":"Transcribe this audio."},
        {"type":"input_audio","input_audio":{"data":"data:audio/wav;base64,..."}}
      ]}],"temperature":0}'

llama.cpp 团队提供了不同的量化版本。我们已在 Apple Silicon 芯片上测试了 Q2_K、Q4_K_S 和 Q_8。你可以通过添加量化 ID 作为后缀来运行每个量化版本，llama serve -hf ggml-org/Muse-Spark-Open-816B-A42B:Q2_K。

SGLang

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

在 SGLang 集成环境中，从 Hugging Face Hub 下载检查点并启动服务器：

export MODEL_ID=meta-models/Muse-Spark-Open-816B-A42B-NVFP4
export CKPT="$(hf download "$MODEL_ID")"

SGLANG_FLASHINFER_NVFP4_PER_TOKEN_ACTIVATION=1 \
uv run sglang_meta serve \
  --model-path "$CKPT" \
  --served-model-name "$MODEL_ID" \
  --quantization modelopt_fp4 \
  --moe-runner-backend flashinfer_trtllm \
  --tp-size 4 \
  --ep-size 4 \
  --chat-template "$CKPT/muse_spark_1_2_oss.jinja" \
  --port 30000

检查点包含聊天模板，我们显式传递了它。启动器配置了 Muse 推理和工具调用解析器。

通过 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

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

安装参考插件及其依赖项后，从 Hugging Face Hub 下载检查点并启动服务器：

export MODEL_ID=meta-models/Muse-Spark-Open-816B-A42B-NVFP4
export CKPT="$(hf download "$MODEL_ID")"

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 \
VLLM_PLUGINS=musespark1x_models,ptq_nvfp4 \
vllm serve "$CKPT" \
  --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 的服务上下文。插件提供模型实现、检查点加载器以及推理和工具调用解析器。

使用相同的 Hub 模型 ID 发送请求：

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
  }'

MLX

Muse Spark Open 目前可在 oMLX 和 mlx-lm 中使用。针对 oMLX 优化的 oQ 量化版本有 3-bit 和 4-bit 两种，可立即使用。

我们在 M3 Ultra (512 GB) 上测试了 oQ3e 量化版本。模型占用约 344 GB，为 KV 缓存留出了空间，在 1024 token 提示词和 128 个生成 token 的情况下，预填充速度约为 225 tok/s，生成速度约为 21 tok/s。

通过 oMLX 界面下载模型后，你可以在内置的聊天 UI 中与其聊天。从聊天 UI 中，你可以添加图像并随时调整推理努力程度，从 low 到 xhigh。模型的推理显示为可折叠的思考块，与最终答案分开。

请注意，无法关闭推理，默认设置（Auto）使用 xhigh。如果你希望在较简单的任务上使用更少的 token，请将其设置为“low”。

该语言模型也可在官方 mlx-lm 仓库的此 PR 中找到。你可以像这样使用相同的高质量 oQ3e 量化版本运行它：

mlx_lm.generate --model mlx-community/Muse-Spark-Open-816B-A42B-oQ3e \
  --prompt "Explain convolutional networks like I am 5" \
  --max-tokens 5000

这是一个大模型，如上所述，即使是 3-bit 量化也需要超过 256 GB 的内存。你也可以在多台计算机上运行分布式推理，详情请参阅文档。

使用推理端点部署 Muse Spark Open

你可以在推理端点上部署 Muse Spark Open，使用针对 NVFP4 变体预先验证的 SGLang 配方，该配方可以在 8 × NVIDIA RTX Pro 6000 98 GB 上运行，上下文长度为 131072，或者如果你想要 1048576 的上下文长度，可以使用 8 x NVIDIA H200 141GB。

要部署，请使用 Hugging Face CLI 运行一条命令：

hf endpoints catalog deploy --repo meta-models/Muse-Spark-Open-816B-A42B-NVFP4 --name muse-spark

或者打开 endpoints.huggingface.co/new/meta-models/Muse-Spark-Open-816B-A42B-NVFP4 并选择 Create Endpoint。

该端点暴露了一个 OpenAI 兼容的 API，Chat Completions API 位于 /v1/chat/completions，Responses API 位于 /v1/responses。

curl "https://<your-endpoint>.endpoints.huggingface.cloud/v1/chat/completions" \
  -H "Authorization: Bearer $HF_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-models/Muse-Spark-Open-816B-A42B-NVFP4",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "image_url", "image_url": {"url": "https://huggingface.co/datasets/merve/vl-test-suite/resolve/main/pills.jpg"}},
        {"type": "text", "text": "Do any of the components in this supplement interact?"}
      ]
    }],
    "chat_template_kwargs": {"enable_thinking": false}
  }'

任何 OpenAI 兼容的客户端都可以使用相同的 URL 和你的 Hugging Face token 作为 API 密钥。

使用 TRL 进行微调 Quentin Gallouédec Ben Burtenshaw

你可以使用 TRL SFTTrainer 对完整的 816B 检查点进行微调。本节展示了我们如何在 8 个节点、每个节点 8 个 H100 GPU 上使用 TRL 对完整的 816B 检查点进行微调。该配方在注意力层上训练 LoRA 适配器。专家层保持冻结。完整脚本位于 TRL 示例中

首先，我们需要将模型拆分到 64 个 GPU 设备上。鉴于模型体积庞大，我们需要在多个维度上进行并行化。我们使用 DistributedConfig 对张量、数据和专家进行并行化，它告诉 transformers 在加载时如何拆分模型：

from transformers.distributed import DistributedConfig


distributed_config = DistributedConfig(fsdp_size=64, ep_size=8)

在上面的代码片段中，fsdp_size=64 使用 FSDP2 将模型分片到所有 64 个 GPU 上，而 ep_size=8 将每层的 256 个专家分成 8 组。Transformers 将每个 token 发送到持有其专家的 GPU，因此每个 GPU 都在批次的自己切片上进行训练

现在，我们可以为训练运行配置 SFTConfig。这里我们执行了一个简单的任务，在一个开源数据集上适配模型的聊天模板，但你也可以将其应用于自己的用例。


import torch
from datasets import load_dataset
from peft import LoraConfig
from trl import SFTConfig, SFTTrainer

train_dataset = load_dataset("allenai/tulu-3-sft-mixture", split="train[:500000]")

training_args = SFTConfig(
    output_dir="muse-spark-lora-sft",
    model_init_kwargs={"dtype": torch.bfloat16, "distributed_config": distributed_config},
    per_device_train_batch_size=1,
    max_steps=500,
    max_length=2048,
    packing=True,
    save_only_model=True,
    logging_steps=1,
    report_to="trackio",
)

trainer = SFTTrainer(
    model="meta-models/Muse-Spark-Open-816B-A42B",
    args=training_args,
    train_dataset=train_dataset,
    peft_config=LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj", "k_proj", "v_proj", "o_proj"]),
)
trainer.train()

这里的核心部分是 packing=True，它将示例连接成 2048-token 的序列，没有填充。块对角掩码保持示例的独立性。save_only_model=True 保存适配器且不保存优化器状态，因为训练器无法恢复在加载时分片的模型。LoraConfig 针对四个注意力投影，而每层的 256 个专家保持冻结。

然后我们可以在每个节点上运行此命令：

torchrun --nnodes 8 --nproc_per_node 8 --rdzv_backend c10d --rdzv_endpoint "$MASTER_IP:29700" sft_muse_spark.py

我们训练了 500 步，在 64 个 H100 上耗时约 2 小时，速度约为每秒 8,000 tokens。平均 token 准确率从 72% 上升到 84%，损失从 1.26 下降到 0.57，这表明微调运行良好。

演示

Muse Spark Open 是一个编码和智能体模型。我们想亲自验证这一点，因此尝试了使用模型图像和音频输入的多模态和智能体任务混合。以下所有内容都可以运行或 fork。

3D 资产生成器

我们将 2-bit 量化的 Muse Spark open（在 llama.cpp 上提供服务）与 Pi 编码智能体结合，在 Three.js 中生成并迭代改进 3D 资产。你可以在这里找到提示词，由于模型经过量化，它需要更多的引导。在 Mac Ultra 上的 llama.cpp 上我们获得 18 TPS。

我们首先描述该资产，然后 Pi 使用该模型为资产生成 Three.js 代码，在浏览器中渲染结果，并从多个角度截取屏幕截图。接着，它将这些图像发送回 llama server 上的同一模型以获取视觉反馈。Pi 利用该反馈编辑代码并重复此过程。

使用 OpenEnv 和 Hugging Face 沙盒进行浏览器交互

我们在计算机使用任务上测试了 Spark，对其性能印象深刻，因此构建了一个精简的演示，同时也用于教你了解计算机使用智能体是如何工作的。你还可以根据自己的需求进一步定制它。这既是一个教育示例，也是一个只需几行代码即可运行的项目。你可以在这里找到它。

使用 OpenEnv 和 HF 沙盒的 Muse Spark NVFP4 浏览器智能体

Hugging Face 沙盒是构建在 Hugging Face Jobs 之上的沙盒，用于轻松执行代码。该演示由三个组件组成：

通过推理端点提供的 Muse Spark Open，
OpenEnv 使用 helium 和 selenium 封装 web 驱动程序操作（点击、输入、滚动等），定义浏览器环境的重置、步骤、观察和终止接口，
Chromium 网络浏览器

远程沙盒包含环境和浏览器，如下图所示。

你可以按照示例中描述的步骤轻松尝试。使用 Muse Spark Open 启动推理端点（NVFP4 效果也很好！），将你的端点 URL 添加为环境变量，在 Spaces 中发布你的 OpenEnv 服务器并提供该地址，然后你就可以运行智能体循环了。 Muse Spark Open 会查看之前的操作、系统提示词、URL 以及浏览器截图以采取操作，除此之外没有其他信息（没有 DOM，没有 HTML 代码，什么都没有），因此这是一个真正的多模态浏览器演示。

调用你的浏览器

最后，我们希望将 Spark 的智能体多模态能力推向极限，因此我们设置了这个空间，将模型的音频、图像和智能体特性结合到一个浏览器智能体中。我们给模型一个关于所需事物的通用描述，它会与集成的浏览器交互，在 Amazon 上寻找选项。

Muse Spark Open 接收语音输入，推理出符合描述的产品类型，在 Amazon 上搜索，并根据标准选择最合适的产品。

总结

Muse Spark Open 是 Muse 系列的全尺寸开放权重模型。从BF16或NVFP4检查点开始，或尝试其中一个优秀的llama.cpp quants。如果你使用 Muse Spark Open 构建了某些东西，请分享它，并在仓库的讨论区告诉我们。