Классический процесс квантования нейронных сетей долгое время сводился к сжатию весов из исходных плавающих форматов (FP32 или BF16/FP16) в более компактные целочисленные типы (INT8, INT4) или промежуточные представления вроде EXL2 и GGUF/k-quants с использованием техник смешанного квантования (QAT/AWQ).

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

Следующим шагом стала попытка перейти от аппроксимации вещественных чисел в целые к дискретному представлению весов. Используя бинарную (1-bit) и тернарную (1.58-bit) структуру, разработчики кардинально ужали размеры моделей. Они даже начали что-то показывать в синтетических тестах, но в реальных задачах их точность редко превышала показатели моделей с Q1/Q2-квантизацией. Результаты были не очень вдохновляющими, да и чипы памяти были доступны в необходимых количествах, поэтому дискретные методы квантования широкого распространения не получили.

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

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

1. Бинарные веса (1-bit): допустимы всего два значения: [-1, +1].

2. Тернарные веса (1.58-bit): допустимы три значения: [-1, 0, +1].

3. Квинарные веса (2.32-bit): допустимы пять значений: [-1.0, -0.5, 0, 0.5, 1.0].

4. N-нарные веса (log_2(N)-bit): допустимы N значений […,…,…]{N}.

Информационная емкость каждого веса определяется двоичным логарифмом количества значений дискретизации, поэтому для бинарной квантизации емкость составляет log_2(2) = 1 bit, для тернарной log_2(3) ~1.58 bit и для квинарной log_2(5) ~2.32 bit. Квинарная квантизация сейчас не используется по причине плохой поддержки такого формата современными ускорителями.

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

Что это такое, разобрались. Теперь посмотрим, как это работает и чем отличается от традиционных вариантов квантования. В стандартных GPU (и в CPU) умножение чисел с плавающей точкой (и целочисленное умножение в тензорных ядрах) считается одной из самых затратных операций. В бинарных и тернарных сетях умножение вектора на вес +1 оставляет элемент без изменений, -1 меняет знак, а 0 полностью отбрасывает вычисление. В результате операции умножения матриц превращаются в простые инструкции сложения и вычитания.

Конечное количество значений весов радикально сокращает необходимый размер видеопамяти. В отличие от традиционных методов low-bit квантования, где маркетинговое название вроде IQ2_XXS скрывает реальный средний размер в 2.8 bit на каждый вес сети, дискретные архитектуры линейно упаковывают модель как есть. В итоге тернарный формат сжимает исходную FP16-модель примерно в 9.4 раза, а бинарный в 14.2 раза. Это означает, что стандартная 27B модель, занимающая в FP16 54 GB, в тернарном виде занимает около 6-8 GB, а в бинарном всего 3.5-3.9 GB.

Такое сжатие позволяет запускать подобные системы даже на обычных потребительских видеокартах и на мобильных устройствах. Но и это еще не все: при пошаговой генерации токенов в LLM основной задержкой является не скорость процессора, а скорость считывания миллиардов весов из VRAM в его кэш. Уменьшив объем моделей в 8-10 раз, мы получаем многократный прирост скорости генерации.

Вишенкой на торте является сверхвысокая энергоэффективность, ведь выполнение операций сложения требует на порядок меньше энергии по сравнению с умножением. В тестах на мобильных процессорах Apple Silicon энергопотребление бинарной модели снижается до рекордных 0.275 mWh на токен, а аккумулятора iPhone 17 Pro Max хватает почти на 67 000 сгенерированных токенов.

Небольшое отступление: лично для меня вопрос энергоэффективности критически важен, т.к. рабочая станция, на которой я обучаю и инферю модели, переведена на водяное охлаждение “в круг” двумя контурами: CPU, GPU, плашки ОЗУ, NVME-диски, VRM и чипсет южного моста материнской платы. Только такой подход позволил инферить/файнтюнить Q8/FP16 модели сутками напролет, т.к. делать дома холодный коридор почему-то не разрешает жена.

Все описанное выше очень красиво выглядело в теории, на практике же все было довольно печально: агрессивное дискретное квантование приводило к критической потере способности рассуждать и общему коллапсу модели.

И вот: компания PrismML выпустила семейство моделей Bonsai 27B. Архитектурно это бинарные и тернарные версии архитектуры Qwen 3.6 27B. Стоит отметить, что это решение появилось не из ниоткуда, ведь команда PrismML прошла долгий путь: сначала применила продвинутые техники обучения с учетом квантования (Quantization-Aware Training, QAT) и дистилляции знаний от исходной FP16-модели, затем последовательно пробовала дискретную квантизацию на 1.7B, 4B, 8B моделях и, наконец, выпустила первый действительно хороший практический результат на 27B. По размерам: бинарная версия занимает 3.8 GB, тернарная версия занимает 7.17 GB, а исходная несжатая версия занимает 53.8 GB. Команда заявляет следующее:

1. Сохранение до 90–95% базовых возможностей оригинала (Qwen 3.6 27B) в кодинге, математике и логических тестах.

2. Возможность автономного развертывания модели уровня 27B на локальном оборудовании без необходимости покупать дорогостоящие ускорители уровня NVIDIA A100 / H100.

Второй пункт автоматически подтверждается размерами файлов модели, поэтому давайте проверим пункт первый. Я провел серию тестов: от написания последовательности Фибоначчи и объяснения мемов с Ди Каприо по картинкам до использования различных инструментов. Чтобы не засорять текст длинными таблицами тестов, я перейду сразу к результатам.

Также я намеренно не даю конкретные цифры в tok/sec, т.к. они актуальны исключительно для моего железа и конфигурации. Эталоном в данном случае является Qwen 3.6 27B, поэтому буду сравнивать тернарную Bonsai 27B с ней. Бинарный вариант я не рассматриваю, т.к. он хуже тернарного на 20-25% и все его преимущество заключается в возможности запуска на iPhone 17 Pro Max.

В задачах на текст и кодинг тернарная Bonsai 27B размышляет (thinking mode) в 2 раза быстрее эталона и в 3 раза быстрее генерирует текст ответа, но демонстрирует неравномерное падение навыков. При тернарном квантовании математика, синтаксис Python и простые ответы на вопросы держатся хорошо (~75% от эталона). Однако мульти-агентный вызов функций в 3-4 шага и сложные инструкции теряют в качестве сильнее (~60% от эталона).

Ни о каких 90-95% базовых возможностей речи не идет, но и такие результаты тестов для модели, которая в 10 раз меньше по размеру, выглядят действительно достойным уровнем качества. Также в сочетании с 4-битным квантованием KV-кэша модель способна удерживать контекст до 262K токенов, забирая всего около 4.3 GB памяти под кэш, что делает работу с действительно длинными документами возможной прямо на обычных ноутбуках.

Перефразируя, можно сказать, что эта модель размером с квантованный Q3-вариант эталона выдает результат как квантованный Q4 эталона (а в некоторых сценариях как Q6), при этом помещаясь в 8GB VRAM, тогда как Q4 требует 16GB. И это, на мой взгляд, самое важное достижение: пользователи получают модель с качеством, которое раньше предоставляли только системы вдвое большего размера видеопамяти. При этом модель предоставляет базовые возможности чат-бота в агентном режиме, работает как копилот в программировании несложных задач и подходит как инструмент разбора простых изображений.

Для дополнительного ускорения работы на GPU в комплекте с моделью поставляется легкий спекулятивный драфтер DSpark. Он генерирует блоки по 4 токена за один проход, а основная дискретная модель проверяет их за один шаг. Потеря качества при этом нулевая, так как математически сохраняется исходное распределение токенов, а чистая скорость генерации вырастает еще на ~35%.

К сожалению, запустить эту модель как обычно не получится. Большинство фреймворков выдаст ошибку, связанную с несовместимостью формата квантования. Модели серии Bonsai 27B от PrismML используют нестандартные тернарные/бинарные матрицы (BitNet / i1-S / i1-M / custom ternary quant) вместо классических квантов Q2_0, Q4_K_M и т.д. При загрузке библиотека попытается спарсить структуру файла как стандартный квант GGML Q2_0, но из-за кастомного формата упакованных весов смещение тензоров сбивается.

Со временем новые методы квантования будут добавлены во все фреймворки, сейчас же, чтобы обойти эту проблему, можно использовать специальный форк Llama.cpp от PrismML. В сборке этого форка нет ничего сложного:

git clone https://github.com/PrismML-Eng/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON && cmake --build build -j

hf download prism-ml/Ternary-Bonsai-27B-gguf Ternary-Bonsai-27B-Q2_0.gguf --local-dir .

./build/bin/llama-cli \
    -m Ternary-Bonsai-27B-Q2_0.gguf \
    -cnv \
    -sys "Ты полезный ассистент. Всегда отвечай только на русском языке, независимо от языка вопроса." \
    -p "Напиши эффективный алгоритм бинарного поиска на Python и объясни его сложность." \
    -n 4096 --temp 0.7 --top-p 0.95 --top-k 20 -ngl 99

Далее ответ сети без блока размышлений:

Вот эффективная итеративная реализация бинарного поиска на Python, а также подробный разбор его сложности.

Алгоритм

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

def binary_search(arr, target):
    """
    Выполняет бинарный поиск элемента target в отсортированном массиве arr.
    
    Args:
        arr (list): Отсортированный список чисел.
        target (int/float): Искомое значение.
        
    Returns:
        int: Индекс элемента, если найден, иначе -1.
    """
    left = 0
    right = len(arr) - 1
    
    while left <= right:
        # Вычисляем индекс среднего элемента
        # Используем битовый сдвиг для эффективности (эквивалентно (left + right) // 2)
        mid = (left + right) >> 1 
        
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            # Если элемент меньше, искомое находится в правой части
            left = mid + 1
        else:
            # Если элемент больше, искомое находится в левой части
            right = mid - 1
            
    # Элемент не найден
    return -1

# Пример использования
if __name__ == "__main__":
    data = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
    search_val = 23
    
    result = binary_search(data, search_val)
    
    if result != -1:
        print(f"Элемент {search_val} найден на индексе: {result}")
    else:
        print(f"Элемент {search_val} не найден в массиве.")

Анализ сложности

1. Время выполнения (Time Complexity)

Сложность:

• Обоснование: На каждом шаге цикла мы сужаем диапазон поиска ровно наполовину.

  • Исходная длина массива:

  • После 1-го шага:

  • После 2-го шага:

  • …

  • После шагов:

• Поиск завершается, когда диапазон становится меньше или равен 1 ().

• Отсюда , или .

• Это означает, что число итераций растет логарифмически относительно размера массива. Это намного быстрее линейного поиска ().

2. Пространственная сложность (Space Complexity)

Сложность:

• Обоснование: Мы используем итеративный подход (цикл while). Нам требуется хранить только три переменные: left, right и mid, независимо от размера входного массива.

• Примечание: Если реализовать алгоритм рекурсивно, сложность по памяти станет из-за глубины стека вызовов. Итеративная версия выше предпочтительнее в Python.

Важные нюансы

1. Сортировка: Алгоритм гарантированно работает только если входной массив arr уже отсортирован. Если он не отсортирован, результат будет непредсказуемым.

2. Индексация: В Python индексы начинаются с 0, что учтено в инициализации right = len(arr) - 1.

3. Производительность: В реальных задачах на Python часто рекомендуется использовать встроенную функцию bisect из стандартной библиотеки, так как она реализована на C и работает быстрее, чем чистый Python-код. Однако написанный выше алгоритм отлично подходит для interviews и понимания логики.

[ Prompt: 245,3 t/s | Generation: 56,5 t/s ]

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

Вместо заключения.

Этот небольшой обзор не является полноценным исследованием, т.к. для него нужны более масштабные тесты, но уже сейчас можно утверждать следующее: разработки вроде PrismML Bonsai 27B демонстрируют, что вектор развития локальных ИИ-систем уходит от гонки за гигабайтами памяти к фундаментальной переработке архитектуры весов и упрощению математики расчетов.

Переход на 1.58-битные архитектуры позволяет перенести локальные нейросети с мощных рабочих станций на обычные ноутбуки, смартфоны и встраиваемые системы, сохраняя при этом базовый уровень “интеллекта” современных LLM. Такие попытки были и раньше, но это первая с действительно заметным практическим результатом. Будет крайне интересно попробовать 235B и 405B модели с тернарным квантованием в исполнении PrismML.