Machine Learning on kenji.blog

【初心者向け】Transformerモデルの数学的構造を読み解く

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

はじめに：なぜTransformerの数学を学ぶのか？

現代の自然言語処理（NLP）、そしてAI全体の歴史を塗り替えたと言っても過言ではないアーキテクチャが「Transformer」です。2017年にGoogleの研究者らによって発表された論文『Attention Is All You Need』で初めて提案されたこのモデルは、OpenAIのGPTシリーズ（ChatGPTの基盤技術）やGoogleのBERT、AnthropicのClaudeなど、現在世界を席巻している大規模言語モデル（LLM）の心臓部として機能しています。

しかし、Transformerの仕組みについて「Attention（注意機構）を使って文脈を理解する」といった定性的な説明はよく見かけますが、その背後にある数学的な構造について初心者向けに深く掘り下げた解説は意外と少ないのが現状です。AIがどのようにして「言葉」を「数式」として処理し、驚くほど自然な文章を生成しているのかを真に理解するためには、その数学的メカニズムを読み解くことが不可欠です。

本記事では、数学やプログラミングの基礎知識を持つ方（高校レベルの行列や微分の概念がわかる方）を対象に、Transformerの心臓部である「Self-Attention機構」「クエリ・キー・バリュー（Q/K/V）モデル」「Softmax関数による正規化」、そして「Positional Encoding」などの数学的構造を徹底的に、かつわかりやすく解き明かしていきます。

数式の羅列に圧倒されるかもしれませんが、一つ一つの計算には明確な「意味」があります。この記事を読み終える頃には、Transformerが単なる魔法のブラックボックスではなく、精緻に設計された数学と統計の結晶であることが理解できるはずです。

1. 従来手法の限界とTransformerの革新性

Transformerが登場する前、自然言語処理の主流はリカレントニューラルネットワーク（RNN）や、その派生であるLSTM（Long Short-Term Memory）でした。RNNは時系列データを処理するために設計されており、文章を単語ごとに先頭から順番に読み込んでいきます。

しかし、RNNには致命的な弱点が2つありました。

長期依存性の学習が困難：文章が長くなると、最初の方に入力された単語の情報が、最後の方に到達するまでに薄れてしまう（勾配消失問題）。
並列計算が不可能：単語を順番に処理しなければならないため、GPUを用いた大規模な並列計算が難しく、学習に膨大な時間がかかる。

Transformerは、RNNの構造を完全に捨て去り、「Attention」のみを用いて文脈を捉えるというパラダイムシフトを起こしました。これにより、系列長がどれだけ長くても情報の損失がなく、かつ計算を並列化してGPUの性能を最大限に引き出すことが可能になったのです。

2. Transformerの全体アーキテクチャ

まずは、Transformer全体のアーキテクチャを俯瞰してみましょう。Transformerは大きく分けて「Encoder（エンコーダ）」と「Decoder（デコーダ）」の2つのブロックから構成されています。翻訳タスクを例にとると、Encoderが入力言語（例：英語）を数学的なベクトル表現に変換し、Decoderがそのベクトル表現をもとに出力言語（例：日本語）を生成します。

以下の図は、Encoderブロックの内部構造を簡略化したものです。

graph TD A["Input Tokens"] --> B["Input Embedding"] B --> C["Positional Encoding"] C --> D["Multi-Head Self-Attention"] D --> E["Add & Layer Normalization"] E --> F["Feed Forward Network"] F --> G["Add & Layer Normalization"] G --> H["Output to Next Layer"] C -.->|"Residual Connection"| E E -.->|"Residual Connection"| G

ここからは、各コンポーネントで行われている数学的な操作を順を追って見ていきましょう。

3. 単語のベクトル化と位置エンコーディング（Positional Encoding）

コンピュータはテキストをそのまま理解することはできません。入力されたテキストはまず「トークン（Token）」と呼ばれる単位に分割され、それぞれが固定長のベクトルに変換されます。これがInput Embeddingです。

3.1 Input Embeddingの数学

語彙（ボキャブラリー）のサイズを $V$、埋め込みベクトルの次元数を $d_{model}$（元の論文では $d_{model} = 512$）とします。各単語 $w_i$ は、埋め込み行列 $W_E \in \mathbb{R}^{V \times d_{model}}$ を用いてベクトル $x_i \in \mathbb{R}^{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です。位置 $pos$ にある単語の $i$ 番目の次元に対するPositional Encoding $PE$ は、以下の三角関数を用いて計算されます。

$$ 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$ だけ離れた位置 $pos + k$ のPositional Encodingは、位置 $pos$ のPositional Encodingの線形結合として表すことができます。つまり、行列 $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}}$（ここでは話を簡単にするためバッチサイズは無視します）に対して、学習可能な重み行列 $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 $$

この計算により得られる行列 $\text{Scores} \in \mathbb{R}^{N \times N}$ の各要素 $s_{ij}$ は、$i$ 番目の単語のQueryと $j$ 番目の単語のKeyの内積、すなわち「関連度の強さ」を表します。

4.3 スケーリング（Scale）

内積によるスコア計算には一つの問題があります。ベクトルの次元 $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関数において、最大値以外の勾配が極端に小さくなる「勾配消失」が発生し、学習が進まなくなってしまいます。これを防ぐため、スコアを $\sqrt{d_k}$ で割る（スケーリングする）ことで、分散を常に $1$ に保つようにします。

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

4.4 Softmax関数による確率化

得られたスコアを、合計が $1$ になるような確率分布（重み）に変換するために Softmax関数 を行ごとに適用します。

$$ 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$ を見ると、「単語 $i$ を理解する上で、他のどの単語 $j$ にどれくらい注目（Attention）すべきか」が 0 から 1 の値で表現されています。

4.5 Valueの重み付き和

最後に、得られたAttention Weight行列 $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["Input X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Head 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Head 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Head h"] H1 & H2 & HN --> C["Concatenate"] C --> WO["Multiply by WO"] WO --> OUT["Multi-Head Output"]

6. Feed-Forward Neural Network (FFN)

Multi-Head Attentionの出力は、次に Position-wise Feed-Forward Network (FFN) に入力されます。これは、系列の「各位置（単語）ごとに独立して」適用される2層の全結合ニューラルネットワークです。

数式で表すと以下のようになります。

$$ \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$ によって次元を一時的に大きく拡大（例えば $d_{model}=512$ から $d_{ff}=2048$ に4倍拡大）し、特徴空間上で複雑な計算を行った後、第二層の重み $W_2$ で再び元の次元に戻します。この「次元の拡大と縮小」によって、モデルの表現力が飛躍的に高まっています。

7. 残差接続（Residual Connection）とLayer Normalization

ディープラーニングにおいて、ネットワークの層を深くしていくと、学習時に勾配が消失または爆発してしまい、うまく学習できなくなる問題が発生します。これを防ぐために、Transformerの各サブレイヤー（AttentionとFFN）の周囲には、残差接続（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$ は学習可能なスケールとシフトのパラメータ）

バッチ方向の正規化（Batch Normalization）ではなく、層方向の正規化（Layer Normalization）を採用した理由は、文章のように長さが一定でない系列データを処理する際、バッチ間の統計量が不安定になりやすいためです。Layer Normalizationにより、Transformerはバッチサイズに依存せずに安定した学習が可能になります。

8. デコーダ特有の構造：Masked AttentionとCross-Attention

ここまで解説した構造はエンコーダのものです。文章を生成するデコーダブロックでは、構造が少し異なります。

8.1 Masked Multi-Head Attention

デコーダの役割は「過去の単語から次の単語を予測すること」です。したがって、訓練時に「未来の単語」を見てしまってはカンニングになってしまいます。これを防ぐための数学的操作が Masking（マスキング） です。

スコア行列 $Q K^T$ に対して、上三角部分（未来の情報に相当）に $-\infty$ に近い非常に小さな値を設定するマスク行列 $M$ を足し合わせます。

$$ 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

デコーダの2つ目のサブレイヤーは、エンコーダからの出力を参照する 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$ が数万〜数十万に達し、従来のAttention計算ではGPUのメモリが即座に枯渇してしまいます。

この $O(N^2)$ の呪いを断ち切るために、近年では数学的・ハードウェア的アプローチから様々な最適化が提案されています。その代表例が FlashAttention です。FlashAttentionは、GPUのメモリ階層（SRAMとHBM）間のデータ転送（メモリアクセス）を最小限に抑えるよう、Attention計算をタイル状に分割（Tiling）して行うアルゴリズムです。数式上は標準的なAttentionと全く同じ結果を出力する（Exact Attention）にもかかわらず、ハードウェアレベルの最適化により劇的な高速化とメモリ削減を実現し、GPT-4などの長文脈モデルの実現を可能にしました。

他にも、計算量を $O(N \log N)$ や $O(N)$ に近似する Sparse Attention や Linear Attention などの研究も盛んに行われています。

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
 # 最後の2つの次元を転置して行列積を計算
 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を超える新たなアーキテクチャ（State Space ModelであるMambaなど）が登場する可能性もありますが、Transformerが築き上げた「Attentionによる文脈理解」の数学的枠組みは、AIの歴史に永遠に刻まれるはずです。

もしあなたが今後、ChatGPTやClaudeなどのLLMを使う機会があれば、そのバックグラウンドで毎秒何兆回もの $Q K^T$ の行列積が計算され、Softmax関数が確率を弾き出している様子を想像してみてください。技術に対する解像度が上がり、よりAIの世界が面白く感じられるはずです。

参考文献

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

この記事は、自然言語処理とAIの数学的基礎を学ぶ方々へのガイドとして執筆されました。質問や議論があれば、ぜひコメント欄でお知らせください！

llama.cppの量子化技術（GGUF）の仕組みを解説

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

1. はじめに：なぜLLMには量子化が必要なのか？

近年の大規模言語モデル（LLM: Large Language Models）の進化は目覚ましいものがありますが、その裏で「計算資源の枯渇」と「メモリ帯域のボトルネック」という深刻な問題が浮上しています。例えば、Llama 3 のような 70B（700億）パラメータのモデルを、標準的な 16ビット浮動小数点（FP16）でメモリにロードした場合、パラメータだけで約 140GB の VRAM/RAM を消費します。これに推論時のコンテキスト（KVキャッシュ）が加わると、データセンター向けのハイエンドGPU（NVIDIA A100 80GB や H100 80GB）を複数台クラスタリングしなければ動作しません。

個人開発者やエッジデバイス（MacBookや一般的なゲーミングPC）でLLMを動作させるための救世主として登場したのが 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. 対称量子化 vs 非対称量子化

ゼロポイント $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 を語る上で欠かせないのが、C++で書かれたテンソル演算ライブラリ GGML と、そこから派生したファイルフォーマット GGUF です。

3.1. GGMLの課題

初期の llama.cpp は ggml フォーマット（および ggjt などの亜種）を使用していました。しかし、これらには以下の問題がありました。

拡張性の欠如: マジックナンバーやハイパーパラメータが固定長・固定順序でハードコードされており、新しいモデルアーキテクチャ（例: Llama, Falcon, Mixtral など）や新しいトークナイザを追加するたびに破壊的変更が生じた。
後方互換性の喪失: フォーマットが頻繁にアップデートされ、古いモデルファイルが最新の llama.cpp で読み込めなくなる事態が多発しました。

3.2. GGUFフォーマットの誕生

2023年8月に導入された GGUF は、これらの問題を解決するために設計された汎用性の高いフォーマットです。最大の特徴は、キー・バリュー（Key-Value）ベースのメタデータ構造 を採用したことです。

以下の Mermaid 図は、GGUFのファイル構造を抽象化したものです。

graph TD A["GGUF File"] --> B["Header (Magic, Version)"] A --> C["Metadata (Key-Value Pairs)"] A --> D["Tensor Info (Name, Shape, Offset)"] A --> E["Tensor Data (Binary payload)"] C --> C1["general.architecture: llama"] C --> C2["llama.context_length: 4096"] C --> C3["tokenizer.ggml.tokens: [...]"] E --> E1["Layer 0 Weights"] E --> E2["Layer 1 Weights"] E --> E3["..."]

GGUFの主な利点:

柔軟性: モデルのハイパーパラメータやRoPE（Rotary Positional Embedding）の設定、トークナイザの語彙データなどをすべて名前付きの Key-Value ペアとして格納。未知のキーは無視されるため、新機能の追加が容易。
エンディアン非依存: GGUFはデフォルトでリトルエンディアンを採用していますが、明示的にフラグを持つため異なるアーキテクチャ間でも安全にポータブルです。
mmap(メモリマッピング)への最適化: テンソルデータは特定の境界でアライメント（パディング）されており、OSの 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重みを1つのブロックとし、1つのFP16スケールファクタを共有していました。

ブロックサイズ: 32
メモリ: 1つのスケール(16bit) + 32個の4bitウェイト(128bit) = 144bit
要素あたりの実効ビット数 (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["Super-block (256 weights)"] --> B["Scale metadata (FP16/INT8)"] A --> C["Sub-block 0 (32 weights, 4-bit)"] A --> D["Sub-block 1 (32 weights, 4-bit)"] A --> E["..."] A --> F["Sub-block 7 (32 weights, 4-bit)"] B --> B1["Super-scale (FP16)"] B --> B2["Sub-scales (8 x 6-bit)"] B --> B3["Sub-mins (8 x 6-bit)"]

C++（GGML）における実際の構造体は以下のように定義されています。

1
2
3
4
5
6
7
8


// llama.cpp における block_q4_K の概念的な構造
#define QK_K 256

struct block_q4_K {
 uint8_t d[2]; // スーパーブロック全体のスーパー・スケール (FP16 x 2 など)
 uint8_t scales[12]; // 8つのサブブロック(32要素ずつ)の 6-bit スケールと 6-bit 最小値(ゼロポイント)をパックしたデータ
 uint8_t qs[QK_K/2]; // 4-bit で量子化されたウェイトデータ (256要素 / 2 = 128 bytes)
};

数学的なデキュー（Dequantization）処理：

サブブロック $i$（$0 \le i < 8$）内の要素 $j$（$0 \le j < 32$）の近似的な実数値 $\tilde{W}_{i, j}$ は、以下のように計算されます。

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

$S_{\text{super}}$: スーパーブロック全体の浮動小数点スケール
$s_i$: サブブロック $i$ 用に量子化された 6-bit スケール
$m_i$: サブブロック $i$ 用に量子化された 6-bit 最小値（ゼロポイント）
$w_{i, j}$: 4-bit の量子化ウェイト ($0 \dots 15$)

この階層構造により、外れ値への適応力を維持しながら、スケールファクタ自体が占めるメモリ量を劇的に削減しています。Q4_K_M は全体で 4.8 bpw 程度を実現します。

4.3. 多様な k-quants オプション

llama.cpp は目的に応じて多数のバリエーションを提供しています。「K」の後ろのサフィックス（S, M, L）はサイズの大小を表します。

フォーマット	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	FP16とほぼ同等のPerplexityを維持するが、ファイルサイズは大きめ。
Q8_0	8.5	INT8相当。主に推論時の計算用中間テンソルや、最終層でのみ使用される。

※実際のBPWは、モデルのテンソル（例えば Attention の Q/K/V プロジェクションか、FFNの重みか）によって、混合量子化（Mixed Quantization）が行われるため、モデル全体で平均化されます。重要なテンソルはQ6で、それ以外をQ4で量子化するなどの最適化が内部で行われています。

5. 推論時のパフォーマンス最適化：SIMDとCUDAアーキテクチャ

GGUFモデルをメモリにロードしただけでは、推論は高速になりません。LLMの推論の大半は「行列積（Matrix-Vector Multiplication, 略して GEMV、あるいは Matrix-Matrix, GEMM）」です。量子化された重みと、FP16（またはFP32）で保持されているアクティベーション（入力データ）の積和演算をいかに高速化するかが鍵です。

5.1. CPU環境におけるSIMD命令の活用

llama.cpp がCPU推論において驚異的な速度を誇るのは、アセンブリ・レベルでの SIMD (Single Instruction, Multiple Data) 最適化にあります。例えば Intel/AMD の CPU では AVX2 や AVX-512、Apple Silicon では ARM NEON 命令セットをフル活用します。

推論中、わざわざ $W_q$ を FP32 に戻して（Dequantizeして）から掛け算を行うわけではありません。アクティベーション側もブロック単位で動的に量子化（Dynamic Quantization、通常は INT8 へ量子化）し、INT8 $\times$ INT4 の整数演算を SIMD の特殊なドット積命令（例: vdpaddd や _mm256_madd_epi16）を用いて一気に計算します。最終的なアキュムレータで FP32 に戻してスケールファクタを掛けることで、驚異的なスループットを実現しています。

5.2. GPU環境 (cuBLAS / CUDA) でのオフロード

最近の llama.cpp は CPU だけでなく、NVIDIA GPU に対する強力なサポート（CUBLAS / CUDA）も持っています。 GGUFファイルの一部または全部の層をVRAMにオフロードすることが可能です（--n-gpu-layers オプション）。

sequenceDiagram participant User participant CPU_RAM as CPU & RAM (mmap) participant VRAM as GPU VRAM participant Compute as Tensor Cores User->>CPU_RAM: Load GGUF (mmap) CPU_RAM->>VRAM: Offload Layers (e.g. 30/32 layers) Note over CPU_RAM, VRAM: Data remains quantized in VRAM User->>Compute: Forward Pass (Input Tokens) Compute->>VRAM: Fetch Quantized Weights Compute->>Compute: Dequantize to FP16 on-the-fly in SRAM Compute->>Compute: Matrix Multiplication (cuBLAS / Custom Kernels) Compute->>User: Output Logits

GPU上で計算する場合、VRAMの帯域幅（Memory Bandwidth）が最大のボトルネックになります。重みが k-quants で圧縮されているため、VRAMからGPUの演算ユニット（SM: Streaming Multiprocessor や Tensor Cores）へのデータ転送量が 1/3 ～ 1/4 に削減されます。計算ユニットに重みが到達した瞬間に、オンザフライでFP16にデキュー（展開）され、Tensor Core を使って超高速に行列積が実行されます。つまり、量子化は**「計算量を減らす」ためではなく「メモリ転送量を減らす」ために行われている**と言えます。

6. メモリ使用量と性能のトレードオフの具体例

ここで、Llama 3 8B モデルを例に、GGUFの量子化レベル別の要求スペックを見てみましょう。（数値はおおよその目安です）

モデル/量子化	ファイルサイズ	必要なVRAM/RAM	推論速度(目安)	Perplexity劣化
Llama-3-8B (FP16)	約 16 GB	18 GB以上	基準	なし (Base)
Llama-3-8B (Q8_0)	約 8.5 GB	10 GB以上	高速	ほぼゼロ
Llama-3-8B (Q6_K)	約 6.6 GB	8 GB以上	非常に高速	極小
Llama-3-8B (Q4_K_M)	約 4.9 GB	6.5 GB以上	最速・最適	許容範囲・微小
Llama-3-8B (Q3_K_M)	約 3.9 GB	5.5 GB以上	最速	やや目立つ
Llama-3-8B (Q2_K)	約 3.0 GB	4.5 GB以上	高速	明らかな劣化

注意点 (KVキャッシュの影響): LLMの推論において、コンテキスト長（プロンプトのトークン数）が長くなると、モデルの重みだけでなく、過去のAttention状態を保存する KVキャッシュ のメモリ消費が爆発的に増加します。例えばコンテキストが 8192 トークンの場合、KVキャッシュだけで数GBを消費します。したがって、実運用では モデルファイルサイズ + 約1.5GB～3GB のマージン（Headroom）を確保しておく必要があります。Q4_K_M が推奨される理由は、このKVキャッシュを確保しても、一般的な 8GB VRAM 搭載の GPU（RTX 3060 / 4060 など）で安全に動作する絶妙なラインだからです。

最近の llama.cpp では、この KVキャッシュ自体を Q8_0 や Q4_0 で量子化する機能 も追加されており、コンテキスト長をさらに伸ばすための工夫が絶え間なく行われています。

7. まとめ

本記事では、llama.cpp の心臓部である GGUF フォーマットと k-quants 量子化技術の内部構造について、深く掘り下げて解説しました。

GGUFの柔軟性: キー・バリュー型のメタデータ構造により、LLMの急速な進化（新しいモデルアーキテクチャの登場）にも破壊的変更なしに追従できる強固なエコシステムを構築しました。
k-quantsによる極限圧縮: スーパーブロックとサブブロックの階層的なスケールファクタ管理により、外れ値の情報を保持しつつ、重み1つあたり平均 4.8 ビット（Q4_K_M）という驚異的な圧縮を実現しました。
メモリ帯域ネックの解消: SIMDやCUDAにおける高度なカーネル実装により、オンザフライでデキューしながら計算を行うことで、VRAM転送量を削減し、推論スピードを劇的に向上させました。

AIの民主化を推し進める llama.cpp の技術力は、単なるツールの枠を超え、現代のソフトウェア・エンジニアリングの最高峰の一つと言っても過言ではありません。量子化アルゴリズムやGGUFフォーマットの仕組みを理解することで、ご自身の環境に最適なモデルの選択や、パフォーマンスチューニングがより正確に行えるようになるでしょう。

参考リンク

（おわり）