Фреймворк вывода Microsoft для 1-битных крупномасштабных языковых моделей

17 октября 2024 года Microsoft (MSFT ) анонсировала BitNet.cpp, фреймворк вывода, предназначенный для запуска 1-битных квантованных крупномасштабных языковых моделей (LLM). BitNet.cpp представляет собой значительный прогресс в области генеративного ИИ, позволяющий эффективно развертывать 1-битные LLM на стандартных ЦП, без необходимости использования дорогих ГПУ. Этот прорыв демократизирует доступ к LLM, делая их доступными на широком спектре устройств и открывая новые возможности для приложений ИИ на устройстве.

Понимание 1-битных крупномасштабных языковых моделей

Крупномасштабные языковые модели (LLM) традиционно требовали значительных вычислительных ресурсов из-за использования высокоточных чисел с плавающей запятой (обычно FP16 или BF16) для весов модели. Это необходимость сделала развертывание LLM дорогим и энергозатратным.

В своей основе 1-битные LLM используют экстремальные методы квантования для представления весов модели, используя только три возможных значения: -1, 0 и 1, отсюда и термин “1,58-бит” (поскольку для кодирования трех состояний требуется немного больше одного бита).

Тернарная система весов

Концепция

1-битное квантование в BitNet.cpp представляет собой тернарную систему весов. BitNet работает только с тремя возможными значениями для каждого параметра:

• -1 (отрицательное)
• 0 (нейтральное)
• 1 (положительное)

Это приводит к требованию хранилища около 1,58 бита на параметр, отсюда и название BitNet b1.58. Это радикальное уменьшение битовой ширины параметра приводит к впечатляющему уменьшению использования памяти и вычислительной сложности, поскольку большинство умножений с плавающей запятой заменяются простыми сложениями и вычитаниями.

Математическая основа

1-битное квантование включает в себя преобразование весов и активаций в их тернарное представление через следующие шаги:

1. Бинаризация весов

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

Wf​=Sign(W−α)

Где:

• W — исходная матрица весов.
• α — среднее значение весов.
• Sign(x) возвращает +1, если x > 0, и -1 в противном случае.

2. Квантование активаций

Квантование активаций гарантирует, что входные данные ограничены определенной битовой шириной:

x^e​=Quant(x)=Clip(γx×Qb​​,−Qb​+ϵ,Qb​−ϵ)

Где:

• Qb = 2(b−1)2^{(b-1)}2(b−1) — максимальный уровень квантования для b-битовой ширины.
• γ — максимальное абсолютное значение x (обозначается как ∣∣x∣∣∞​).
• ε — небольшое число, предотвращающее переполнение во время вычислений.

3. Битлинейная операция

Слой BitLinear заменяет традиционные матричные умножения на упрощенную операцию:

y=Wf​×x^e​×(Qb​βγ​)

Где:

• β — масштабирующий коэффициент, используемый для минимизации ошибок аппроксимации.
• γ масштабирует активации.
• Q_b — коэффициент квантования.

Это преобразование позволяет выполнять эффективные вычисления, сохраняя при этом производительность модели.

Последствия для производительности

Эффективность памяти

Тернарная система весов значительно снижает требования к памяти:

• Традиционные LLM: 16 бит на вес
• BitNet.cpp: 1,58 бита на вес

Это снижение приводит к экономии памяти примерно на 90% по сравнению с традиционными 16-битными моделями, что позволяет разместить более крупные модели в рамках одних и тех же аппаратных ограничений.

Скорость вывода, энергоэффективность (Apple [securities_stock_price_tag symbol="AAPL" exchange="NASDAQ"] M2)

Скорость вывода, энергоэффективность (i7-13700H)

1. Скорость вывода: быстрее на обоих ЦП

Скорость вывода представлена как количество токенов, обработанных в секунду. Вот краткий обзор наблюдений:

• На Apple M2 Ultra: BitNet.cpp достигает до 5,07-кратного ускорения для более крупных моделей (30B) по сравнению с Llama.cpp, с пиковой скоростью 593,43 токена в секунду для модели 125M, что является 1,37-кратным ускорением. Для более крупных моделей, таких как 3,8B и 7B, BitNet.cpp поддерживает скорость выше 84,77 токенов в секунду, демонстрируя свою эффективность во всех масштабах.
• На Intel (INTC ) i7-13700H: BitNet.cpp достигает еще более впечатляющих улучшений скорости. При размере модели 7B BitNet.cpp обеспечивает невероятное 5,68-кратное ускорение по сравнению с Llama.cpp. Для более мелких моделей, таких как 125M, она обрабатывает 389,08 токенов в секунду, что является 2,37-кратным ускорением по сравнению с Llama.cpp.

2. Энергоэффективность: прорыв для устройств на краю сети

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

• На Apple M2 Ultra: энергосбережение BitNet.cpp существенно. Для модели 700M оно потребляет на 55,4% меньше энергии на токен по сравнению с Llama.cpp, снижаясь с 0,314 до 0,140. Эта тенденция продолжается для более крупных моделей, при этом модель 70B показывает снижение энергопотребления на 70,0%.
• На Intel i7-13700H: BitNet.cpp обеспечивает снижение энергопотребления на 71,9% для модели 700M, при этом потребление снижается с 1,367 до 0,384. Хотя данные об энергопотреблении для модели 70B в Llama.cpp недоступны, BitNet.cpp остается эффективной, с энергопотреблением на уровне 17,33 для модели 70B.

3. Пересечение порога скорости чтения человека

Одним из наиболее интересных выводов из этих графиков является ссылка на скорость чтения человека, обозначенную на уровне 5-7 токенов в секунду. Эта красная линия показывает, что обе реализации, особенно BitNet.cpp, могут комфортно превосходить скорость чтения человека даже для самых крупных моделей:

• На Apple M2 Ultra BitNet.cpp превосходит скорость чтения человека для всех размеров моделей, при этом наименьшая скорость составляет 8,67 токенов в секунду для модели 70B.
• На Intel i7-13700H модель 100B все еще достигает 1,70 токенов в секунду, почти достигая нижнего предела скорости чтения человека, в то время как все более мелкие модели превосходят этот показатель.

Рассмотрения при обучении

Прямой оценщик (STE)

Поскольку 1-битное квантование вводит недифференцируемые функции, обучение включает в себя специальную технику, известную как Прямой оценщик (STE). В этом подходе градиенты протекают без изменений через недифференцируемые точки. Вот упрощенная реализация на Python:

class StraightThroughEstimator(Function):
@staticmethod
def forward(ctx, input):
return input.sign()

<p>@staticmethod
def backward(ctx, grad_output):
return grad_output

Обучение с смешанной точностью

Для поддержания стабильности во время обучения используется смешанная точность:

• Веса и активации: квантованы до 1-битной точности.
• Градиенты и состояния оптимизатора: хранятся в более высокой точности.
• Латентные веса: поддерживаются в высокой точности для обеспечения точных обновлений во время обучения.

Стратегия с большим шагом обучения

Особой проблемой 1-битных моделей является то, что небольшие обновления могут не повлиять на бинаризированные веса. Для смягчения этого шаг обучения увеличивается, обеспечивая более быструю сходимость и лучшую оптимизацию по сравнению с традиционными подходами.

Групповая квантовация и нормализация

BitNet.cpp вводит групповую квантовацию и нормализацию для улучшения параллелизма модели. Вместо расчета параметров для всей матрицы весов BitNet делит веса и активации на несколько групп (G).
Это группирование позволяет выполнять эффективную параллельную обработку без дополнительного межгруппового взаимодействия, обеспечивая обучение и вывод крупномасштабных моделей.

Примечания к реализации и оптимизациям

Оптимизация ЦП

BitNet.cpp использует несколько низкоуровневых оптимизаций для достижения пиковой производительности ЦП:

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

Вот пример ключевой функции, реализующей квантование и вывод в BitNet:

def bitlinear_forward(input, weight, scale):
# Квантуем входные данные с помощью квантования по абсолютному максимуму
input_q = quantize(input)

<p># Выполняем бинарное матричное умножение
output = binary_matmul(input_q, weight)</p>

<p># Масштабируем выход, чтобы он соответствовал исходной точности
return output * scale</p>

<p>def quantize(x):
# Выполняем квантование по абсолютному максимуму
scale = torch.max(torch.abs(x))
return torch.clamp(x / scale, -1, 1) * scale

<p># Функция бинаризации для 1-битных весов
def binarize_weights(W):
alpha = W.mean()
W_binarized = np.sign(W - alpha)
return W_binarized</p>