Meta 發佈開放權重多模態混合專家模型 Muse Spark Open

Muse Spark Open 是 Meta 推出的開放權重模型。這個混合專家模型將文字、圖像、音訊和影片整合至同一模型，總參數約 8,160 億，每個 token 約啟用 420 億個參數，上下文視窗最長可達 100 萬個 tokens。模型會生成文字，為開發者提供統一介面，讓他們就不同類型的輸入提問。

繼 Muse Glimmer 之後，Muse Spark Open 以大得多的規模引入混合專家架構，並成為迄今能力最強的美國開放權重模型。

Meta 為 Agentic 編碼訓練 Muse Spark Open：讀取程式碼庫、編寫和除錯程式碼，以及呼叫工具。它亦可接收圖像、音訊和影片輸入，因此同一模型在處理程式碼時，可以讀取螢幕截圖、聆聽語音備忘錄，或觀看螢幕錄影。本文會示範如何執行和微調模型，以及我們以它構建的內容。

整體能力與架構

Meta 表示，Muse Spark Open 是一款經過編碼最佳化的模型，訓練資料涵蓋多檔案重構和長時間除錯等開發者實際工作流程。Muse Spark Open 是一款以 Agent 工作為核心的模型，能在長時間任務中規劃、執行、觀察並自行修正，包括以圖像瀏覽網頁。

功能	Muse Spark Open
模型規模	總參數約 816B；每個 token 約啟用 42B
專家路由	每個 MoE 層有 256 個專家；每個 token 選取 8 個
輸入	文字、圖像、音訊和影片
輸出	文字
上下文視窗	最長 1M tokens
檢查點格式	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 中，輸入嵌入層和輸出層是兩個獨立矩陣，各約有 1.66B 個參數。

混合專家

語言模型有 62 層，隱藏維度為 8192。每層有 128 個查詢頭和 16 個鍵值頭（羣組查詢注意力）。每個注意力頭的維度為 64。注意力區塊設有輸出閘門和輸出正規化層。模型亦會對查詢和鍵進行正規化（QK-norm）。每個區塊透過經學習的殘差閘門結合輸入和輸出，而非直接相加。

Muse Glimmer 在每層使用一個密集前饋網絡。Muse Spark Open 則以混合專家（MoE）區塊取代這個密集網絡。每個 MoE 區塊有 256 個專家，路由器會為每個 token 選取 8 個專家。每個專家都是一個前饋網絡，會將維度由 8192 投影至 4096，再投影回 8192，然後對輸出套用專屬的正規化。專家網絡佔模型總參數約 97%。

每個詞元只會啟用 8 個專家，因此模型每次計算一個詞元時，約會用到 42B 個參數。全部 256 個專家都會留在記憶體中，因此部署所需的記憶體相當於 816B 參數模型，但運行速度快得多，相當於 42B 模型的速度。BF16 檢查點採用 safetensors 格式，大小約為 1.5 TB。NVFP4 檢查點以 4 位元精度儲存參數，精確度損失極小，專為 NVIDIA Blackwell GPU 設計。在 transformers 中，BF16 檢查點使用張量平行（TP=32），橫跨 4 個各配備 8 張 H200 GPU 的節點運行；NVFP4 則在單一 B200 節點上運行。若要部署 Muse Spark Open，請參閲下方的 llama.cpp、vLLM 和 SGLang 配置範例。

感知編碼器

感知編碼器會將圖像和影片影格轉換成供語言模型使用的詞元，與 Muse Glimmer 的做法相同。編碼器有 1.8B 個參數、50 層、1536 的隱藏維度，以及 16 個注意力頭。它會將每張圖像分割成 14×14 個圖塊，並產生維度為 4096 的特徵。位置資訊來自學習式絕對嵌入和 2D RoPE。每層的前饋網絡使用 LayerNorm 和 GELU。每隔 4 層及最後一層使用完整注意力，其餘層則使用稀疏注意力。

Muse Glimmer 30B 使用相同架構的編碼器。這項設計參考了 Meta 的感知編碼器研究。影片輸入會與圖像一樣，經過同一個編碼器處理。

音訊編碼器

Muse Spark Open 透過音訊編碼器接受音訊輸入。音訊分詞器會將音訊轉換成詞元，而聊天範本會以 <|audio|> 詞元標示音訊位置。編碼器每 80 ms 輸出一個音訊詞元，即每秒 12.5 個詞元。例如，假設音訊長 10 秒，輸入音訊詞元數量便會是 125。編碼器本身是一個卷積金字塔，每個階段都由一個採用不同圖塊尺寸的圖塊嵌入器，以及 2 個卷積區塊組成；卷積區塊使用大小為 7、步幅為 1 的 1d 卷積核。這些階段會按 [16, 6, 5, 4] 的圖塊尺寸重複排列。最後一個階段結束時，時間影格會輸入最終區塊，依序經過 RMSNorm → 線性投影 → RMSNorm。

長上下文

推理時的上下文視窗為 1M 個詞元。設定會將 max_position_embeddings 設為 1,048,576。此視窗會同時容納圖像、影片和音訊詞元，以及文字詞元。

分組查詢注意力可讓這種規模的模型維持較小的 KV 快取。每個詞元會為快取增加 2 × 16 個注意力頭 × 64 個維度 × 62 層 = 126,976 個值。以 BF16 儲存時，每個詞元約佔 250 KB，完整的 1M 詞元上下文則約佔 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 使用以 channel 為基礎的聊天範本（Harmony，最初由 gpt-oss 引入）。請注意，你不必瞭解其內部運作方式，但如果輸出品質較低，查看模型路由至的 channel 會有幫助。以下輸入訊息中：

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

在 Llama Server 上執行的 Muse Spark 2-bit

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 用量，請將模型的推理強度設為「low」。
我們在 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

Muse Spark Open 的 SGLang 整合支援文字、圖片、音訊和影片輸入。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

Muse Spark Open 的 vLLM 參考整合支援文字和圖片輸入，並使用需要 Blackwell 系列 GPU 的 NVFP4 檢查點。

安裝參考外掛及其相依項目後，從 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 時，預填速度約為 [000] tok/s，生成速度約為 [00] tok/s。

透過 oMLX 介面下載模型後，你可以在內置聊天介面中與它對話。你可以在聊天介面中加入圖片，並即時調整推理力度，從 low 到 xhigh。模型的推理過程會顯示為可摺疊的思考區塊，與最終答案分開。

請注意，Muse Spark Open 無法關閉推理功能，而預設設定（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 RAM。你也可以在多部電腦上進行分散式推理，詳情請參閲文件。

使用 Inference Endpoints 部署 Muse Spark Open

你可以使用適用於 NVFP4 版本、經預先驗證的 SGLang 配置，在 Inference Endpoints 上部署 Muse Spark Open。此配置可在 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，包括位於 /v1/chat/completions 的 Chat Completions API，以及位於 /v1/responses 的 Responses API。

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 相容的用戶端都可以使用相同網址，並以你的 Hugging Face token 作為 API 金鑰。

使用 TRL 微調 Quentin Gallouédec Ben Burtenshaw

你可以使用 TRL SFTTrainer 微調完整的 816B 檢查點。本節將展示我們如何使用 TRL，在 8 個節點（每個節點配備 8 張 H100 GPU）上微調完整的 816B 檢查點。這個方案會在注意力層訓練 LoRA adapter，而專家保持凍結。完整指令碼位於 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 會儲存 adapter，但不儲存優化器狀態，因為 trainer 無法從載入時已分片的模型恢復訓練。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 個 token。平均 token 準確率由 72% 升至 84%，損失值則由 1.26 降至 0.57，顯示這次微調成效良好。

示範

Muse Spark Open 是一款程式編寫及 Agent 型模型。我們想親自了解它的能力，因此試用了多模態及 Agent 任務，運用模型的圖像及音訊輸入。以下每個項目都可以執行或 fork。

3D 資產產生器

我們將 2-bit 量化的 Muse Spark Open（透過 llama.cpp 提供服務）與 Pi coding agent 結合，在 Three.js 中生成並反覆改良 3D 資產。提示詞可在此處找到。由於模型經過量化，因此需要多一些引導。在 Mac Ultra 上使用 llama.cpp，速度可達 18 TPS。

我們首先描述這個物件，Pi 便使用模型為它生成 Three.js 程式碼，在瀏覽器中算繪結果，並從多個角度截取畫面。接着，Pi 會將這些圖片傳回 llama server 上的同一模型，取得視覺回饋。Pi 會根據回饋修改程式碼，並重複這個流程。

使用 OpenEnv 和 Hugging Face Sandbox 與瀏覽器互動

我們在電腦操作任務上測試 Spark，其表現令人驚喜，因此製作了一個精簡示範，讓你瞭解電腦操作 Agent 的運作方式。你也可以按自己的需要進一步自訂。這既是一個教學示例，也是一個只需幾行程式碼便可執行的工具。你可以在這裏找到它。

使用 OpenEnv 和 HF Sandboxes 的 Muse Spark NVFP4 瀏覽器 Agent

Hugging Face Sandboxes 是建基於 Hugging Face Jobs 的沙盒，方便執行程式碼。這個示範由三個部分組成：

透過 Inference Endpoints 提供服務的 Muse Spark Open，
OpenEnv 透過 helium 和 selenium 封裝網頁驅動程式操作（點擊、輸入、捲動等），並定義瀏覽器環境的重設、步驟、觀察及終止介面，
Chromium 網頁瀏覽器

如下圖所示，遠端沙盒內包含環境和瀏覽器。

你只需幾個步驟便可輕鬆試用，詳情載於示例中。使用 Muse Spark Open（NVFP4 也運作良好！）啟動 Inference Endpoint，將端點 URL 加入環境變數，在 Spaces 發佈 OpenEnv 伺服器並提供該伺服器，然後便可執行 Agent 迴圈。 Muse Spark Open 會根據先前的操作、系統提示詞、網址和瀏覽器截圖採取行動，不會取得其他資訊（沒有 DOM、HTML 程式碼或其他內容），因此這是一個真正的多模態瀏覽器示範。

呼叫你的瀏覽器

最後，我們希望盡量發揮 Spark 的 Agent 多模態能力，因此建立了這個 Space，將模型的音訊、圖像和 Agent 能力結合成一個瀏覽器 Agent。我們向模型簡單描述所需物品，模型便會與整合的瀏覽器互動，在 Amazon 尋找選項。

Muse Spark Open 會接收語音輸入，推理出符合描述的產品類型，在 Amazon 搜尋，並根據準則選出最合適的產品。

總結

Muse Spark Open 是 Muse 系列的全尺寸開放權重模型。你可以從 BF16 或 NVFP4 檢查點開始，或試用其中一個出色的 llama.cpp quants。如果你使用 Muse Spark Open 製作了作品，歡迎分享，並在儲存庫的討論區告訴我們。