Meta се завръща с Muse Glimmer: локален, агентен, мултимодален и с отворен код

Meta се завръща с Muse Glimmer: локален, агентен, мултимодален и с отворен код! Страхотни новини от пионерите на езиковите модели с отворен код! Muse Glimmer, представен днес, е новият мултимодален модел на Meta, създаден специално за локални агентни приложения. Дестилиран от Muse до 30 млрд. параметъра и публикуван под лиценза Apache 2.0, той е идеален за локално внедряване с цел защита на поверителността, намаляване на разходите или просто експериментиране. Предназначен е за приложения, съобразени с поверителността, като програмиране, анализ на документи, лични асистенти и конфигурации, подобни на Claw или Hermes.

За да отпразнуваме премиерата, заедно с Meta осигуряваме поддръжка още от първия ден в transformers, llama.cpp, vLLM, Inference Endpoints и други библиотеки. Създадохме няколко интересни неща и споделяме резултатите си в тази статия. Разгледайте демонстрациите по-долу за вдъхновение. Можете да откриете Muse Glimmer в Hugging Face Hub.

Бенчмаркове

Резултати от бенчмарковете

Резултатите са посочени така, както са публикувани. Получерният шрифт обозначава най-добрия резултат сред сравняваните модели; ↓ показва, че по-ниската стойност е по-добра.

Архитектура

Muse Glimmer е плътен модел с 30 млрд. параметъра, състоящ се от:

• 2B ViT-подобен енкодер за зрение (Perception Encoder)
• Текстов декодер с 28 млрд. параметъра

В допълнение към основния VLM има и модел за спекулативно декодиране, реализиран върху DFlash. Използването на този модул е по избор и може да осигури значително по-бързо генериране срещу известен разход на памет. Установихме, че този модел е особено подходящ за генериране на структурирано съдържание, например код.

Текстов декодер

Езиковият модел използва следните архитектурни компоненти:

• Хибридно внимание: Редуват се три слоя с плъзгащ се прозорец (от 2 048 токена), използващи ротационно позиционно вграждане, последвани от четвърти слой, който използва пълно внимание и NoPE (без позиционно вграждане). Така полученият модел (SWA, SWA, SWA, Full) се повтаря 13 пъти, за общо 52 слоя. Това позволява на модела да запазва информацията за относителния ред и разстояние чрез RoPE и да съхранява глобално информацията чрез NoPE.
• Gated Grouped-Query Attention: Всяка key-value глава се споделя от 16 query глави, което намалява паметта за KV кеша 16 пъти и прави генерирането по-бързо и по-евтино.
• Q-K нормализация с допълнително мащабиране на query: Преди изчисляването на вниманието Muse Glimmer прилага RMS нормализация към всяка query и key глава, за да поддържа стабилни логити на вниманието. След това заявките се умножават по коефициент на мащабиране, който задава целевия мащаб на логитите след нормализацията. Допълнителното мащабиране на query действа като обратна температура на ниво softmax.

Енкодер за възприятие

Muse Glimmer използва един енкодер за изображения, който обработва както изображения, така и видеоклипове. За разлика от сравнително малките зрителни енкодери, използвани в други VLM, това е голям ViT-подобен модел с 2 млрд. параметъра, проектиран по архитектурата Perception Encoder. Perception Encoder беше представен по-рано от Meta като основа за различни пространствени и мултимодални задачи надолу по веригата.
Енкодерът разделя изображенията на пачове с форма 2 кадъра x 3 канала x 14 x 14 и ги прекарва през линеен слой за проекция. След това към тези вграждания се добавя интерполирано абсолютно позиционно вграждане от обучена таблица с позиции. Те се подават към кулата за зрение, която се състои от 50 слоя и GELU MLP. Подобно на езиковия модел, схемата на вниманието се състои от три слоя с внимание в прозорец, последвани от един слой с пълно внимание. В слоевете за внимание към заявките и ключовете се прилага 2D RoPE.

След трансформатора pixel shuffle обединява групи от 2x2 съседни пространствени токена, което намалява броя на токените за изображение 4 пъти, без да изхвърля каналите им. След това обединените характеристики се проектират към споделеното пространство за вграждане на текстовия декодер.

Видеоклиповете преминават през същия енкодер кадър по кадър, като всеки кадър се преобразува в пачове (с форма [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"


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

Същият фрагмент работи без промени с графични процесори NVIDIA (CUDA), AMD (ROCm) и Intel (XPU); 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)



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)

Llama.cpp

Muse Glimmer се поддържа в llama.cpp още от първия ден. Meta разпространява калибрирани квантизирани версии в това хранилище, а Uunsloth също публикува оптимизирани квантизирани версии. Поддържа се и спекулативното декодиране DFlash. Можете да използвате предварително компилиран двоичен файл на llama, за да стартирате llama сървър или 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 използва лек модел за чернови на блокова дифузия, за да осигури същия резултат с допълнително ускорение във фазата на декодиране. Transformers и llama.cpp поддържат модела за чернови DFlash на Muse Glimmer още от първия ден.

По-долу можете да видите как спекулативното декодиране може да ускори генерирането в реалистични конфигурации. Видеото показва webui на llama.cpp с DFlash отляво и стандартното генериране отдясно.

Спекулативно декодиране с transformers

Можете да заредите модела за чернови и основния модел по следния начин и да извършвате извеждане както с базовия модел, но с допълнителен параметър (показан в следващите фрагменти).

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 при всяка стъпка на спекулативното декодиране. Моделът DFlash на Muse Glimmer е обучен с размер на блока 16 — един котвен токен плюс 15 предложени токена, така че всяка стойност над 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 във vLLM с backend на transformers

С това издание добавяме поддръжка на vLLM с backend на transformers.

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

Можете да използвате TRL за фино дообучаване на Muse Glimmer чрез различни методи — от SFT до Async GRPO. Проведохме два експеримента с bf16 върху графични процесори от клас Hopper, всеки с 80 GB VRAM.

Като част от това издание предоставяме пример за фино дообучаване на Muse Glimmer върху малък дял от набора данни MolmoWeb. Той показва как да накарате модела да генерира структурирани изходи и как да го дообучите върху изображения.

Експериментирахме и със стартирането на модела в OpenCode с примера за AsyncGRPO. Моделът демонстрира силни способности за програмиране, затова ви насърчаваме да опитате обучение със среди за програмиране в OpenEnv и TRL.

Демонстрации

Ето няколко забавни начина да изпробвате Muse Glimmer. Според нас най-впечатляващото в този модел е, че представлява локален личен асистент, който може да програмира. Това означава, че можете да го накарате да прави неща като да квантизира сам себе си, да намира квантизирани тегла в Hub, да се внедрява в inference endpoints и дори да се оптимизира за конкретен хардуер! Напред, локален екип 🚀

Свързване на OpenClaw с Muse Glimmer

Приемаме, че Inference Endpoint предоставя OpenAI-съвместим /v1 API.

Задайте HF_TOKEN в средата на gateway на OpenClaw, след което добавете следното в ~/.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"

Използвайте точния идентификатор на модела, върнат от отговора на endpoint-а при /v1/models, ако той се различава.

Хей, 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 Inference Endpoints — полезно, ако искате да ускорите работата върху авангарден хардуер.

Забележка: Можете просто да внедрите Muse Glimmer в Inference Endpoints директно и да свържете своя агент.

Muse Glimmer фиксира ревизията на модела, внедрява го в защитен Hugging Face Inference Endpoint и проверява състоянието, откриването на модела и завършването на чат заявките. След това свързва агента Claw със запазени тайни и възможност за връщане към предишна версия. Ето подканата, която добавихме към AGENTS.md. Muse Glimmer ще се нуждае и от Hugging Face MCP и/или Hugging Face CLI и Skills.

Подкана за внедряване в Inference Endpoint

## 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. Можем да инструктираме агента да оптимизира собствения си inference engine за конкретен хардуер — в случая Nvidia H100. За целта агентът ще трябва да използва друг inference engine, като Inference Endpoints по-горе.

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 изпраща всяка заявка към модела до частен Hugging Face Inference Endpoint чрез неговия OpenAI-съвместим API. Той се свързва и с официалния Hugging Face MCP сървър, предоставяйки на агента инструменти само за четене за търсене и преглед на хранилища в Hub, модели, набори от данни, Spaces, документация и статии.

В заключение

Радваме се да приветстваме Muse Glimmer в Hugging Face Hub. Изпробвайте Muse Glimmer с локалните си конфигурации за програмиране още днес!

Глас „за“

5

• 
• 
• 
• 
• 

Модели, споменати в тази статия 3

Статии, споменати в тази статия 1