Machine Learning on kenji.blog

【Для начинающих】Разбор математической структуры модели Transformer

Fri, 11 Sep 2026 22:00:00 +0900

Введение: зачем изучать математику Transformer?

Архитектура «Transformer» — это архитектура, о которой можно смело сказать, что она переписала историю современной обработки естественного языка (NLP) и ИИ в целом. Впервые предложенная в 2017 году исследователями Google в статье «Attention Is All You Need», эта модель функционирует как сердце крупномасштабных языковых моделей (LLM), которые сейчас доминируют в мире, таких как серия GPT от OpenAI (базовая технология ChatGPT), BERT от Google и Claude от Anthropic.

Однако, хотя часто встречаются качественные объяснения работы Transformer, такие как «понимание контекста с помощью механизма внимания (Attention)», на самом деле существует на удивление мало подробных объяснений математической структуры, стоящей за этим, для начинающих. Чтобы по-настоящему понять, как ИИ обрабатывает «слова» как «математические формулы» и генерирует удивительно естественные тексты, необходимо разобраться в его математических механизмах.

В этой статье мы подробно и доступно объясним математическую структуру, которая является сердцем Transformer: «Механизм внутреннего внимания (Self-Attention)», «Модель Запрос-Ключ-Значение (Q/K/V)», «Нормализация с помощью функции Softmax» и «Позиционное кодирование (Positional Encoding)». Статья предназначена для тех, кто обладает базовыми знаниями в области математики и программирования (понимает концепции матриц и производных на уровне старшей школы).

Вас может ошеломить обилие формул, но за каждым вычислением стоит четкий «смысл». К тому моменту, как вы дочитаете эту статью, вы должны понять, что Transformer — это не просто волшебный черный ящик, а тщательно спроектированный кристалл математики и статистики.

1. Ограничения традиционных методов и инновационность Transformer

До появления Transformer в обработке естественного языка доминировали рекуррентные нейронные сети (RNN) и их производные, такие как LSTM (Long Short-Term Memory). RNN были разработаны для обработки временных рядов данных и читают текст слово за словом с самого начала.

Однако у RNN было два фатальных недостатка:

Сложность изучения долгосрочных зависимостей: Когда предложение становится длинным, информация о словах, введенных в начале, затухает к тому времени, когда достигается конец (проблема исчезающего градиента).
Невозможность параллельных вычислений: Поскольку слова необходимо обрабатывать последовательно, трудно выполнять крупномасштабные параллельные вычисления с использованием GPU, что требует огромного времени на обучение.

Transformer полностью отбросил структуру RNN и произвел сдвиг парадигмы, используя исключительно «Attention» (внимание) для понимания контекста. Благодаря этому, независимо от длины последовательности, не происходит потери информации, а также становится возможным распараллеливание вычислений для максимального использования производительности GPU.

2. Общая архитектура Transformer

Сначала давайте взглянем на общую архитектуру Transformer. Transformer в общих чертах состоит из двух блоков: «Encoder» (кодировщик) и «Decoder» (декодировщик). На примере задачи перевода: Encoder преобразует исходный язык (например, английский) в математическое векторное представление, а Decoder на основе этого векторного представления генерирует целевой язык (например, японский/русский).

Следующая диаграмма представляет собой упрощенную внутреннюю структуру блока Encoder.

graph TD A["Входные токены"] --> B["Входное вложение"] B --> C["Позиционное кодирование"] C --> D["Многоголовое внутреннее внимание"] D --> E["Сложение и нормализация слоя"] E --> F["Сеть прямой связи"] F --> G["Сложение и нормализация слоя"] G --> H["Вывод на следующий слой"] C -.->|"Остаточное соединение"| E E -.->|"Остаточное соединение"| G

С этого момента мы шаг за шагом рассмотрим математические операции, выполняемые в каждом компоненте.

3. Векторизация слов и позиционное кодирование (Positional Encoding)

Компьютеры не могут понимать текст как таковой. Введенный текст сначала разбивается на единицы, называемые «токенами (Token)», и каждый из них преобразуется в вектор фиксированной длины. Это и есть Input Embedding.

3.1 Математика Input Embedding

Пусть размер словаря (vocabulary) равен $V$, а размерность вектора вложения (embedding) равна $d_{model}$ (в оригинальной статье $d_{model} = 512$). Каждое слово $w_i$ преобразуется в вектор $x_i \in \mathbb{R}^{d_{model}}$ с использованием матрицы вложения $W_E \in \mathbb{R}^{V \times d_{model}}$.

$$ x_i = W_E \cdot \text{one\_hot}(w_i) $$

Таким образом, весь текст представляется как матрица $X \in \mathbb{R}^{N \times d_{model}}$ (где $N$ — длина текста).

3.2 Необходимость и формулы позиционного кодирования (Positional Encoding)

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

Чтобы предоставить модели эту информацию о порядке слов, было придумано Positional Encoding. Позиционное кодирование $PE$ для $i$-го измерения слова, находящегося в позиции $pos$, вычисляется с использованием следующих тригонометрических функций:

$$ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$ $$ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$

Где $pos$ — это позиция слова ($0, 1, 2, \dots, N-1$), а $i$ — индекс размерности вектора ($0, 1, \dots, d_{model}/2 - 1$).

Почему используются синус и косинус?

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

Вспомните теоремы сложения для тригонометрических функций, которые изучают в старшей школе:

$$ \sin(\alpha + \beta) = \sin\alpha \cos\beta + \cos\alpha \sin\beta $$ $$ \cos(\alpha + \beta) = \cos\alpha \cos\beta - \sin\alpha \sin\beta $$

Позиционное кодирование для позиции $pos + k$, сдвинутой на $k$ относительно позиции $pos$, может быть представлено как линейная комбинация позиционного кодирования позиции $pos$. Другими словами, используя матрицу $M_k$, это можно записать следующим образом:

$$ PE_{pos+k} = M_k \cdot PE_{pos} $$

Благодаря этому механизм Attention позволяет легко распознавать относительное расстояние («насколько далеко друг от друга находятся слова») посредством вычисления скалярного произведения. Кроме того, комбинируя несколько синусоидальных и косинусоидальных волн с разной длиной волны, есть преимущество в том, что можно создать уникальный вектор позиции, независимо от длины текста.

Итоговая входная матрица $X_{input}$ представляет собой сумму вектора вложения слов и этого позиционного кодирования.

$$ X_{input} = X + PE $$

4. Глубокая математика внутреннего внимания (Self-Attention)

Наконец-то мы переходим к самому важному компоненту Transformer — Self-Attention (Механизм внутреннего внимания). Цель Self-Attention — «вычислить степень связи между всеми словами в тексте и обновить вектор каждого слова до более богатого представления с учетом контекста».

Здесь используется аналогия с «поисковой системой»:

Query (Q): Запрос (поисковый запрос). «Какую информацию я сейчас ищу?»
Key (K): Ключ (заголовок). «Какая информация у меня есть?»
Value (V): Значение (сущность). «Какую информацию я на самом деле предоставляю?»

4.1 Создание матриц $Q, K, V$

Для входной матрицы $X \in \mathbb{R}^{N \times d_{model}}$ (для упрощения мы здесь игнорируем размер батча (batch size)), умножая на обучаемые весовые матрицы $W^Q, W^K, W^V \in \mathbb{R}^{d_{model} \times d_k}$, мы вычисляем запрос $Q$, ключ $K$ и значение $V$. (Обычно $d_k = d_v = d_{model} / h$)

$$ Q = X W^Q $$ $$ K = X W^K $$ $$ V = X W^V $$

Здесь $Q, K, V$ — все являются матрицами $\mathbb{R}^{N \times d_k}$.

4.2 Вычисление оценки внимания (Attention Score) - Скалярное произведение

Чтобы измерить, насколько Query каждого слова связан с Key всех остальных слов, мы вычисляем скалярное произведение векторов. В матричном виде это записывается следующим образом:

$$ \text{Scores} = Q K^T $$

Каждый элемент $s_{ij}$ полученной таким образом матрицы $\text{Scores} \in \mathbb{R}^{N \times N}$ представляет собой скалярное произведение Query $i$-го слова и Key $j$-го слова, то есть «силу связи».

4.3 Масштабирование (Scale)

При вычислении оценки (score) с помощью скалярного произведения возникает одна проблема. Если размерность вектора $d_k$ становится большой, значение скалярного произведения может стать экстремально большим или маленьким.

Давайте докажем это математически. Предположим, что каждый элемент запроса $q \sim \mathcal{N}(0, 1)$ и каждый элемент ключа $k \sim \mathcal{N}(0, 1)$ следуют независимому стандартному нормальному распределению. Найдем среднее и дисперсию скалярного произведения $q \cdot k = \sum_{i=1}^{d_k} q_i k_i$. Среднее: Так как $\mathbb{E}[q_i k_i] = \mathbb{E}[q_i] \mathbb{E}[k_i] = 0 \times 0 = 0$, среднее суммы также равно $0$. Дисперсия: Из независимости дисперсия $q_i k_i$ равна $\text{Var}(q_i k_i) = \mathbb{E}[(q_i k_i)^2] - (\mathbb{E}[q_i k_i])^2 = 1 \times 1 - 0 = 1$. Следовательно, дисперсия всего скалярного произведения будет равна размерности $d_k$.

$$ \text{Var}(q \cdot k) = d_k $$

Когда дисперсия становится большой, градиенты функции Softmax, применяемой после этого, становятся экстремально маленькими для значений, отличных от максимального, происходит «исчезновение градиента», и обучение останавливается. Чтобы предотвратить это, оценка (score) делится (масштабируется) на $\sqrt{d_k}$, чтобы дисперсия всегда оставалась равной $1$.

$$ \text{Scaled Scores} = \frac{Q K^T}{\sqrt{d_k}} $$

4.4 Преобразование в вероятности с помощью функции Softmax

К полученным оценкам по строкам применяется функция Softmax, чтобы преобразовать их в распределение вероятностей (веса), сумма которых равна $1$.

$$ a_{ij} = \text{softmax}(s_i)_j = \frac{\exp(s_{ij} / \sqrt{d_k})}{\sum_{m=1}^N \exp(s_{im} / \sqrt{d_k})} $$

Матрица $A \in \mathbb{R}^{N \times N}$ называется матрицей весов внимания (Attention Weight). Глядя на каждую строку $i$ этой матрицы, мы видим значения от 0 до 1, которые показывают, «насколько много внимания (Attention) следует уделить любому другому слову $j$ для понимания слова $i$».

4.5 Взвешенная сумма Value

Наконец, используя полученную матрицу весов внимания $A$, вычисляется взвешенная сумма матрицы Value $V$.

$$ \text{Output} = A V = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

Матрица $Z \in \mathbb{R}^{N \times d_v}$, полученная в результате этой операции, представляет собой набор «векторных представлений слов, обновленных с учетом контекста». Это и есть полная картина Scaled Dot-Product Attention, определенная в оригинальной статье.

5. Multi-Head Attention (Многоголовое внимание)

Возможно, что с помощью всего одного вычисления Attention (одна голова) контекст будет понят только с одной точки зрения (например, «грамматические отношения»). Поэтому для одновременного учета разнообразных семантических и синтаксических отношений в языке (таких как «подлежащее и сказуемое», «местоимение и его референт» и т.д.) был введен механизм Multi-Head Attention.

Ранее описанные процессы генерации $Q, K, V$ и вычисления Attention выполняются параллельно $h$ раз (количество голов, в оригинальной статье $h=8$).

$$ \text{head}_i = \text{Attention}(X W_i^Q, X W_i^K, X W_i^V) $$

Здесь $W_i^Q, W_i^K, W_i^V \in \mathbb{R}^{d_{model} \times d_k}$ — обучаемые весовые матрицы, специфичные для $i$-й головы.

Результаты $\text{head}_i \in \mathbb{R}^{N \times d_v}$, выведенные каждой головой, объединяются (Concatenate) по горизонтали.

$$ \text{Concat}(\text{head}_1, \dots, \text{head}_h) \in \mathbb{R}^{N \times (h \cdot d_v)} $$

Поскольку обычно устанавливается так, что $h \cdot d_v = d_{model}$, размерность после объединения возвращается к исходной $d_{model}$. Наконец, эта матрица умножается на весовую матрицу $W^O \in \mathbb{R}^{d_{model} \times d_{model}}$ для получения окончательного вывода.

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O $$

graph TD X["Вход X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Голова 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Голова 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Голова h"] H1 & H2 & HN --> C["Объединить"] C --> WO["Умножить на WO"] WO --> OUT["Многоголовый вывод"]

6. Сеть прямой связи (Feed-Forward Neural Network, FFN)

Вывод Multi-Head Attention затем передается в Position-wise Feed-Forward Network (FFN). Это двухслойная полносвязная нейронная сеть, применяемая «независимо к каждой позиции (слову)» в последовательности.

В виде формулы это выражается следующим образом:

$$ \text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 $$

Где $\max(0, z)$ представляет функцию активации ReLU (Rectified Linear Unit) (в недавних моделях также часто используются GELU или SwiGLU).

Роль этой сети чрезвычайно важна. В то время как механизм Attention изучает «отношения между словами (пространственные и последовательные отношения)», FFN отвечает за «нелинейное преобразование признаков каждого вектора слова самого по себе». Обычно вес первого слоя $W_1$ временно значительно увеличивает размерность (например, в 4 раза с $d_{model}=512$ до $d_{ff}=2048$), выполняет сложные вычисления в пространстве признаков, а затем вес второго слоя $W_2$ возвращает её к исходной размерности. Благодаря этому «расширению и сжатию размерности» выразительная сила модели резко возрастает.

7. Остаточное соединение (Residual Connection) и Нормализация слоя (Layer Normalization)

В глубоком обучении по мере углубления слоев сети возникает проблема исчезновения или взрыва градиентов во время обучения, из-за чего обучение проходит неудачно. Для предотвращения этого вокруг каждого подслоя (Attention и FFN) в Transformer размещены Остаточное соединение (Residual Connection) и Нормализация слоя (Layer Normalization).

В виде формулы вывод подслоя обрабатывается следующим образом:

$$ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) $$

7.1 Остаточное соединение ($x + \text{Sublayer}(x)$)

Вход $x$ напрямую прибавляется к выводу подслоя. Благодаря этому при обратном распространении ошибки градиенты напрямую передаются в более мелкие слои по короткому пути, что стабилизирует обучение даже при глубокой структуре слоев.

7.2 Математика нормализации слоя (Layer Normalization)

Layer Normalization — это технология, которая вычисляет среднее и дисперсию по направлению размерности признаков и нормализует данные. Для входа с размером батча $B$, длиной последовательности $N$ и размерностью $d_{model}$, нормализация выполняется для одного вектора слова $x \in \mathbb{R}^{d_{model}}$.

Вычисляются среднее $\mu$ и дисперсия $\sigma^2$:

$$ \mu = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} x_i $$ $$ \sigma^2 = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} (x_i - \mu)^2 $$

Затем получается нормализованный вывод $\hat{x}$:

$$ \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \gamma + \beta $$

(где $\epsilon$ — малая константа для предотвращения деления на ноль, а $\gamma, \beta$ — обучаемые параметры масштаба и сдвига)

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

8. Специфическая структура декодера: Masked Attention и Cross-Attention

Описанная до сих пор структура принадлежит кодировщику. В блоке декодера, генерирующем текст, структура немного отличается.

8.1 Masked Multi-Head Attention

Роль декодера заключается в «предсказании следующего слова на основе предыдущих слов». Следовательно, во время обучения недопустимо заглядывать в «будущие слова», иначе это будет похоже на списывание. Математическая операция, предотвращающая это, называется Masking (Маскирование).

К матрице оценок $Q K^T$ прибавляется матрица маски $M$, в которой верхнетреугольная часть (соответствующая будущей информации) заполнена очень маленькими значениями, близкими к $-\infty$.

$$ M_{ij} = \begin{cases} 0 & (i \le j) \\ -\infty & (i > j) \end{cases} $$ $$ \text{Masked Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T + M}{\sqrt{d_k}}\right) V $$

При вычислении функции Softmax $\exp(-\infty) = 0$, поэтому веса внимания (Attention Weight) для будущих слов становятся полностью равными $0$. Это обеспечивает авторегрессионную генерацию с сохранением причинно-следственной связи (Causality).

8.2 Encoder-Decoder Cross-Attention

Второй подслой декодера — это Cross-Attention, который обращается к выводу кодировщика. Здесь $Q$ генерируется из предыду слоя декодера, а $K$ и $V$ генерируются из вывода последнего слоя кодировщика.

$$ Q_{decoder} = X_{dec} W^Q $$ $$ K_{encoder} = X_{enc} W^K $$ $$ V_{encoder} = X_{enc} W^V $$

С помощью этого вычисления модель может изучать в задачах, таких как перевод, «с какой частью исходного предложения на иностранном языке сильнее всего связано переводимое в данный момент слово».

9. Вычислительная сложность и математика оптимизации в современную эпоху

Transformer — великолепная модель, но из-за ее математической структуры у нее есть свои «слабые стороны». Обратите внимание на вычислительную сложность Self-Attention. При вычислении матрицы оценок $Q K^T$ матрица размера $(N \times d_k)$ умножается на матрицу размера $(d_k \times N)$, поэтому вычислительная сложность составляет $O(N^2 \cdot d_{model})$.

Другими словами, вычислительная сложность и использование памяти растут квадратично относительно длины последовательности $N$. Это не проблема для коротких текстов, но если попытаться ввести в LLM длинный контекст, например целую книгу, $N$ достигнет десятков или сотен тысяч, и память GPU мгновенно исчерпается при традиционных вычислениях Attention.

Чтобы разорвать это проклятие $O(N^2)$, в последние годы были предложены различные оптимизации с точки зрения математики и аппаратного обеспечения. Типичным примером является FlashAttention. FlashAttention — это алгоритм, который делит вычисления Attention на плитки (Tiling), чтобы минимизировать передачу данных (доступ к памяти) между иерархиями памяти GPU (SRAM и HBM). Хотя математически он выдает точно такой же результат, как стандартный Attention (Exact Attention), оптимизация на аппаратном уровне обеспечивает резкое ускорение и сокращение используемой памяти, что сделало возможным создание моделей с длинным контекстом, таких как GPT-4.

Кроме того, активно ведутся исследования таких подходов, как Sparse Attention и Linear Attention, которые аппроксимируют вычислительную сложность до $O(N \log N)$ или $O(N)$.

10. Пример реализации (псевдокод в стиле PyTorch)

Если перевести описанную математическую структуру в реальный программный код (Python / PyTorch), то окажется, что она описывается удивительно просто. Вот псевдокод ядра Self-Attention.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import torch
import torch.nn.functional as F
import math

def scaled_dot_product_attention(q, k, v, mask=None):
 # форма q, k, v: [batch_size, num_heads, seq_length, d_k]
 d_k = q.size(-1)

 # 1. Вычисление оценки скалярным произведением: Q * K^T
 # Транспонируем последние два измерения для умножения матриц
 scores = torch.matmul(q, k.transpose(-2, -1))

 # 2. Масштабирование
 scores = scores / math.sqrt(d_k)

 # 3. Маскирование (в случае Masked Attention)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)

 # 4. Преобразование в вероятности с помощью Softmax
 attention_weights = F.softmax(scores, dim=-1)

 # 5. Умножение на матрицу Value
 output = torch.matmul(attention_weights, v)

 return output, attention_weights

Как можно видеть, формула $Q K^T / \sqrt{d_k}$ интуитивно реализована как torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k). Тот факт, что математическая теория реализуется в несколько строк кода с помощью продвинутых библиотек оптимизации, является очень интересным аспектом глубокого обучения.

Заключение: форма «интеллекта», видимая через формулы

В этой статье мы раскрыли математическую структуру, лежащую в глубине модели Transformer.

Embedding, отображающий слова в многомерное векторное пространство, Positional Encoding, выражающее информацию о позиции через сложение тригонометрических волн, и механизм Self-Attention, который представляет собой вычисление скалярного произведения матриц, рожденное из аналогии с информационным поиском. Каждый из этих компонентов — не более чем наложение базовой математики: линейной алгебры, дифференциального и интегрального исчисления, а также теории вероятностей и статистики.

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

Как и предполагает провокационное название «Attention Is All You Need» (Внимание - это все, что вам нужно), красота этой архитектуры, отбросившей сложную рекуррентную и сверточную обработку и специализирующейся исключительно на вычислении «внимания (степени связи)», заключается именно в ее математической простоте.

Возможно, в будущем появятся новые архитектуры, превосходящие Transformer (например, Mamba, являющаяся State Space Model), но математическая база «понимания контекста с помощью Attention», созданная Transformer, навсегда останется в истории ИИ.

Если у вас будет возможность использовать LLM, такие как ChatGPT или Claude в будущем, представьте себе, как в фоновом режиме каждую секунду вычисляются триллионы матричных умножений $Q K^T$, а функция Softmax выдает вероятности. Разрешение вашего понимания технологий повысится, и мир ИИ покажется вам еще более интересным.

Литература

Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems.
Alammar, J. (2018). “The Illustrated Transformer.”

Эта статья была написана как руководство для тех, кто изучает математические основы обработки естественного языка и ИИ. Если у вас есть вопросы или вы хотите что-то обсудить, пожалуйста, дайте знать в комментариях!

Объяснение работы технологии квантования llama.cpp (GGUF)

Fri, 11 Sep 2026 00:00:00 +0900

1. Введение: Почему LLM нужно квантование?

Эволюция больших языковых моделей (LLM: Large Language Models) в последние годы поразительна, но за ней скрываются серьезные проблемы: “истощение вычислительных ресурсов” и “узкое место пропускной способности памяти”. Например, если загрузить модель с 70 миллиардами параметров (70B), такую как Llama 3, в память с использованием стандартных 16-битных чисел с плавающей запятой (FP16), только параметры займут около 140 ГБ VRAM/RAM. Если к этому добавить контекст во время логического вывода (KV кэш), модель не будет работать без кластеризации нескольких высококлассных GPU для дата-центров (NVIDIA A100 80GB или H100 80GB).

Спасителем, появившимся для запуска LLM индивидуальными разработчиками и на периферийных устройствах (MacBook или обычные игровые ПК), стал llama.cpp и лежащая в его основе технология квантования (Quantization). В частности, формат файлов GGUF (GPT-Generated Unified Format) и продвинутый алгоритм блочного квантования, известный как k-quants, представляют собой революционный метод сжатия размера модели в несколько раз, максимально ограничивая при этом снижение точности модели (Perplexity).

В этой статье мы подробно объясним квантование в llama.cpp, начиная с математических основ, различий с форматом GGML, детальной структуры формата GGUF и заканчивая внутренними механизмами k-quants.

2. Математические основы квантования (Quantization)

В контексте LLM квантование относится к операции отображения непрерывных значений (или высокоточных чисел с плавающей запятой) в дискретные значения с меньшим количеством бит (INT8, INT4, INT3 и т.д.).

2.1. Базовые формулы линейного квантования

Самым простым подходом является линейное квантование (Min-Max квантование). Пусть $W$ - исходный тензор весов с высокой точностью, а $W_q$ - квантованный целочисленный тензор.

$$ W_q = \text{round}\left( \frac{W}{S} \right) + Z $$

Где,

$S$ - это масштабный коэффициент (Scale Factor), определяющий размер шага (разрешение) квантования.
$Z$ - это нулевая точка (Zero-point), значение смещения для сдвига, определяющее, какому целому значению после квантования соответствует вещественный $0.0$.
$\text{round}(\cdot)$ - функция округления до ближайшего целого.

При обратном квантовании (Dequantization) во время логического вывода восстанавливаются приблизительные вещественные веса $\tilde{W}$.

$$ \tilde{W} = S \times (W_q - Z) $$

2.2. Симметричное и асимметричное квантование

В зависимости от обработки нулевой точки $Z$, методы делятся на два основных типа.

Асимметричное квантование (Asymmetric Quantization) Отображение использует минимальное значение данных $W_{\min}$ и максимальное значение $W_{\max}$.
$$ S = \frac{W_{\max} - W_{\min}}{2^b - 1}, \quad Z = \text{round}\left(-\frac{W_{\min}}{S}\right) $$
Где $b$ - количество бит квантования (например, для 4 бит $2^4-1 = 15$). Поскольку необходимо хранить $Z$, незначительно увеличиваются накладные расходы на вычисления и память.
Симметричное квантование (Symmetric Quantization) Отображение центрируется вокруг нуля с использованием максимального абсолютного значения данных ($Z=0$).
$$ S = \frac{\max(|W_{\max}|, |W_{\min}|)}{2^{b-1} - 1}, \quad Z = 0 $$
Раннее квантование llama.cpp (например, унаследованное Q4_0) использовало симметричное квантование. Поскольку член $Z$ отсутствует, преимуществом является значительное ускорение вычислений скалярного произведения с помощью инструкций SIMD.

3. Эволюция от GGML к GGUF и структура файла

Говоря о llama.cpp, нельзя не упомянуть GGML, библиотеку тензорных вычислений, написанную на C++, и производный от нее формат файлов GGUF.

3.1. Проблемы GGML

Ранний llama.cpp использовал формат ggml (и его варианты, такие как ggjt). Однако у них были следующие проблемы:

Отсутствие расширяемости: Магические числа и гиперпараметры были жестко закодированы (hardcoded) с фиксированной длиной и порядком, что приводило к разрушительным изменениям каждый раз при добавлении новой архитектуры модели (например, Llama, Falcon, Mixtral и т.д.) или нового токенизатора.
Потеря обратной совместимости: Формат часто обновлялся, из-за чего старые файлы моделей часто переставали читаться в последних версиях llama.cpp.

3.2. Рождение формата GGUF

GGUF, представленный в августе 2023 года, является универсальным форматом, разработанным для решения этих проблем. Его главная особенность - принятие структуры метаданных на основе пар ключ-значение (Key-Value).

Следующая диаграмма Mermaid абстрактно показывает файловую структуру GGUF.

graph TD A["Файл GGUF"] --> B["Заголовок (Magic, Version)"] A --> C["Метаданные (Пары Ключ-Значение)"] A --> D["Информация о тензоре (Name, Shape, Offset)"] A --> E["Данные тензора (Binary payload)"] C --> C1["general.architecture: llama"] C --> C2["llama.context_length: 4096"] C --> C3["tokenizer.ggml.tokens: [...]"] E --> E1["Веса Слоя 0"] E --> E2["Веса Слоя 1"] E --> E3["..."]

Основные преимущества GGUF:

Гибкость: Все настройки, такие как гиперпараметры модели, конфигурация RoPE (Rotary Positional Embedding), данные словаря токенизатора и т.д., хранятся в виде именованных пар Key-Value. Неизвестные ключи игнорируются, что упрощает добавление новых функций.
Независимость от порядка байтов (Endianness): GGUF по умолчанию использует порядок от младшего к старшему (Little-endian), но имеет явный флаг, что делает его безопасно переносимым между различными архитектурами.
Оптимизация для mmap (отображение в память): Данные тензоров выровнены (с отступами) по определенным границам, что позволяет отображать их напрямую с диска в адресное пространство памяти с помощью системного вызова ОС mmap(). Благодаря этому время инициализации при загрузке модели практически равно нулю.

4. Глубины k-quants: Продвинутое блочное квантование

Истинная ценность формата GGUF заключается в механизме k-quants (K-quantization), отвечающем за сжатие весов модели.

Обычно веса нейронной сети близки к нормальному распределению, если рассматривать слой целиком, но локально существуют выбросы (Outliers). Если квантовать веса всего слоя с помощью единого масштабного коэффициента $S$, масштаб будет искажен выбросами, и информация о малых весах будет полностью потеряна.

Чтобы предотвратить это, llama.cpp выполняет блочное квантование (Block-wise Quantization). Тензор весов разбивается на небольшие блоки (например, по 32 или 256 элементов), и каждому блоку присваивается свой собственный масштабный коэффициент (и нулевая точка).

4.1. Ограничения унаследованного квантования (Q4_0, Q4_1)

В раннем Q4_0 блок состоял из 32 весов FP16 и имел один общий масштабный коэффициент FP16.

Размер блока: 32
Память: 1 масштаб (16 бит) + 32 4-битных веса (128 бит) = 144 бита
Эффективное количество бит на элемент (bpw: bits per weight): $144 / 32 = 4.5$ bpw

Хотя это уже было довольно эффективно, проявились пределы точности и степени сжатия. Тогда и появился k-quants, имеющий более сложную и продуманную иерархическую структуру.

4.2. Иерархическая структура суперблоков и субблоков (Пример Q4_K_M)

k-quants имеет иерархическую структуру, состоящую из больших “Суперблоков (Super-block)” и содержащихся в них меньших “Субблоков (Sub-block)”. Это позволяет также квантовать сами метаданные (значения масштаба и т.д.), предельно снижая bpw при сохранении точности.

Давайте рассмотрим структуру Q4_K_M, которая является наиболее популярной конфигурацией. Q4_K_M использует суперблок из 256 элементов.

graph TD A["Суперблок (256 весов)"] --> B["Метаданные масштаба (FP16/INT8)"] A --> C["Субблок 0 (32 веса, 4-бит)"] A --> D["Субблок 1 (32 веса, 4-бит)"] A --> E["..."] A --> F["Субблок 7 (32 веса, 4-бит)"] B --> B1["Супер-масштаб (FP16)"] B --> B2["Суб-масштабы (8 x 6-бит)"] B --> B3["Суб-минимумы (8 x 6-бит)"]

Фактическая структура в C++ (GGML) концептуально определяется следующим образом:

1
2
3
4
5
6
7
8


// Концептуальная структура block_q4_K в llama.cpp
#define QK_K 256

struct block_q4_K {
 uint8_t d[2]; // Супер-масштаб для всего суперблока (например, FP16 x 2)
 uint8_t scales[12]; // Упакованные данные: 6-битные масштабы и 6-битные минимумы (нулевые точки) для 8 субблоков (по 32 элемента)
 uint8_t qs[QK_K/2]; // Данные весов, квантованные до 4 бит (256 элементов / 2 = 128 байт)
};

Математический процесс деквантования (Dequantization):

Приблизительное вещественное значение $\tilde{W}_{i, j}$ элемента $j$ ($0 \le j < 32$) внутри субблока $i$ ($0 \le i < 8$) вычисляется следующим образом:

$$ \tilde{W}_{i, j} = S_{\text{super}} \times s_i \times (w_{i, j} - m_i) $$

$S_{\text{super}}$: Масштаб с плавающей запятой для всего суперблока
$s_i$: 6-битный масштаб, квантованный для субблока $i$
$m_i$: 6-битный минимум (нулевая точка), квантованный для субблока $i$
$w_{i, j}$: 4-битный квантованный вес ($0 \dots 15$)

Благодаря этой иерархической структуре, сохраняя способность адаптироваться к выбросам, резко сокращается объем памяти, занимаемый самими масштабными коэффициентами. Q4_K_M достигает в целом около 4.8 bpw.

4.3. Разнообразие опций k-quants

llama.cpp предлагает множество вариаций в зависимости от цели. Суффиксы (S, M, L) после “K” обозначают размер (маленький, средний, большой).

Формат	BPW (Bits per Weight)	Обзор и особенности
Q2_K	2.5～3.3	Экстремальное сжатие. Значительное падение точности, но подходит для сред с крайне малым объемом VRAM.
Q3_K_M	3.3	Стандарт для 3-битного квантования. Уступает Q4, но часто остается в пределах допустимого.
Q4_K_M	4.8	Рекомендуемая золотая середина. Баланс между уменьшением размера модели вдвое и сохранением точности.
Q5_K_M	5.5	Когда требуется более высокая точность. Промежуточное положение между Q4 и FP16.
Q6_K	6.6	Сохраняет Perplexity почти на уровне FP16, но размер файла больше.
Q8_0	8.5	Эквивалент INT8. Используется в основном для промежуточных тензоров при логическом выводе вычислений и только в финальных слоях.

※ Фактический BPW усредняется по всей модели, поскольку выполняется смешанное квантование (Mixed Quantization) в зависимости от тензоров модели (например, проекции Q/K/V в Attention или веса в FFN). Внутри производится оптимизация, при которой важные тензоры квантуются в Q6, а остальные - в Q4.

5. Оптимизация производительности при логическом выводе: архитектуры SIMD и CUDA

Простая загрузка модели GGUF в память не делает логический вывод быстрым. Большая часть логического вывода в LLM - это «умножение матрицы на вектор (Matrix-Vector Multiplication, или GEMV, или Matrix-Matrix, GEMM)». Ключ к успеху - это то, как ускорить операцию умножения и сложения между квантованными весами и активациями (входными данными), хранящимися в FP16 (или FP32).

5.1. Использование инструкций SIMD в процессорных средах

Невероятная скорость, с которой llama.cpp работает при логическом выводе на CPU, обусловлена оптимизацией SIMD (Single Instruction, Multiple Data) на уровне ассемблера. Например, он в полной мере использует наборы инструкций AVX2 и AVX-512 на процессорах Intel/AMD, и ARM NEON на Apple Silicon.

Во время логического вывода не тратится время на возвращение $W_q$ в формат FP32 (деквантование) перед умножением. Сторона активации также динамически квантуется блоками (Dynamic Quantization, обычно в INT8), и целочисленные операции INT8 $\times$ INT4 вычисляются сразу с использованием специальных инструкций скалярного произведения SIMD (например, vdpaddd или _mm256_madd_epi16). В конечном аккумуляторе происходит преобразование обратно в FP32 и умножение на масштабный коэффициент, что обеспечивает поразительную пропускную способность.

5.2. Разгрузка в средах GPU (cuBLAS / CUDA)

Современный llama.cpp имеет надежную поддержку не только CPU, но и GPU NVIDIA (CUBLAS / CUDA). Можно выгрузить (offload) некоторые или все слои файла GGUF в VRAM (опция --n-gpu-layers).

sequenceDiagram participant User participant CPU_RAM as CPU и RAM (mmap) participant VRAM as GPU VRAM participant Compute as Тензорные ядра User->>CPU_RAM: Загрузка GGUF (mmap) CPU_RAM->>VRAM: Выгрузка слоев (напр. 30/32 слоев) Note over CPU_RAM, VRAM: Данные остаются квантованными в VRAM User->>Compute: Прямой проход (Входные токены) Compute->>VRAM: Извлечение квантованных весов Compute->>Compute: Динамическое деквантование в FP16 в SRAM (on-the-fly) Compute->>Compute: Умножение матриц (cuBLAS / Пользовательские ядра) Compute->>User: Вывод логитов (Logits)

При вычислениях на GPU пропускная способность памяти (Memory Bandwidth) VRAM становится самым большим узким местом. Поскольку веса сжаты с помощью k-quants, объем данных, передаваемых из VRAM в вычислительные блоки GPU (SM: Streaming Multiprocessor или Tensor Cores), сокращается в 3-4 раза. В тот момент, когда веса достигают вычислительного блока, они динамически деквантуются (разворачиваются) в FP16, и с помощью Tensor Cores выполняется сверхбыстрое умножение матриц. Другими словами, можно сказать, что квантование выполняется не для “уменьшения объема вычислений”, а для “уменьшения объема передаваемых данных из памяти”.

6. Конкретные примеры компромисса между использованием памяти и производительностью

Здесь, на примере модели Llama 3 8B, давайте посмотрим на требования к спецификациям для каждого уровня квантования GGUF. (Цифры являются приблизительными ориентирами.)

Модель / Квантование	Размер файла	Требуемая VRAM/RAM	Скорость вывода (ориентир)	Снижение Perplexity
Llama-3-8B (FP16)	Около 16 ГБ	от 18 ГБ	Базовая	Нет (Base)
Llama-3-8B (Q8_0)	Около 8.5 ГБ	от 10 ГБ	Высокая	Почти нулевое
Llama-3-8B (Q6_K)	Около 6.6 ГБ	от 8 ГБ	Очень высокая	Минимальное
Llama-3-8B (Q4_K_M)	Около 4.9 ГБ	от 6.5 ГБ	Самая быстрая / Оптимальная	В допустимых пределах / Небольшое
Llama-3-8B (Q3_K_M)	Около 3.9 ГБ	от 5.5 ГБ	Самая быстрая	Немного заметное
Llama-3-8B (Q2_K)	Около 3.0 ГБ	от 4.5 ГБ	Высокая	Очевидное снижение

Внимание (Влияние KV-кэша): При логическом выводе LLM, когда длина контекста (количество токенов промпта) увеличивается, потребление памяти взрывообразно растет не только из-за весов модели, но и из-за KV-кэша, который сохраняет прошлые состояния Attention. Например, если длина контекста составляет 8192 токена, только KV-кэш будет потреблять несколько гигабайт. Поэтому при реальном использовании необходимо обеспечить запас (Headroom) в размере Размер файла модели + около 1.5 ГБ ~ 3 ГБ. Причина, по которой рекомендуется Q4_K_M, заключается в том, что это идеальная линия, при которой даже с учетом резервирования этого KV-кэша модель безопасно работает на типичном графическом процессоре с 8 ГБ VRAM (например, RTX 3060 / 4060).

В последних версиях llama.cpp также была добавлена функция квантования самого KV-кэша в Q8_0 или Q4_0, и постоянно ведется работа по дальнейшему увеличению длины контекста.

7. Заключение

В этой статье мы глубоко погрузились во внутреннюю структуру формата GGUF и технологии квантования k-quants, которые являются сердцем llama.cpp.

Гибкость GGUF: Структура метаданных типа “ключ-значение” создала надежную экосистему, которая может идти в ногу с быстрой эволюцией LLM (появление новых архитектур моделей) без разрушительных изменений.
Экстремальное сжатие с помощью k-quants: Иерархическое управление масштабными коэффициентами суперблоков и субблоков позволило добиться удивительного сжатия - в среднем 4.8 бита на вес (Q4_K_M) - с сохранением информации о выбросах.
Устранение узкого места пропускной способности памяти: Продвинутые реализации ядер для SIMD и CUDA позволили выполнять вычисления с динамическим деквантованием (on-the-fly), что сократило объем передаваемых данных из VRAM и значительно повысило скорость логического вывода.

Технологическое мастерство llama.cpp, способствующее демократизации ИИ, выходит за рамки простого инструмента и, без преувеличения, является одной из вершин современной программной инженерии. Поняв алгоритм квантования и структуру формата GGUF, вы сможете более точно выбирать оптимальную модель для вашей среды и выполнять настройку производительности.

Полезные ссылки

(Конец)