Ветка на Reddit, где обсуждают neural-weight-compression, не даёт ответа на вопрос «пробовал ли кто-то это на практике»: в посте нет ссылок на код, замеров и результатов, а сама страница открывается только после проверки на бота. Проверять там нечего.
Сама аббревиатура при этом существует в двух независимых контекстах. Первый, открытый проект parda21/NWC на GitHub, заявляет lossless-сжатие весов LLM с декодированием прямо внутри CUDA-ядра matvec: для BF16-моделей обещано уменьшение размера на 31%, для fp8 на 13%. Второй, исследовательская работа с тем же названием, где Neural Weight Compression описан как обучаемый нейрокодек и речь идёт о сжатии с потерями в режиме 4-6 бит.
Дальше разбор без домыслов: как работает lossless-сжатие весов, что именно обещает проект на GitHub, как запустить демо на своей машине и какие данные нужны, чтобы отличить рабочий метод от красивой строчки в README.
Что такое lossless-сжатие весов и зачем оно нужно
Веса LLM хранятся в формате BF16: два байта на параметр. Открытая модель на 7,61 млрд параметров занимает около 15,2 ГБ в файлах весов в BF16, такой пример приводит обзорная статья на TorLab.
Lossless-сжатие не меняет значения весов. После распаковки байты совпадают с исходными бит в бит, поэтому качество модели остаётся тем же. Работает это на энтропийном кодировании: веса распределены неравномерно, и плотная упаковка позволяет записать те же числа меньшим количеством байт. Аналогия с ZIP честная по смыслу, но есть разница в требованиях: архив на диске можно распаковывать секундами, веса же нужны на каждом шаге генерации токена. Если распаковка тормозит сильнее, чем экономит чтение из памяти, метод теряет смысл.
Чем lossless-сжатие отличается от квантизации
Квантизация переводит веса в формат с меньшей разрядностью, например в 4 бита. Значения при этом меняются: часть информации теряется, и качество может просесть. Зато выигрыш в размере радикально больше: четырёхбитная модель занимает примерно вчетверо меньше, чем BF16. Для модели на 2,8 трлн параметров при 4 битах на параметр потребуется около 1,4 ТБ, тот же обзор на TorLab приводит эту оценку.
Lossless-сжатие идёт другим путём: значения не трогают, выигрыш скромнее. По заявлениям проекта NWC, BF16-модель ужимается на 31%, fp8 на 13%. Точность остаётся исходной, но рассчитывать на четырёхкратное сокращение не стоит.
Почему это важно именно для VRAM
VRAM задаёт потолок: если веса не помещаются, модель не запустится без выгрузки слоёв в RAM или на диск, а это уже другой режим по скорости. Каждый сжатый байт весов напрямую уменьшает занимаемую память. Проект NWC заявляет, что Qwen2.5-7B в полном BF16 помещается на 12-гигабайтную карту, а Qwen3-4B на RTX 4070 расходует на 2,4 ГБ VRAM меньше нативного BF16.
Практический бюджет памяти под веса, KV-кеш и рабочие буферы подробно разобран в материале про true Q4_K_M на RTX 5080 с 16 ГБ: там видно, что расчёт места без учёта KV-кеша и длины контекста даёт неверную картину даже при сжатых весах.
Сжатие не добавляет вычислительной мощности. Оно снижает давление на память и объём чтения на токен, и только от качества ядра декодирования зависит, превратится ли это в выигрыш по скорости или в потерю.
Проект NWC на GitHub: что он обещает
parda21/NWC описывается автором как lossless-компрессия весов LLM, распаковываемая внутри CUDA-ядра матрично-векторного умножения. Веса остаются бит-идентичными, дополнительной квантизации нет. Отдельно заявлено сжатие несвязанных (untied) таблиц эмбеддингов через gather-ядро.
Все цифры ниже взяты из описания репозитория и не проверены независимо. Это главная оговорка ко всему разделу.
Как работает декодирование внутри CUDA-ядра
Механика такая: веса лежат в VRAM в энтропийно-кодированном виде, а декодируются в регистрах внутри ядра matvec. Распакованный массив весов не попадает в память вообще, поэтому GPU читает меньше байт на каждый токен. Этим подход отличается от схемы «распаковать в буфер, потом умножить»: там экономия на хранении обменивается на дополнительный трафик памяти.
Плата за такую схему - жёсткая привязка к NVIDIA. Ядра пишутся под CUDA, и на AMD или Apple Silicon метод не поедет.
Заявленные цифры: BF16, fp8 и примеры моделей
| Формат или модель | Заявление проекта |
|---|---|
| BF16 | 31% меньше размера и быстрее cuBLAS |
| weight-only fp8 e4m3 | 13% меньше при нативной скорости fp8 matvec; значения хранятся lossless и занимают 87% исходных байт |
| Qwen3-4B на RTX 4070 | работает быстрее нативного BF16 и использует на 2,4 ГБ VRAM меньше |
| Qwen2.5-7B в полном BF16 | помещается на 12-гигабайтную карту |
На карте с ограниченной пропускной способностью (NVIDIA A16) проект заявляет, что метод всё ещё быстрее нативного BF16. Часть вариантов layout, например layout 2, на A16 и H100 в описании ещё не измерена, а на RTX 4070 тот же layout 2 медленнее layout 0 из-за штрафа за размер. Это тоже слова автора, а не сторонний замер.
Как проверить NWC на практике: установка и демо
Проект ставится как pip-пакет neural-weight-compression. Есть готовые сжатые чекпоинты и демо-скрипты, поэтому первичную проверку можно сделать без обучения и ручной конвертации модели.
Требования к железу и ПО
Нужны NVIDIA GPU поколения Turing или новее (замеры сделаны на Ampere и новее), драйвер под CUDA 12.6+ и PyTorch с поддержкой CUDA. На картах старше Turing метод недоступен, как и на любом не-NVIDIA железе. Это ограничение стоит озвучить сразу, чтобы не тратить время на установку.
Как запустить демо и что смотреть
pip install neural-weight-compression python -m nwc.demo Parda21/Qwen3-0.6B-NWC --load --graph python -m nwc.demo Parda21/Qwen3-4B-NWC --load --graph python -m nwc.demo Parda21/Qwen3-4B-NWC-fp8 --load --graph python -m nwc.demo Qwen/Qwen3-4B --native --graph
Последняя команда запускает несжатую Qwen/Qwen3-4B, чтобы сравнить с ней сжатые версии. Смотреть стоит на три вещи: занятую VRAM, скорость генерации и качество ответов на одних и тех же промптах.
Качество проект предлагает мерить perplexity методом llama.cpp, тогда числа из PyTorch и из GGUF оказываются сопоставимыми. Для любой BF16-модели HF causal LM есть путь конвертации: nn.Linear заменяется на NWCLinear, а сжатый чекпоинт сохраняется в safetensors вместе с nwc_config.json, подробности есть в репозитории проекта.
Демо не заменяет бенчмарк: это способ познакомиться с методом на трёх готовых моделях и одной несжатой. Как выглядит честный набор замеров, видно в разборе теста 500+ заданий по кодингу, pandas и локальному RAG: там сравнивают поведение моделей на одном наборе задач, а не на одном удачном промпте.
Ограничения и риски lossless-сжатия весов
Декодирование в ядре стоит вычислений. На карте с высокой пропускной способностью памяти выигрыш от меньшего чтения перекрывает эти затраты, при маленьком батче или медленной памяти соотношение может быть другим. Заявленное ускорение относительно cuBLAS получено на конкретных моделях и конкретной видеокарте.
Степень сжатия упирается в статистику данных. Проект указывает, что символы почти не сжимаются: около 5% с текущим кодером и до 13% с идеальным. Это ограничивает достижимый коэффициент для реальных чекпоинтов.
Отдельная тема - структурные выбросы. Веса распределены неравномерно, и часть параметров имеет аномально большие величины, несущие непропорционально большой вес в логике модели; при клиппинге или плохой квантизации таких значений способность модели рассуждать резко деградирует, об этом прямо сказано в исследовании на alphaXiv. Lossless-сжатие выбросы не клиппирует, но кодировать их всё равно приходится корректно.
Почему нельзя слепо доверять заявлениям
Все приведённые выше цифры взяты из описания проекта и не проверены независимо. Чтобы понять реальную пользу, нужен набор данных, которого пока нет: тесты на нескольких моделях, а не на одной Qwen; замеры на разном железе, а не только на RTX 4070; perplexity и качество генерации до и после сжатия; поведение при батчинге и длинном контексте; прямое сравнение с квантизацией при том же бюджете памяти. До появления таких чисел метод нельзя рекомендовать как готовое решение.
Сравнение с квантизацией: когда что выбирать
Если приоритет - не потерять ни одного бита весов и есть NVIDIA GPU с CUDA 12.6+, lossless-сжатие даёт скромную, но бесплатную по качеству экономию VRAM. Если цель уместить модель в минимальную память и небольшая потеря качества допустима, квантизация выигрывает по объёму: четырёхбитные форматы дают куда большее сокращение.
Исследовательская работа по NWC идёт дальше и предлагает обучать нейрокодек на датасете весов вместо ручных преобразований: канального масштабирования (channel-wise scaling), ортогональных вращений, преобразования Адамара. Авторы отчитываются о сильных результатах именно в режиме 4-6 бит (alphaXiv). Это уже сжатие с потерями, и путать его с lossless-проектом на GitHub нельзя.
Два разных NWC: lossless-сжатие и обучаемый нейрокодек
Под одной аббревиатурой скрываются два подхода с разными целями.
Первый, проект parda21/NWC: lossless-сжатие весов, декодирование внутри CUDA-ядра matvec, бит-идентичный результат, экономия VRAM без потери точности. Второй, исследовательский фреймворк Neural Weight Compression, где нейрокодек из пары сетей (analysis и synthesis transforms) обучается по rate-distortion objective сжимать тензоры весов (описание на alphaXiv). Там акцент на 4-6-битном режиме, то есть заведомо на сжатии с потерями.
Общая идея у обоих направлений одна: не хранить веса в удобном для вычислений формате, а восстанавливать их на лету. Рядом стоит более радикальный взгляд, при котором модель вообще не сохраняют, а собирают веса по «рецепту», правилу, позволяющему вычислять их на ходу, о таком подходе пишет TorLab.
Что в итоге: стоит ли пробовать NWC
Подтверждённых данных о том, что технику neural-weight-compression кто-то успешно воспроизвёл в обсуждаемом посте на Reddit, нет: там нет ни кода, ни замеров. Публичный проект с таким названием существует, но все его цифры - заявления автора, а не результат независимого аудита.
Если у вас NVIDIA GPU от Turing и новее, драйвер CUDA 12.6+ и PyTorch с CUDA, разумный шаг такой: поставить pip-пакет, прогнать демо на Qwen3-4B и сравнить VRAM и скорость с несжатой Qwen/Qwen3-4B на своих промптах. Полчаса работы дадут больше, чем чтение README.
Ждать, что lossless-сжатие заменит квантизацию, не приходится: 31% экономии на BF16 это не четырёхкратное сокращение. Метод полезен там, где качество критично и есть современная NVIDIA-карта; в остальных случаях выигрыш от квантизации будет заметнее. Независимые замеры пока придётся искать самостоятельно, а методику честных сравнений локального запуска стоит взять из разбора Qwen 3.8 27B на одной RTX 5090, где отдельно проговаривают, что подтверждено, а что остаётся предположением.