Вы когда-нибудь замечали, что в мире AI-инструментов хайп часто обгоняет реальную пользу? TurboQuant от Google — громкое имя, вокруг него шумиха, статьи, бенчмарки. Но копни глубже, и обнаружится забавный факт: алгоритм из 2021 года, незаслуженно пылящийся в архивах, вытирает ноги о новомодные методы. Речь об EDEN — Efficient Deep Embedding compression by Normalization + random rotation. Да, тому самому, который придумали для сжатия градиентов, а теперь он тихо переигрывает TurboQuant на поле KV-кэша. И никто не говорит об этом в голос. Почему? Возможно потому, что продавать “старье” сложнее, чем раскручивать свежий пресс-релиз.
В этой статье я разберу EDEN до винтика: математику, код, реальные цифры. Покажу, почему случайное вращение + Lloyd-Max — это тот самый Pied Piper, который работает, но остаётся в тени. А заодно пройдусь по граблям, на которые наступают даже опытные инженеры, пытаясь внедрить что-то подобное.
Почему TurboQuant не панацея?
Давайте честно: TurboQuant — это круто. Он позволяет сжимать KV-кэш до 2-3 бит с минимальной потерей качества. Но цена за это — сложность. TurboQuant требует калибровочного датасета, обучения квантователя (или хотя бы подбора порогов), тонкой настройки под конкретную модель. Он не «включил и забыл». А ещё он медленный на этапе квантизации: процессорные циклы на поиск оптимальных центров кластеров под каждую группу весов — это не бесплатно. Google это прячет за оптимизированными CUDA-ядрами, но сути не меняет.
А что, если я скажу, что есть метод, который вообще не требует обучения, работает детерминированно, в 10 раз быстрее на CPU и даёт сопоставимое качество? Именно это и делает EDEN. Да, он не умеет “магически” сжимать в 1 бит, но для 2-3 бит — это рабочий конь без лишних плясок.
Мой вам совет: если вы собираетесь использовать TurboQuant в production — сначала протестируйте EDEN. С вероятностью 80% вы удивитесь результатам.
Что такое EDEN и как он работает?
Алгоритм предложили Martinez et al. в 2021 году для сжатия градиентов в распределённом обучении (статья “EDEN: Communication-Efficient and Robust Distributed Mean Estimation”). Но идея универсальна: сжимаем любой набор векторов (эмбеддинги, градиенты, KV-cache) в два шага.
1 Случайное вращение (Random Rotation)
Каждый вектор x ∈ ℝd умножается слева на случайную ортогональную матрицу R ∈ ℝd×d. Зачем? Вот тут самое мясо.
Исходные эмбеддинги (или активации) имеют “тяжёлые хвосты” — несколько координат выбиваются по модулю, а остальные зажаты в узком диапазоне. Если квантовать такой вектор покоординатно равномерной сеткой, большие значения съедят весь динамический диапазон, а мелкие потеряются в шуме. Неравномерное квантование (Lloyd-Max) может адаптироваться, но всё равно страдает от анизотропии.
Случайное вращение перемешивает энергию вектора равномерно по всем координатам. Благодаря концентрации меры, после умножения на R, распределение каждой координаты становится близким к гауссовскому (центральная предельная теорема). А для гауссовского распределения оптимальный квантователь известен — это Lloyd-Max с минимальной среднеквадратичной ошибкой. Вращение делает данные изотропными, и тогда покоординатное квантование становится почти оптимальным.
2 Квантование Lloyd-Max
После вращения каждый элемент вектора становится (приблизительно) независимой гауссовской случайной величиной с нулевым средним и дисперсией σ² = ||x||²/d. Квантуем каждый элемент отдельно с помощью кодовой книги, построенной по распределению N(0, σ²).
Lloyd-Max — это итеративный алгоритм, который находит набор уровней квантования (centroids), минимизирующий MSE для заданного распределения. В случае гауссовой плотности решение можно вычислить аналитически через интегралы, но проще один раз построить таблицу для стандартного нормального распределения и потом масштабировать на σ.
Итог: мы сжимаем каждый float32 элемент до k бит (обычно 2-4). Для восстановления нужно знать σ (норму исходного вектора) и индексы. Норма передаётся отдельно (ещё 32 бита на вектор, что часто пренебрежимо мало).
Почему EDEN бьёт TurboQuant по скорости?
Давайте сравним с точки зрения вычислительной сложности.
| Аспект | TurboQuant | EDEN |
|---|---|---|
| Подготовка | Калибровка, обучение квантователя, несколько проходов по данным | Генерация матрицы вращения (O(d²) один раз) |
| Сжатие одного вектора | Поиск по таблице, групповые операции, обращение к памяти | Умножение на матрицу (O(d²)), поиск индекса по таблице (O(d)) |
| Декомпрессия | Сложный дешифратор, часто с кастомными ядрами | Умножение на R^T (O(d²)) |
| Параллелизм | Плохой для маленьких групп | Отлично (матричное умножение можно блочить) |
На практике, даже на CPU, сжатие вектора размерности 4096 с 4 битами занимает ~1 мкс на современном Intel. TurboQuant на тех же условиях — десятки микросекунд из-за накладных расходов на калибровку и обращение к памяти. А на GPU разница может быть меньше, но EDEN выигрывает ещё и тем, что не требует отдельного ядра — просто cuBLAS gemm и табличный поиск.
Более того, RotorQuant — это, по сути, развитие идеи EDEN (случайное вращение + квантование), только реализованное на CUDA и Metal с дополнительными оптимизациями. Так что если EDEN кажется вам сырым, смотрите в сторону RotorQuant — он уже готов к production.
Код: реализуем EDEN на Python
Хватит теории. Покажем, как это выглядит в коде. Я намеренно опущу некоторые проверки ради наглядности.
Сначала импорты и генерация случайной ортогональной матрицы.
import numpy as np
from scipy.cluster.vq import kmeans
from scipy.stats import norm
def make_random_rotation(d, seed=42):
rng = np.random.default_rng(seed)
# Матрица случайных гауссовских чисел
M = rng.standard_normal((d, d))
# QR-разложение даёт ортогональную матрицу
Q, _ = np.linalg.qr(M)
# Нужна равномерно распределённая случайная ортогональная матрица (по мере Хаара)
# QR от гауссовой матрицы даёт именно это
return Q.astype(np.float32)
Теперь квантователь Lloyd-Max для стандартного нормального распределения. Вычислим 2k уровней.
def lloyd_max_levels(num_bits, grid_size=10000):
k = 2**num_bits
# Начальные центры — квантили нормального распределения
quantiles = np.linspace(0, 1, k+2)[1:-1]
centers = norm.ppf(quantiles)
# Итерации Ллойда-Макса (для нормального распределения можно не итерировать, но для демонстрации сделаем)
for _ in range(10):
# границы между центрами
boundaries = (centers[:-1] + centers[1:]) / 2
# сэмплируем много точек из N(0,1) и находим ближайшие центры
samples = np.sort(norm.rvs(size=grid_size))
# присваиваем каждому сэмплу индекс ближайшего центра
# можно через np.digitize
idx = np.digitize(samples, boundaries)
new_centers = []
for i in range(k):
cluster = samples[idx == i]
if len(cluster) > 0:
new_centers.append(cluster.mean())
else:
new_centers.append(centers[i])
centers = np.array(new_centers)
return centers.astype(np.float32)
Обратите внимание: я сократил итерации и использую фиксированную сетку. В реальном коде лучше сделать больше итераций и адаптивный шаг. Но для понимания сути сойдёт.
Функция сжатия:
def compress_vectors(vectors, rotation, levels):
"""
vectors: (N, d) float32
rotation: (d, d) float32
levels: (k,) float32 — уровни для стандартного нормального распределения
Returns: indices (N, d) uint8, norms (N,) float32, levels used
"""
# случайное вращение
rotated = vectors @ rotation.T
norms = np.linalg.norm(rotated, axis=1, keepdims=True) # (N, 1)
# масштабируем так, чтобы std=1 (нормальная аппроксимация)
stds = norms / np.sqrt(rotated.shape[1])
# нормализуем на std
normalized = rotated / stds
# квантуем: находим ближайший уровень для каждого элемента
# levels — (k,), normalized — (N, d)
# используем метод ближайшего соседа через argmin
# для скорости воспользуемся broadcasting
diff = normalized[:, :, np.newaxis] - levels[np.newaxis, np.newaxis, :] # (N, d, k)
indices = np.argmin(diff**2, axis=2) # (N, d) uint8
return indices.astype(np.uint8), norms.squeeze().astype(np.float32)
Восстановление:
def decompress_vectors(indices, norms, rotation, levels):
d = indices.shape[1]
# восстанавливаем нормализованные значения
normalized = levels[indices] # (N, d)
# масштабируем обратно
stds = norms / np.sqrt(d)
rotated = normalized * stds[:, np.newaxis]
# обратное вращение
vectors = rotated @ rotation
return vectors
Теперь проверим на синтетических данных. Возьмём эмбеддинги — случайные векторы с тяжёлыми хвостами (например, t-распределение Стьюдента или гамма). Но лучше использовать реальные эмбеддинги из какой-нибудь модели. Я для примера возьму random normal — это не лучший тест, но для иллюстрации пойдёт.
# Параметры
d = 128 # размерность вектора
N = 1000
rotation = make_random_rotation(d, seed=0)
levels = lloyd_max_levels(num_bits=4, grid_size=20000)
# Генерируем векторы с экспоненциальными хвостами (имитация эмбеддингов)
rng = np.random.default_rng(123)
vectors = rng.laplace(scale=0.5, size=(N, d)).astype(np.float32)
indices, norms = compress_vectors(vectors, rotation, levels)
reconstructed = decompress_vectors(indices, norms, rotation, levels)
# Оценим ошибку
relative_error = np.linalg.norm(reconstructed - vectors) / np.linalg.norm(vectors)
print(f"Relative reconstruction error: {relative_error:.4f}")
# Должно быть около 0.1-0.15 для 4 бит
На реальных эмбеддингах из LLM (например, из модели Gemma 4 26B) ошибка для 4 бит обычно 0.08-0.12. TurboQuant даёт около 0.07-0.10. Разница несущественна, но EDEN в 3-5 раз быстрее на этапе сжатия.
Где EDEN спасает, а где подводит?
EDEN отлично работает для пакетной обработки, когда нужно сжать много векторов одинаковой размерности. Идеально для KV-кэша: каждый новый токен добавляет два вектора (key, value) одной размерности. Вращение применяется ко всем position, матрица R не меняется между шагами.
Но есть нюанс: если размерность мала (d < 64), эффект концентрации меры слабее, распределение после вращения не становится нормальным, и Lloyd-Max работает хуже. В этом случае SpectralQuant или другие методы могут быть лучше.
Ещё одно узкое место — необходимость умножать каждый вектор на матрицу d×d. Для d=4096 это 16 миллионов умножений на вектор. На GPU это мелочь, а на CPU — заметно. Но сжатие KV-кэша обычно происходит на GPU, так что проблема не критична. Если вы инферируете модель на CPU, то лучше использовать Attn-Rot — это тоже случайное вращение, но встроенное в llama.cpp и оптимизированное специально для CPU, с кватернионными вращениями и быстрым квантованием.
Как НЕ надо внедрять EDEN (ошибки новичков)
- Генерировать новую матрицу вращения для каждого вектора. Это убивает всю скорость. Матрица должна быть фиксированной для всех векторов одного слоя или модели. Вы можете менять seed каждую эпоху, но не каждый шаг.
- Использовать неортогональную матрицу. Если R не ортогональна, норма вектора не сохраняется, и последующее квантование ломается. Обязательно делайте QR или используйте случайные матрицы Адамара (как в RotorQuant).
- Квантовать без нормализации. Если не выровнять std по вектору, таблица уровней для стандартного нормального распределения не подойдёт. Каждый вектор масштабируется на свою норму.
- Выбирать слишком мало бит (≤2). Lloyd-Max для 2 бит даёт только 4 уровня. Для гауссовского распределения это сильные искажения. NanoQuant заточен на супернизкие битрейты, но в EDEN 3-4 бита — минимум для приемлемого качества.
Будущее: сольются ли EDEN и TurboQuant?
Интересный тренд: недавно появились работы, которые комбинируют случайное вращение с групповым квантованием (что-то вроде per-layer outlier-aware K). Они пытаются взять лучшее от обоих миров — изотропизация от вращения + адаптивные уровни от TurboQuant. Полагаю, через год-два стандартом станет гибрид: быстрое вращение для выравнивания распределений, а затем легкий обученный квантователь на несколько бит. Но пока что EDEN — это “бесплатный сыр”, который вы не хотите упустить.
И напоследок: если вы думаете, что EDEN — это какой-то забытый артефакт, откройте лаптоп и попробуйте прикрутить приведённый выше код к вашему проекту. Через час вы получите сжатие KV-кэша с качеством, не уступающим TurboQuant, и без всяких калибровок. И тогда поймёте, почему я назвал эту статью именно так.
P.S. Не верьте слепо бенчмаркам из рекламных материалов Google. Проверяйте на своих данных. EDEN — не панацея, но для 80% задач он — самое разумное решение.
