Meta开源Muse Glimmer：本地运行、多模态、Agent化

为庆祝发布，我们在上线首日即为 transformers、llama.cpp、vLLM、Inference Endpoints 等库提供了 Meta 支持。我们在构建过程中实现了一些有趣的东西，并将研究发现在这篇博客中分享。以下是一些灵感演示，你可以直接在 Hugging Face Hub 上找到 Muse Glimmer 模型。

分数以发布版本为准。加粗表示对比模型中的最佳结果；↓ 表示越低越好。

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

2B ViT 风格的视觉编码器（Perception Encoder）

28B 参数量的文本解码器

除了主 VLM 模型外，还有一个基于 DFlash 实现的投机解码（speculative decoding）起草器。使用这个模块是可选的，它可以用一定的显存开销换取更快的生成速度。我们发现这个起草器特别适合编程等结构化内容生成任务。

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

混合注意力机制：交替使用三层滑动窗口注意力（每层 2048 个 token），采用旋转位置编码（rotary position embedding），随后是第四层使用全注意力并搭配 NoPE（无位置编码）的注意力层。因此模式为（SWA、SWA、SWA、Full），重复 13 次共 52 层。这种设计使得模型能够通过 RoPE 保留相对顺序和距离信息，同时通过 NoPE 在全局范围内保持信息传递。

门控分组查询注意力（Gated Grouped-Query Attention）：每个 key-value 头被 16 个查询头共享，这使 KV-cache 显存占用降低 16 倍，让生成速度更快、成本更低。

Q-K 归一化与额外查询缩放：在计算注意力之前，Muse Glimmer 对每个查询和 key 头应用 RMS 归一化，以保持注意力 logits 稳定。之后，查询会乘以一个缩放因子，以在归一化后设定目标 logit 缩放比例。额外的查询缩放在 softmax 层面表现得像一个逆温度（inverse temperature）参数。

Muse Glimmer 使用一个图像编码器同时处理图像和视频。与其他 VLM 中使用的相对较小的视觉编码器不同，这是一个参数量达 2B 的类 ViT 模型，架构基于 Perception Encoder。Perception Encoder 此前由 Meta 提出，作为各种下游空间任务和多模态任务的骨干网络。该编码器将图像 patchify 为 2 帧 × 3 通道 × 14 × 14 的形状，然后通过一个线性层进行投影。之后从可学习的位置表中插值得到绝对位置编码，并将其加到这些嵌入向量上。这些向量被送入由 50 层和 GELU MLP 组成的视觉塔（vision tower）。与语言模型类似，注意力模式由三个窗口注意力层和一个全注意力层组成。在注意力层内部，2D RoPE 被应用于查询和 key。

经过 transformer 后，像素洗牌（pixel shuffle）将相邻空间 token 按 2×2 分组拼接，将图像 token 数量减少 4 倍，同时不丢弃其通道信息。合并后的特征被投影到文本解码器的共享嵌入空间。

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

请升级 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"

# 加载模型
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" 会自动将模型放置在可用的加速器上。

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

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

# 处理输入
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=1024)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

我们需要安装 torchvision 才能使用图像和文本输入。

pip install torchvision

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

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]

# 生成输出
outputs = model.generate(**inputs, max_new_tokens=512)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
print(response)

Muse Glimmer 支持多模态工具调用，以下是具体用法。在下面的示例中，我们让模型根据图像中的城市调用天气工具。

import json
import re

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, max_new_tokens=128)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)

parsed = processor.tokenizer.parse_response(response)

你可以使用 Muse Glimmer 进行开放式目标检测，方法如下。

import json

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,
).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)
# [{"x_min": 0, "y_min": 390, "x_max": 520, "y_max": 603}]

注意需要将 X 和 Y 值按图像尺寸进行缩放才能可视化：

xyxy = (
    round(box["x_min"] / 1000 * width),
    round(box["y_min"] / 1000 * height),
    round(box["x_max"] / 1000 * width),
    round(box["y_max"] / 1000 * height),
)

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

pip install torchcodec

Muse Glimmer 可以回答有关无声视频的复杂问题。你可以按如下方式进行视频推理，以下是来自 VideoMME2 的示例，它是目前最流行的视频问答基准测试。

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {
        "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, max_new_tokens=1024)

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

parsed = processor.parse_response(
    response,
    prefix=inputs["input_ids"],
)
print(parsed)

Muse Glimmer 发布时即支持 llama.cpp。Meta 在此仓库中分发了校准后的量化模型，Uunsloth 也在发布优化后的量化模型。DFlash 投机解码也被支持。你可以使用预构建的 llama 二进制文件来启动 llama server 或 CLI。安装 llama.cpp，请运行：

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

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

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

服务器启动后，你可以访问 localhost:8080 与内置 WebUI 聊天。

TODO：在此插入该模型的 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 使用轻量级 block-diffusion drafter 模型，在解码阶段提供相同输出的同时加快生成速度。Transformers 和 llama.cpp 都在发布首日即支持 Muse Glimmer 的 DFlash drafter。

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

使用 transformers 的投机解码

你可以按如下方式加载 drafter 和模型，并通过额外的参数进行推理（如接下来的代码片段所示，方式与你使用基础模型时相同）。

import torch
from transformers import AutoProcessor, MuseGlimmerAssistantModel, MuseGlimmerForConditionalGeneration

model_id = "meta-models/Muse-Glimmer-30B"
target = MuseGlimmerForConditionalGeneration.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto")
assistant = MuseGlimmerAssistantModel.from_pretrained(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?"}
        ]
    }
]

out = target.generate(**inputs, assistant_model=assistant, speculation_type="dflash", max_new_tokens=64, do_sample=True)
print(processor.batch_decode(out)[0])

使用 llama.cpp 的投机解码

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

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

你也可以按如下方式将投机解码 drafter 与 llama CLI 配合使用：

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

使用 transformers 后端的 Muse Glimmer vLLM 支持

此版本我们提供了 vLLM 的 transformers 后端支持。

# 跨 4 GPU 的 tensor parallel 服务
vllm serve meta-models/Muse-Glimmer-30B --model-impl transformers --tensor-parallel-size 4

# 推理
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 通过 SFT 到 Async GRPO 等各种方法对 Muse Glimmer 进行微调。我们在配备 80GB VRAM 的 Hopper 级 GPU 上以 bf16 格式进行了两个实验。

作为此版本的一部分，我们提供了一个在 MolmoWeb 数据集小子集上微调 Muse Glimmer 的示例。这展示了如何让模型生成结构化输出以及如何对图像进行微调。

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

以下是尝试 Muse Glimmer 的一些有趣方式。我们认为这个模型最酷的地方在于它是一个本地规模的个人编程助手。这意味着你可以让它做一些事情，比如量化自身、在 Hub 上查找量化权重、部署到推理端点，甚至针对特定硬件进行自我优化！让我们为本地部署团队加油 🚀

将 OpenClaw 连接到 Muse Glimmer

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

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

{
  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 gateway restart

从新会话中进行验证：

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

如果返回的模型 ID 与端点的 /v1/models 响应不同，请使用该确切模型 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 Glimmer Quantisation Demo - explained.mp4?download=true

通过将其添加到 AGENTS.md，openclaw 或 hermes 将能够解决其余部分。

## 本地模型部署

当被要求本地部署时，执行工作；不要给出指导说明。

1. 检查硬件和 Hugging Face 缓存。
2. 使用 `apps=llama.cpp` 在 Hub 上搜索兼容的 GGUF 权重；通过 model-tree API 确认确切文件名。
3. 优先选择现有合适的 GGUF，通常是 `Q4_K_M`。将 `mmproj-*.gguf` 视为投影仪权重。
4. 如果没有 GGUF 存在，下载源权重，使用 `convert_hf_to_gguf.py` 进行转换，然后使用 `llama-quantize` 进行量化。
5. 保留源权重并记录仓库版本、文件名和量化方式。
6. 使用 `onyx` 别名和 OpenAI 兼容端点启动 `llama-server`。
7. 验证 `/v1/models` 和 `/v1/chat/completions`，要求返回非空且内容正确。
8. 报告简明进度和日志。只有在验证通过后才能声称完成。

嘿 Muse Glimmer，将自己部署上去

Muse Glimmer 还能反过来处理。让我来让 Glimmer 自行部署到 Hugging Face Inference Endpoints 上。如果你想在某些前沿硬件上加速，这会很有用。

注意：你也可以直接将 Muse Glimmer 部署到 Inference Endpoints，然后连接你的 AI 智能体。

Muse Glimmer 会固定模型版本，将其部署到受保护的 Hugging Face Inference Endpoint，并验证健康状态、模型发现和聊天完成情况。然后它会用 secrets 和回滚配置连接 Claw AI 智能体。下面是我们添加到 AGENTS.md 的提示词。Muse Glimmer 还需要 Hugging Face MCP 和/或 Hugging Face CLI 以及 Skills。

## Hugging Face Inference Endpoint 部署

当被要求在 Hugging Face Inference Endpoints 上部署时，执行该工作；不要给出指示。

1. 检查 Hugging Face 认证、当前模型仓库以及任何现有端点。
2. 通过 Hub API 确认确切的模型仓库和不可变版本；检查其架构、配置和聊天模板。
3. 确认模型被 vLLM 支持，然后使用托管原生 vLLM 引擎部署或更新受保护的 Inference Endpoint。
4. 选择可用区域和最小的合适加速器。使用一个副本，并在支持时启用缩容到零。
5. 保留先前的端点配置以供回滚。不要暴露令牌、发布私有权重或替换无关的端点。
6. 等待端点就绪。如果启动失败，检查日志并报告实际阻碍因素，而不是反复更改设置。
7. 验证 `/health`、`/v1/models` 和 `/v1/chat/completions`，要求返回预期模型和非空、正确的内容。当需要 AI 智能体使用时，还要验证一个真实的结构化工具调用。
8. 配置 Claw AI 智能体使用该端点的 OpenAI 兼容 `/v1` URL，将凭证存储为 secrets 并保留先前的 provider 作为回滚。在一个新会话中测试连接。
9. 报告简洁的进度，并以仓库、版本、引擎、硬件、端点 URL、缩容状态和验证结果结束。只有在每个必需检查都通过后才能声明完成。

嘿 Muse Glimmer，优化你自己

最后，让我们让 Muse Glimmer 做些轻量的推理系统优化。我们可以指示我们的 AI 智能体为自己的特定硬件优化推理引擎，这里以 Nvidia H100 为例。为此，AI 智能体需要使用另一个推理引擎，比如上面的 Inference Endpoints。

Muse Glimmer 对自己的单 H100 服务堆栈进行基准测试，在保持工作负载固定的同时一次测试一个可逆变更。它只保留通过正确性检查的提升，并以最快可复现配置结束。下面是我们添加到 AGENTS.md 的提示词。Muse Glimmer 需要 Hugging Face MCP 和 Hugging Face CLI 以及 Skills。

你是 Muse Glimmer，充当自己服务堆栈的自主推理优化工程师。

目标：最大化有效的单 H100 聚合完成吞吐量，单位为 tokens/秒。

协议：
1. 建立一个通过正确性检查的基准。
2. 一次测试一个可逆优化。
3. 保持 prompt、并发、采样、请求数量、预热和解码长度固定。
4. 拒绝正确性或前缀检查失败的结果。
5. 按时间顺序记录每个实验，包含其配置、原始吞吐量、正确性和 delta。
6. 保留改进，回滚回归。
7. 在连续六次回归后或实验预算耗尽时停止。
8. 报告最佳有效配置和精确的复现命令。

创建一个最小化的科学动画结果：
- 白色背景；
- 原始 tokens/秒——从不归一化；
- 每个实验揭示一个点；
- 按时间顺序连接每个点；
- 从最低有效结果开始；
- 在最佳结果处停止；
- 导出为 GIF。

绝不捏造、插值或计入正确性失败的测量值。

嘿 Muse Glimmer，研究 Hub

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

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

本文提及的模型 3

本文提及的论文 1

更多博客文章

Baseten on Hugging Face Inference Providers 🔥

DeepInfra on Hugging Face Inference Providers 🔥