Qwen 3.8 27B локально: 17 ГБ общей памяти, а не VRAM

Цифра, которая ходит по сети для Qwen3.8-27B, — это 17 ГБ, и она взята прямо из таблицы требований самого Unsloth. Но если дочитать заголовок таблицы, там сказано нечто более конкретное, чем подразумевает само число: единицы измерения — это общая память, RAM плюс VRAM, либо объединённая память. Именно эта разница отделяет модель, которая работает на вашей видеокарте, от модели, которая частично работает на материнской плате.

Что можно запустить локально, а что нельзя

С 24 ГБ вы запускаете тот квант, который задумывал Qwen; с 16 ГБ — компромисс; ниже этого не стоит и начинать. Qwen выложила Qwen3.8-27B на Hugging Face под лицензией Apache 2.0: плотная модель на 27B с обработкой изображений и нативным контекстом в 262 144 токена. Она достаточно мала, чтобы вопрос перестал быть «какой дата-центр» и стал «поместится ли это в машину у меня на столе». Это совсем другой разговор, чем вокруг GLM 5.2, где даже 2 бита требуют Mac Studio на 256 ГБ. Коротко о главном.

Лицензия весов:          Apache 2.0, коммерческое использование разрешено
Параметры:               27B плотных (llama.cpp считает 27,32B)
Нативный контекст:       262 144 токена (до 1M через YaRN)
Минимальный рабочий GGUF: 9,01 ГБ (Unsloth UD-IQ2_XXS)
GGUF на 4 битах:         16,81–18,97 ГБ в зависимости от издателя
Рекомендация вендора:    11–13 ГБ на 2 битах, 17–19 ГБ на 4 битах, RAM+VRAM
Зрение:                  отдельный файл mmproj, +0,63–0,93 ГБ по издателю
Замер на M2 Pro 16 ГБ:   7,11 tok/s генерация на 2 битах, 74,59 tok/s промпт
Та же машина на 4 битах: промпт вчетверо медленнее, генерация падает совсем
Время настройки:         около 20 минут, большая часть — загрузка

Что вы получите после настройки: сильная модель для кода и агентских задач работает автономно, без потокенной оплаты и без выхода данных за пределы машины. Чего вы не получите: латентности хостинга, полного контекста 256K на потребительском железе и уровня Max, у которого открытых весов нет вовсе.

Честный вывод: карта на 24 ГБ — это точка входа для кванта, который Qwen действительно предлагает использовать, а 32 ГБ — там, где перестаёт быть тесно. Ниже 16 ГБ интересен уже не выбор кванта, а вопрос, подходит ли локальный инференс вообще.

Сколько VRAM на самом деле нужно Qwen 3.8 27B?

От 11 до 19 ГБ общей памяти, и слово «общей» здесь несёт основную нагрузку. Таблица требований Unsloth помечает единицы измерения явно: общая память, то есть RAM плюс VRAM, либо объединённая память на Apple silicon. Это бюджет на всю машину, а не спецификация видеокарты.

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

Здесь и возникает неверное прочтение: на той же странице Unsloth сказано, что 4 бита «будут работать на большинстве устройств с 17-19 ГБ VRAM вроде RTX 5080, 4090 или Mac с 24 ГБ RAM». Однако по собственной сравнительной странице NVIDIA RTX 5080 поставляется с 16 ГБ GDDR7, как и 5070 Ti. У 4090 — 24 ГБ, у 5090 — 32 ГБ. То есть на 5080 путь через 4 бита — это бюджет общей памяти, который набирается картой плюс системной памятью, ровно как написано в заголовке таблицы, а вовсе не 17 ГБ, лежащие в VRAM. Работать оно всё равно будет. Просто часть слоёв окажется по другую сторону шины PCIe, и скорость генерации отправится туда же.

Если нужно одно правило, возьмите правило Unsloth: сумма RAM и VRAM должна быть не меньше размера файла кванта, иначе всё работает, но подкачивается с диска и сильно тормозит.

Какой квант GGUF скачивать?

Берите самый крупный файл, после которого остаётся 2–3 ГБ запаса, и сравнивайте байты, а не названия квантов. Название — это не размер. Три издателя выпустили для этой модели файл под именем Q4_K_M, и они различаются на 2,2 ГБ, потому что каждый по-своему выбирает точность отдельных тензоров под одной и той же меткой.

На карте с 16 ГБ этот разброс и есть всё решение. Сборка LM Studio на 300 МБ меньше, чем у Unsloth, и на 2,2 ГБ меньше, чем у ggml-org, и ничего из этого не видно по названию кванта.

Практический выбор по бюджету памяти:

• От 32 ГБ: UD-Q4_K_XL на 17,92 ГБ или Q6_K на 22,88 ГБ, если хотите потратить запас на точность, а не на контекст.
• 24 ГБ: Q4_K_M от lmstudio-community на 16,81 ГБ оставляет больше всего места под KV-кэш.
• 16 ГБ: UD-Q3_K_XL на 13,44 ГБ помещается с запасом для работы. Файлы на 4 битах без выгрузки не поместятся.
• Mac с 16 ГБ объединённой памяти: UD-IQ2_XXS на 9,01 ГБ. Это пол, и вы это почувствуете.

Приставка UD у Unsloth обозначает их динамические кванты, которые держат чувствительные слои в более высокой точности вместо равномерного квантования. На уровне 2 и 3 бит это важнее номинальной разрядности.

Когда локальный запуск Qwen 3.8 27B оправдан, а когда нет?

Когда данные не могут покидать периметр или когда нагрузка достаточна, чтобы видеокарта окупилась. В остальных случаях хостинг дешевле и заметно быстрее.

Локальная установка подходит, когда:

1. Вы работаете с кодом или документами по договору, запрещающему сторонний инференс.
2. У вас уже есть GPU на 24 или 32 ГБ и хочется перестать платить потокенно за рутинный рефакторинг и ревью.
3. Вам нужна автономность: в самолёте, в изолированной лаборатории или за сетью, которую вы не контролируете.

Локальная установка не подходит, когда:

1. У вашей карты 12 ГБ или меньше. Кванты, которые поместятся, не настолько хороши, чтобы оправдать настройку.
2. Вам нужна вершина семейства. Qwen3.8-Max доступен только через API без открытых весов, а родственной 2.4T-A95B нужно 397 ГБ даже на 1 бите.
3. Вы гоняете длинные агентские сессии. При замеренных ниже 2,91 tok/s на реальном промпте задача, которую хостинг завершает за четыре минуты, будет идти почти час.

Правило остановки: если вы дошли до шага 4 ниже и генерация держится ниже 5 tok/s на той длине контекста, которой вы реально пользуетесь, прекращайте настройку. Эта машина не подходит для такой модели, и ни один флаг не изменит порядок величины.

Какое железо тянет Qwen 3.8 27B?

GPU на 24 ГБ или Mac на 32 ГБ — комфортная точка входа; 16 ГБ работает с компромиссами. Конкретная карта значит меньше, чем общий объём памяти и её пропускная способность.

Со стороны софта llama.cpp мешает меньше, чем принято думать. Строка архитектуры в config.json — это qwen3_5, а llama.cpp поддерживает это семейство с февраля 2026 года, когда PR #19435 добавил поддержку плотных и MoE-моделей. Проверено здесь: сборка b10375, опубликованная 2026-08-12 в 12:18 UTC, то есть до того, как сами веса появились на Hugging Face на следующий день в 08:23 UTC, загружает и запускает файл без нареканий. Так что «обновите llama.cpp» редко бывает настоящим решением: если ваша сборка достаточно свежая, чтобы запускать Qwen 3.5 или 3.6, она запустит и эту модель. На macOS brew install llama.cpp достаточно свеж, на Linux и Windows берите релизный бинарник или собирайте из исходников.

Есть одна деталь Apple silicon, которой нет ни в одной таблице вендоров. macOS не отдаёт GPU весь объём памяти. На 16-гигабайтном M2 Pro, использованном для этой статьи, llama.cpp напечатал лимит Metal прямо при старте:

ggml_metal_device_init: has unified memory    = true
ggml_metal_device_init: recommendedMaxWorkingSetSize  = 12713.12 MB

12,71 ГБ, а не 16. Именно эта строка определяет, какие кванты вообще являются кандидатами на любом Mac, и её стоит прочитать до того, как скачивать 17 ГБ весов.

Как запустить Qwen 3.8 27B в llama.cpp?

Пять шагов, и медленный из них — загрузка. Всё описанное ниже выполнялось на том самом M2 Pro.

Шаг 1: установить llama.cpp

brew install llama.cpp
llama-cli --version

Ожидаемый результат: строка сборки. У меня это b10450-ece963f41. Как сказано выше, подойдёт почти любая сборка 2026 года.

Шаг 2: выбрать квант и сверить его со своим потолком

curl -s "https://huggingface.co/api/models/unsloth/Qwen3.8-27B-GGUF/tree/main" \
  | python3 -c "import json,sys;[print(f\"{f['path']:32s}{f['size']/1e9:6.2f} GB\") for f in json.load(sys.stdin) if f['path'].endswith('.gguf')]"

Ожидаемый результат: полный список файлов с точными размерами. Сравнивайте с общей памятью, а не с видеокартой.

Шаг 3: скачать веса

curl -L -o qwen38-27b.gguf \
  "https://huggingface.co/unsloth/Qwen3.8-27B-GGUF/resolve/main/Qwen3.8-27B-UD-Q3_K_XL.gguf"

Ожидаемый результат: один файл, на таком размере без шардов. Подставьте имя того кванта, который выбрали на шаге 2.

Шаг 4: запустить

llama-server -m qwen38-27b.gguf -c 16384 \
  --temp 1.0 --top-p 0.95 --top-k 20 --port 8080

Ожидаемый результат: OpenAI-совместимая точка входа на localhost:8080. Эти значения сэмплинга — опубликованные Qwen настройки для режима размышления. Для режима без размышления используйте --temp 0.7 --top-p 0.80 --top-k 20 --presence-penalty 1.5.

Шаг 5: добавить зрение, если оно нужно

Базовый GGUF содержит только текст. Загрузите его отдельно, и llama.cpp прямо сообщит об этом строкой modalities : text. Визуальная половина живёт в отдельном файле проектора:

curl -L -o mmproj.gguf \
  "https://huggingface.co/unsloth/Qwen3.8-27B-GGUF/resolve/main/mmproj-F16.gguf"
llama-server -m qwen38-27b.gguf --mmproj mmproj.gguf -c 16384 --port 8080

Ожидаемый результат: приём изображений на вход. Заложите 0,93 ГБ на этот проектор F16 — сверх весов, а не внутри той цифры, которую вы планировали. Если нужен более компактный проектор Q8_0 на 0,63 ГБ, из трёх издателей его выпускает только ggml-org, так что этот файл придётся брать из другого репозитория.

Насколько быстр Qwen 3.8 27B на Mac с 16 ГБ?

7,11 токена в секунду на 2 битах, а файл на 4 битах не генерирует вовсе. Замерено через llama-bench на том же M2 Pro, llama.cpp b10450, оба кванта на одной машине:

Строка с 4 битами заслуживает отдельного внимания. Файл загружается. Модель верно сообщает количество параметров. Обработка промпта идёт, вчетверо медленнее, чем на 2 битах, потому что веса больше не помещаются в рабочий набор Metal на 12,71 ГБ и машина уходит в подкачку. А затем генерация падает с failed to decode generation batch, res = -3. Заголовочный файл llama.cpp документирует любое возвращаемое значение ниже -1 как фатальную ошибку, в отличие от кода 1 — обычного «не нашлось слота KV» при слишком большом батче. Уход ниже вендорской цифры по памяти на этом железе не деградирует плавно. Он даёт бенчмарк, выполненный наполовину.

Это синтетические числа при нулевом контексте. В реальности хуже. Если подать ту же 2-битную модель через llama-server с -c 16384 и отправить промпт на 7072 токена, собственный отчёт llama.cpp по таймингам выглядит так:

prompt eval time = 208988.11 ms /  7072 tokens ( 33.84 tokens per second)
       eval time =  27129.34 ms /    80 tokens (  2.91 tokens per second)
      total time = 236117.45 ms /  7152 tokens

Четыре минуты на один ход, генерация на 2,91 tok/s вместо обещанных бенчмарком 7,11. Обработка промпта замедляется по мере заполнения контекста: скользящее среднее, которое llama.cpp печатает на каждом шаге прогресса, показывает 43,58 tok/s на токене 2090 и 37,82 к токену 6186. Любая цифра tok/s, названная при нулевом контексте, включая цифры из таблицы выше, — это лучший случай, который вы когда-либо увидите.

Тот же запрос демонстрирует и поведение размышления по умолчанию. Он был ограничен 80 токенами ответа и вернул фрагмент вместо ответа, потому что reasoning_effort по умолчанию равен xhigh и рассуждение израсходовало бюджет до того, как ответ появился. Признак проверяется легко: задайте вопрос, требующий нескольких шагов рассуждения, ограничьте max_tokens восемьюдесятью — и ответ придёт с finish_reason: length, пустым content и всеми 80 токенами внутри reasoning_content. Спросите вместо этого 84 * 3, и тот же лимит окажется достаточным: от 29 до 51 токена за три запуска, потому что короткое рассуждение помещается. Проблема не в лимите, а в том, что лимит встретился с вопросом, над которым модель хочет подумать. На такой медленной машине для рутинной работы ставьте reasoning_effort в low или отключайте размышление и задавайте вменяемый max_tokens.

Ещё одна тихая деталь в логе загрузки: llama.cpp печатает model has unused tensor blk.64.nextn.* и пропускает этот тензор. Это голова многотокенного предсказания, которую Qwen обучала для ускорения инференса и которую данный путь GGUF не использует. ggml-org публикует веса MTP отдельными файлами. Если вам нужно это ускорение, за ним придётся сходить самому.

Плата за качество на 2 битах проявляется быстро. На просьбу слить два отсортированных связных списка модель в трассировке размышления набросала решение как некорректный Python: def __init__(self, val): self.val; self.next — это два выражения без эффекта, а не присваивания. Трассировки размышления — это черновик, и итоговый ответ вполне мог быть в порядке, но такие оговорки становятся реже по мере роста кванта. Это самый сильный аргумент в пользу того, чтобы найти 24 ГБ, а не выжимать 16.

Две метки, из-за которых не стоит путаться. llama.cpp сообщает архитектуру как qwen35, потому что Qwen3.8-27B построена на архитектуре Qwen3.5, и config.json объявляет model_type: qwen3_5. Он же сообщает динамический 2-битный файл Unsloth как ftype Q4_K - Small, но это поле заголовка, а не фактический состав. Доверяйте количеству байт.

Почему модели на 27B нужен такой маленький KV-кэш?

Потому что полное внимание используют только 16 из её 64 слоёв. Qwen публикует топологию слоёв в карточке модели: 16 повторений из трёх блоков Gated DeltaNet, за которыми идёт один блок Gated Attention. Gated DeltaNet — это слой линейного внимания, состояние которого имеет фиксированный размер на последовательность и не растёт вместе с разговором. Кэш на каждый токен держат только 16 слоёв полного внимания.

По данным config.json эти слои используют 4 KV-головы при размерности головы 256. На f16 это 4 КиБ на токен на слой, а на 16 слоёв — 64 КиБ на токен:

Обычной 64-слойной модели с той же конфигурацией голов потребовалось бы вчетверо больше кэша, 64 ГиБ на полном контексте. Именно гибридная компоновка делает модель на 27B с окном 256K вообще пригодной для настольной машины.

Отсюда же следует честный ответ про контекст. Веса поддерживают 262 144 токена нативно и растягиваются до миллиона через YaRN, но полный нативный контекст сам по себе стоит 16 ГиБ кэша. На тестовой машине с 16 ГБ llama-server стартовал и обслуживал запросы с -c 16384 на 2-битном кванте, и практичный диапазон там — от 8K до 16K. На 32 ГБ можно спокойно держать 32K рядом с 4-битной моделью. Ставьте -c на то, чем реально пользуетесь, а если нужно больше — квантуйте кэш через --cache-type-k q8_0 --cache-type-v q8_0, это примерно вдвое сокращает объём при небольшой потере качества. Полное окно оставьте хостингу — та же логика применима и к контекстным окнам в целом.

Частые ошибки при локальной настройке и их исправление

Большинство локальных сбоев здесь — это сбои памяти в другой одежде. Каждая строка ниже воспроизведена на тестовой машине, кроме последней, которая взята из собственных рекомендаций Qwen.

Может ли команда пользоваться одной локальной машиной с Qwen 3.8 27B?

Одна машина обслуживает одного-двух разработчиков, но не команду. llama-server открывает OpenAI-совместимую точку входа, на которую любой коллега может направить клиент, и эта часть действительно проста:

llama-server -m qwen38-27b.gguf -c 16384 --host 0.0.0.0 --port 8080 --parallel 2

Ограничение — арифметика. Одна потребительская видеокарта, гоняющая 27B на 4 битах, производит один поток токенов, а --parallel делит ваш бюджет контекста между слотами, а не умножает пропускную способность. Двое разработчиков на 4090 заметят друг друга. Четверо встанут в очередь.

Командам, которым нужна общая локальная точка входа, стоит смотреть на vLLM или SGLang на серверной карте, а это уже другой проект с другим бюджетом. Этот путь разобран в руководстве по железу и стоимости самостоятельного хостинга GLM 5.2; логика расчёта переносится, даже если модель другая. Модель 27B на 4 битах занимает примерно треть памяти карты на 48 ГБ, что оставляет реальное место под параллельный KV-кэш, поэтому одна такая карта для команды — более разумная покупка, чем четыре 4090, каждая из которых держит собственную копию весов.

Что делать, когда локальная машина не тянет посреди задачи?

Направьте клиент на размещённую точку входа, говорящую на том же протоколе, и продолжайте работу. У любой локальной установки есть одни и те же два пробела, и llama.cpp в них не виноват.

Первый — это ёмкость. Ваша машина гоняет одну модель на той скорости, которую позволяет пропускная способность памяти, и когда задаче нужна родственная 2.4T, уровень Max или просто более быстрый ответ, локальной точке входа предложить нечего. Второй — это охват. У Qwen3.8-27B открытые веса есть, у Qwen3.8-Max их нет, а карточка модели указывает на размещённый 27B с контекстом 1M по умолчанию на Qwen Cloud, помеченный как скоро появится, причём страница обзора по ссылке на момент написания по-прежнему отдаёт 404. Часть этого семейства вы не разместите ни при каком бюджете на железо.

Поскольку llama-server говорит в формате OpenAI Chat Completions, как и размещённые шлюзы, решение одинаково с обеих сторон: поменяйте base_url и ключ, код оставьте как есть. Шлюз вроде ofox.ai держит bailian/qwen3.8-max рядом с предыдущим поколением bailian/qwen3.6-27b и bailian/qwen3.5-27b, так что один и тот же клиент может откатиться с вашей видеокарты на размещённый уровень без второго аккаунта. Самой модели с открытыми весами на 27B в этом каталоге на момент написания нет; на OpenRouter её отдают два провайдера, оба с полным контекстом в 262 144 токена: Chutes по 0,40 доллара за миллион входных токенов и 3,00 за миллион выходных на fp8, и AkashML по 0,45 и 3,20 на bf16. Тот же урок, что и в таблице GGUF, работает уровнем выше. Более дешёвая точка входа — это квантованная, и разница в цене есть разница в точности.

Посчитайте до покупки железа. По этим ставкам разработчик, прогоняющий 10 миллионов входных и 2 миллиона выходных токенов в месяц, платит от 10 до 11 долларов в зависимости от того, чей провайдер обслужил запрос. Против этого 4090 себя не окупает; причины владеть ею — приватность и автономность, а не арифметика.

Стоит ли вообще запускать 27B?

Против собственного предшественника — определённо да. По опубликованным Qwen цифрам, Qwen3.8-27B набирает 73,0 на Terminal Bench 2.1 против 63,4 у Qwen3.6 27B, 61,7 на SWE-bench Pro против 53,5 и 79,0 на внутреннем QwenSWEBench против 49,3. По работе с компьютером OSWorld-Verified вырос с 63,9 до 84,3. Это вендорские числа, полученные на Claude Code harness с корректировками части наборов задач, поэтому воспринимайте их как направление, а не как турнирную таблицу — но для одного поколения при том же числе параметров направление крутое. Для независимого взгляда на то, как размерный класс 27B держится против передовой размещённой модели, сравнение Qwen 3.6 27B и Claude Opus 4.6 в кодинге — ближайшая имеющаяся у нас база.

Для локальной машины важнее сравнение с тем квантом, который вы реально можете себе позволить запускать. 27B на 4 битах на карте с 24 ГБ близка к той модели, которую Qwen прогоняла по бенчмаркам. 27B на 2 битах на ноутбуке с 16 ГБ — нет, и разрыв между ними больше, чем разрыв между поколениями.

Есть независимая точка отсчёта для того, что покупает дополнительная память. Когда вышло предыдущее поколение, Simon Willison запустил его локально и 2026-04-22 сообщил собственные числа: “I tried it out with the 16.8GB Unsloth Qwen3.6-27B-GGUF:Q4_K_M quantized version”, зафиксировав генерацию на 25,57 токена в секунду и назвав это “an outstanding result for a 16.8GB local model”. Это тот же размерный класс поколением раньше, на 4 битах, на машине, где он помещается. Mac с 16 ГБ из этой статьи выдаёт 7,11 tok/s на синтетическом бенчмарке и 2,91 на реальном промпте, при 2 битах. От трёх до девяти раз медленнее, на худшем кванте, ради примерно 8 ГБ. Покупайте память раньше, чем что-либо ещё.

References

• Qwen/Qwen3.8-27B model card
• Qwen3.8-27B config.json
• Unsloth: Qwen3.8 how to run locally
• unsloth/Qwen3.8-27B-GGUF file listing
• ggml-org/Qwen3.8-27B-GGUF file listing
• lmstudio-community/Qwen3.8-27B-GGUF file listing
• NVIDIA GeForce graphics card comparison
• OpenRouter: qwen/qwen3.8-27b
• llama.cpp
• Simon Willison: Qwen3.6-27B