Colibri: запуск GLM-5.2 (744B MoE) на потребительском ПК (Colibri)

Обзор и концепция

Colibri решает задачу, которая казалась невозможной: запуск 744-миллиардной параметрической модели смеси экспертов на потребительском оборудовании. Ключевая идея проста, но элегантна: модель GLM-5.2 активирует только ~40 миллиардов параметров на каждый токен, и только ~11 гигабайт из них меняются от токена к токену (маршрутизированные эксперты).

Архитектура решения строится на трёхуровневой иерархии памяти: плотная часть (внимание, общие эксперты, эмбеддинги — ~17B параметров) остаётся резидентной в оперативной памяти в формате int4 (~9,9 ГБ); 21 504 маршрутизированных эксперта (75 слоёв MoE × 256 экспертов + голова MTP, ~19 МБ каждый в int4) живут на диске (~370 ГБ) и потоком загружаются по требованию с кэшем LRU для каждого слоя, опциональным закреплённым горячим хранилищем и кэшем страниц ОС в качестве бесплатного L2 уровня.

Движок — это один файл C (`c/glm.c`, ~2400 строк) плюс небольшие заголовки. Нет BLAS, нет Python во время выполнения, нет GPU (хотя есть опциональный слой CUDA для закреплённых экспертов). Результат: 744-миллиардная модель, которая думает на вашем домашнем ноутбуке.

Основные возможности

Архитектурные особенности

Colibri реализует полнофункциональный форвардный проход GLM-5.2 с точностью на уровне токена, что было валидировано против трансформеров оракула (teacher-forcing 32/32, жадный поиск 20/20 на маленькой случайной модели с реальной архитектурой):

• MLA внимание (q/kv-LoRA, чередующееся частичное RoPE) с компрессированным KV-кэшем: 576 float'ов/токен вместо 32 768 (57× меньше — GLM-5.2 имеет 64 головы и без GQA)
• DeepSeek-V3-стиль сигмоид-маршрутизатор (noaux_tc, routed_scaling_factor), общий эксперт, первые 3 плотные слои
• Собственное спекулятивное декодирование MTP — голова многотокенного предсказания GLM-5.2 (слой 78) черновик токенов, которые главная модель проверяет в одном пакетном форварде. Голова должна быть int8: при int4 черновике принятие схлопывается на 0–4%, а спекуляция не включается; при int8 это 39–59% принятия, **2,2–2,8 токена/форвард** (сообщается сообществом). Без потерь в точной арифметике, но не байт-идентично не-спекулятивному жадному поиску в практике
• Грамматика-форсированные спекулятивные черновики (`GRAMMAR=file.gbnf`) — на constrained-output нагрузках (JSON/NDJSON, function calling, структурированная экстракция) грамматика сама является третьим источником черновиков: везде, где она допускает ровно один легальный байт (скобки, кавычки, названия ключей, тела enum), этот форсированный span токенизируется и инъектируется как предпринятые черновики с ~1.0 приёмкой

Оптимизация производительности

• Целочисленные точечные ядра (Q8_0-стиль int8 активаций, AVX2 `maddubs`): int8 matmuls на 1,4–2,5× быстрее (119 GFLOP/s измерено), int4 на 1,8× в батче — маршрутизация по форме выбирается путём измерения
• Поглощение весов MLA (трюк DeepSeek) для декода: нет реконструкции k/v для каждого токена — запрос поглощает `kv_b`, контекст проецируется после внимания
• Асинхронный опережающий заход экспертов: пока один блок экспертов умножается, ядро уже читает следующий (`WILLNEED`)
• Ядра квантизации: int8 / упакованный int4 / упакованный int2, шкалы для каждого ряда, AVX2, dequant-on-use
• DSA разреженное внимание — молниеносный индексатор GLM-5.2, верный ссылочному `glm_moe_dsa` моделированию: выбор топ-2048 каузального ключа для каждого слоя (полные/общие слои индексатора), автоопределяемый из весов `out-idx-*`

Управление памятью и кэшированием

• Персистентность KV-кэша — разговоры переоткрываются в тёплом состоянии между перезагрузками движка: режим обслуживания добавляет сжатый MLA KV к `.coli_kv` после каждого поворота (~182 КБ/токен, крахо-безопасный) и возобновляет его при запуске с нулевым re-prefill
• Опережающий просмотр маршрутизатора (`PILOT=1`, экспериментальный) — маршрутизация экспертов следующего слоя на 71,6% предсказуема из состояния после внимания текущего слоя; выделенный поток I/O предварительно загружает эти эксперты во время вычисления текущего слоя
• Batch-union MoE: в prefill (и верификации MTP) каждый уникальный эксперт батша читается один раз и применяется ко всем позициям, которые на него маршрутизируют
• Безопасность RAM: кэш экспертов автоматически определяется из `MemAvailable` при запуске — честная проекция пика (рабочий набор, KV, MTP ряд, буферы реконструкции)

Дополнительные возможности

• Байт-уровневый BPE токенизатор на C (GPT-2-стиль с регексом для Unicode-свойств, 320k мерж)
• Истинная выборка — температура + nucleus, значения по умолчанию настроены для int4-реальности (0,7 / 0,90; официальная 1,0 / 0,95 образцы квантизационный шум из хвоста)
• Автоматическое расширение кэша экспертов (с 2026-07-10): движок теперь *повышает* лимит LRU для заполнения бюджета RAM вместо только его снижения
• Обучаемый кэш: движок записывает, какие эксперты на самом деле маршрутизирует ваша нагрузка (`.coli_usage` рядом с моделью, обновляется каждый поворот) и при запуске автоматически закрепляет самые горячие в запасной RAM. Colibri буквально становится быстрее, чем больше вы его используете
• Адаптация живой иерархии (`--repin N`, опт-ин): на безопасных границах поворотов карта тепла сессии с затуханием заменяет холодные закреплённые эксперты более горячими потоковыми. Замена загружает эксперта с диска в существующий слот RAM; слоты, поддерживаемые GPU, сразу же обновляют бюджет того же слоя VRAM

Установка и настройка

Быстрый старт на Linux/WSL2

Установка состоит из нескольких простых шагов:

cd c
./setup.sh                      # проверяет gcc/OpenMP, собирает, self-tests

# ОДНА команда делает всё на стороне модели: загружает GLM-5.2-FP8 shard за shard
# (никогда не нужны полные 756 ГБ одновременно), конвертирует в контейнер int4, затем
# конвертирует голову MTP для спекулятивного декодирования. Возобновляется в любой точке.
# Конверсия (только) нужен python с: pip install torch safetensors huggingface_hub numpy
./coli convert --model /nvme/glm52_i4     # ~400 ГБ свободно на настоящем ext4/NVMe пути

# chat — бюджет RAM, кэш экспертов и MTP автоматически определяются:
COLI_MODEL=/nvme/glm52_i4 ./coli chat

Планирование хранилища

Перед загрузкой модели проверьте планируемую иерархию хранилища:

COLI_MODEL=/nvme/glm52_i4 ./coli plan
COLI_MODEL=/nvme/glm52_i4 ./coli plan --gpu 0,1 --ram 128 --vram 48 --json

# применить ограниченный план к обычному бегуну
COLI_MODEL=/nvme/glm52_i4 ./coli chat --auto-tier

`coli plan` читает только заголовки safetensors и сообщает точный размер плотной/экспертной части модели, резерв RAM во время выполнения, безопасный лимит кэша экспертов и ограниченный горячий слой VRAM. Его версионированный JSON-вывод предназначен для совместного использования CLI, сервером API, веб-интерфейсом и оболочкой рабочего стола; он не выделяет тензоры модели и не запускает вывод.

Проверка готовности

Перед загрузкой модели `coli doctor` выполняет check только для чтения и объясняет, является ли выбранное размещение Disk/RAM/VRAM запускаемым:

COLI_MODEL=/nvme/glm52_i4 ./coli doctor
COLI_MODEL=/nvme/glm52_i4 ./coli doctor --gpu 0 --ram 128 --json

Doctor валидирует директорию модели, конфиг, токенизатор, заголовки safetensors, исполняемый файл движка, доступную RAM, запрашиваемые устройства NVIDIA, связь CUDA и тот же бюджет размещения, используемый `coli plan`. Он никогда не запускает `glm`, не читает нагрузки тензоров, не импортирует фреймворк модели и не создаёт контекст CUDA. Версионированный JSON-отчёт использует стабильные ID проверок для автоматизации. Предупреждения сохраняют статус выхода 0; отсутствующие требования или небезопасная проекция RAM возвращают 1, а недействительные значения CLI возвращают 2.

Получение модели

Предварительно конвертированная модель GLM-5.2 int4 для colibri доступна на Hugging Face — используйте версию с голове MTP int8 (клон matey-0):

https://huggingface.co/mateogrgic/GLM-5.2-colibri-int4-with-int8-mtp

⚠️ Голова MTP должна быть int8. Оригинальное зеркало ([jlnsrk/GLM-5.2-colibri-int4](https://huggingface.co/jlnsrk/GLM-5.2-colibri-int4)) поставляет int4 голову MTP, которая даёт 0% приёмки черновика — спекуляция молча никогда не включается и вы теряете ~2× MTP рычаг. Это самый частый доклад «почему MTP застрял на 0%?». Голова int8 даёт измеренный 39–59% приёмки. Клон matey-0 выше — это оригинальная модель int4 с тремя файлами `out-mtp-*` уже поменянными на int8 — загрузите эту и готово.

Проверьте, что у вас есть: `ls -l <model>/out-mtp-*`

• int8 (правильно): `3527131672 / 5366238584 / 1065950496`
• int4 (0% приёмки): `1765523544 / 2686077736 / 536747200` — если вы видите эти, замените только эти три файла из зеркала int8

Windows 11 (нативно, без WSL)

Colibri собирается и работает нативно на Windows 11 x86-64 с MinGW-w64. Портирование добавляет слой совместимости `_WIN32` в `c/compat.h`, который отображает POSIX I/O в Windows API (pread → ReadFile+OVERLAPPED, posix_fadvise no-op, выравниванное выделение, MoveFileEx переименование, GlobalMemoryStatusEx определение RAM). Все различия платформы остаются в `compat.h`; источник движка неизменён.

Toolchain: GCC через [winlibs](https://winlibs.com/) или MSYS2 MinGW-w64. Тестировано с GCC 16.1.0 (x86_64-ucrt-posix-seh).

# Установка toolchain один раз (выберите один):
scoop install mingw-winlibs                    # портативный, не нужна оболочка
# или: pacman -S mingw-w64-x86_64-gcc make     # через MSYS2

# Сборка (из директории c/):
make glm.exe            # GLM-5.2 engine (статический, без DLL зависимостей)
make olmoe.exe          # OLMoE engine (те же shims)
make iobench.exe        # бенчмарк диск I/O
make test-c             # запустить C тесты
make test-python        # запустить Python тесты (требует python)

# Проверка (маленькая модель, 2,4 МБ):
pip install torch transformers safetensors huggingface_hub
python tools/make_glm_oracle.py                # генерирует маленький оракул
SNAP=./glm_tiny TF=1 ./glm.exe 64 16 16        # ожидай "32/32 positions"

# Запуск с реальной моделью:
SNAP=D:\glm52_i4 ./glm.exe 64 4 16            # batch вывод
python coli chat --model D:\glm52_i4            # интерактивный чат
python coli serve --model D:\glm52_i4            # OpenAI-совместимый API

Статус: Фаза 1 завершена (собирается, правильно, статически связано). O_DIRECT (Фаза 2), GPU через `LoadLibrary` на `coli_cuda.dll` (Фазы G0–G2) и полная валидация модели — отдельные потоки работы. Смотрите `PORT_WINDOWS_PLAN.md` для полного плана.

Использование

Интерактивный чат

$ ./coli chat
  🐦 colibrì v1.0 — GLM-5.2 · 744B MoE · int4 · streaming CPU
  ✓ ready in 32s · resident 9.9 GB
  › ciao!
  ◆ Ciao! 😊 Come posso aiutarti oggi?

Интерактивный чат позволяет вам общаться с моделью естественным образом. Команды:

• `:reset` — очистить историю разговора
• `:more` — продолжить усечённый ответ
• Обычный текст — отправить сообщение

Управление параметрами

Полезные флаги и переменные окружения:

• `--temp T` — температура выборки токенов (по умолчанию 0,7 + nucleus 0,90 — настроено для int4; 0 = жадный поиск)
• `--topp 0.7` — адаптивный top-p для экспертов (30–40% меньше диска)
• `--ngen N` — максимум токенов на ответ
• `--ram BYTES` — бюджет оперативной памяти
• `--vram BYTES` — бюджет VRAM GPU (если доступно)
• `--repin N` — адаптировать RAM/VRAM горячие эксперты каждые N излучаемых токенов
• `AUTOPIN=0` — отключить обучаемый кэш
• `THINK=1` — включить блок рассуждений GLM-5.2
• `DRAFT=n` — глубина черновика MTP (спекулятивное декодирование)
• `GRAMMAR=g.gbnf` — грамматика-форсированные черновики для constrained JSON/NDJSON вывода
• `GRAMMAR_DRAFT=n` — лимит форсированного span для каждого форварда (по умолчанию 24)
• `TF=1` — teacher-forcing валидация
• `PILOT=1` — маршрутизатор опережающего диск-prefetch (экспериментальный)
• `CAP_RAISE=0` — не автоматически растить кэш экспертов
• `KVSAVE=0` — отключить персистентность KV-кэша

Специализированные команды

Пакетный вывод (без интерактива):

COLI_MODEL=/nvme/glm52_i4 ./coli run "Объясни принцип MoE" --ngen 256

Бенчмарки качества:

cd c
pip install tokenizers datasets                # дополнительно к deps конверсии
./coli bench                                   # hellaswag, arc_challenge, mmlu — по 40 вопросов
./coli bench hellaswag --limit 200             # один таск, больше вопросов
./coli bench mmlu arc_challenge --ram 100      # выберите tasks, установите бюджет RAM

Печатает точность для каждого task (log-likelihood scoring, EleutherAI-harness стиль).

I/O бенчмарк диска:

gcc -O2 -fopenmp iobench.c -o iobench
./iobench /path/to/glm52_i4/out-00069.safetensors 19 64 8 0   # буферизированный, 8 потоков
./iobench /path/to/glm52_i4/out-00069.safetensors 19 64 8 1   # O_DIRECT (обход кэша)

Измеряет VRAM образом, как движок его использует (параллельные 19 МБ случайного чтения).

Производительность и бенчмарки

Честные цифры (WSL2, 12 cores, 25 GB RAM, NVMe через VHDX)

Это не быстро. Это 744-миллиардная frontier-class модель, отвечающая правильно на машине, которая стоит меньше, чем один вентилятор H100. Тёплый кэш, закреплённые горячие эксперты и MTP значительно снижают задержку полезного ответа; физика диска делает остальное.

Заметка об SSD

Холодные старты сильно нагружают случайные чтения (~11 ГБ/токен), но чтения не носят значительного износа SSD — потоковая передача colibri только для чтения. Настоящие проблемы при интенсивном использовании: (1) трафик swap, если система кончает RAM (записи износят диск — держите разумный бюджет `--ram`; autoBudget colibri разработан чтобы оставаться чистым от swap), (2) устойчивая термика: часы на полной работе цикла чтения будут нагревать дешёвые диски. Контролируйте температуру и здоровье диска.

Предсказания для лучших машин

Colibri была построена на намеренно скромном оборудовании (12 cores, 25 GB RAM, более старый DRAM-less NVMe). Каждое из этих ограничений — это ручка, которую ваша машина может повернуть:

Это оценки, не измерения — если вы запускаете colibri на серьёзном оборудовании, пожалуйста откройте issue с вашими цифрами: реальные datapoints от лучших машин — это ровно то, что этому проекту нужно дальше.

Бенчмарки сообщества (измеренные)

Реальные числа от реальных машин, стоковая сборка (`setup.sh`, gcc 13), жадный декоде, `--ngen 32`, MTP активен:

Выводы: С 24 ГБ RAM движок автолимит кэш экспертов до 2 слотов/слой, поэтому декод остаётся холодным даже на диске в 2–2,7× быстрее baseline — на маленьких-RAM машинах лимит RAM, не диск, является связывающим ограничением, ровно как таблица предсказывает; `--topp 0.7` один купил чистый 1,6× конец-конец ускорение. M5 Max datapoint ложится прямо на вторую строку таблицы: ~1 tok/s 744B модели на ноутбук SSD — и его 14 ГБ/s диск сдвигает бутылочное горло обратно к бюджету RAM и ядрам. Framework 13 ряды — это кэш-тезис доказан конец-конец на одной машине: 0,29 → 0,37 tok/s (hit 28% → 66%, спекуляция наконец включается на 52% приёмке) просто дав кэшу его RAM — int8 MTP head + больший cap + learned pin. Cap часть теперь автоматический (cap auto-raise, 2026-07-10). Пара 9950X — это чистейший бутылочное горло эксперимент — та же машина, та же история, только диск поменян: ×5,8 пропускная способность диска купила ×2,9 токенов, и профиль флипнулся с 66% диска на 57% matmul.

Бенчмарк качества — помощь нужна

Первое измерение ([#108](https://github.com/JustVugg/colibri/issues/108)): контейнер int4 набрал 62,5% средней точности на hellaswag/arc/mmlu (0-shot log-likelihood, n=40) — ниже 85–95% опубликованного для full-precision GLM-5.2, но разрыв ещё не является результатом квантизации. Два факта сбивают: (1) 0-shot log-likelihood MC scoring плохо обслуживает рассуждающую модель вроде GLM-5.2 (она никогда не получает думать), поэтому большой разрыв ожидается даже на fp16; (2) n=40 это ±14pp. Решающий эксперимент — A/B fp16-vs-int4 OLMoE под этой же шлейкой (достаточно маленькая для запуска обоих точности) — этот delta является стоимостью квантизации с протоколом scoring аннулировано. До его запуска, 62,5% — это datapoint, не вердикт.

OpenAI-совместимый API

Запуск сервера

`coli serve` держит один процесс модели загруженным и раскрывает text-only OpenAI-совместимый HTTP API. Шлюз использует только стандартную Python библиотеку; вывод всё ещё работает в том же dependency-free C движке.

cd c
COLI_MODEL=/nvme/glm52_i4 COLI_API_KEY=local-secret ./coli serve \
  --host 127.0.0.1 --port 8000 --model-id glm-5.2-colibri

curl http://127.0.0.1:8000/v1/chat/completions \
  -H 'Authorization: Bearer local-secret' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "glm-5.2-colibri",
    "messages": [{"role": "user", "content": "Hello"}],
    "stream": true
  }'

Поддерживаемые endpoints

Реализованные endpoints: `GET /v1/models`, `GET /v1/models/{model}`, `POST /v1/chat/completions`, и legacy `POST /v1/completions`. Запросы chat и completion поддерживают JSON ответы, SSE streaming, usage counts, `max_tokens`/`max_completion_tokens`, `temperature` и `top_p`. Расширение `enable_thinking: true` включает блок рассуждений GLM-5.2; стандартное поле `reasoning_effort` также включает его если не установлено на `none`.

Очередь запросов

Первая версия намеренно только-текст и обслуживает одно поколение за раз: 744B модель остаётся в одном персистентном процессе, поэтому одновременные HTTP запросы стоят в очереди вместо загрузки дублирующихся копий модели. Tools, вход image/audio, custom stop sequences, log probabilities и token penalties возвращают явную ошибку скорее чем молчаливо игнорируются. Адрес привязки по умолчанию localhost; установите `COLI_API_KEY` перед обнажением сервера за машину.

Доступ браузера от dev сервера Vite и Tauri local origins включен по умолчанию. Повторите `--cors-origin https://your-ui.example` чтобы разрешить другой точный origin, или используйте `--cors-origin '*'` только на доверенной локальной сети.

Движок владеет одним изменяемым KV контекстом, поэтому HTTP поколение использует ограниченную FIFO очередь допуска вместо притворства что работают unsafe параллельные последовательности. Конфигурируйте с `--max-queue N` (default 8) и `--queue-timeout SECONDS` (default 300), или переменные окружения `COLI_MAX_QUEUE` / `COLI_QUEUE_TIMEOUT`. Насыщенные и вышедшие по времени запросы получают OpenAI-shaped HTTP 429 ошибки перед потоком заголовков. `GET /health` раскрывает счётчики active/queued/completed/rejected, и успешные ответы поколения включают `x-colibri-queue-wait-ms`.

Изолированные KV контексты

`coli serve --kv-slots N` выделяет до 16 независимых контекстов последовательности. Запросы выбирают один с опциональным integer полем `cache_slot`; обычные OpenAI клиенты опускают это и держат оригинальное слот 0 поведение.

{
  "model": "glm-5.2-colibri",
  "messages": [{"role": "user", "content": "Continue this conversation"}],
  "cache_slot": 1
}

Каждый slot владеет историей токенов, сжатой памятью MLA/DSA KV, окном MTP и файлом persist crash-safe (`.coli_kv`, `.coli_kv.1`, ...). Движок всё ещё выполняет одну последовательность за раз; это устанавливает явное KV владение без притворства что threaded HTTP — это continuous batching. RAM допуск считает каждый конфигурированный slot. Начните с небольшого значения: при context из 4096 токенов по умолчанию, каждый slot стоит сотни МБ.

GPU бэкенды (CUDA, Metal)

Экспериментальный Metal backend (Apple Silicon)

На Apple Silicon профиль декода matmul-bound, и unified memory удаляет PCIe копию налога что держит потоковые эксперты CUDA на CPU — так colibri имеет opt-in Metal backend что запускает routed-expert SwiGLU (batched, zero-copy от RAM slabs), fused decode attention (полный MLA слой в одной command buffer, S≤4) и prefill's large GEMMs на GPU. Token-exact vs CPU path.

cd c
make glm METAL=1          # macOS только; Xcode не требуется (shader компилируется во время runtime)
make metal-test           # standalone kernel/attention correctness vs CPU reference
COLI_METAL=1 COLI_MODEL=/path/glm52_i4 ./coli chat --ram 96

Измеренно на M4 Max (128 GB, тёплый кэш, MTP on): CPU 0.30 → Metal 0.42 tok/s (~1.4×). Ключевые точки дизайна: Metal's ~5 ms submit latency делает per-matmul dispatch потерей — всё batched в несколько command buffers на слой, и работа резидентных экспертов GPU submitted перед missed экспертами disk reads так I/O и compute перекрываются. `COLI_METAL_GEMM_MIN` тюнит prefill GEMM row threshold (default 16). Streaming, cache, MTP, DSA и persistence форматы неизменены; каждый GPU path falls back к CPU per-block на любую fault. Numerics — dequant→f32-MAC (same как CUDA tier); greedy выходы byte-identical к CPU движку.

Экспериментальный resident CUDA backend

Colibri включает opt-in CUDA backend для model-resident tensors. Потоковые эксперты намеренно остаются на оригинальном CPU path пока: копирование эксперта с NVMe на GPU на каждое использование только заменил бы диск бутылочное горло на PCIe бутылочное горло. Resident квантизированные тензоры uploaded лениво один раз и переиспользуются.

cd c
make cuda-test CUDA=1                  # q8/q4/q2/f32 kernel correctness
make CUDA=1
# optional dense-path эксперимент (горячие эксперты конфигурируются ниже)
COLI_CUDA=1 COLI_GPU=0 CUDA_DENSE=1 SNAP=/nvme/glm52_i4 ./glm 64 4 4

Требования: Linux, NVIDIA driver и CUDA Toolkit под `/usr/local/cuda` (override с `CUDA_HOME=/path/to/cuda`). `CUDA_ARCH=native` собирает для GPU текущей машины; установите explicit архитектуру при cross-compile. Запрос CUDA с CPU-only двоичным файлом, invalid устройством или недоступным runtime fail'ит при запуске вместо молчания fallback'а.

CUDA конфигурация эксперта

Нормальное `make` сборка и runtime поведение неизменены. CUDA defaults к expert-only accelerator. `CUDA_DENSE=1` дополнительно распределяет resident dense/attention projection тензоры round-robin через выбранные устройства; их projected footprint зарезервирован перед expert tier размещением. На шести RTX 5090 с 150 GB expert tier, warmed two-request/64-token GLM-5.2 run улучшился с 1.650 к 2.157 aggregate tok/s (+30.8%) сохраняя полный expert tier. Рассматривайте это как opt-in до projected dense set и 2 GB per-device runtime reserve подходит target GPU.

Measured `PIN` профиль может promote его hottest эксперты в persistent VRAM tier пока держит остаток в RAM:

STATS=stats.txt SNAP=/nvme/glm52_i4 ./glm 64 4 4   # собирают routing frequencies сначала
COLI_CUDA=1 COLI_GPU=0 CUDA_EXPERT_GB=16 \
PIN=stats.txt PIN_GB=160 SNAP=/nvme/glm52_i4 ./glm 64 4 4
# multi-GPU expert tier, 150 GB total budget через six 32 GB devices
COLI_CUDA=1 COLI_GPUS=0,1,2,3,4,5 CUDA_EXPERT_GB=150 \
CUDA_DENSE=1 PIN=stats.txt PIN_GB=300 RAM_GB=226 \
SNAP=/nvme/glm52_i4 ./glm 64 4 4

Выбранные эксперты uploaded во время startup, так failures вместимость occur перед inference и лог reports их exact tensor footprint. Бюджет clamped против free VRAM после резервирования projected dense resident set и 2 GB runtime headroom per выбранное device. С `COLI_GPUS`, `CUDA_EXPERT_GB` — total бюджет через device set; эксперты assigned целиком к least-loaded device что может их hold. Multi-GPU runs также default к `PIN_FILL=1`: measured hot set placed сначала, потом unused VRAM filled с zero-heat экспертами. `CUDA_RELEASE_HOST=1` (multi-GPU default) releases RAM copy после успешного upload и reloads из диска только если CUDA позже fail'ит. Установите любую переменную к `0` чтобы восстановить conservative поведение.

Лучшие бенчмарки на серьёзном оборудовании

На шести RTX 5090 32 GB cards с GLM-5.2 int4, 150 GB hot-first tier sustained 0.94 token/s через varied 64-token prompt (87.8% expert hit rate) и reached 1.64 token/s на warmed short prompt (99.3% hit rate). Та же вместимость filled без routing heat managed только 0.29 token/s, так quality profile важнее чем raw VRAM вместимость. Эти — single-run инженерные измерения, не portable performance гарантия.

Текущие ограничения: устройства используют independent контексты и synchronous host-staged activation копии—нет P2P/NCCL dependency ещё. Independent эксперт группы execute concurrently через devices, но single эксперт not sharded. Ядра — correctness-first custom ядра вместо cuBLAS/Tensor Core ядер.

Продвинутые возможности

Политика ресурсов

`coli plan` reports планируемый hot (VRAM), warm (RAM) и cold backing (диск) tiers, причину для каждого размещения и expected bottleneck. Default `--policy quality` и `--policy balanced` modes preserve checkpoint квантизацию и router решения если `--topk` или `--topp` passed; те explicit lossy overrides печатают warning и proceed.

coli plan --model /models/glm52_i4 --policy quality
coli run --auto-tier --policy quality "Объясни MoE offloading"
# Explicit research-only router редукция:
coli run --policy experimental-fast --topk 4 "Benchmark prompt"

Обучаемый кэш и live адаптация

Кэш учится автоматически: движок записывает какие эксперты ваша нагрузка на самом деле маршрутизирует (`.coli_usage` рядом с моделью, обновляется каждый поворот) и при startup автоматически pins hottest в spare RAM. Colibri буквально становится быстрее чем больше вы его используете.

Live tier адаптация (`--repin N`, opt-in): на safe turn boundaries, decaying session heat map заменяет cold pinned экспертов с hotter streamed. Замена loads эксперта с диска в existing RAM slot; GPU-backed slots сразу refresh тот же VRAM tier бюджет. 25% hysteresis и four-swap limit prevent tier thrashing. Persistent `.coli_usage` остаётся long-term signal и is not decayed.

Grammar-forced спекулятивные черновики

На constrained-output нагрузках (JSON/NDJSON, function calling, структурированная экстракция), грамматика форсирует legal spans:

COLI_MODEL=/nvme/glm52_i4 GRAMMAR=constraints.gbnf ./coli chat

Везде где грамматика допускает ровно один legal байт (скобки, кавычки, key названия, enum bodies), этот форсированный span tokenized и injected как pre-accepted черновики с ~1.0 приёмкой — no draft head lookup, и это engages даже с int4 MTP head. Это никогда не constrains sampling: forced spans verified в той же batch-union forward как любой draft, так wrong или out-of-sync грамматика не может change output — worst case это rejected черновики.

Router-lookahead prefetch

Экспериментальный режим: GLM-5.2's expert маршрутизация measurably предсказуема ahead of time — применяя layer L+1's router к layer L's post-attention state recalls 71.6% true top-8 (vs 41.3% для «same experts как last token»). `PILOT=1` использует это для issue next-layer expert readahead из dedicated I/O thread пока current layer computes.

COLI_MODEL=/nvme/glm52_i4 PILOT=1 ./coli chat

Разговоры переоткрываются в тёплом состоянии

Начиная с 2026-07-10, `coli chat` persists compressed MLA KV-cache к диску после каждого поворота (~182 KB/токен, incremental append, crash-safe). Close чат, переоткройте завтра — модель still помнит whole разговор и zero re-prefill happens: validated byte-identical к uninterrupted сессии. `:reset` очищает это, `KVSAVE=0` disables.

Batch I/O оптимизация

Cold expert reads используют deferred pipeline: resident RAM/VRAM эксперты execute пока missing эксперты loaded в bounded background I/O pool, потом cold results join перед layer завершением. `IO_THREADS=n` overrides default восемь loader потоков когда foreground работа exists. Profiling reports оба disk service time и smaller foreground-visible wait time так overlap explicit вместо credited как unexplained speedup.

Часто задаваемые вопросы

Полезные ссылки и ресурсы

Ключевые Issue и обсуждения

• #8: MTP спекуляция (39-59% приёмки с int8 голове)
• #12: Автоматическое расширение кэша экспертов для больших RAM машин
• #48: Grammar-forced спекулятивные черновики
• #100: Byte-неидентичность и специальные обсуждения MTP
• #101: Бенчмарки на 7-core Ryzen 9800X3D с RTX 5090
• #102: Общие вопросы MTP
• #103: Metal backend на M5 Max с 1024-token run
• #104: 430 GB EPYC benchmarks с RAID NVMe
• #107: Mac Mini M4 Pro Metal backend
• #108: Первые бенчмарки качества (hellaswag/arc/mmlu)
• #113: Первый native Windows 11 datapoint (MinGW)