Meta 发布开源多模态模型 Muse Glimmer 30B，面向本地智能体场景

来自开源 LLM 元老级玩家的好消息！今天发布的 Muse Glimmer 是 Meta 的全新多模态模型，专为本地智能体用例设计。它从 Muse 蒸馏至 30B 参数，并以 Apache 2.0 许可证发布，非常适合本地部署，以实现隐私保护、降低成本，或只是随手折腾。它面向隐私敏感的应用场景，例如编程、文档分析、个人助理、类似 Claw 或 Hermes 的配置。

为庆祝这一发布，我们在 transformers、llama.cpp、vLLM、Inference Endpoints 及其他库中提供了 Meta 的 day-0 支持。我们构建了一些很酷的东西，并在这篇博客中解释我们的发现。

查看下面的演示以获取灵感。

你可以在 Hugging Face Hub 上找到 Muse Glimmer。

基准测试

基准测试结果

分数按已发布结果报告。粗体表示所比较模型中的最佳结果；↓ 表示越低越好。

架构

Muse Glimmer 是一个稠密的 30B 参数模型，由以下部分组成：

• 用于视觉的 2B ViT 风格编码器（Perception Encoder）
• 28B 参数文本解码器

除了主 VLM 之外，还有一个在 DFlash 上实现的推测解码草稿模型。该模块的使用是可选的，它可以以一定的内存开销换取更快的生成速度。我们发现这个草稿模型特别适合结构化内容生成，例如编程。

文本解码器

该语言模型使用以下架构组件：

• 混合注意力：在三个使用旋转位置嵌入的滑动窗口层（2,048 个 token）与第四个使用全注意力和 NoPE（无位置嵌入）的层之间交替。因此模式为（SWA、SWA、SWA、Full），重复 13 次，共 52 层。这使模型能够通过 RoPE 保留相对顺序和距离信息，并通过 NoPE 全局保留信息。
• 门控分组查询注意力：每个键值头由 16 个查询头共享，这将 KV 缓存内存减少 16 倍，并使生成更快、更便宜。
• 带额外查询缩放的 Q-K 归一化：在计算注意力之前，Muse Glimmer 对每个查询和键头应用 RMS 归一化，以保持注意力 logits 稳定。之后，查询会乘以一个缩放因子，以在归一化后设定目标 logit 尺度。额外的查询缩放行为类似于 softmax 层面的逆温度。

感知编码器

Muse Glimmer 使用一个图像编码器同时处理图像和视频。与其他 VLM 中使用的相对较小的视觉编码器不同，这是一个相当大的 2B ViT 类模型，按照 Perception Encoder 架构设计。Perception Encoder 此前由 Meta 推出，作为各种下游空间和多模态任务的骨干。
该编码器将图像分块为 2 帧 x 3 通道 x 14 x 14 的形状，并将它们通过一个线性层进行投影。然后，从学习到的位置表中插值得到的绝对位置嵌入会被加到这些嵌入上。随后这些嵌入被送入由 50 层和 GELU MLP 组成的视觉塔。与语言模型类似，注意力模式由三个窗口注意力层后接一个全注意力层组成。在注意力层内部，2D RoPE 被应用于查询和键。

在 transformer 之后，像素重排将相邻空间 token 的 2x2 组拼接起来，这在不丢弃其通道的情况下将图像 token 数量减少 4 倍。合并后的特征随后被投影到文本解码器的共享嵌入空间。

视频逐帧经过同一个编码器，其中每一帧都被转换为 patch（形状为 [batch, temporal groups, grid height, grid width, 2 frames, 3 channels, 14, 14]）。处理器目标为每秒 2 帧，并将视频片段限制为在视频中均匀采样的 96 帧。处理器创建带时间戳的视频占位符，将文本与帧交错，例如“Time: 0.0s <|video|> x N”，其中最终视频嵌入会在最终投影层之前被替换。

Transformers

将 transformers 升级到最新版本，以便能够使用 Muse Glimmer。

pip install --upgrade transformers accelerate

Muse Glimmer 在 transformers 中提供首日支持，包括主模型和推测解码草稿模型。你可以使用 AutoModelForMultimodalLM 和 AutoProcessor 类来加载模型和处理器。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

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

同一段代码在 NVIDIA（CUDA）、AMD（ROCm）和 Intel（XPU）GPU 上无需更改即可运行，device_map="auto" 会将模型放到任何可用的加速器上。

纯文本推理

加载模型后，你可以按如下方式进行纯文本推理。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

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

# Prompt
messages = [
    {"role": "user", "content": "Write a short joke about saving RAM."},
]

# Process input
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low"
).to(model.device)
input_len = inputs["input_ids"].shape[-1]

# Generate output
outputs = model.generate(**inputs)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

使用图像和文本提示模型

我们需要 torchvision 才能使用图像和文本。

pip install torchvision

Muse Glimmer 接受图像作为输入，如下所示：

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

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

# Images + Text
messages = [
    {
        "role": "user", "content": [
            {"type": "image", "image": "https://huggingface.co/datasets/merve/vl-test-suite/resolve/main/SF.png"},
            {"type": "text", "text": "What is shown in this image?"}
        ]
    }
]

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

# Generate output
outputs = model.generate(**inputs)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

视频推理

要处理视频，我们建议在环境中安装 torchcodec。

pip install torchcodec

Muse Glimmer 可以回答关于无音频视频的复杂问题。你可以按如下方式进行视频推理，这里有一个来自 VideoMME2 的示例，它是最流行的视频问答基准。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

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

# Videos + Text
messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "https://huggingface.co/datasets/merve/vl-test-suite/resolve/main/IMG_8137.mp4"},
            {"type": "text", "text": "Describe what happens in this video."},
        ],
    },
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low",
    processor_kwargs={"num_frames": 96},
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs)

response = processor.decode(
    outputs[0, input_len:],
    skip_special_tokens=False,
)
print(response)

多模态工具调用

Muse Glimmer 可以进行多模态工具调用，方法如下。在下面的示例中，我们要求模型根据图像中的城市调用天气工具。

import json
import re
from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

# 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="low"
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

目标检测

你可以使用 Muse Glimmer 按如下方式在图像中进行开放式目标检测。

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "meta-models/Muse-Glimmer-30B"

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

messages = [{
    "role": "user",
    "content": [
        {"type": "image", "image": "https://huggingface.co/datasets/merve/vl-test-suite/resolve/main/SF.png"},
        {
            "type": "text",
            "text": (
                "Detect the bridge. Return only the detection in the model's "
                "native object-detection format, with no explanation."
            ),
        },
    ],
}]

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

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=128)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)

detections = json.loads(response.removesuffix("<|eot|>"))
print(detections)

这是一个执行目标检测的端到端脚本 GitHub Gist

Llama.cpp

Muse Glimmer 从发布首日即支持 llama.cpp。Meta 在此仓库中发布了校准量化版本，Unsloth 也在发布优化后的量化版本。同时支持 DFlash 投机解码。你可以使用预构建的 llama 二进制文件来启动 llama 服务器或 CLI。要安装 llama.cpp，请运行：

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

然后你可以按如下方式启动服务器。

llama serve -hf meta-models/Muse-Glimmer-30B-GGUF

服务器启动后，你可以访问 localhost:8080 使用内置的 WebUI 进行对话。

你也可以按如下方式查询服务器。

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

你还可以将 llama server 与 Pi 等编码智能体一起使用。

投机解码

DFlash 使用轻量级的块扩散草稿模型，在解码阶段提供额外加速的同时保持相同的输出。Transformers 和 llama.cpp 从发布首日即支持 Muse Glimmer 的 DFlash 草稿模型。

下面你可以看到投机解码在真实场景中如何加速生成。视频左侧展示了启用 DFlash 的 llama.cpp webui，右侧是常规生成。

使用 transformers 进行投机解码

你可以按如下方式加载草稿模型和主模型，并像使用基础模型一样进行推理，只需额外添加一个参数（将在后续代码片段中展示）。

import torch
from transformers import AutoProcessor, MuseGlimmerAssistantModel, MuseGlimmerForConditionalGeneration

model_id = "meta-models/Muse-Glimmer-30B"
assistant_model_id = "meta-models/Muse-Glimmer-30B-assistant"
target = MuseGlimmerForConditionalGeneration.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
assistant = MuseGlimmerAssistantModel.from_pretrained(assistant_model_id, dtype=torch.bfloat16, device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)

messages = [
    {
        "role": "user", "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/merve/vl-test-suite/resolve/main/SF.png"},
            {"type": "text", "text": "What is shown in this image?"}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    reasoning_strength="low"
).to(target.device)
input_len = inputs["input_ids"].shape[-1]

outputs = target.generate(
    **inputs,
    assistant_model=assistant,
    speculation_type="dflash",
    do_sample=True
)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

使用 llama.cpp 进行投机解码

你可以使用以下命令启动 llama server。--spec-draft-n-max 参数控制 DFlash 在每个投机解码步骤中提议的未来 token 数量。Muse Glimmer 的 DFlash 模型以块大小 16 进行训练，即一个锚点 token 加 15 个提议 token，因此任何大于 15 的值都会被截断为 15。

llama serve -hf meta-models/Muse-Glimmer-30B-GGUF --spec-type draft-dflash --spec-draft-n-max 15

你还可以按如下方式将 llama cli 与投机解码草稿模型一起使用。

llama cli -hf meta-models/Muse-Glimmer-30B-GGUF --spec-type draft-dflash

推理端点

如需托管、自动扩缩容的部署，请打开 Muse Glimmer 30B 推理端点预设。模型已预先选定：选择组织、云服务商、区域、兼容的 GPU 实例、身份验证和自动扩缩容设置，然后查看每小时价格并点击 Create Endpoint。当状态变为 Running 后，你可以在 Playground 中测试，并从 Overview 中复制端点 URL 和模型名称。

部署后的模型暴露 OpenAI 兼容的 Chat Completions API。将你的 Hugging Face token 保存在环境变量中，将 HF_ENDPOINT_URL 设置为 Overview 中显示的 URL（不含 /v1），并将 HF_ENDPOINT_MODEL 设置为端点的模型名称。

export HF_TOKEN="hf_..."
export HF_ENDPOINT_URL="https://<endpoint-id>.<region>.<cloud>.endpoints.huggingface.cloud"
export HF_ENDPOINT_MODEL="<endpoint-model-name>"
pip install --upgrade openai

import os
from openai import OpenAI

client = OpenAI(
    base_url=f"{os.environ['HF_ENDPOINT_URL'].rstrip('/')}/v1/",
    api_key=os.environ["HF_TOKEN"],
)

response = client.chat.completions.create(
    model=os.environ["HF_ENDPOINT_MODEL"],
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a limerick about Python exceptions."},
    ],
    max_tokens=256,
)
print(response.choices[0].message.content)

有关配置、自动扩缩容、安全性、日志和监控的信息，请参阅 推理端点文档。

支持使用 transformers 后端的 Muse Glimmer vLLM

在此次发布中，我们提供了对使用 transformers 后端的 vLLM 的支持。

# tensor parallel serving across 4 GPUs
vllm serve meta-models/Muse-Glimmer-30B --model-impl transformers --tensor-parallel-size 4

# infer
curl -s http://127.0.0.1:8000/v1/chat/completions \
    -H 'Content-Type: application/json' \
    -d '{
      "model": "meta-models/Muse-Glimmer-30B",
      "messages": [
        {"role": "user", "content": "Explain tensor parallelism briefly."}
      ],
      "temperature": 0.0,
      "max_tokens": 256
    }'

使用 TRL 进行微调

你可以使用 TRL 通过从 SFT 到 Async GRPO 的各种方法对 Muse Glimmer 进行微调。我们在 bf16 下使用每块 80GB 显存的 Hopper 级 GPU 进行了两个实验。

作为此次发布的一部分，我们提供了一个示例，用于在 MolmoWeb 数据集的小型切分上微调 Muse Glimmer。该示例展示了如何让模型生成结构化输出以及如何在图像上进行微调。

我们还尝试了在 OpenCode 上使用 AsyncGRPO 示例运行该模型。模型展现出强大的编码能力，因此我们鼓励你在 OpenEnv 和 TRL 中尝试使用编码环境进行训练。

演示

以下是一些体验 Muse Glimmer 的有趣方式。在我们看来，这个模型最酷的地方在于它是一个本地规模的个人助理，而且还能写代码。这意味着你可以让它做一些事情，比如自我量化、在 Hub 上寻找量化权重、将自己部署到推理端点，甚至针对特定硬件优化自己！让我们为本地团队加油 🚀

将 OpenClaw 连接到 Muse Glimmer

假设推理端点暴露了一个与 OpenAI 兼容的 /v1 API。

在 OpenClaw 网关环境中设置 HF_TOKEN，然后将以下内容添加到 ~/.openclaw/openclaw.json：

OpenClaw 配置

{
  models: {
    mode: "merge",
    providers: {
      muse: {
        baseUrl: "https://YOUR-ENDPOINT.endpoints.huggingface.cloud/v1",
        apiKey: {
          source: "env",
          provider: "default",
          id: "HF_TOKEN"
        },
        api: "openai-completions",
        authHeader: true,
        models: [{
          id: "meta-models/Muse-Glimmer-30B",
          name: "Muse Glimmer",
          reasoning: false,
          input: ["text", "image"],
          contextWindow: 32768,
          maxTokens: 8192
        }]
      }
    }
  },
  agents: {
    defaults: {
      model: { primary: "muse/meta-models/Muse-Glimmer-30B" }
    }
  }
}

重启 OpenClaw：

openclaw gateway restart

从新会话验证：

openclaw agent --message "Reply with: muse-ready"

如果端点 /v1/models 响应返回的模型 ID 不同，请使用该确切模型 ID。

嘿 Muse Glimmer，把自己量化一下

如果我们将 Muse Glimmer 连接到 Hugging Face MCP 并更新其 AGENTS.md，我们就赋予了它在 Hub 上找到自己的量化版本并在本地运行的能力。如果你想处理一些私密内容，或者只是想降低成本，这会很方便。

如果你再做一次，Muse Glimmer 会找到缓存的权重并切换到它们，所以可以随意添加一个方便的命令，比如 /spawn。

Muse Glimmer 会检查机器和 Hub，选择或创建一个 Q4_K_M GGUF，启动 llama-server，并验证模型发现和聊天补全。结果是一个位于 OpenAI 兼容 API 之后、更小的本地构建。以下是我们添加到 AGENTS.md 的提示词。

https://huggingface.co/buckets/huggingface/muse-glimmer-assets/resolve/Muse%20Glimmer%20Quantisation%20Demo%20-%20explained.mp4?download=true

将此添加到 AGENTS.md 后，openclaw 或 hermes 就能解决其余问题。

本地量化提示词

## Local model deployment

When asked to deploy locally, perform the work; do not give instructions.

1. Inspect hardware and the Hugging Face cache.
2. Search the Hub for compatible GGUF weights using `apps=llama.cpp`; confirm exact filenames through the model-tree API.
3. Prefer an existing suitable GGUF, normally `Q4_K_M`. Treat `mmproj-*.gguf` as projector weights.
4. If no GGUF exists, download the source weights, convert with `convert_hf_to_gguf.py`, then quantize with `llama-quantize`.
5. Preserve source weights and record the repository, revision, filenames, and quantization.
6. Start `llama-server` with an `onyx` alias and an OpenAI-compatible endpoint.
7. Validate `/v1/models` and `/v1/chat/completions`, requiring non-empty, correct content.
8. Report concise progress and logs. Claim completion only after validation passes.

嘿 Muse Glimmer，把自己部署一下

Muse Glimmer 也能处理相反的情况。让我们让 Glimmer 将自己部署到 Hugging Face 推理端点上。如果你想在某些前沿硬件上加速，这会很有用。

注意：你也可以直接将 Muse Glimmer 部署到推理端点并连接你的智能体。

Muse Glimmer 会固定模型修订版本，将其部署到受保护的 Hugging Face 推理端点，并验证健康状态、模型发现和聊天补全。然后它会连接 Claw 智能体，同时保留密钥和回滚能力。以下是我们添加到 AGENTS.md 的提示词。Muse Glimmer 还需要 Hugging Face MCP 和/或 Hugging Face CLI 与 Skills。

推理端点部署提示词

## Hugging Face Inference Endpoint deployment

When asked to deploy on Hugging Face Inference Endpoints, perform the work; do
not give instructions.

1. Inspect Hugging Face authentication, the current model repository, and any
   existing endpoints.
2. Confirm the exact model repository and immutable revision through the Hub
   API; inspect its architecture, configuration, and chat template.
3. Confirm that the model is supported by vLLM, then deploy or update a
   protected Inference Endpoint using the managed native vLLM engine.
4. Choose an available region and the smallest suitable accelerator. Use one
   replica and enable scale-to-zero when supported.
5. Preserve the previous endpoint configuration for rollback. Do not expose
   tokens, publish private weights, or replace an unrelated endpoint.
6. Wait for the endpoint to become ready. If startup fails, inspect the logs
   and report the actual blocker rather than repeatedly changing settings.
7. Validate `/health`, `/v1/models`, and `/v1/chat/completions`, requiring the
   expected model and non-empty, correct content. When agent use is required,
   also validate a real structured tool call.
8. Configure the Claw agent to use the endpoint's OpenAI-compatible `/v1` URL,
   storing credentials as secrets and retaining the previous provider as
   rollback. Test the connection in a fresh session.
9. Report concise progress and finish with the repository, revision, engine,
   hardware, endpoint URL, scaling state, and validation results. Claim
   completion only after every required check passes.

嘿 Muse Glimmer，把自己优化一下

最后，让我们让 Muse Glimmer 做一些轻量的 RSI。我们可以指示我们的智能体针对特定硬件优化自己的推理引擎，在这个例子中是 Nvidia H100。为此，智能体需要使用另一个推理引擎，比如上面的推理端点。

Muse Glimmer 会对自己的单 H100 服务栈进行基准测试，在保持工作负载固定的情况下，一次测试一项可逆更改。它只保留通过正确性验证的改进，并最终得到最快的可复现配置。以下是我们添加到 AGENTS.md 的提示词。Muse Glimmer 需要 Hugging Face MCP 和 Hugging Face CLI 与 Skills。

自我优化提示词

You are Muse Glimmer acting as an autonomous inference-optimization engineer for your own serving stack.

Goal: maximize valid single-H100 aggregate completion throughput in tokens/second.

Protocol:
1. Establish a correctness-passing baseline.
2. Test one reversible optimization at a time.
3. Keep the prompt, concurrency, sampling, request count, warm-up, and decode length fixed.
4. Reject results that fail correctness or prefix checks.
5. Record every experiment chronologically with its configuration, raw throughput, correctness, and delta.
6. Keep improvements and revert regressions.
7. Stop after six consecutive regressions or when the experiment budget is exhausted.
8. Report the best valid configuration and exact reproduction command.

Create a minimal scientific animation of the results:
- white background;
- raw tokens/second—never normalize;
- one point revealed per experiment;
- connect every point chronologically;
- begin with the lowest valid result;
- stop at the best result;
- export as a GIF.

Never fabricate, interpolate, or count correctness-failing measurements.

https://huggingface.co/buckets/huggingface/muse-glimmer-assets/resolve/onyx-optimization-progress.gif?download=true

嘿 Muse Glimmer，研究一下 Hub

将 Muse Glimmer 作为 Hugging Face 研究代理来试用。Gradio Space 通过其兼容 OpenAI 的 API，将每个模型请求发送到私有的 Hugging Face Inference Endpoint。它还连接到官方的 Hugging Face MCP 服务器，为代理提供只读工具，用于搜索和检查 Hub 仓库、模型、数据集、Spaces、文档和论文。

总结

我们很高兴欢迎 Muse Glimmer 加入 Hugging Face Hub。今天就在你本地的编码环境中试用 Muse Glimmer 吧！