# NVIDIAのGPUはなぜAIに強いのか — Tensor Core・低精度演算・HBM・NVLinkを数式と公称値から読み解く

> NVIDIAのGPUがAIに強い理由を、Tensor Core・低精度演算（FP8/FP4）・HBM・NVLinkの4層で解説。H100のFP8 3,958 TFLOPSがスパース性込みの値であること、LLM推論のデコードが演算ではなくメモリ帯域で決まる理由を、公称値と数式から理論値として示します。

- 公開日: 2026-11-17
- 著者: 友田 陽大
- タグ: AI, インフラ, パフォーマンス, 技術選定, コスト最適化
- URL: https://tomodahinata.com/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained
- カテゴリ: NVIDIA・GPU・AI半導体

## 要点

- AIの計算の大半は行列積（GEMM）で、その演算量は 2MNK。NVIDIAの強みは「行列積専用の演算器（Tensor Core）」「小さな数値形式」「演算器に餌を運ぶHBM」「GPU同士をつなぐNVLink/NCCL」の4層と、それを使い切るソフトウェアの掛け算にある。
- H100 SXM の FP8 3,958 TFLOPS は 2:4 構造化スパース性を使った値で、密行列では 1,979 TFLOPS。通常の FP32 は 66.9 TFLOPS で、Tensor Core の FP16（密）989 TFLOPS とは別物。
- H100 は 1 バイト読むあいだに約295回の FP16 演算ができる（Ridge Point）。バッチ1のデコードは 1 バイトあたり約1回の演算しかしないため、演算器ではなくメモリ帯域が速度を決める。
- V100 から B200 までで、最低精度どうしの密演算性能は約72倍（精度をFP16にそろえると約18倍）、HBM帯域は約8.6倍。演算の伸びが帯域の伸びを大きく上回ったため、帯域律速の処理ほど世代交代の恩恵が小さい。
- 公称値はすべて理論ピークで、実測ではない。GPU選定は「学習か推論か」「プレフィル中心かデコード中心か」で効く指標が変わる。

---

「NVIDIAのGPUはAIに強い」と言われます。では、何がどう強いのでしょうか。

よくある答えは「演算器がたくさんあるから」です。半分は正しいのですが、それだけでは説明がつかない現象がいくつもあります。演算性能が10倍のGPUに替えても、チャットボットの応答が10倍速くならないことがあります。スペック表のFP8性能は、ほとんどのワークロードで出ません。GPUを8枚に増やしても、学習が8倍速くなるとは限りません。

この記事では、NVIDIAのGPUの強さを**4つの層の掛け算**として分解します。

1. **行列積に特化した演算器**（Tensor Core）
2. **小さな数値形式で計算すること**（FP16・BF16・FP8・FP4）
3. **演算器にデータを運ぶメモリ**（HBM）
4. **GPU同士をつなぐ通信**（NVLink・NVSwitch・NCCL）

さらに、この4層を使い切るためのソフトウェア（cuBLAS・cuDNN・NCCL・PyTorchなど）が、すべての層を横断して支えています。

**結論から言うと**、NVIDIAのGPUが強いのは、この4層とソフトウェアがそろっているからです。ただし、チャットの応答速度を決めるのは、多くの場合、演算性能ではなくメモリ帯域です。この記事の後半で、その理由を数式で示します。

各節は冒頭で「なぜそうなるのか」を言葉で説明し、そのあとに数式と公称値で裏づけます。経営判断の材料が欲しい方は各節の冒頭と、最後の「判断基準」（13節）を、エンジニアの方は数式と表を中心にお読みください。

**この記事の数値について。** 性能の数値はすべてNVIDIAが公表している**理論ピーク**（クロック周波数×演算器の数から計算した上限）か、それを使った筆者の計算です。筆者がH100やB200で測った実測値ではありません。計算で導いた値には「理論値」と明記します。なお、筆者の実務はTesla T4 1枚規模の推論基盤で、H100やB200のクラスタを運用した経験はありません。

## 1. AIの計算は「巨大な掛け算と足し算」でできている

ニューラルネットワークの中身を一言で言えば、**大量の掛け算と足し算**です。

たとえば言語モデルの1つの層は、入力のベクトル $x$ に重みの行列 $W$ を掛けて、出力 $y$ を作ります。

$$
y = Wx
$$

$W$ が 4096×4096 の行列なら、出力の1要素を作るのに4096回の掛け算と4096回の足し算が必要で、それが4096要素ぶんあります。実際には1トークンずつではなく、多数のトークンをまとめて行列×行列として計算します。これを **GEMM**（General Matrix Multiply、一般行列積）と呼びます。

$M \times K$ の行列と $K \times N$ の行列の積の演算量は、次の式で数えられます。

$$
F_{\mathrm{GEMM}} \approx 2MNK \quad [\mathrm{FLOP}]
$$

- $M$：まとめて処理するトークン数（バッチ×系列長）
- $K$：入力の次元
- $N$：出力の次元
- 係数の2は、1回の「掛けて足す」を掛け算1回＋足し算1回の2 FLOP と数えるため

2,048トークンを 4096×4096 の層に通すと、$2 \times 2048 \times 4096 \times 4096 \approx 68.7 \times 10^9$、つまり約687億回の浮動小数点演算になります。これが1層ぶんで、モデルにはこの種の層が数百あります。

Transformerの学習全体では、Kaplanらのスケーリング則の論文が、埋め込み層を除くパラメータ数を $N$、学習トークン数を $D$ として、学習の総演算量を次のように近似しています。

$$
C \approx 6ND
$$

順伝播が1トークンあたり約 $2N$ FLOP、逆伝播がその約2倍なので、合わせて約 $6N$ です（論文の表記は $C \approx 6NBS$ で、$BS$ が学習トークン数にあたります）。ただしこれは近似で、注意機構（Attention）が系列長に比例して増やす項を省いています。論文は、モデルの幅が系列長に比べて十分大きい条件で、この項が小さいとしています。長い文脈を扱うモデルでは、この近似は過小評価になります。

ここまでで押さえておきたいのは一点です。**AIの計算の大部分は、同じ形の掛け算と足し算を、互いに独立に、膨大な回数くり返すことです。** 独立に計算できるので、たくさんの演算器で同時に処理できます。これがGPUと相性のよい理由の出発点です。

## 2. CUDAコアとTensor Core：演算器の粒度が違う

### FMA：「掛けて足す」を1命令で

GPUの基本的な演算器（NVIDIAの用語ではCUDAコア）は、**FMA**（Fused Multiply-Add）を1命令で実行します。

$$
d = a \times b + c
$$

FMAは掛け算の結果を丸めずに足し算まで進め、最後に1回だけ丸めます。丸めの回数が減るので、別々に計算するより精度が高く、命令数も半分になります。行列積の内積は、FMAを延々と積み重ねる計算です。

CPUのコアとは単位が違う点にも注意が必要です。CPUのコアは、分岐予測や命令の順序の入れ替えを備えた、独立して動ける実行単位です。CUDAコアは、同じ命令を多数のデータに同時に適用する演算のレーンに近いものです。GPUは処理の単位（スレッド）を32本ずつの組（warp）にまとめ、組の中では同じ命令を一斉に実行します。そのため、CUDAコアの数とCPUのコア数を比べても、速さの比較にはなりません。

### Tensor Core：小さな行列積を丸ごと1命令で

**Tensor Core**は、FMAをスカラー（1つの数）ではなく**小さな行列のブロック**単位で実行する演算器です。概念的には次の計算を1回の操作で行います。

$$
D = A \times B + C \quad (A, B, C, D \text{ は小さな行列のタイル})
$$

例えるなら、CUDAコアが「電卓を持った作業員」だとすると、Tensor Coreは「掛け算九九の表を丸ごと1回で埋める専用の機械」です。汎用性は低い代わりに、行列積という一つの仕事では桁違いに速く働きます。

Tensor Coreを最初に搭載したのは、2017年のTesla V100（Volta世代）です。V100は1つのSM（Streaming Multiprocessor、GPUの基本的な演算ブロック）に8個、全体で640個のTensor Coreを持ち、各Tensor Coreは1クロックあたり64回のFMAを実行します。ここから理論ピークを計算できます。

$$
640 \times 64 \,\mathrm{FMA} \times 2 \,\mathrm{FLOP/FMA} \times 1.530\,\mathrm{GHz} \approx 125\,\mathrm{TFLOPS}
$$

NVIDIAがV100の性能として公表した「125 Tensor TFLOPS」と一致します。**スペック表の理論ピークは、このような掛け算で作られた数字であり、何かを動かして測った値ではない**ことが分かります。

### H100の「FP32性能」と「Tensor Core性能」は別物

この違いを、H100 SXM5（H100のうち、専用基板に載せるSXM版という製品型番）の公称値で確認しましょう（NVIDIAのホワイトペーパー v1.04、Table 1より）。TFLOPSは「1秒あたり1兆回の浮動小数点演算」を表す単位です。「密」は、ゼロを飛ばさない通常の行列計算での値を指します（スパース性は5節で扱います）。

| 演算 | 理論ピーク（密） | 備考 |
|---|---|---|
| FP64 | 33.5 TFLOPS | CUDAコア |
| FP32 | 66.9 TFLOPS | CUDAコア |
| TF32 Tensor Core | 494.7 TFLOPS | スパース性ありの公称値は 989.4 |
| FP16 / BF16 Tensor Core | 989.4 TFLOPS | スパース性ありの公称値は 1,978.9 |
| FP8 Tensor Core | 1,978.9 TFLOPS | スパース性ありの公称値は 3,957.8 |

FP16のTensor Core（密）はFP32のCUDAコアの約15倍です（$989.4 / 66.9 \approx 14.8$）。この差が「行列積に特化した演算器」の効果です。逆に言えば、**Tensor Coreに乗らない計算（分岐の多い処理、行列積の形にならない処理）は、この15倍の恩恵を受けません。**

なお、H100 SXM5のFP16 Tensor Coreの理論ピークも、V100と同じように分解できます。SM数132、SMあたりTensor Core 4個、SMあたり1クロックで4,096 FLOP（FP16、密）、Tensor Core演算時のブーストクロック1,830 MHzから、次のようになります。

$$
132 \times 4096 \times 1.83 \times 10^9 \approx 989.4 \times 10^{12}\ \mathrm{FLOP/s}
$$

## 3. 数値形式：小さな数で計算すると何が得で、何を失うか

### なぜ「小さな数」が効くのか

1つの数を32ビットで表すか、8ビットで表すかで、次の3つが変わります。

1. **演算器の数**：同じ面積のチップに、小さな演算器ほど多く詰め込める。表の通り、H100ではFP8の理論ピークがFP16の2倍。
2. **メモリの量**：同じモデルが半分・4分の1の容量に収まる。
3. **メモリ帯域**：1回に運べる数が増える。後で見るように、推論ではこれが最も効く場面が多い。

代償は**精度と範囲**です。ビット数を減らすと、表せる桁数（仮数部）か、表せる大きさの範囲（指数部）のどちらかが減ります。

### 浮動小数点数の構造

IEEE 754型の浮動小数点数は、符号・指数部・仮数部の3つで数を表します。正規化された数（正規化数）は、次の式で表されます。

$$
x = (-1)^{s} \times 2^{e - \mathrm{bias}} \times (1.m)_2
$$

ゼロに近いごく小さな数（サブノーマル）は、$(0.m)_2 \times 2^{1-\mathrm{bias}}$ の形で表します。なお、FP32とFP16はIEEE 754の標準形式ですが、BF16・TF32・FP8・FP4は同じ考え方に基づく別の形式で、IEEE 754の標準形式ではありません。

- 指数部のビット数が**範囲**（どれだけ大きい数・小さい数を表せるか）を決める
- 仮数部のビット数が**精度**（隣り合う数の間隔）を決める

AIでよく使う形式を並べると次のようになります。最大値・最小値・機械イプシロン（1の次に表せる数との差、$2^{-m}$）は、ビット配置から筆者がPythonで計算し、FP8・FP4は原典の表と照合しました。

| 形式 | ビット | 指数 | 仮数 | 最大値 | 機械イプシロン | 主な用途 |
|---|---|---|---|---|---|---|
| FP32 | 32 | 8 | 23 | 約 3.4×10³⁸ | 約 1.2×10⁻⁷ | 基準・マスターウェイト |
| TF32 | (19) | 8 | 10 | 約 3.4×10³⁸ | 約 9.8×10⁻⁴ | Tensor Coreの内部モード |
| BF16 | 16 | 8 | 7 | 約 3.4×10³⁸ | 約 7.8×10⁻³ | 学習 |
| FP16 | 16 | 5 | 10 | 65,504 | 約 9.8×10⁻⁴ | 学習・推論 |
| FP8 E4M3 | 8 | 4 | 3 | 448 | 0.125 | 重み・活性化 |
| FP8 E5M2 | 8 | 5 | 2 | 57,344 | 0.25 | 勾配 |
| FP4 E2M1 | 4 | 2 | 1 | 6 | 0.5 | 推論（スケールと併用） |

いくつか補足します。

- **BF16とFP16は同じ16ビットでも性格が逆です。** BF16はFP32と同じ8ビットの指数部を持つので範囲が広く、FP16は仮数部が3ビット多いので精度が高い。学習でBF16が好まれるのは、勾配が極端に小さくなってもゼロに潰れにくいからです。
- **TF32は保存用の形式ではありません。** A100で導入された、Tensor Coreの演算モードです。NVIDIAの説明では、FP32の入力をTF32（指数8ビット・仮数10ビット）に丸めて掛け算し、積はFP32で累積し、FP32で書き出します。メモリ上のデータはFP32のままです。なお、NVIDIAの2021年のブログは「TF32が既定」と書いていますが、PyTorchの行列積でTF32を使うフラグ（`torch.backends.cuda.matmul.allow_tf32`）は、PyTorch 1.12以降は既定でオフです（畳み込みの `torch.backends.cudnn.allow_tf32` は既定でオン。新しいPyTorchでは `fp32_precision` 系の設定への移行が案内されています）。
- **FP8には2種類あります。** Micikevicius らの論文（arXiv:2209.05433）は、範囲は狭いが精度の高いE4M3を重みと活性化に、範囲が広いE5M2を勾配に使うことを推奨しています。E4M3は無限大を持たず、その分のビットパターンを通常の数に回して最大値を448まで広げています。
- **FP4（E2M1）が表せる正の値は 0, 0.5, 1, 1.5, 2, 3, 4, 6 の8つだけです。** これだけで重みを表すのは無理があるので、**ブロックごとのスケール**と組み合わせます。

### 「演算精度」「累積精度」「保存精度」を分けて考える

低精度演算の議論が混乱しやすいのは、1つの行列積の中に精度が3種類あるからです。

1. **入力の精度**：掛け算に使う値の形式（例：FP8）
2. **累積の精度**：掛け算の結果を足し合わせていく変数の形式（例：FP32）
3. **保存の精度**：結果をメモリに書き戻す形式（例：BF16）

内積は数千個の積を足し合わせるので、累積を低精度で行うと誤差が積み上がります。そのためTensor Coreは、入力が低精度でも**累積はより高い精度で行う**構成が基本です。V100のTensor Coreも、FP16の入力に対してFP32で累積する動作を持っていました。「FP8で計算する」と言うときは、多くの場合「入力がFP8」という意味です。

### ブロックスケーリング：MXFP4とNVFP4

4ビットのように値の数が極端に少ない形式では、少数の値の並びごとに「倍率（スケール）」を持たせ、その倍率を掛けて元の大きさに戻します。

- **MXFP4**（Open Compute ProjectのMicroscaling仕様 v1.0）：32個の値ごとに、8ビットのスケール（E8M0、つまり2のべき乗だけを表す形式）を1つ持つ。
- **NVFP4**（NVIDIAがBlackwellで導入）：16個の値ごとにFP8（E4M3）のスケールを1つ、さらにテンソル全体にFP32のスケールを1つ持つ。

NVFP4はブロックが小さく、スケールに2のべき乗以外の値も使えるので、量子化の誤差を細かく抑えられます。NVIDIAのブログは、1値あたり約4.5ビットになり、FP16の約3.5分の1、FP8の約1.8分の1のメモリで済むとしています。同じブログは、DeepSeek-R1-0528でFP8比の精度劣化が1%以下だったとしていますが、これはNVIDIA自身の評価です。自社のモデルとタスクでの劣化は、別途測る必要があります。

量子化方式（AWQ・GPTQ・FP8・GGUF）の実務上の選び方は、この記事では深入りしません。[Qwen3-8Bの量子化方式の選び方](/blog/qwen3-quantization-awq-gptq-fp8-gguf-comparison-guide)と、[量子化のサービング経済学：AWQ vs FP8、KVキャッシュとVRAM予算](/blog/llm-quantization-serving-economics-awq-fp8-kv-cache-vram-budget)で、GPUの世代ごとの対応状況とあわせて扱っています。

## 4. 混合精度学習：精度を落としても学習が壊れない仕組み

### 3つの工夫

16ビットで学習すると速くなりメモリも減りますが、そのままでは学習が壊れることがあります。Micikevicius らの2018年の論文「Mixed Precision Training」（ICLR 2018）は、次の3つの工夫で、FP16を使ってもFP32と同等の精度で学習できることを示しました。

1. **重みのマスターコピーをFP32で持つ。** 1回の更新量は重みに比べてごく小さく、FP16で足すと丸めで消えてしまう。更新はFP32の重みに対して行い、計算に使うときだけ16ビットに変換する。
2. **損失をスケールする（Loss Scaling）。** 勾配が小さすぎるとFP16で表せずゼロになる。FP16の最小の正の数（サブノーマル）は $2^{-24} \approx 5.96 \times 10^{-8}$ なので、それより小さい勾配は失われる。そこで損失を例えば $2^{16}$ 倍してから逆伝播し、勾配が表せる範囲に入るようにして、更新の直前に同じ倍率で割り戻す。
3. **積の累積はFP32で行う。** 前節で見た累積精度の話で、内積の足し合わせを高い精度で行う。

BF16はFP32と同じ指数部を持つので、2つ目の損失スケーリングは通常いりません。

### PyTorchでの実装

PyTorchでは `torch.autocast` と `torch.amp.GradScaler` でこれを実現します。以下は、CUDAがあればFP16＋損失スケーリング、なければCPUのBF16で動く完全な例です。低精度の行列積の結果をFP32と比べ、誤差が想定の範囲かを `assert` で確かめています。

- 対象：Python 3.9 以降、PyTorch 2.3 以降（`pip install torch`。`torch.amp.GradScaler` は 2.3 で追加された）
- ハードウェア：CPUだけで動きます。CUDA対応のNVIDIA GPUがあれば自動でFP16の経路を使います。

```python
"""混合精度の行列積と学習ステップ（PyTorch 2.3 以降）。

- CUDA があれば FP16 autocast + GradScaler、無ければ CPU の BF16 autocast。
- 低精度の結果を FP32 の参照値と比べ、誤差が許容範囲かを assert で確かめる。
"""
import torch

torch.manual_seed(0)
device = "cuda" if torch.cuda.is_available() else "cpu"
amp_dtype = torch.float16 if device == "cuda" else torch.bfloat16
print(f"torch {torch.__version__} / device={device} / autocast dtype={amp_dtype}")

# --- 1. 行列積だけを低精度で実行し、FP32 と比べる ---
M, N, K = 512, 512, 512
a = torch.randn(M, K, device=device)
b = torch.randn(K, N, device=device)
ref = a @ b  # FP32 の参照値

with torch.autocast(device_type=device, dtype=amp_dtype):
    low = a @ b  # autocast の対象 op（matmul）は低精度で実行される

print("autocast matmul の出力 dtype:", low.dtype)
rel_err = ((low.float() - ref).norm() / ref.norm()).item()
print(f"FP32 に対する相対誤差: {rel_err:.2e}")
# 入力を BF16 に丸める誤差と、出力を BF16 に丸める誤差が乗る（BF16 の機械イプシロンは 2^-7）
assert rel_err < 1e-2, "低精度の誤差が想定より大きい"

# --- 2. 1 ステップの混合精度学習 ---
model = torch.nn.Sequential(
    torch.nn.Linear(256, 1024), torch.nn.GELU(), torch.nn.Linear(1024, 10)
).to(device)
opt = torch.optim.AdamW(model.parameters(), lr=1e-3)
# FP16 は勾配がアンダーフローしやすいので損失をスケールする。BF16 では通常不要。
scaler = torch.amp.GradScaler(device, enabled=(amp_dtype == torch.float16))

x = torch.randn(64, 256, device=device)
y = torch.randint(0, 10, (64,), device=device)
for step in range(3):
    opt.zero_grad(set_to_none=True)
    with torch.autocast(device_type=device, dtype=amp_dtype):
        logits = model(x)                                   # Linear は低精度で実行
        loss = torch.nn.functional.cross_entropy(logits, y)  # 損失は FP32 で計算される
    scaler.scale(loss).backward()
    scaler.step(opt)
    scaler.update()
    print(f"step {step}: loss={loss.item():.4f} (loss dtype={loss.dtype})")

# 重み（マスターウェイト）は FP32 のまま保持されている
print("重みの dtype:", next(model.parameters()).dtype)
assert next(model.parameters()).dtype == torch.float32
```

筆者の環境（Apple M4 Pro、PyTorch 2.8.0、CPU）で実行した出力です。

```text
torch 2.8.0 / device=cpu / autocast dtype=torch.bfloat16
autocast matmul の出力 dtype: torch.bfloat16
FP32 に対する相対誤差: 2.87e-03
step 0: loss=2.3306 (loss dtype=torch.float32)
step 1: loss=1.9683 (loss dtype=torch.float32)
step 2: loss=1.6284 (loss dtype=torch.float32)
重みの dtype: torch.float32
```

3つの点が確認できます。行列積の出力はBF16になり、FP32との相対誤差は約0.3%でした。損失はFP32で計算されています。重みはFP32のまま保持されています。CUDA（FP16＋`GradScaler`）の経路は、この環境では実行していません。

PyTorchの公式ドキュメントの注意点を2つ挙げます。`torch.cuda.amp.GradScaler` と `torch.cuda.amp.autocast` は非推奨になり、`torch.amp.GradScaler("cuda")` と `torch.autocast("cuda")` を使うよう案内されています。また、`autocast` で囲むのは順伝播と損失の計算までで、逆伝播は囲まないことが推奨されています。

## 5. スパース性：スペック表の大きい数字の正体

NVIDIAのスペック表で最も誤解されているのが、**スパース性（疎性）ありの数値**です。

A100で導入された**2:4構造化スパース性**は、重みを4つずつの組に分け、各組のうち2つを必ずゼロにする規則です。ゼロの位置が規則的なので、Tensor Coreはゼロの掛け算を飛ばし、演算のスループットを最大2倍にできます。スペック表で「疎性あり」と注記された数値は、この2倍を織り込んだものです。

H100 SXM5のFP8で言えば、3,957.8 TFLOPSはスパース性ありの値で、密行列では1,978.9 TFLOPSです。NVIDIAの日本語の製品ページも「疎性あり」と注記しています。Blackwellのデータシートは、表の注記に「スパース性ありの値。密行列はその半分」と書く形式になっています。

この2倍が実際の速度になるには、条件があります。

- **重みを2:4の形に刈り込む必要がある。** Mishra らの論文（arXiv:2104.08378）が示す手順は、通常どおり学習→2:4に刈り込み→同じ設定でもう一度学習して精度を回復、です。学習（または学習の一部のフェーズ）をもう一度行う必要があります。
- **2倍になるのは行列積の演算部分だけ。** モデル全体の処理時間には、行列積以外の処理やメモリの読み書きが含まれます。同じ論文も、速度向上は行列の大きさと演算強度に依存するとしています。
- **TF32では規則が1:2になる。** 精度モードによって条件が変わります。

**判断基準：** GPUの性能を比べるときは、まず「密か、スパースか」を揃えてください。一般的な学習や推論の見積もりには、密の値を使うのが安全です。

## 6. メモリ帯域：演算器を飢えさせないために

### 演算器は、データが届かなければ遊ぶ

ここからが、NVIDIAのGPUを理解するうえで最も重要な部分です。

どれほど速い演算器も、計算するデータが届かなければ何もできません。料理に例えるなら、腕の速い料理人を何十人雇っても、食材の搬入口が1つしかなければ、厨房は食材待ちで止まります。GPUの「搬入口」がメモリ帯域です。

データセンター向けのNVIDIAのGPUは、**HBM**（High Bandwidth Memory）というメモリを使います。HBMはメモリのチップを縦に積み重ね、GPUのすぐ隣に置き、非常に幅の広い配線でつなぎます。H100 SXM5のHBM3は5,120ビット幅で、帯域は3,352 GB/s（約3.35 TB/s）です。このHBMが、GPUのメモリ（VRAM）そのものです。

### Roofline：演算と帯域のどちらが律速するか

処理の速さの上限は、**Rooflineモデル**で見積もれます（Williams, Waterman, Patterson, 2009）。

$$
P \le \min\left(P_{\mathrm{peak}},\; B \times I\right)
$$

- $P$：達成できる演算性能 [FLOP/s]
- $P_{\mathrm{peak}}$：演算器の理論ピーク [FLOP/s]
- $B$：メモリ帯域 [byte/s]
- $I$：**演算強度**（Williamsらの論文の用語では operational intensity）＝メモリとのデータ転送1バイト（読み書き）あたりに行う演算の数 [FLOP/byte]

$B \times I$ は「データの供給が追いつく範囲で出せる演算性能」です。演算強度が低い処理は、どれだけ演算器が速くても $B \times I$ で頭打ちになります。

2つの線が交わる点を**Ridge Point**と呼びます。$I_{\mathrm{ridge}} = P_{\mathrm{peak}} / B$ です。演算強度がこれより低い処理は帯域律速、高い処理は演算律速になります。

H100 SXM5のFP16 Tensor Core（密）で計算すると、次のようになります（理論値）。

$$
I_{\mathrm{ridge}} = \frac{989.4 \times 10^{12}\ \mathrm{FLOP/s}}{3.352 \times 10^{12}\ \mathrm{byte/s}} \approx 295\ \mathrm{FLOP/byte}
$$

H100の演算器を使い切るには、メモリから1バイト読むたびに約295回の演算をする必要がある、ということです。

### 推論のプレフィルとデコードで、律速が入れ替わる

大規模言語モデル（LLM）の推論は、性質の違う2つの段階に分かれます。

- **プレフィル（prefill）**：入力されたプロンプト全体を一度に処理する段階。数百〜数千トークンを行列×行列で計算するので、重みを1回読むあいだに多くの演算ができる。演算強度が高く、**演算律速**になりやすい。
- **デコード（decode）**：出力を1トークンずつ生成する段階。1トークン分のベクトルと重み行列の積（行列×ベクトル）なので、重みを全部読んでも演算は少ない。

デコードの演算強度を見積もってみます。バッチサイズ1で、FP16の重み（1要素2バイト）を1要素読むたびに、掛け算と足し算を1回ずつ（2 FLOP）行うので、

$$
I_{\mathrm{decode}} \approx \frac{2\ \mathrm{FLOP}}{2\ \mathrm{byte}} = 1\ \mathrm{FLOP/byte}
$$

Ridge Pointの約295に対して、およそ300分の1です。**バッチ1のデコードでは、H100の演算性能のごく一部しか使えず、速度はメモリ帯域で決まります。** vLLMの論文（Kwon et al., SOSP '23）も、デコードは行列×ベクトルの計算でGPUの演算能力を大きく使い残し、メモリ律速になると述べています。

### 理論値：70Bモデルの生成速度の上限

この関係から、デコードの速度の上限を見積もれます。1トークン生成するたびに重みを全部読む、という近似（密なモデルの場合。複数の専門家ネットワークから一部だけを使うMoEでは、選ばれた専門家の重みだけを読む）では、

$$
\text{トークン/秒の上限} \approx \frac{B}{\text{重みのバイト数}}
$$

700億パラメータ（70B）のモデルをH100 SXM5（3.352 TB/s）1枚で、バッチ1で動かす場合の理論上の上限は次の通りです。

| 重みの形式 | 重みのサイズ | 上限（理論値） |
|---|---|---|
| FP16 | 140 GB | 約24 トークン/秒 |
| FP8 | 70 GB | 約48 トークン/秒 |
| 4ビット | 35 GB | 約96 トークン/秒 |

ただし、この表はいくつもの前提の上に成り立つ**上限**です。

- FP16の140 GBはH100の80 GBに収まらないので、実際には複数枚に分割する必要がある。この表は帯域の関係を示すための単純化。
- KVキャッシュ（後述）の読み出しを無視している。文脈が長いほど、実際の速度はこの上限から下がる。
- H100にはFP4のTensor Coreがない。4ビットの行は、重みを4ビットで保存し、読み出した後に高い精度へ戻して計算する場合（weight-only量子化）の帯域上の上限。
- バッチサイズを上げると、同じ重みの読み出しで複数のリクエストを処理できるので、合計のスループットは上がる。その代わり1リクエストあたりの待ち時間は伸びうる。

この表が示す本質は、**デコードでは「重みのバイト数を減らす」ことが、演算器を速くすることより直接効く**という点です。量子化が推論を速くする主な理由は、演算器の速さより先に、ここにあります。

## 7. KVキャッシュとFlashAttention：注意機構のメモリ問題

### KVキャッシュの大きさ

Transformerは、過去のトークンの情報（Key と Value）を毎回再計算しないよう、メモリに保存しておきます。これが**KVキャッシュ**です。1トークンあたりの大きさは次の式で計算できます。

$$
S_{\mathrm{KV}} = 2 \times L \times n_{\mathrm{kv}} \times d_{\mathrm{head}} \times b
$$

- 2：KeyとValueの2つ
- $L$：層の数
- $n_{\mathrm{kv}}$：KVヘッドの数
- $d_{\mathrm{head}}$：1ヘッドの次元
- $b$：1要素のバイト数（FP16なら2）

Llama 3の論文（arXiv:2407.21783）のTable 3によると、70Bモデルは80層、モデル次元8,192、注意ヘッド64、KVヘッド8です。1ヘッドの次元は $8192 / 64 = 128$ なので、FP16では

$$
S_{\mathrm{KV}} = 2 \times 80 \times 8 \times 128 \times 2 = 327{,}680\ \mathrm{byte} \approx 0.31\ \mathrm{MiB/トークン}
$$

8,192トークンの文脈なら、1リクエストあたり約2.5 GiBです（理論値）。もしKVヘッドを64個すべて持つ従来の方式（MHA）だったら、その8倍の約20 GiBになります。KVヘッドを減らす**GQA**（Grouped-Query Attention、Ainslie et al., 2023）は、このメモリを削るための設計です。

同時に処理するリクエストの数だけKVキャッシュが必要になるので、推論サーバーが何人を同時にさばけるかは、多くの場合**VRAMのうち重みを除いた残り**で決まります。vLLMの論文は、従来のシステムではKVキャッシュ用のメモリのうち実際のトークンの保存に使われていたのは20.4〜38.2%だったと報告し、ページング方式（PagedAttention）でこの無駄を減らしました。具体的なVRAM予算の組み方は、[量子化のサービング経済学](/blog/llm-quantization-serving-economics-awq-fp8-kv-cache-vram-budget)と[vLLMでLlamaを本番セルフホストする](/blog/vllm-llama-self-hosting-production-inference-server)で、計算例とあわせて扱っています。

### FlashAttention：HBMへの往復を減らす

注意機構は、系列長 $n$ に対して $n \times n$ の大きさの中間行列（注意スコア）を作ります。素朴に実装すると、この巨大な行列をHBMに書き出し、また読み戻すことになり、帯域を浪費します。

**FlashAttention**（Dao et al., NeurIPS 2022）は、$n \times n$ の中間行列をHBMに書き出さない手法です。計算を小さなタイルに分けてGPUのチップ上の高速なメモリ（SRAM）で処理し、softmaxを少しずつ正規化し直し、逆伝播では中間結果を保存せずに再計算します。演算量はむしろ増えますが、HBMとの往復が減るので速くなります。重要なのは、これが**近似ではなく厳密な計算**だという点です。論文が報告する速度向上（GPT-2の学習でHugging Faceの実装比3倍など）はA100で測られたもので、H100向けに最適化したFlashAttention-3は別の論文として発表されています。

この例は、**GPUの性能を引き出す鍵は演算の速さではなく、データの移動をいかに減らすかにある**ことをよく表しています。

## 8. NVLinkとNCCL：GPUを束ねる通信

### なぜ通信が問題になるのか

大きなモデルの学習は、1枚のGPUには収まりません。たとえば、混合精度でAdamを使って学習する場合、ZeROの論文（Rajbhandari et al., 2020）の計算では、パラメータ1つあたり16バイトのメモリが必要です（FP16の重み2バイト＋FP16の勾配2バイト＋FP32の重み・モーメント・分散で12バイト）。

$$
M_{\mathrm{model\ states}} = 16\Psi\ \ [\mathrm{byte}] \quad (\Psi = \text{パラメータ数})
$$

7B（70億パラメータ）のモデルでも $16 \times 7 \times 10^9 = 112$ GBとなり、80 GBのH100 1枚には、活性化のメモリを数える前の段階で収まりません。ZeRO-3のように8枚に分割すれば1枚あたり14 GBになります（いずれも理論値）。そこで、複数のGPUにデータやモデルを分けて計算し、結果を通信で合わせます。

- **データ並列**：各GPUが同じモデルを持ち、別々のデータで計算し、勾配を平均する。
- **テンソル並列**：1つの行列積を複数のGPUで分担する。Megatron-LMの方式では、Transformerの1層ごとに順伝播で2回、逆伝播で2回の集約通信が発生する。
- **パイプライン並列**：層を区切って複数のGPUに割り当てる。
- **ZeRO**：データ並列の各GPUが持つ重み・勾配・最適化器の状態を分割し、重複をなくす。

どの方式でも、GPU間の通信が計算の待ち時間になります。

### All-Reduceの通信時間を見積もる

データ並列で勾配を平均する操作を**All-Reduce**と呼びます。NVIDIAの通信ライブラリNCCLのテストツール（nccl-tests）の資料は、送受信（point-to-point）の組み合わせだけで行うAll-Reduce（リングでもツリーでも）の最短時間を、次のように示しています。

$$
t \approx \frac{2(n-1)}{n} \times \frac{S}{B}
$$

- $n$：GPUの数
- $S$：集約するデータの大きさ [byte]
- $B$：1つのGPUが送受信できる帯域 [byte/s]（ボトルネックになっている経路の、片方向の帯域）

各GPUは少なくとも $2(n-1)/n \times S$ のデータを送受信する必要があり、GPU側で足し算をする方式ではこれが下限であることを、Patarasuk と Yuan（2009）が示しています。ただし、H100の世代のNVSwitchは、スイッチの中で足し算を行う機能（NVIDIA SHARP）を持っています。この機能を使う場合は前提が変わるので、下の表のNVLinkの行は下限ではなく目安として読んでください。

ここで、帯域の**数字の定義**に注意が必要です。NVIDIAがH100のNVLinkとして公表している「900 GB/s」は、25 GB/sのリンク18本の、**双方向の合計**です（ホワイトペーパーは、1リンクが「各方向に25 GB/s」と書いています）。片方向では450 GB/sです。同様に、PCIe Gen5 x16の「128 GB/s」も双方向の合計で、片方向は64 GB/sです。

これを使って、7Bモデルの勾配（BF16で14 GB）を8枚のGPUで1回All-Reduceする最短時間を見積もります（理論値。通信の遅延や、計算との重ね合わせは考慮していません）。

| 経路 | 片方向の帯域 | All-Reduce 1回の最短時間の目安（理論値） |
|---|---|---|
| NVLink 4（H100） | 450 GB/s | 約54 ms |
| PCIe Gen5 x16 | 64 GB/s | 約383 ms |

学習では、これがステップごとに発生します。1ステップの計算が数百ミリ秒なら、PCIe経由では通信が計算と同じかそれ以上の時間を占めうることになります。NVLinkと、それを複数のGPUに張り巡らすNVSwitchの価値は、ここにあります。DGX H100は8枚のH100を4つのNVSwitchで接続し、各GPUが他のGPUと900 GB/s（双方向合計）で通信できます。

なお、GB200 NVL72の「130 TB/s」は、72枚のGPUそれぞれの1.8 TB/sを合計した値です。システム全体を二分したときの帯域（二分割帯域）とは別の指標なので、比較に使うときは注意してください。

## 9. 世代ごとの進化：演算は帯域より速く伸びた

ここまでの4層を、世代ごとの公称値で並べます。すべてNVIDIAが公表した理論ピークで、性能は**密行列**の値にそろえています。

| 世代（SKU） | 年 | FP16 Tensor（密） | 最低精度の密演算 | HBM帯域 | NVLink（双方向合計） |
|---|---|---|---|---|---|
| V100 SXM2（Volta） | 2017 | 125 TFLOPS | FP16：125 TFLOPS | 900 GB/s | 300 GB/s |
| A100 SXM 80GB（Ampere） | 2020 | 312 TFLOPS | FP16：312 TFLOPS※ | 2,039 GB/s | 600 GB/s |
| H100 SXM5（Hopper） | 2022 | 989.4 TFLOPS | FP8：1,978.9 TFLOPS | 3,352 GB/s | 900 GB/s |
| HGX B200（Blackwell） | 2024 | 2,250 TFLOPS | FP4：9,000 TFLOPS | 7,700 GB/s | 1,800 GB/s |

※ A100は浮動小数点ではFP16/BF16が最低精度（INT8の整数演算は除く）。B200の値はBlackwellデータシートのHGX B200（1基あたり、TDP最大1,000 W）の値で、スパース性ありの公称値（FP4は18 PFLOPS）を、データシートの注記に従って半分にしたもの。GB200に搭載されるB200は、別の値（HBM 8 TB/s、TDP最大1,200 W）が公表されています。年は各アーキテクチャの発表年です。

この表から、筆者は次の2つを読み取ります。

**1つ目：最低精度の演算性能は約72倍になったが、帯域は約8.6倍にとどまる。** V100からB200までで、最低精度の密演算性能は $9000 / 125 = 72$ 倍、HBM帯域は $7700 / 900 \approx 8.6$ 倍です。72倍の内訳は、同じFP16での伸びが18倍、FP16からFP4へ**数値形式を小さくしたことによる上乗せ**が4倍（$9000 / 2250 = 4$）です。

**2つ目：Ridge Pointが右へ動き続けている。** FP16で計算したRidge Pointは、V100の約139 FLOP/byteから、H100の約295 FLOP/byteへ上がりました。最低精度で見れば、H100のFP8で約590、B200のFP4では約1,169です（いずれも理論値）。つまり、**新しい世代ほど、演算器を使い切るために必要な演算強度が高くなっています。**

その結果、デコードのような帯域律速の処理は、演算性能の伸びほどには速くなりません。例として、70Bモデル（FP16、バッチ1）のデコードの上限を比べます。B200では約55トークン/秒で、H100の約24トークン/秒の約2.3倍です（理論値）。この近似では、上限の比は帯域の比（$7.7 / 3.352 \approx 2.3$）そのもので、演算性能の伸びとは関係しません。

これは、NVIDIAの設計がAIの学習と、大きなバッチでの推論に最適化されていることを意味します。同時に、小さなバッチでの推論では、最新のGPUの演算性能を使い残しやすいことも意味します。

次の世代のRubinについては、NVIDIAは2026年1月のCESで「フル生産中」と発表し、パートナーからの提供は2026年後半としています。2026年11月16日に公表されたMLPerf Training v6.1には、Rubin世代のGPUを使った結果が初めて含まれました。ただし、この記事の執筆時点（2026年11月17日）で、1基あたりの公称値の整理と一般の顧客への提供状況を確認できていないため、表には含めていません。

## 10. 実測ベンチマークの読み方：MLPerf

理論ピークは上限にすぎません。実際の速さを比べる指標として最も広く使われているのが、業界団体MLCommonsの**MLPerf**です。MLPerf Trainingは、決められたモデルを決められた品質まで学習させるのにかかった**実時間**を測ります。2026年11月16日には、最新ラウンドのMLPerf Training v6.1の結果が公表され、24の組織から250件の結果が提出されました。

MLPerfの結果を読むときは、次の点を確認してください。

- **部門**：Closed部門は参照と同じモデルを使う、公平な比較のための部門。Open部門はモデルの変更を認める。
- **提供状況**：Available（購入またはクラウドで利用できる）、Preview（次のラウンドまでにAvailableとして提出できるもの）、RDI（研究・開発・社内用）の区分がある。
- **チップ数とシステム構成**：数千枚のGPUを使った結果と、8枚の結果は比較できない。
- **出典**：メーカーのブログに書かれた「すべてのベンチマークで最速」といった主張は、MLCommonsの公式の結果そのものではない。MLCommonsのガイドラインは、結果を引用する際に結果ID・バージョン・部門などの出典表記を求め、結果を比較する際には区分（Availableなど）やチップ数の違いを明示するよう求めている。消費電力あたりの性能をTDPから計算したものなどの派生指標は、MLPerfの公式指標ではない。

## 11. ソフトウェア：4層を使い切る仕組み

ここまでの4層は、ソフトウェアがなければ使えません。Tensor Coreに行列積を割り振り、FP8のスケールを管理し、GPU間の通信を計算と重ねる処理を、アプリケーションの開発者が一から書くことはまずありません。

- **cuBLAS**：行列積などの線形代数のライブラリ。行列の形やGPUの世代に合わせて、Tensor Coreを使う実装を選ぶ。
- **cuDNN**：畳み込みや注意機構など、ニューラルネットワークの演算のライブラリ。
- **NCCL**：8節のAll-Reduceなど、GPU間の集団通信のライブラリ。NVLinkやネットワークの経路を意識した通信を行う。
- **PyTorchなどのフレームワーク**：上記のライブラリを内部で呼び出す。4節の `torch.autocast` のように、利用者は数行の指定で低精度演算を使える。

NVIDIAの強みを「演算器の性能」だけで語れないのは、このためです。仕様の一部の数値では、他社のアクセラレータがNVIDIAのGPUを上回る例もあります。たとえばAMDのInstinct MI300Xは、AMDの公称値でHBM3が192 GB、メモリ帯域が5.3 TB/sで、H100 SXM5の80 GB・3.35 TB/sより大きい値です。それでも、フレームワークやライブラリが実際にその性能を引き出せるかどうかで、利用者が得る速さは変わります。他社もそれぞれソフトウェアの整備を進めており、この差は固定されたものではありません。

## 12. 限界と反例：GPUが強くない場面

ここまでの話を裏返すと、GPUが期待通りに働かない条件が見えてきます。

- **並列にできる計算が少ない。** 小さなモデル、少ないデータ、逐次的な処理では、GPUの演算器のほとんどが遊びます。CPUとGPUの間のデータ転送や、カーネル（GPU上で動く個々の計算プログラム）の起動のコストのほうが大きくなることもあります。
- **行列積以外が支配的。** 前処理、データの読み込み、トークナイズ、分岐の多い後処理は、Tensor Coreの恩恵を受けません。GPUを増やしたのに速くならないとき、ボトルネックはGPUの外にあることがよくあります。
- **帯域律速。** バッチ1のデコードのように演算強度が低い処理では、演算性能の高いGPUに替えても、帯域の比の分しか速くなりません。
- **低精度の誤差が許容できない。** FP8やFP4は、モデルとタスクによっては精度の劣化が問題になります。評価のコストも発生します。
- **通信がボトルネック。** GPUを増やすほど通信の割合が増え、台数に比例して速くはなりません。
- **調達と運用のコスト。** 公称のTDP（熱設計電力。冷却設計の前提となる消費電力の上限）はH100 SXM5で最大700 W、GB200のB200で最大1,200 Wです。電力・冷却・調達の待ち時間・ソフトウェアの保守も、総コストに入ります。

## 13. 判断基準：GPUの選定で何を見るか

最後に、GPUやGPUクラウドを選ぶときに、どの指標を見るべきかを整理します。

| ワークロード | 律速しやすいもの | 見るべき指標 |
|---|---|---|
| 大規模な学習 | 演算・GPU間通信 | 密の演算性能（使う精度で）、NVLinkの帯域と接続できる台数 |
| 推論のプレフィル（長い入力） | 演算 | 密の演算性能 |
| 推論のデコード（長い出力・小さなバッチ） | メモリ帯域・容量 | HBM帯域、VRAM容量（重み＋KVキャッシュ） |
| 小さなモデルの推論 | GPUの外（前処理・転送） | まずGPUが本当に必要かを測る |

この表の考え方は、H100やB200に限らず、クラウドで借りやすいT4・L4・L40Sのような推論向けのGPUにもそのまま当てはまります。たとえばT4（Turing世代）にはFP8やBF16のTensor Coreがないので、使える数値形式や量子化方式もGPUの世代で決まります。

発注者や意思決定者の方には、次の順で確認することをおすすめします。

1. **処理の形を測る。** 学習か推論か。推論なら、入力と出力のトークン数の分布はどうか。同時に何リクエストを処理する必要があるか。
2. **律速を特定する。** その形の処理が、演算・帯域・容量・通信・GPUの外のどれで止まるのかを、Rooflineの考え方で見積もり、可能なら小規模に実測する。
3. **その律速に効く指標で比較する。** スパース性の有無、精度、SKUを揃えたうえで比べる。
4. **総コストで判断する。** 1時間あたりのGPU料金ではなく、1トークンあたりや1回の学習あたりのコストで比べる。APIとの比較は、[Llama推論コストの設計：API vs セルフホストの損益分岐](/blog/llama-inference-cost-optimization-self-host-vs-api)と[生成AIのコストと損益分岐](/blog/generative-ai-cost-api-vs-self-hosting-decision-guide)で、計算式とあわせて扱っています。

筆者が実務で扱ってきたのは、スポットのTesla T4 1枚の上で、vLLMとAWQ量子化のQwen3-8Bを動かす規模の推論基盤です（[AI動画ローカライズのGPUパイプライン](/blog/production-ai-video-localization-lipsync-gpu-pipeline)）。H100やB200の大規模クラスタを運用した経験はありません。それでも、この記事で扱った「帯域」と「容量」の制約は、T4 1枚の規模でもそのまま設計を左右しました。たとえば、同時に複数のジョブを流すとVRAMが足りなくなるため、GPUを使う処理は1件ずつ直列に実行する設計にしています。GPUの規模が変わっても、律速を見極めてから投資するという原則は変わりません。

## まとめ

NVIDIAのGPUがAIに強い理由は、単に演算器が多いからではありません。

- AIの計算の大半は**行列積**で、Tensor Coreはそれを専用の回路で処理する。H100のFP16 Tensor Coreは、FP32のCUDAコアの約15倍の理論ピークを持つ。
- **小さな数値形式**は、演算器の数・メモリの量・帯域のすべてに効く。ただし入力・累積・保存の精度を分けて考える必要があり、FP8やFP4はスケーリングと評価を前提にする。
- スペック表の大きい数字の多くは**スパース性あり**の値で、密行列ではその半分になる。
- 実際の速度は、多くの場面で**メモリ帯域**が決める。H100のRidge Pointは約295 FLOP/byte、バッチ1のデコードの演算強度は約1 FLOP/byteで、その差は約300倍ある。
- 世代が進むにつれ、演算性能は帯域よりはるかに速く伸びた。帯域律速の処理ほど、新しいGPUの恩恵は小さくなる。
- 大規模な学習では、GPU間の**通信**が計算と同じくらい重要で、NVLinkとNCCLがそれを支えている。

そして、これらの層を実際に使い切れるかどうかは、cuBLAS・cuDNN・NCCL・PyTorchといったソフトウェアにかかっています。ハードウェアの理論ピークとソフトウェアの成熟度の両方がそろっていることが、現時点でのNVIDIAの強さの実体です。

このシリーズでは、ここで扱った仕組みを別の角度からも掘り下げています。CPUとの設計の違いは[CPUとGPUは何が違うのか](/blog/cpu-vs-gpu-architecture-pipeline-simt-roofline-explained)、GPUのプログラミングは[CUDAの仕組みとGPUプログラミング入門](/blog/cuda-programming-model-ptx-memory-hierarchy-guide)、TPUとの比較と1トークンあたりの原価は[CPU・GPU・TPUの違いと選び方](/blog/cpu-gpu-tpu-comparison-ai-workload-tco-selection-guide)、競争環境と今後のシナリオは[NVIDIAの強みはCUDA独占だけではない](/blog/nvidia-competitive-advantage-cuda-ecosystem-future-scenarios)で扱います。企業としての歩みは[NVIDIAの歴史](/blog/nvidia-history-from-gpu-to-ai-infrastructure)、輸出規制は[米中AI半導体戦争と輸出規制](/blog/us-china-ai-chip-export-controls-bis-ear-explained)をご覧ください。
