Мета-описание: Полные тесты dual-GPU (RTX 5080 против 4060 Ti, прямое соответствие ПСП 1:1), ускорение Flash Attention на +171 %, выбор между Q8 и Q4 на 16 ГБ VRAM, бюджет цепочки рассуждений до 45 000 токенов и параллельная multi-stream генерация, ускоряющая написание кода почти в 3 раза.

Введение

Когда команда SparkLLM связалась с нами и поблагодарила за освещение 1024 Developer Festival, они предложили провести практическое тестирование с их технической поддержкой. Мы подошли к этому со всей серьезностью: за один день мы загрузили, развернули, протестировали и детально изучили Spark-X2.6-4B на нашем стенде. Результаты выходят далеко за рамки банального замера скорости генерации.

Это не обычная компактная модель. Это нативная reasoning-архитектура в формате 4B, созданная для работы на потребительских видеокартах, с бюджетом рассуждений, способным превышать 45 000 токенов на одну задачу. Тестирование её традиционными методами (zero-shot, temperature 0, лимит в 2048 токенов) приводит к абсолютно искаженным выводам. Ниже мы разберем, почему это происходит и как заставить её работать на максимуме возможностей.

1. Тестовый стенд

Наш тестовый стенд намеренно асимметричен для изолированного анализа аппаратных факторов:

Обе видеокарты оснащены ровно 16 ГБ видеопамяти. В квантовании Q8_0 модель 4B весит 4,07 ГБ — она целиком помещается в память вместе с KV-кэшем на любой из карт без выгрузки в ОЗУ или файл подкачки. Это позволяет оценить чистое влияние пропускной способности памяти (ПСП).

2. Аппаратная дуэль: RTX 5080 против RTX 4060 Ti

Мы изолировали модель на каждой карте (-dev cuda0 против -dev cuda1) в квантовании Q4_K_M с контекстом 32 768 токенов и активным Flash Attention:

Закон пропускной способности памяти: Соотношение скорости генерации (184,5 против 77,2 т/с = 2,39×) практически идеально соответствует разнице в реальной ПСП между RTX 5080 (~1 000 ГБ/с GDDR7) и RTX 4060 Ti (288 ГБ/с GDDR6) с учетом сглаживания кэшем L2. Для небольшой резидентной модели фаза генерации на 100 % упирается в память.

При скорости 184,5 токена/с RTX 5080 генерирует ответ на 500 слов менее чем за 3 секунды. В то же время 4060 Ti со скоростью 77,2 т/с отлично подходит для локальных агентов.

3. Flash Attention: Обязательный параметр

Мы замерили влияние Flash Attention (-fa on против -fa off) на RTX 5080:

Без Flash Attention обработка длинных запросов замедляется почти в 6 раз, а время до первого токена резко возрастает. При локальном запуске Spark-X2.6-4B флаг -fa on строго обязателен.

4. Q4 или Q8? Точка в споре на основе данных

Большинство репозиториев (включая Ollama по умолчанию) загружают Q4_K_M ради совместимости с картами на 6 ГБ. На видеокарте с 16 ГБ VRAM такой компромисс не имеет смысла:

Разница в скорости генерации (184,5 / 147,5 = 1,25×) в точности соответствует разнице в объеме весов (4,07 / 3,29 = 1,24×).

Почему Q8_0 выигрывает на 16 ГБ: Даже при контексте 65 536 токенов модель занимает менее 7 ГБ видеопамяти, оставляя свободными более 9 ГБ. Скорость 147,5 т/с обеспечивает свыше 8 800 слов в минуту, полностью сохраняя точность, которая сильно страдает при 4-битном квантовании моделей меньше 7B.

5. Анализ чувствительности параметров

KV Cache — оставляйте f16: Квантование KV-кэша в q8_0 снижает скорость генерации со 184,5 до 173,2 т/с (−6,5 %). Для 4B модели, чей KV-кэш весит всего ~1 ГБ при 32K контекста, нативный f16 быстрее и полностью точен математически.
Потоки CPU — 16 для 9800X3D: Переход с 8 на 16 потоков снижает задержку диспетчеризации CUDA на коротких промптах (TTFT падает с 92 до 81 мс).
Reasoning — ключевой параметр: Чат-шаблон Spark по умолчанию включает режим рассуждений. В сложных задачах модель генерирует до 31 000 токенов внутреннего монолога на скорости 170 т/с перед выдачей ответа. С флагом --reasoning off ответ формируется сразу, но логическое качество решения резко падает.

6. Ловушка Thinking Budget

Spark-X2.6-4B — модель глубоких рассуждений, которой необходимо пространство для внутреннего анализа задачи.

#### Ловушка 1: Zero-shot ампутация

Тестировать нативную reasoning-модель в классических бенчмарках (температура 0, --reasoning off, лимит 2048 токенов) — всё равно что связать ей руки. Архитектуры 4B опираются на цепочку рассуждений для построения логики. Отключение этого механизма превращает модель в генератор случайных предположений. Рекомендация: используйте temperature: 1.0, top_p: 0.95 и открывайте лимиты токенов.

#### Ловушка 2: Искусственное ограничение токенов

Официальные замеры iFlytek показывают масштаб внутренних цепочек рассуждений модели:

Если ограничить параметр max_tokens значением 16 000, модель израсходует весь лимит внутри блока <think>, так и не успев закрыть тег </think> и вывести код. Тестовый скрипт сообщает « no code block » — ложный отказ, вызванный банальной остановкой по лимиту.

#### Ловушка 3: Парадокс « Overthinking » в коде

Официальные тесты показывают неожиданную закономерность:

В математике чем глубже рассуждения, тем выше точность. В программировании всё наоборот: режим Low превосходит High! Генерируя более 58 000 токенов размышлений, модель 4B начинает переусложнять структуру кода, придумывать несуществующие граничные условия и менять сигнатуры функций. Для программирования оптимален именно режим Low (~42 000 токенов).

7. Революция Multi-Stream: в 2,9 раза быстрее для ОДНОГО разработчика

#### Проблема: Последовательное ограничение

Стандартные LLM пишут код строго по цепочке: токен за токеном. На скорости 147 т/с файл объемом 2000 токенов генерируется 14 секунд. Тензорные ядра GPU при этом простаивают ~70 % времени в ожидании данных из памяти.

Недавние отчеты по TensorFold (ashhart/TensorFold) показали, что видеокарты Blackwell способны выдавать более 700 токенов/с суммарно при одновременной обработке 4 потоков. Мы решили проверить: может ли один разработчик использовать параллельные потоки, чтобы сгенерировать один файл в 3 раза быстрее?

#### Решение: Parallel AST Chunking

Контракт (0,05 с): Короткий запрос генерирует каркас модуля (импорты и сигнатуры классов).
Параллельная диспетчеризация: Через ThreadPoolExecutor отправляются 4 одновременных запроса к llama-server (-np 4), каждый поток реализует отдельный класс.
Сборка: Готовые блоки объединяются в итоговый файл .py.

#### Практический тест: генерация fast_stats_engine.py (4 сложных класса)

Время ожидания разработчика: сократилось в 2,91 раза.

Разбивка по потокам на RTX 5080:

ExponentialMovingAverage: завершено за 1,06 с (92,3 т/с) — 13 строк
HistogramAccumulator: завершено за 1,62 с (99,5 т/с) — 20 строк
StatsPipeline: завершено за 1,97 с (90,7 т/s) — 22 строки
OnlineVariance (Welford): завершено за 2,34 с (99,7 т/s) — 28 строк

Итоговый файл на 100 % валиден (байт-код скомпилирован без ошибок), а разработчик ждал 2,3 секунды вместо почти 7 секунд.

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

Когда 4 запроса поступают одновременно, GPU загружает 4 ГБ весов ровно один раз, но применяет их к вычислениям 4 пользователей одновременно (GEMM матрица-матрица вместо матрица-вектор). Тензорные ядра наконец загружены на полную мощность. При той же нагрузке на чтение памяти GPU выдает 4 токена вместо одного.

8. Расчет памяти на GPU 16 ГБ: миф о 1M

Spark-X2.6-4B заявляет архитектурный контекст в 1 048 576 токенов. Но что реально можно запустить на потребительской карте с 16 ГБ памяти?

В llama-server флаг -c задает общий контекст, распределяемый между слотами -np:

Пытаться выделить 1M контекста для программирования бессмысленно: 1M токенов в FP16 KV весит 43 ГБ. Но на карте 16 ГБ можно запустить 2 слота по 131k токенов или 4 слота по 65k токенов, оставаясь на 100 % в сверхбыстрой GDDR7. С контекстом 65k или 131k на слот reasoning-бюджет модели никогда не будет обрезан.

9. Почему Spark-X2.6 раскрывается на Агентах (а не на синтетических тестах)

Официальные бенчмарки iFlytek наглядно показывают истинное призвание этой модели:

Spark-X2.6-4B создан не для разгадывания синтетических загадок без контекста: это агент для реального мира. Он раскрывается при наличии инструментов, интерпретатора Python, серверов MCP или браузера.

10. Идеальный рецепт для локального запуска

Оптимальная команда llama-server (видеокарта 16 ГБ):

llama-server.exe -m Spark-X2.6-4B-Q8_0.gguf \ --host 127.0.0.1 --port 8650 \ -dev cuda0 -ngl 99 \ -c 262144 -np 4 -fa on -cb \ --batch-size 2048 --ubatch-size 512 \ --threads 16 --reasoning on

Рекомендуемые параметры инференса:

temperature: от 0,7 до 1,0 — строго избегайте 0, которая блокирует цепочку рассуждений
top_p: 0,95
max_tokens: выделите не менее 32 000 – 65 000 токенов на вывод
В чистом программировании: используйте режим Low Reasoning, чтобы избежать оверсинкинга

Блок для llama-swap (config.yaml):

Spark-X2.6-4B: aliases: [Spark-X2.6-4B, Spark-4B] cmd: | python run_model.py llama-server.exe -m Models/Spark-X2.6-4B-Q8_0.gguf --port ${PORT} --host 127.0.0.1 --threads 16 -np 4 -c 262144 -fa on --batch-size 2048 --ubatch-size 512 -ngl 99 -dev cuda0 --reasoning on ttl: 300

Заключение: компактная модель с масштабным мышлением

Spark-X2.6-4B знаменует важный рубеж в открытом ИИ. Она доказывает, что модель на 4 миллиарда параметров с нативным рассуждением может на равных конкурировать с архитектурами на 9B–12B в агентских задачах. На потребительской RTX 5080 она выдает 184 токена/с в соло-режиме, а через multi-stream генерирует полноценные модули кода за 2,3 секунды.

Это не просто хорошая 4B-модель: при правильной настройке это один из самых быстрых, экономичных и впечатляющих локальных движков года.

Команде [SparkLLM](https://x.com/SparkLLM) / [XHToken](https://github.com/XHToken): спасибо за приглашение. Было настоящим удовольствием изучить глубину вашей архитектуры.

Ссылка на нашу вводную статью: [Spark-X2.6-4B Release](https://chats-llm.com/en/blog/spark-x2-6-4b-release)

Модель: [XHToken/Spark-X2.6-4B-GGUF](https://huggingface.co/XHToken/Spark-X2.6-4B-GGUF) · GitHub: [github.com/XHToken](https://github.com/XHToken) · X: [@SparkLLM](https://x.com/SparkLLM)

Благодарности сообществу LocalLLaMA и экосистеме llama.cpp.