Qwen3.8-27B на одной RTX 3090: контекст 262K и 65–80 токенов в секунду

Плотная модель на 27 миллиардов параметров, полное окно контекста в 262K, одна немолодая потребительская видеокарта и скорость генерации, при которой кажется, что говоришь с человеком. Ещё недавно это звучало как рекламный слоган. С Qwen3.8-27B и специальной сборкой llama.cpp это теперь воспроизводимая конфигурация на одной RTX 3090.

Немного контекста, почему это важно. Qwen3.8-27B — сильная модель на каждый день, заметно лучше предыдущего поколения Qwen3.6. Но запускать её в хорошем качестве до сих пор было дорого. Версия Q8, почти без потерь, требует около 28 ГБ видеопамяти, так что ни одна потребительская карта её не вмещает. Во многих домашних сборках ставили две RTX 3090 только ради одной такой модели. Рецепт ниже позволяет обойтись куда более лёгкой конфигурацией на обычной карте с 24 ГБ, вышедшей в 2020 году.

Сначала цифры

Замеры на разных машинах, по одной модели и одной видеокарте на каждой:

| GPU            | Decode Speed    | Prompt Prefill   |
|----------------|-----------------|------------------|
| RTX 3090       | 65–80 tok/s     | 1,000–1,300 t/s  |
| RTX 3090 Ti    | 70–100 tok/s    | 1,200–1,700 t/s  |
| RTX 5090       | 150–180 tok/s   | 3,000–4,000 t/s  |

Посмотрите ещё раз на первую строку: от 65 до 80 токенов в секунду на одной RTX 3090. Это быстрее, чем читает большинство людей, и намного выше примерно 30 ток/с, с которых чат начинает ощущаться естественным. И всё это на карте, которую NVIDIA выпустила в 2020 году, с плотной 27B-моделью на полном контексте. 3090 Ti выдаёт около 100, а 5090 — от 150 до 180, что несколько лет назад сошло бы за производительность дата-центра.

Это намного больше, чем давали прежние локальные конфигурации. Так что же изменилось?

Три шага, чтобы повторить

Шаг 1: собрать специальный форк llama.cpp

Форк llama.cpp под названием llamAmpere рассчитан на GPU Ampere и новее и агрессивно их оптимизирует:

git clone -b main https://github.com/JakeATX/llamAmpere.git
cd llamAmpere
cmake -S . -B build-sm86 -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON -DGGML_CUDA_FA=ON \
      -DCMAKE_CUDA_ARCHITECTURES=86 -DGGML_NATIVE=ON
cmake --build build-sm86 -j8 --target llama-server

86 здесь — код архитектуры CUDA для карт серии RTX 30. Для более нового поколения его нужно заменить: у Ada (серия 40) это 89, у Blackwell (серия 50) — 120. Сам форк работает на всех них, отличается только этот флаг компиляции.

Шаг 2: скачать особую квантованную модель

Скорость во многом держится на специально сделанной квантизации ATX-4-XS. Она опубликована на Hugging Face как jakeatx/Qwen3.8-27B-ATX-IQ4_XS-M-GGUF и весит 14,5 ГБ. Скачать её можно двумя способами. Через Hugging Face CLI:

huggingface-cli download jakeatx/Qwen3.8-27B-ATX-IQ4_XS-M-GGUF \
    --local-dir ~/models/qwen38-27b-atx

Или обычным wget в любую папку:

mkdir -p ~/models/qwen38-27b-atx
wget -O ~/models/qwen38-27b-atx/Qwen3.8-ATX-4-XS.gguf \
  "https://huggingface.co/jakeatx/Qwen3.8-27B-ATX-IQ4_XS-M-GGUF/resolve/main/Qwen3.8-ATX-4-XS.gguf"

Поменяйте пути, если модели у вас лежат в другом месте, например на отдельном диске.

Шаг 3: запустить сервер

Запустите вот такой командой, подставив свои каталоги:

CUDA_VISIBLE_DEVICES=0 GGML_Q8_TURBO3_MMA_FUSED=1 \
/home/andrewzhu/storage_1t_1/github_repos/llamAmpere/build-sm86/bin/llama-server \
    -m /mnt/data_2t_3/ai_models_all/Qwen3.8-27B-ATX-IQ4_XS-M-GGUF/Qwen3.8-ATX-4-XS.gguf \
    --alias Qwen3.8-27B-GGUF \
    -c 262144 -b 4096 -ub 1024 -t 8 -tb 8 -ngl 99 -fa on -ctk q8_0 -ctv turbo3 \
    --parallel 1 --jinja --fit off \
    --cache-prompt --cache-ram 8192 --ctx-checkpoints 24 --checkpoint-min-step 10240 \
    --spec-type draft-mtp --spec-draft-n-max 3 --spec-draft-p-min 0 \
    --spec-draft-type-k q8_0 --spec-draft-type-v q8_0 \
    --host 0.0.0.0 --port 8082 \
    --spec-draft-vocab-map docs/mtp-vocab/atx_65536.txt

Две детали, если их пропустить, стоят скорости. Первая — переменная окружения GGML_Q8_TURBO3_MMA_FUSED=1: в заметках самого форка сказано, что она даёт 13% и что про неё все забывают. Вторая — файл vocab-map в конце. Путь docs/mtp-vocab/atx_65536.txt лежит внутри репозитория форка, который вы уже склонировали.

Почему это работает

Здесь складываются четыре отдельные идеи. Ни одна из них не магия, а вместе они показывают аккуратную инженерную работу.

1. Сборка, переписанная под одно семейство чипов

Обычный llama.cpp пишет CUDA-ядра так, чтобы они корректно работали на многих поколениях GPU. Этот форк идёт обратным путём: переписывает горячие участки под одну архитектуру и доводит их, пока выжимать больше нечего.

Два примера. Qwen3.8-27B — не чистый трансформер: в 48 её слоях вместо внимания хранится рекуррентное состояние Gated DeltaNet. Форк переделал эти ядра так, что каждый warp GPU обрабатывает четыре столбца состояния, а не один, и конвейер железа загружен плотнее. Это дало примерно 5–6% и на prefill, и на decode.

Оставшиеся 16 слоёв занимаются настоящим вниманием. Их ключи хранятся в сжатом виде, и прежний путь распаковки использовал лишь около 10% пропускной способности памяти — как пить через тонкую соломинку. Переписанный код подгружает данные асинхронным копированием и исправляет порядок чтения, так что декодирование на длинном контексте ускоряется до 11%.

Не менее важны были и менее эффектные исправления. Две правки выделения памяти освободили 2,8 ГБ видеопамяти: один буфер выделялся дважды, а спекулятивный драфтер резервировал собственные вычислительные буферы, хотя мог делить их с основной моделью. Именно эти 2,8 ГБ решают, поместится ли контекст 262K на карту.

2. Квантизация, которая разумно тратит биты

Схема квантизации определяет, сколько бит получает каждый вес. Наивная схема даёт всем тензорам одинаковый бюджет, скажем 4 бита. Но тензоры по-разному страдают от округления.

Рецепт ATX-4-XS появился из замеров того, какие роли тензоров действительно портятся при сжатии, например проекции внимания и выходные головы. За основу взят формат IQ4_XS, а отдельные роли повышены до Q5_0, Q6_K или Q8_0. В итоге получается файл на 14,5 ГБ — меньше стандартной сборки Q4_K_M той же модели. На каждом проходе он читает из памяти меньше байтов, а качество для повседневной работы остаётся близким к полному.

Меньше значит быстрее, потому что генерация по одному токену упирается в пропускную способность памяти: для каждого токена веса нужно один раз прочитать из видеопамяти. Меньше байтов на токен — больше токенов в секунду. Чтобы это не ударило по качеству, понадобились тщательные замеры того, какие биты оставить.

3. Turbo3: компактная кратковременная память

Во время генерации модель держит KV-кэш — запись всего, что она прочитала и написала, чтобы каждый новый токен мог оглянуться назад. На 262K токенов этот кэш огромен. В стандартных форматах он съел бы большую часть видеопамяти ещё до загрузки весов.

Этот стек, унаследованный от линии работ TurboQuant+, хранит ключи внимания в q8_0 (почти без потерь), а значения — повёрнутыми и сжатыми примерно до 3 бит. Отсюда и название Turbo3. Асимметрия намеренная: ключи работают как адреса, и ошибка в них раскладывает всё не по тем полкам, а значения — это содержимое, которое переносит сокращённую запись.

Честная оговорка: это не точность Q8 на всём пути. Для кода, текстов и повседневной работы с агентами никакого потолка качества не заметно, но если вашей задаче нужно побитово точное воспроизведение при температуре 0, оставайтесь на Q8 с двумя картами.

4. MTP и словарная карта: дешёвое угадывание наперёд

Самый большой выигрыш даёт спекулятивное декодирование с MTP (multi-token prediction). У модели есть собственная маленькая черновая голова, которая предлагает следующие токены, а большая модель проверяет эти предложения параллельно. В этом форке глубина равна 3: угадываются три токена, все три проверяются за один проход, и все верные догадки сохраняются.

Изменилась именно проверка. Старый llama.cpp принимал черновой токен только при точном совпадении с лучшим вариантом основной модели — строго и расточительно. Этот стек вместо этого использует нормальную выборку с отклонением. Каждый черновой токен принимается с вероятностью min(1, p/q), где p — вероятность токена у основной модели, а q — у драфтера. Проще говоря, это честные кости, и итоговое распределение доказуемо совпадает с обычной генерацией: ответ приходит быстрее при том же качестве.

Остаётся файл карты. Зачем команде запуска вообще словарная карта?

Словарь Qwen3.8-27B — почти 248 000 токенов. На каждом шаге черновика скрытое состояние умножается на огромную матрицу проекции, покрывающую их все, примерно 1 152 × 248 320, то есть около 286 миллионов умножений-сложений на каждый черновой токен. При этом реальный текст почти не задевает большую часть словаря. По замерам на реальном выводе короткий список из 65 536 самых частых токенов покрывает 99,59% предложений драфтера.

Поэтому карта урезает только проекцию драфтера, а основная модель по-прежнему выбирает из всего словаря:

Full vocab draft head:    1,152 × 248,320 ≈ 286M MACs per draft token
Shortlisted (65K):        1,152 ×  65,536 ≈  75M MACs per draft token

Это примерно на 75% меньше работы в самой дорогой матрице драфтера. Поскольку черновики строятся по нескольку раз на каждый сгенерированный токен, это оказалось самым большим ускорением в релизе v0.2 — скачок примерно с 65 до 75 ток/с. Без карты каждая догадка оплачивается по полной.

Сложите все четыре слоя: переписанные ядра, более умное распределение бит, сжатую память и дешёвый взгляд вперёд. И видеокарта 2020 года обгоняет то, что специализированное железо предлагало в 2023-м. RTX 3090 не стала лучше. Просто сообщество очень хорошо научилось её выжимать.

Общая картина

Подумайте, что произошло. Один инженер с помощью передовых моделей за несколько дней заставил потребительскую видеокарту 2020 года обслуживать ведущую открытую модель примерно втрое быстрее официального стека, а потом бесплатно выложил ядра, квантизацию и рецепт.

Вот так выглядит локальный ИИ в 2026 году. Каждый месяц то, что в прошлом квартале требовало двух карт, помещается на одну. Это меняет и спор о том, кто контролирует ИИ. Железо, которое уже стоит у людей дома, может запускать современные модели офлайн, без API-ключа, без оплаты за токены и без чьего-либо разрешения. Правила, которые повышают стоимость инференса или ограничивают, кто может покупать вычислительные мощности, сильнее всего ударили бы именно по такой независимой работе.

Что бы вы ни думали об этих политических спорах, практический вывод простой. Веса лежат на вашем собственном диске, а работа над эффективностью в open-source-сообществе, которая приходит в виде ядер и коммитов, а не анонсов, продолжает снижать цену запуска своей модели. Код — в репозитории llamAmpere, модель — jakeatx/Qwen3.8-27B-ATX-IQ4_XS-M-GGUF.