# CPU・GPU・TPUの違いと選び方 — シストリックアレイ・メモリ帯域・1Mトークン原価で比べる

> TPUとは何か、CPU・GPUと何が違うのかを、シストリックアレイ・メモリ帯域・ソフトウェアの3点で解説。「TPUはGPUの15〜30倍速い」を今の比較に使えない理由と、バッチサイズ・稼働率・遅延の目標で入れ替わるAI推論の1Mトークン原価の計算式、選定の手順を示します。

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

## 要点

- CPUは何でもこなす汎用プロセッサ、GPUは32スレッド単位のSIMTで大量の並列計算を回すプロセッサ、TPUは積和器を格子状につないだシストリックアレイで行列積を流れ作業にするGoogleのASIC。3つとも行列積は計算できるが、柔軟性と効率の配分が違う。
- TPU v1論文の「GPUの15〜30倍速い」は、2015年に配備された推論専用・8ビット整数のチップを、同時代のK80とHaswellに、Google社内の6種類のモデルで比べた結果で、現在のTPUとGPUの比較には使えない。
- Google Cloudの公式ページでは、TPU7x（Ironwood）は1チップあたりBF16 2,307 TFLOPS・HBM 192 GiB・7,380 GB/s。公称値ではNVIDIAのB200と同じ水準だが、公称値は実測ではなく、比べるならMLPerfのように条件をそろえた実測を使う。
- 1Mトークンあたりの原価は「時間単価 ÷（トークン/秒 × 稼働率）」で決まる。仮定の数値で計算すると、バッチサイズ・需要量・遅延の目標（SLO）を変えるだけで、どの機材が安いかが入れ替わる。
- 選定は、APIで足りるかの確認 → 処理の形（学習か推論か、遅延の目標）→ ソフトウェアの制約 → メモリ容量と帯域 → 実測したトークン/秒でのCost/Token → 乗り換えのコスト、の順に決める。

---

「TPUとは何か」「TPUはGPUより速いのか」「推論にはどれを使えば安いのか」。AI基盤を選ぶ場面で、こうした問いがよく出ます。

**短い答えを先に書きます。** TPU（Tensor Processing Unit）は、Googleが機械学習のために設計したASIC（特定用途向けの集積回路）です。CPU・GPU・TPUは、どれも行列積を計算できます。違うのは、**柔軟性と効率をどう配分したか**です。CPUは何でもこなせる代わりに行列積の効率は低く、TPUは行列積に特化した代わりに不得意な処理がはっきりしています。GPUはその中間で、柔軟性を残したまま行列積を速くしています。

そして、**どれが安いかはチップの性能だけでは決まりません。** 推論の原価は「1Mトークンあたりの原価 ＝ 時間単価 ÷（実測したトークン/秒 × 稼働率）」で決まり、バッチサイズ、需要量、遅延の目標（SLO：Service Level Objective。この記事では1トークンの生成間隔などの上限）を変えると、同じ機材どうしでも、どちらが安いかが入れ替わります。

この記事では、まず3つのプロセッサの仕組みを順に説明します。TPUの心臓部であるシストリックアレイについては、小さな例とコードで動きを追います。そのうえで、数値精度・メモリ・インターコネクト・ソフトウェア・ベンチマーク・電力を比べ、最後に**1Mトークンあたりの原価（Cost/Token）を計算するモデル**と、技術選定の手順を示します。

**この記事の数値について。** 性能の数値は、各社が公式ページで公表している**理論ピーク（公称値）**か、それを使った筆者の計算（「理論値」と明記）です。筆者が測った実測値ではありません。Cost/Tokenの計算に使う機材の数値は、説明のために置いた**仮定**で、実在の製品や価格ではありません。なお、筆者の実務はTesla T4 1枚でvLLMとAWQ量子化のQwen3-8Bを動かす推論基盤の規模で、TPUを本番で運用した経験はありません。

選定の結論だけ知りたい方は、15節の手順と表を先にお読みください。

## 1. なぜ「3種類のプロセッサ」を比べる必要があるのか

AIの計算の大半は、大きな行列どうしの掛け算と足し算です。この点は、シリーズの[NVIDIAのGPUはなぜAIに強いのか](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)で、行列積の演算量（$2MNK$）とあわせて詳しく説明しました。

同じ行列積を計算するのに、なぜ3種類のプロセッサがあるのでしょうか。それは、**チップの面積と電力をどこに使うか**の選択が違うからです。

料理に例えます。

- **CPU**は、どんな料理も作れる熟練のシェフが数人いる厨房です。注文が複雑でも、途中で手順が変わってもこなせます。ただ、同じ料理を1万皿作るのは得意ではありません。
- **GPU**は、同じレシピを一斉にこなす大勢の調理スタッフがいる厨房です。全員が同じ手順で動くときは圧倒的に速く、レシピを書き換えることもできます。
- **TPU**は、食材がベルトコンベアで流れてくる専用の加工ラインです。決まった加工は最も効率よくこなせますが、ラインにない料理は作れません。

この違いは、TPU v1の論文（Jouppi et al., ISCA 2017）が端的に書いています。論文は、CPUやGPUが平均的なスループットを上げるために備えている仕組み、たとえばキャッシュ、分岐予測、アウトオブオーダー実行、マルチスレッディング、投機的なプリフェッチを、TPUは**持たない**と書き、それが小さく低電力なチップにできた理由だと説明しています。TPU v1のダイで制御回路が占める面積はわずか2%でした。

## 2. 共通の土台：行列積と「メモリの壁」

3つを比べるための共通の物差しは、**演算強度**（メモリから読む1バイトあたりに行う演算の数）です。処理の速さの上限は、演算性能とメモリ帯域の小さいほうで決まり（Rooflineモデル）、演算性能 ÷ メモリ帯域を**Ridge Point**と呼びます。演算強度がこれより低い処理は帯域で、高い処理は演算で速さが決まります。数式での説明は[シリーズのピラー記事の6節](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)に譲ります。

TPU v1の論文は、このモデルで3つのプロセッサを比べています。論文の図の値では、Ridge Pointは重み1バイトあたり、Haswell（CPU）が13、K80（GPU、1ダイ）が9、TPU v1が1,350です。TPU v1は、演算器が多い割にメモリ（DDR3、34 GB/s）が遅かったため、Ridge Pointが極端に右にあります。実際、論文によれば6つのアプリケーションのうち4つはTPU上でメモリ帯域に律速されていました。

この「演算器は速いのにメモリが追いつかない」という問題は、2015年のTPU v1だけのものではありません。現在のTPUもGPUも、**HBM**（High Bandwidth Memory。メモリのチップを積み重ねてプロセッサのすぐ隣に置き、幅の広い配線でつないだ高帯域のメモリ）という高価なメモリを積んでいますが、それでも多くの推論処理は帯域で速さが決まります。

## 3. CPU：何でもこなす汎用プロセッサ

CPUは、大きなキャッシュ、分岐予測と投機実行、アウトオブオーダー実行にチップの面積を割き、データによって手順が変わる処理（分岐の多いプログラム、前処理やトークナイズ）を速くしています。行列積のような規則的な計算にはこれらはあまり効きませんが、現在のCPUにも、SIMD命令や、IntelのAMX（ライブラリoneDNNのドキュメントでINT8・BF16などを扱う命令セットとして挙げられている）のような行列積の機能があります。パイプライン・分岐予測・アウトオブオーダー実行の仕組みは、[CPUとGPUのアーキテクチャの違い](/blog/cpu-vs-gpu-architecture-pipeline-simt-roofline-explained)の4〜5節で詳しく扱っています。

GoogleのCloud TPUのドキュメントは、CPUが向いている処理として、最大限の柔軟性が必要な試作、学習に時間のかからない単純なモデル、実効バッチサイズの小さい小さなモデル、ホストのI/Oやネットワーク帯域に律速されるモデルなどを挙げています。

## 4. GPU：SIMTで数千のスレッドを同時に動かす

GPUのスレッドは32本で1つの**warp**にまとめられ、warpは**SIMT**（Single-Instruction, Multiple-Thread）という方式で同じ命令を実行します（NVIDIAのCUDA Programming Guide）。プログラマは1スレッド分のコードを書けばよく、warp内で分岐が割れると両方の経路を順に実行する（warp divergence）点に性能上の注意が要ります。この仕組みは[CPUとGPUのアーキテクチャの違い](/blog/cpu-vs-gpu-architecture-pipeline-simt-roofline-explained)の10節で詳しく説明しています。データセンター向けのGPUは、さらに行列積の専用演算器（NVIDIAのTensor Core）とHBMを持ちます（[ピラー記事](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)の2節）。

GPUの強みは、**行列積が速いのに、汎用性も残っている**点です。独自のカーネル（GPU上で動くプログラム）を書けるので、新しい演算や、行列積以外の処理が混ざるモデルも扱えます。Google Cloudのドキュメントも、PyTorchやJAXの独自の演算を多く含むモデルや、中〜大規模で実効バッチサイズの大きいモデルを、GPUが向いている例として挙げています。

## 5. TPU：行列積を「流れ作業」にするシストリックアレイ

### 積和器を格子状につなぐ

TPUは、Googleが機械学習のために設計したASIC（特定用途向けの集積回路。汎用のプロセッサと違い、決まった種類の計算のために回路を作り込んだチップ）です。その心臓部は**MXU**（Matrix Multiply Unit）です。Google Cloudのドキュメントによれば、MXUは積和器（掛け算と足し算を1回ずつ行う回路）を格子状に並べた**シストリックアレイ**で、TPU v6eとTPU7xでは256×256、それより前の世代では128×128の積和器でできています。

「シストリック」は心臓の収縮（systole）に由来する言葉で、データが一定のリズムで格子の中を脈打つように流れることを指します。ドキュメントの説明では、TPUはまずパラメータ（重み）をHBMからMXUに読み込み、次にデータを読み込みます。そして、掛け算を1回実行するごとに、その結果を隣の積和器に渡します。行列積の途中では、メモリへのアクセスが要りません。

Google Cloudのドキュメントは、これをCPUやGPUとの違いとして、「GPUは数千の演算器での計算のたびにレジスタや共有メモリにアクセスする必要がある」と説明しています。この説明は、CPUのSIMD演算器やGPUのCUDAコアには当てはまります。ただし、GPUのTensor Coreも、小さな行列の塊（タイル）の中では積和を内部でつないで計算しており、計算のたびにレジスタへ書き戻しているわけではありません。**本当の違いは、データを再利用する単位の大きさです。** MXUは128×128（v6eとTPU7xでは256×256）という大きな格子全体に重みを固定し、部分和を格子の端から端まで受け渡します。そのぶん、レジスタやSRAMを読み書きする回数とその電力を大きく減らせます。TPU v1の論文も、大きなSRAMの読み出しは演算より多くの電力を使うため、シストリック実行で読み書きを減らして電力を節約した、と書いています。

### 小さな例でデータの流れを追う

TPU v1の論文の説明（入力データは左から流れ込み、重みは上から事前に読み込まれ、積和の演算は斜めの波面となって格子の中を進む）に沿って、**重みを固定する方式**（weight-stationary）のシストリックアレイを、2×2の小さな例で追ってみます。

計算するのは $Y = XW$ です。

$$
X = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{pmatrix},\quad
W = \begin{pmatrix} 1 & 10 \\ 100 & 1000 \end{pmatrix}
$$

$X$ の各行（3本の入力）を、2×2の格子に流します。ルールは3つだけです。

1. セル $(k, n)$ には、重み $W_{kn}$ を最初に置いておく（動かさない）。
2. 毎サイクル、各セルは「左から来た入力 $x$」と「上から来た部分和 $p$」を受け取り、$p + x \times W_{kn}$ を下へ、$x$ を右へ渡す。
3. 入力の第 $k$ 列は、$k$ サイクル遅らせて左端に入れる（タイミングをそろえるため）。

最下段から出てきた値が、完成した出力 $Y$ の要素です。次のPythonコードは、このルールを1サイクルずつそのまま実行します。

- 言語・依存：Python 3.9以上、NumPy 1.24以上
- 実行環境：任意のCPU（筆者はApple M4 Pro、Python 3.9、NumPy 2.0.2で実行）
- 実行方法：`python systolic.py`

```python
# systolic.py — 重み固定（weight-stationary）型シストリックアレイを1サイクルずつ模擬する
# Python 3.9 以上 / NumPy 1.24 以上。実行: python systolic.py
import numpy as np


def systolic_matmul(X, W, trace=False):
    """Y = X @ W を K×N のシストリックアレイで計算し、(Y, サイクル数) を返す。

    X: (B, K) 入力（左から流れてくる）
    W: (K, N) 重み（各セルに1つずつ事前に置いておく）
    セル (k, n) は毎サイクル「左から来た x」と「上から来た部分和」を受け取り、
    部分和 + x * W[k, n] を下へ、x を右へ渡す。
    """
    B, K = X.shape
    K2, N = W.shape
    assert K == K2
    a_reg = [[None] * N for _ in range(K)]  # 各セルが右へ渡す入力値
    p_reg = [[None] * N for _ in range(K)]  # 各セルが下へ渡す部分和
    Y = np.zeros((B, N))
    cycles = B + K + N - 2                  # 最初の入力から最後の出力までの総サイクル数
    for t in range(cycles):
        new_a = [[None] * N for _ in range(K)]
        new_p = [[None] * N for _ in range(K)]
        for k in range(K):
            for n in range(N):
                if n == 0:                  # 左端：行 k には x[b, k] を k サイクル遅らせて入れる
                    b = t - k
                    a_in = X[b, k] if 0 <= b < B else None
                else:                       # それ以外：左隣が前のサイクルに持っていた値
                    a_in = a_reg[k][n - 1]
                if a_in is None:
                    continue
                p_in = 0.0 if k == 0 else p_reg[k - 1][n]
                new_a[k][n] = a_in
                new_p[k][n] = p_in + a_in * W[k, n]
                if trace:
                    b = t - k - n
                    print(f"  t={t} cell({k},{n}): x[{b},{k}]={a_in:g} * w={W[k, n]:g}"
                          f" + {p_in:g} -> {new_p[k][n]:g}")
        for n in range(N):                  # 最下段から出た部分和が完成した出力
            if new_p[K - 1][n] is not None:
                b = t - (K - 1) - n
                Y[b, n] = new_p[K - 1][n]
        a_reg, p_reg = new_a, new_p
    return Y, cycles


if __name__ == "__main__":
    # 1) 小さな例：2x2 の重みに 3 本の入力を流す
    X = np.array([[1, 2], [3, 4], [5, 6]], dtype=float)
    W = np.array([[1, 10], [100, 1000]], dtype=float)
    Y, cycles = systolic_matmul(X, W, trace=True)
    print("Y =", Y.tolist(), " cycles =", cycles)
    print("X @ W =", (X @ W).tolist())

    # 2) 大きめの乱数で NumPy と一致するか確かめる
    rng = np.random.default_rng(0)
    for B, K, N in [(1, 16, 16), (16, 16, 16), (256, 16, 16)]:
        X = rng.standard_normal((B, K))
        W = rng.standard_normal((K, N))
        Y, cycles = systolic_matmul(X, W)
        err = np.abs(Y - np.einsum("bk,kn->bn", X, W)).max()  # NumPy で計算した参照値との差
        util = B * K * N / (K * N * cycles)  # 有効な積和 ÷ (セル数 × サイクル数)
        print(f"B={B:3d} K={K} N={N}: cycles={cycles:3d} max_err={err:.1e} utilization={util:.1%}")
```

実行結果です（筆者の環境での出力をそのまま載せています）。

```text
  t=0 cell(0,0): x[0,0]=1 * w=1 + 0 -> 1
  t=1 cell(0,0): x[1,0]=3 * w=1 + 0 -> 3
  t=1 cell(0,1): x[0,0]=1 * w=10 + 0 -> 10
  t=1 cell(1,0): x[0,1]=2 * w=100 + 1 -> 201
  t=2 cell(0,0): x[2,0]=5 * w=1 + 0 -> 5
  t=2 cell(0,1): x[1,0]=3 * w=10 + 0 -> 30
  t=2 cell(1,0): x[1,1]=4 * w=100 + 3 -> 403
  t=2 cell(1,1): x[0,1]=2 * w=1000 + 10 -> 2010
  t=3 cell(0,1): x[2,0]=5 * w=10 + 0 -> 50
  t=3 cell(1,0): x[2,1]=6 * w=100 + 5 -> 605
  t=3 cell(1,1): x[1,1]=4 * w=1000 + 30 -> 4030
  t=4 cell(1,1): x[2,1]=6 * w=1000 + 50 -> 6050
Y = [[201.0, 2010.0], [403.0, 4030.0], [605.0, 6050.0]]  cycles = 5
X @ W = [[201.0, 2010.0], [403.0, 4030.0], [605.0, 6050.0]]
B=  1 K=16 N=16: cycles= 31 max_err=1.1e-15 utilization=3.2%
B= 16 K=16 N=16: cycles= 46 max_err=1.8e-15 utilization=34.8%
B=256 K=16 N=16: cycles=286 max_err=3.6e-15 utilization=89.5%
```

トレースを読むと、仕組みが見えてきます。

- **t=1** のセル(1,0)は、上のセル(0,0)が t=0 に計算した部分和「1」（$1 \times 1$）を受け取り、自分の入力 $x_{0,1} = 2$ と重み100を掛けて足し、$1 + 200 = 201$ を出力しています。これが $Y_{0,0}$ です。
- **t=2** には4つのセルすべてが同時に働いています。3本の入力が、斜めにずれながら格子を通り抜けていくのがわかります。論文の言う「斜めの波面」です。
- どのセルも、途中結果をメモリに書き戻していません。部分和は下へ、入力は右へ、隣のセルに直接渡されるだけです。

### 小さなバッチではアレイが遊ぶ

出力の後半は、もう1つ大事なことを示しています。$K \times N$ のアレイに $B$ 本の入力を流すと、最初の入力が入ってから最後の出力が出るまでに $B + K + N - 2$ サイクルかかります。そのあいだに行う有効な積和は $BKN$ 回なので、アレイの使用率は

$$
\text{使用率} = \frac{BKN}{KN\,(B + K + N - 2)} = \frac{B}{B + K + N - 2}
$$

です。16×16のアレイで、入力が1本なら3.2%、16本で34.8%、256本で89.5%でした。**格子に「流し込む」までと「流し出す」までの時間は、入力の本数によらず固定でかかる**ので、入力が少ないとアレイの大半が遊びます。

これは説明のための単純なモデルです。実際のTPUは、ある行列積の流し出しと次の行列積の流し込みを重ねて実行します（TPU v1の論文も、$B \times 256$ の入力を $B$ サイクルのパイプラインで処理すると書いています）。一方で、このモデルは**重みを格子に読み込む時間を無視しています。** 実機ではこれが大きく、TPU v1の論文の表3によれば、6つのアプリケーションの平均で、重みの到着を待つ時間（weight stall）がサイクルの43%、重みを格子に送り込む時間（weight shift）が12%を占めていました。どちらの面からも、「十分な量のデータを流さないとアレイを使い切れない」という性質は変わりません。

### 形が合わないと「詰め物」が要る

もう1つの制約は、行列の形です。Google Cloudのドキュメントは、XLAコンパイラが行列積を128×128の塊に分割してMXUで実行すること、MXUを埋められない場合はテンソルをゼロで埋める（パディングする）ことを説明しています。そのため、バッチサイズか特徴量の次元のどちらかを128の倍数に、できれば両方を8の倍数にすることを推奨しています。ただし、この説明は128×128のMXUを前提にしたもので、256×256のMXUを持つv6eとTPU7xで最適な倍数は、このページには書かれていません。

たとえば、幅100の次元を128の塊に入れると、使えるのは $100 / 128 \approx 78\%$ だけです（理論値）。パディングは演算器を無駄にするだけでなく、メモリも余分に使います。

## 6. TPU v1の結果を、現在のTPUに当てはめてはいけない

TPUの話になると、TPU v1の論文の「GPUやCPUの15〜30倍速く、電力あたりの性能は30〜80倍」という数字がよく引用されます。これは論文の要旨に実際に書かれている数字ですが、**今のTPUとGPUの比較に使ってはいけません。** 理由は、この数字が成り立つ条件にあります。

| 条件 | TPU v1論文の比較 | 現在の比較で問われること |
|---|---|---|
| 用途 | **推論のみ**（学習はGPUを購入して実施と論文に明記） | 学習と推論の両方 |
| 数値形式 | **8ビット整数**（16ビットでは4分の1の速度） | BF16・FP8など |
| 時期 | 2015年からデータセンターに配備 | 2026年の製品 |
| 比較相手 | NVIDIA K80（Boostモード無効）とIntel Haswell | Blackwell・Rubin世代など |
| ワークロード | Google社内の6つのモデル（MLP・LSTM・CNN） | Transformer・LLMなど |
| 制約 | 99パーセンタイルの応答時間7ミリ秒（MLP0の場合） | サービスごとに異なる |

特に重要なのは、最後の「応答時間の制約」です。論文の表4によれば、MLP0というモデルを7ミリ秒の制約のもとで動かすとき、CPUとGPUはバッチサイズを16に抑える必要があり、最大スループットのそれぞれ42%と37%しか出せませんでした。一方、TPUはバッチサイズ200で、最大の80%を出せていました。**TPU v1の大差の一部は、レイテンシの制約下でCPUとGPUが性能を出し切れなかったことから来ている**わけです。

それでも、この論文から今も学べることはあります。

- **推論は、スループットより応答時間を優先することが多い。** 遅延の目標が、使えるバッチサイズを決め、それが実効性能を決める。
- **メモリ帯域が性能を決めることが多い。** 論文は、K80と同じGDDR5メモリを使えばTPUはさらに速くなったと分析している。
- **価格は公表されないことが多い。** 論文は、チップの購入価格は交渉で決まり公表できないとして、性能/ワットをTCO（総保有コスト）の代わりの指標に使っている。

その後のTPUは大きく変わりました。TPU v4の論文（ISCA 2023）によれば、2020年に配備されたTPU v4は、BF16とINT8で275 TFLOPSの理論ピーク、32 GiBのHBM2（1,200 GB/s）を持ち、光回線スイッチ（OCS）で最大4,096チップをつなぐ学習用のスーパーコンピュータです。論文は、同程度の規模のシステムでNVIDIA A100より1.2〜1.7倍速く、消費電力は1.3〜1.9分の1だったと報告しています。ただし、これもGoogleの著者による比較で、相手のA100は2020年の製品です。**どの比較も、いつの・どのチップを・どの条件で比べたかを確認する**必要があります。

## 7. 数値精度：何ビットで計算できるか

AIの計算は、32ビットの浮動小数点数（FP32）より小さな数値形式で行うのが一般的です。小さな形式は、演算器の数、メモリの量、帯域のすべてに効きます（形式の構造はピラー記事の3節で説明しています）。3つのプロセッサの対応状況を整理します。

| | CPU | GPU（NVIDIAのデータセンター向け） | TPU（Google Cloud） |
|---|---|---|---|
| 行列積の主な形式 | FP32、AMXなどでINT8・BF16 | FP16・BF16・FP8・FP4など（世代による） | BF16（入力）＋FP32（累積） |
| 8ビット | 命令セットによる | 世代による | INT8（v5e・v6e）、FP8（v5p・TPU7x） |
| 倍精度（FP64） | 標準で対応 | 製品による（下記） | Googleは高精度の演算が必要な処理は不向きとしている |

TPUの8ビットの対応は、Google CloudのTPUアーキテクチャのページの記載によります。ただし、同じGoogle CloudのTPU7xのページにある世代比較の表では、v6eの行にFP8 918 TFLOPSが載っており、ページどうしの記載が食い違っています。

Google Cloudのドキュメントによれば、TPUの行列積はbfloat16の値で掛け算をし、FP32で累積するのが標準です。FP32からbfloat16への変換はXLAコンパイラが自動で挿入し、丸めは最近接偶数丸めで、**Cloud TPUのbfloat16は非正規化数（ゼロに極めて近い小さな値）をサポートせず、ゼロに切り捨てます。** Googleはこの方式で精度を損なわずに収束までの時間を短くできると説明していますが、これはGoogleの主張で、モデルによっては確認が必要です。

GPUも「倍精度に強い」とは一括りにできません。NVIDIAのデータシートでは、HGX B200のFP64性能は1基あたり37 TFLOPSですが、後継のHGX B300では1.2 TFLOPSです。B300は、低精度のAI演算を強化する代わりに倍精度を大きく削っています。**科学技術計算のように倍精度が必要な処理では、GPUでもSKUごとの確認が欠かせません。**

## 8. メモリ：HBMの容量と帯域

### 公称値で並べる

現在のTPUとNVIDIAのGPUの1チップあたりの公称値を、公式の資料の値で並べます（TPUはGoogle Cloudの各ページ、H100はNVIDIAのH100ホワイトペーパー、B200はBlackwellのデータシート）。

| チップ | BF16（TFLOPS） | 8ビット（TFLOPS/TOPS） | HBM容量 | HBM帯域（GB/s） | チップ間接続（双方向、GB/s） |
|---|---|---|---|---|---|
| TPU v5e | 197 | INT8 393 | 16 GiB | 819 | ICI 400 |
| TPU v6e（Trillium） | 918 | INT8 1,836 | 32 GiB | 1,638 | ICI 800 |
| TPU v5p | 459 | FP8 459 | 95 GiB（物理96） | 2,765 | ICI 1,200 |
| TPU7x（Ironwood） | 2,307 | FP8 4,614 | 192 GiB | 7,380 | ICI 1,200 |
| H100 SXM（密） | 989.4 | FP8 1,979 | 80 GB | 3,352 | NVLink 900 |
| HGX B200（密） | 2,250 | FP8 4,500 | 180 GB | 7,700 | NVLink 1,800 |

読むときの注意があります。

- **NVIDIAの値は密行列の値にそろえました。** NVIDIAの製品ページやデータシートの大きな数字はスパース性を使った値で、密行列ではその半分です（理由はピラー記事の5節）。**Google Cloudのページには、密かスパースかの注記がありません。** 表の値はページに書かれたままです。
- **容量の単位がそろっていません。** NVIDIAはGB（10の9乗バイト）で書いています。Googleは主にGiB（2の30乗バイト）で書いていますが、v6eの仕様表だけは「32 GB」と書き、同じページの注記では32 GiBとしています。また、TPUのページは、ランタイムが予約する分を除いた利用可能なHBMは物理容量より小さいと注記しています（v6eは32 GiBのうち31.25 GiB）。
- v5pのFP8は、ページの表ではBF16と同じ459 TFLOPSです。
- チップ間接続はどれも双方向の合計です。H100のNVLinkの900 GB/sは片方向では450 GB/sです。NVIDIAのNVLinkのページは、第4〜6世代のGPUあたり帯域を同じ表に900・1,800・3,000 GB/sと並べ、第6世代の3 TB/sを「双方向」と書いています。

公称値だけを見ると、TPU7xとB200は、BF16・FP8の演算性能もHBM帯域も同じ水準にあります。しかし、**公称値が近いことは、実際の速さが近いことを意味しません。** 実際の速さを比べる方法は11節で扱います。

### Ridge Pointを計算する

表の値から、BF16での理論上のRidge Point（演算性能 ÷ HBM帯域）を計算できます。

| チップ | Ridge Point（BF16、理論値） |
|---|---|
| TPU v5e | 約241 FLOP/byte |
| TPU v6e | 約560 FLOP/byte |
| TPU v5p | 約166 FLOP/byte |
| TPU7x | 約313 FLOP/byte |
| H100 SXM | 約295 FLOP/byte |
| HGX B200 | 約292 FLOP/byte |

どのチップも、演算器を使い切るにはメモリから1バイト読むたびに数百回の演算が必要です。LLMの推論で1トークンずつ生成するデコードは、バッチサイズ1なら1バイトあたり1回程度の演算しかしません。**チップの種類にかかわらず、デコードは帯域で速さが決まりやすい**ということです。v6eのRidge Pointが高いのは、演算性能の割に帯域が小さいことを意味し、帯域律速の処理では演算性能ほどの速さは出ません。

### チップの中のメモリは誰が管理するか

CPUはチップの中のキャッシュをハードウェアが自動で管理します。TPUは違います。TPU v1の論文は、28 MiBのオンチップメモリを「ソフトウェアが管理する」ものと書き、TPU7xのドキュメントも、VMEMというオンチップのSRAMを、MXUへの帯域がHBMよりはるかに高いスクラッチパッドとして説明しています。**どのデータをいつチップの中に置くかを、コンパイラやカーネルの側が決める**設計で、これがTPUでコンパイラ（XLA）が重要になる理由の1つです。

## 9. インターコネクト：ICIとNVLink

大きなモデルを学習するときは、何百、何千というチップが勾配やパラメータを交換し続けます。チップ間の通信の速さは、演算性能と同じくらい重要です。

### TPU：ICIとトーラス

TPUのチップどうしは、**ICI**（Inter-Chip Interconnect）という専用の接続でつながります。Google Cloudのドキュメントによれば、TPU7xの各チップは6本のICIリンクを持ち、1本あたり双方向200 GB/s、合計で双方向1,200 GB/sです。チップは3次元の各方向で隣のチップと直接つながり、64チップ（4×4×4の「キューブ」）以上のスライスはトーラス（端と端がつながった格子）になります。キューブどうしは光ファイバーと再構成できる光回線スイッチ（OCS）でつながり、TPU7xの1つのPodは最大9,216チップです。Podを超える規模は、データセンターのネットワーク（DCN）で複数のスライスをつなぐMultisliceで扱います。

### GPU：NVLinkとスイッチ

NVIDIAのGPUどうしは**NVLink**でつながります。トーラスのように隣どうしをつなぐのではなく、NVLink Switchを介して、同じ「NVLinkドメイン」の中のGPUどうしが互いに通信できる構成です。NVIDIAのデータシートによれば、GB200 NVL72は72基のGPUを1つのNVLinkドメインにまとめ、合計130 TB/sの帯域を持ちます。ドメインの外は、InfiniBandやEthernetのネットワークでつなぎます。

### どちらが有利か

チップあたりの帯域は同じ桁にありますが、**つなぎ方が違うので、通信のパターンによって向き不向きが変わります。**

- TPU v4の論文によれば、学習の逆伝播で使うAll-Reduce（全チップの勾配を足し合わせて全員に配る通信）は、2次元・3次元のトーラスにうまく対応します。
- 全チップが全チップとデータを交換する通信をAll-to-Allと呼びます。推薦モデルの埋め込みで発生し、MoEで専門家にトークンを振り分けるときも同じ形の通信になります。
- 同じ論文は、All-to-Allがトーラスの二分割帯域（ネットワークを半分に切ったときの帯域）に負担をかけると書いています。TPU v4がOCSで「ねじれたトーラス」を選べるようにした理由の1つです。

インターコネクトを比べるときは、チップあたりの帯域の数字だけでなく、**一度に密につなげるチップの数**（NVL72なら72、TPU7xのPodなら9,216）と、**自分のモデルがどの通信パターンを多く使うか**を見てください。推論でも、1つのチップに収まらない大きなモデルを分割して動かすなら、この比較が効いてきます。

## 10. ソフトウェア：CUDA・ROCm/HIP・XLA

ハードウェアの性能は、ソフトウェアが引き出せる分しか使えません。そして、ソフトウェアこそが乗り換えのコストを決めます。

### CUDA（NVIDIA）

NVIDIAのGPUは、CUDAというプログラミングモデルと、その上のライブラリ群（cuBLAS、cuDNN、NCCLなど）で動きます。PyTorchなどの主要なフレームワークは、これらを内部で呼び出します。CUDAの厚い蓄積が、NVIDIAの強みの大きな部分を占めていることは、ピラー記事の11節で説明しました。

### ROCmとHIP（AMD）

AMDのGPUのソフトウェア基盤は**ROCm**です。AMDのドキュメント（2026年11月17日時点でROCm 10.1.0）は、ROCmを「GPUによる計算のためのAMDのオープンなソフトウェアスタック」と説明し、行列演算のhipBLAS・rocBLAS、深層学習のMIOpen、集団通信のRCCLなどを含みます。

CUDAのコードをAMDのGPUで動かすために、**HIP**というC++のAPIとカーネル言語があり、CUDAのAPI呼び出しをHIPに変換するツール（HIPIFY）もあります。ただし、AMDのドキュメント自身が、**HIPはCUDAをそのまま置き換えるものではなく、移植には手作業のコーディングと性能の調整が必要になる**と書いています。PyTorchのドキュメントによれば、ROCm版のPyTorchは `torch.cuda` のインターフェースを意図的にそのまま使っており、PyTorchのレベルで書かれたコードは比較的移しやすくなっています。一方、独自のCUDAカーネルに依存する部分は移植の作業が要ります。

### XLA・JAX・TorchTPU（Google）

TPUで動くコードは、**XLA**（Accelerated Linear Algebra）というコンパイラでコンパイルする必要があります。Google Cloudのドキュメントは、XLAをジャストインタイム（実行時）コンパイラと説明しています。フレームワークが出力した計算のグラフを受け取り、行列積や損失、勾配の部分をTPUの機械語に変換します。XLA自体はオープンソースで、OpenXLAプロジェクトとしてGoogle、NVIDIA、AMD、Intel、Metaなどが開発に参加しており、GPUやCPUでも動きます。

コンパイルを前提にすることには、利点と制約の両方があります。

- **利点**：演算の融合やメモリの配置をコンパイラがまとめて最適化できる。
- **制約**：テンソルの形が実行のたびに変わると、そのたびにコンパイルが必要になる。Google Cloudのドキュメントは、テンソルの形が動的に変わるモデルはTPUにあまり向かないと書いています。JAXのドキュメントも、静的な引数の値が変わると再コンパイルが起きると説明しています。LLMの推論のように入力の長さがばらつく処理では、長さをいくつかの区切りにそろえる（バケット化する）といった工夫が必要です。

TPUで最も自然に使えるフレームワークは**JAX**です。PyTorchについては、**2026年11月に大きな変化がありました。** Google Cloudのドキュメント（2026年11月10日更新）は、PyTorchをTPUで動かす基盤として、Metaと共同開発した**TorchTPU**を案内しています。TorchTPUは標準のPyTorchの書き方で `torch.device("tpu")` を使い、既定では逐次（eager）実行で動き、`torch.compile` を使うとOpenXLA経由でコンパイルされます。従来の**PyTorch/XLAは非推奨**となりました。PyTorch/XLAのドキュメントには、リポジトリを2026年11月15日にアーカイブすると告知されていましたが、2026年11月17日時点では、GitHub上のリポジトリはまだアーカイブされていません。推論では、vLLMやSGLangのTorchTPU版も案内されています。

なお、TPU7xのドキュメントは、TPU7xではJAXとPyTorchが使え、TensorFlowはサポートしないと明記しています。

TorchTPUは生まれたばかりの基盤です。自社のモデルが動くか、性能が出るかは、実際に試すまでわかりません。**「PyTorchで書いてあるからTPUでもそのまま動く」と仮定して計画を立てるのは危険です。**

## 11. 実測で比べる：MLPerfの読み方

公称値は上限にすぎません。チップどうしの実際の速さを比べるときに最も広く使われているのが、業界団体MLCommonsの**MLPerf**です。部門・提供状況の区分・結果IDといった読み方の基本は、[ピラー記事の10節](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)にまとめました。

### MLPerf Training v6.1：TPU7xとRubinが初登場

2026年11月16日に公表されたMLPerf Training v6.1には、MLCommonsの発表によれば、NVIDIAのRubin世代のGPUと、GoogleのTPUv7（Ironwood）を使った結果が初めて含まれています。MLCommonsが公開している結果のリポジトリで、提出者が書いたシステムの記述を確認すると、GoogleのTPU7xのシステム（たとえば `tpu7x-8x16x16`、512ノード×4チップ）はClosed部門で「Available cloud」、NVIDIAのRubin GPUのシステム（`Hecate (8x NVIDIA VR NVL72)`）はClosed部門で「Available on-premise」と記載されています。この記事では、どちらが速いかという比較はしません。

### MLPerf Inferenceと遅延の目標

推論の比較で注目したいのは、MLPerf Inferenceが**遅延の制約つきで**スループットを測る点です。MLPerf Inferenceのルールでは、Serverシナリオはリクエストがランダムに（ポアソン分布で）届く状況で、遅延の制約を守れる最大のスループットを測ります。LLMの場合は、最初のトークンが出るまでの時間（TTFT）と、トークンの生成間隔の平均（TPOT）の2つが制約です。たとえばLlama2-70bでは、会話型の区分がTTFT 2,000ミリ秒・TPOT 200ミリ秒、対話型の区分がTTFT 450ミリ秒・TPOT 40ミリ秒です。

これは、TPU v1の論文が指摘した「推論は応答時間の制約下で性能を出せるかが問題」という論点を、そのまま測る仕組みです。**自社の比較でも、SLOを決めてから、それを守った状態のスループットを測る**ようにしてください。13節のモデルでも、この考え方を使います。

## 12. 電力とTCO

### 公称の電力と、測った電力を混ぜない

チップの電力の数字には、性質の違うものが混在しています。

- **TDP（熱設計電力）**：冷却設計の前提となる上限。NVIDIAの公称値では、H100 SXMが最大700 W、HGX B200が最大1,000 W。
- **実測の電力**：TPU v4の論文は、本番のアプリケーションを動かしたときのチップとHBMの電力を、平均170 W（最小121 W、最大192 W）と報告し、TDPは「N.A.」としています。TPU v1の論文では、TDPが75 W、実行中の実測が40 Wでした。
- **MLPerf Power**：MLCommonsによれば、ベンチマークの実行中にシステム全体がコンセントから消費した平均の交流電力を測るもので、TDPなどそれ以外の電力の数字は、MLCommonsが測定・検証したものではありません。

TPU v4の平均170 Wと、H100のTDP 700 Wを並べて「TPUは4分の1の電力」とは言えません。一方は実測の平均、もう一方は上限で、世代も違います。また、2026年11月17日時点で、Google CloudのTPU7xのページにはチップの電力が書かれていません。

### TCOを1時間あたりに直す

クラウドで借りるなら、TCOの大部分は時間単価に含まれています。自社で購入する場合は、次の式で1時間あたりの費用に直すと、クラウドと同じ物差しで比べられます。

$$
c_{\mathrm{hour}} = \frac{C_{\mathrm{capex}}}{Y \times 8760} + P_{\mathrm{kW}} \times \mathrm{PUE} \times e + c_{\mathrm{ops}}
$$

- $C_{\mathrm{capex}}$：機材の購入費（サーバ、ネットワーク、設置を含む）
- $Y$：償却年数（8760は1年の時間数）
- $P_{\mathrm{kW}}$：実際の平均消費電力（TDPではなく、測った値か見積もり）
- $\mathrm{PUE}$：データセンターの電力使用効率（冷却などを含めた倍率）
- $e$：電力単価（1 kWhあたり）
- $c_{\mathrm{ops}}$：保守・運用の人件費などを1時間あたりに割った額

この $c_{\mathrm{hour}}$ が、次の節のCost/Tokenの式の「時間単価」になります。Google Cloudのv5eとv6eのページには「Performance/TCO (expected)」という指標（v5eが0.65x、v6eが1）が載っていますが、何を基準にした比率かがページに書かれていないため、この記事では比較に使いません。

## 13. 独自分析：Cost/Tokenは条件で入れ替わる

### 計算式

LLMの推論の原価は、1Mトークンあたりの費用で比べます。

$$
\text{1Mトークンあたりの原価} = \frac{c_{\mathrm{hour}} / 3600}{\text{トークン/秒} \times U} \times 10^{6}
$$

$U$ は稼働率（借りている時間のうち、実際に処理に使っている割合）です。APIとセルフホストの損益分岐については、[Llama推論コストの設計](/blog/llama-inference-cost-optimization-self-host-vs-api)と[生成AIのコストと損益分岐](/blog/generative-ai-cost-api-vs-self-hosting-decision-guide)で扱いました。この記事では、**セルフホストする機材どうしを比べると、何によって結論が入れ替わるか**に焦点を当てます。

### 理論モデルと、その前提

ここで1つ大事な注意があります。この式の「トークン/秒」には、本来、**自分のモデルで測った値**を入れるべきです。スペック表のTFLOPSから計算した値は、実効率を仮定で置くしかないため、実際より安く見積もりがちです。

この記事では、条件によって結論がどう変わるかを示すために、トークン/秒を**理論モデル**で近似します。デコードの1ステップ（同時に処理している全リクエストが1トークンずつ進む時間）を、Rooflineの考え方で次のように置きます。

$$
t(b) = \max\left(\frac{W + b\,L\,k}{\eta_{\mathrm{bw}} B_{\mathrm{mem}}},\ \frac{2\,b\,N_{\mathrm{param}}}{\eta_{\mathrm{f}} F}\right)
$$

$b$ はバッチサイズ（同時に処理するリクエスト数）、$W$ は重みのバイト数、$L$ は1リクエストが保持する文脈の長さ、$k$ は1トークンあたりのKVキャッシュのバイト数です。KVキャッシュは、生成済みのトークンの注意機構の計算結果（キーとバリュー）を保存しておくメモリで、生成のたびに読み出されます（詳しくは[ピラー記事の7節](/blog/nvidia-gpu-ai-tensor-core-fp8-hbm-nvlink-explained)）。$B_{\mathrm{mem}}$ はメモリ帯域、$F$ は演算性能、$\eta$ は公称値に対する実効率です。1台のスループットは $b / t(b)$ トークン/秒、1トークンの生成間隔（TPOT）は $t(b)$ です。

前提はすべて**仮定**です。機材A・B・Cは実在の製品ではなく、数値も価格も説明のために置いた値です。

| 項目 | 仮定した値 |
|---|---|
| 機材A（大型・高帯域） | 時間単価 6.0 USD、メモリ 96 GB、帯域 4.0 TB/s、8ビット演算 2,000 TFLOP/s |
| 機材B（小型・推論向け） | 時間単価 1.0 USD、メモリ 24 GB、帯域 0.8 TB/s、8ビット演算 400 TFLOP/s |
| 機材C（CPUサーバ） | 時間単価 1.5 USD、メモリ 256 GB、帯域 0.3 TB/s、演算 20 TFLOP/s |
| モデル | 80億パラメータ、重みは8ビットで8 GB |
| KVキャッシュ | 1トークンあたり128 KiB、平均の文脈長1,024トークン |
| 実効率 | 帯域70%、演算40% |
| その他 | メモリの90%を重みとKVキャッシュに使える。入力を処理するプレフィルは無視し、出力トークンだけを数える |

### 計算機のコード

- 言語・依存：Python 3.9以上、標準ライブラリのみ
- 実行環境：任意のCPU（筆者はApple M4 Pro、Python 3.9で実行）
- 実行方法：`python cost_per_token.py`

```python
# cost_per_token.py — 1M トークンあたりの原価を、バッチサイズ・稼働率・需要量で比べる
# Python 3.9 以上、標準ライブラリのみ。実行: python cost_per_token.py
# 注意: 機材 A/B/C の数値はすべて説明用の「仮定」で、実在する製品の仕様でも価格でもない。
import math
from dataclasses import dataclass


@dataclass(frozen=True)
class Machine:
    name: str
    usd_per_hour: float   # 1台あたりの時間単価（仮定）
    mem_gb: float         # メモリ容量
    bw_tbs: float         # メモリ帯域の公称値 [TB/s]
    tflops: float         # 推論に使う精度での演算性能の公称値（密）[TFLOP/s]


# ---- 仮定（ここを自分の実測値・見積額に置き換える） ----
MACHINES = [
    Machine("A 大型・高帯域", usd_per_hour=6.0, mem_gb=96, bw_tbs=4.0, tflops=2000),
    Machine("B 小型・推論向け", usd_per_hour=1.0, mem_gb=24, bw_tbs=0.8, tflops=400),
    Machine("C CPUサーバ", usd_per_hour=1.5, mem_gb=256, bw_tbs=0.3, tflops=20),
]
PARAMS = 8e9              # モデルのパラメータ数（8Bクラス）
WEIGHT_BYTES = 8e9        # 重み 8ビット → 8 GB
KV_BYTES_PER_TOKEN = 128 * 1024   # 1トークンあたりのKVキャッシュ（GQAの8Bクラスを想定）
CONTEXT = 1024            # 1リクエストが保持する平均の文脈長 [トークン]
ETA_BW, ETA_FLOP = 0.7, 0.4       # 公称値に対する実効率（仮定）
MEM_USABLE = 0.9          # メモリのうち重みとKVに使える割合（仮定）


def step_time(m: Machine, batch: int) -> float:
    """デコード1ステップ（全リクエストが1トークンずつ進む）の時間 [秒]。Roofline の考え方で近似。"""
    bytes_read = WEIGHT_BYTES + batch * CONTEXT * KV_BYTES_PER_TOKEN
    t_mem = bytes_read / (ETA_BW * m.bw_tbs * 1e12)
    t_compute = batch * 2 * PARAMS / (ETA_FLOP * m.tflops * 1e12)
    return max(t_mem, t_compute)


def max_batch_by_memory(m: Machine) -> int:
    free = m.mem_gb * 1e9 * MEM_USABLE - WEIGHT_BYTES
    return max(0, int(free // (CONTEXT * KV_BYTES_PER_TOKEN)))


def best_batch(m: Machine, tpot_slo: float) -> int:
    """メモリに収まり、1トークンの生成間隔（TPOT）が SLO 以内に収まる最大のバッチ。"""
    b = 0
    for cand in range(1, max_batch_by_memory(m) + 1):
        if step_time(m, cand) <= tpot_slo:
            b = cand
    return b


def usd_per_1m_tokens(usd_per_hour: float, tokens_per_sec: float, utilization: float) -> float:
    """cost = (時間単価 / 3600) / (トークン/秒 × 稼働率) × 1e6"""
    return usd_per_hour / 3600 / (tokens_per_sec * utilization) * 1e6


if __name__ == "__main__":
    print("[1] バッチサイズ別（稼働率100%）  TPOT=生成間隔, tok/s=1台の出力スループット")
    for m in MACHINES:
        bmax = max_batch_by_memory(m)
        print(f"  {m.name}: メモリ上の最大バッチ={bmax}")
        for b in [1, 8, 32, 128, bmax]:
            if b > bmax:
                print(f"    b={b:4d}: メモリ不足")
                continue
            t = step_time(m, b)
            tps = b / t
            print(f"    b={b:4d}: TPOT={t*1e3:6.1f} ms  tok/s={tps:7.0f}  "
                  f"USD/1M={usd_per_1m_tokens(m.usd_per_hour, tps, 1.0):6.2f}")

    print("\n[2] 稼働率を変えたとき（バッチはメモリ上の最大）")
    for m in MACHINES:
        b = max_batch_by_memory(m)
        tps = b / step_time(m, b)
        row = "  ".join(f"U={u:.0%}:{usd_per_1m_tokens(m.usd_per_hour, tps, u):6.2f}"
                        for u in [1.0, 0.5, 0.2])
        print(f"  {m.name}: {row}")

    for slo in [0.050, 0.020]:
        print(f"\n[3] TPOT の上限 {slo*1e3:.0f} ms・需要量（tok/s）別の 1M トークン原価（USD）")
        for m in MACHINES:
            b = best_batch(m, slo)
            if b == 0:
                print(f"  {m.name}: SLO を満たせない")
                continue
            cap = b / step_time(m, b)          # 1台が SLO を守って出せる上限
            cells = []
            for demand in [20, 200, 2000, 20000]:
                n = math.ceil(demand / cap)     # 必要な台数（台単位でしか借りられない）
                util = demand / (n * cap)       # 実際の稼働率
                cost = usd_per_1m_tokens(n * m.usd_per_hour, demand, 1.0)
                cells.append(f"{demand:>5}:{cost:7.2f}({n}台,U={util:.1%})")
            print(f"  {m.name} (b={b}, 上限{cap:.0f} tok/s/台): " + "  ".join(cells))
```

実行結果です（筆者の環境での出力をそのまま載せています。[3]の行は長いので横にスクロールしてください）。

```text
[1] バッチサイズ別（稼働率100%）  TPOT=生成間隔, tok/s=1台の出力スループット
  A 大型・高帯域: メモリ上の最大バッチ=584
    b=   1: TPOT=   2.9 ms  tok/s=    344  USD/1M=  4.84
    b=   8: TPOT=   3.2 ms  tok/s=   2469  USD/1M=  0.68
    b=  32: TPOT=   4.4 ms  tok/s=   7288  USD/1M=  0.23
    b= 128: TPOT=   9.0 ms  tok/s=  14234  USD/1M=  0.12
    b= 584: TPOT=  30.9 ms  tok/s=  18930  USD/1M=  0.09
  B 小型・推論向け: メモリ上の最大バッチ=101
    b=   1: TPOT=  14.5 ms  tok/s=     69  USD/1M=  4.03
    b=   8: TPOT=  16.2 ms  tok/s=    494  USD/1M=  0.56
    b=  32: TPOT=  22.0 ms  tok/s=   1458  USD/1M=  0.19
    b= 128: メモリ不足
    b= 101: TPOT=  38.5 ms  tok/s=   2624  USD/1M=  0.11
  C CPUサーバ: メモリ上の最大バッチ=1657
    b=   1: TPOT=  38.7 ms  tok/s=     26  USD/1M= 16.14
    b=   8: TPOT=  43.2 ms  tok/s=    185  USD/1M=  2.25
    b=  32: TPOT=  64.0 ms  tok/s=    500  USD/1M=  0.83
    b= 128: TPOT= 256.0 ms  tok/s=    500  USD/1M=  0.83
    b=1657: TPOT=3314.0 ms  tok/s=    500  USD/1M=  0.83

[2] 稼働率を変えたとき（バッチはメモリ上の最大）
  A 大型・高帯域: U=100%:  0.09  U=50%:  0.18  U=20%:  0.44
  B 小型・推論向け: U=100%:  0.11  U=50%:  0.21  U=20%:  0.53
  C CPUサーバ: U=100%:  0.83  U=50%:  1.67  U=20%:  4.17

[3] TPOT の上限 50 ms・需要量（tok/s）別の 1M トークン原価（USD）
  A 大型・高帯域 (b=584, 上限18930 tok/s/台):    20:  83.33(1台,U=0.1%)    200:   8.33(1台,U=1.1%)   2000:   0.83(1台,U=10.6%)  20000:   0.17(2台,U=52.8%)
  B 小型・推論向け (b=101, 上限2624 tok/s/台):    20:  13.89(1台,U=0.8%)    200:   1.39(1台,U=7.6%)   2000:   0.14(1台,U=76.2%)  20000:   0.11(8台,U=95.3%)
  C CPUサーバ (b=18, 上限363 tok/s/台):    20:  20.83(1台,U=5.5%)    200:   2.08(1台,U=55.1%)   2000:   1.25(6台,U=91.9%)  20000:   1.17(56台,U=98.4%)

[3] TPOT の上限 20 ms・需要量（tok/s）別の 1M トークン原価（USD）
  A 大型・高帯域 (b=357, 上限17877 tok/s/台):    20:  83.33(1台,U=0.1%)    200:   8.33(1台,U=1.1%)   2000:   0.83(1台,U=11.2%)  20000:   0.17(2台,U=55.9%)
  B 小型・推論向け (b=23, 上限1162 tok/s/台):    20:  13.89(1台,U=1.7%)    200:   1.39(1台,U=17.2%)   2000:   0.28(2台,U=86.1%)  20000:   0.25(18台,U=95.6%)
  C CPUサーバ: SLO を満たせない
```

### 結果の読み方：結論が入れ替わる3つの条件

**1つ目の入れ替わり：バッチサイズ。** バッチ1では、機材Bが4.03 USD、機材Aが4.84 USDで、Bのほうが安くなります。どちらも帯域で速さが決まるので、原価は「時間単価 ÷ 帯域」でほぼ決まり、Aは6.0 ÷ 4.0 = 1.5、Bは1.0 ÷ 0.8 = 1.25だからです。ところが、メモリに収まる最大のバッチまで上げると、Aが0.09 USD、Bが0.11 USDで逆転します。Aはメモリが大きく、584リクエストを同時に処理できますが、Bは101で頭打ちになるためです。バッチ1からの原価の下がり方は、Aでは約55倍（4.84 → 0.088）に達します。**同じ2台の機材でも、どれだけまとめて処理できるかで、どちらが安いかが入れ替わります。**

**2つ目の入れ替わり：需要量と台数の粒度（稼働率）。** [2]が示すとおり、原価は稼働率に反比例します。Aの稼働率50%（0.18 USD）は、Bの稼働率100%（0.11 USD）より高くつきます。そして稼働率は、機材を「台単位」でしか借りられないことで決まります。[3]の生成間隔50ミリ秒の条件で、需要が2,000トークン/秒なら、Bは1台で稼働率76.2%（0.14 USD）、Aは1台でも稼働率10.6%（0.83 USD）です。**大きな機材は満杯なら安いのですが、需要が小さいと遊ぶ時間に料金を払うことになります。**

**3つ目の入れ替わり：SLO。** 生成間隔の上限を50ミリ秒にすると、需要20,000トークン/秒ではBが8台で0.11 USD、Aが2台で0.17 USDで、Bが安くなります。ところが上限を20ミリ秒に厳しくすると、Bは生成間隔を守るためにバッチを23まで下げる必要があり、1台あたりの処理量が減って18台必要になり、0.25 USDに上がります。Aはバッチ357でも20ミリ秒を守れるので0.17 USDのままで、**Aのほうが安くなります。** これは、TPU v1の論文が示した「応答時間の制約が使えるバッチを決め、それが実効性能を決める」という構図そのものです。

CPUサーバ（機材C）は、演算性能が低いため、バッチを32まで上げた時点で演算に律速され、処理量が毎秒500トークンで頭打ちになります。生成間隔20ミリ秒のSLOは、バッチ1でも守れません（38.7ミリ秒）。需要が毎秒20トークンの場合でも、この仮定では機材B（13.89 USD）のほうが安くなります。ただし、**既に持っていて他の用途で使い切れていないCPUサーバなら、追加の時間単価はほぼゼロ**なので、この結論は変わりえます。

### このモデルの限界

このモデルは、結論が入れ替わる仕組みを見るための道具で、実際の原価の予測ではありません。

- 機材の数値と価格はすべて仮定で、実在のどの製品にも対応しない。
- 入力を処理するプレフィルを無視している。入力が長い用途ほど、演算性能の重要度が上がる。
- 実効率（帯域70%・演算40%）は固定の仮定で、実際にはバッチサイズや実装で変わる。
- 文脈の長さを平均1,024トークンに固定している。長い文脈ではKVキャッシュの読み出しが増え、バッチを上げても帯域に律速されたままになりやすい。
- 需要の時間変動、冗長化のための予備の台数、オートスケールの遅れを考慮していない。

**実際に選定するときは、このコードのトークン/秒の部分を、自分のモデル・入出力の長さ・SLOで測った値に置き換えてください。** 理論ピークから計算したトークン/秒と、実測のトークン/秒を、同じ表に並べて比べてはいけません。

## 14. ベンダーロックイン：何に縛られるのか

ロックインは「どのチップを使うか」より、**どの層のソフトウェアに依存するか**で決まります。

1. **独自のカーネル**：CUDAで書いたカーネルは、HIPへの移植に手作業が要る（AMDのドキュメント自身がそう書いている）。TPUでは書き直しになる。最も移しにくい層。
2. **フレームワーク**：JAXで書いたコードは、XLAを介してGPUやCPUでも動く。PyTorchで書いたコードは、ROCm版では `torch.cuda` のまま動き、TPUではTorchTPUで動かす道がある。ただし、どれも性能の再調整が要る。
3. **推論エンジンと運用基盤**：vLLMのように複数のハードウェアに対応したエンジンを使えば、上の層を同じに保ったまま下を替えやすい。TPU向けにも、vLLMのTorchTPU版が案内されている。
4. **クラウドと契約**：TPUの公式ドキュメントが案内する利用経路は、Google CloudのCompute Engine、GKE、Gemini Enterprise Agent Platformです。長期の予約や割引の契約も、乗り換えのコストになります。

ロックインを抑える実務上の工夫は、次のとおりです。

- **モデルの重みを標準的な形式で保存する。** Google Cloudのドキュメントは、TPUで学習したチェックポイントを、大がかりな変換なしにCPUやGPUで推論に使えると書いている。
- **独自のカーネルは、本当に必要な箇所に限る。** 使うなら、なぜ必要かと、他のハードウェアでの代替手段を記録しておく。
- **ベンチマークの手順を、ハードウェアに依存しない形で持っておく。** 13節の計算機に入れるトークン/秒を、どのハードウェアでも同じ手順で測れるようにしておけば、乗り換えの判断が速くなる。

## 15. 判断フレームワーク：技術選定の手順

最後に、CPU・GPU・TPUを選ぶ手順をまとめます。順番に意味があります。前の段階で選択肢が絞れるからです。

**ステップ0：APIで足りるかを先に確かめる。**
自前で機材を持つ前に、APIの従量課金で足りないかを確かめる（損益分岐は[生成AIのコストと損益分岐](/blog/generative-ai-cost-api-vs-self-hosting-decision-guide)）。

**ステップ1：処理の形を数値にする。**
学習か推論か。推論なら、入力と出力のトークン数の分布、ピーク時の需要（トークン/秒）、SLO（TTFT・TPOTの上限）を決める。行列積が処理の中心でないなら、CPUで足りるかを先に確かめる。

**ステップ2：ソフトウェアの制約で絞る。**
独自のCUDAカーネルに依存するなら、NVIDIAのGPUがほぼ前提になる。JAXで書かれているなら、TPUは自然な選択肢。PyTorchの標準的なモデルなら、GPUとTPU（TorchTPU）の両方が候補だが、TPUは動作と性能を必ず試す。テンソルの形が頻繁に変わるなら、TPUではバケット化などの対策が要る。

**ステップ3：メモリで絞る。**
重みとKVキャッシュ（学習ならオプティマイザの状態も）が、何チップに収まるか。1チップに収まらないなら、チップ間の接続（NVLinkドメインの大きさ、ICIのトポロジ）が性能を左右する。

**ステップ4：実測したトークン/秒でCost/Tokenを計算する。**
候補の機材で、自社のモデルをSLOを守った状態で動かし、トークン/秒を測る。それを13節の式に入れ、需要量に応じた台数と稼働率で原価を出す。公称値のTFLOPSは、この段階では使わない。自社のモデルでトークン/秒を測る手順の設計や、VRAMと予算の見積もりから始めるのが実務的です。

**ステップ5：乗り換えのコストを加える。**
移植の工数、運用の習熟、契約の期間を見積もる。原価の差がこのコストを上回らないなら、慣れた基盤を選ぶほうが合理的なことも多い。

判断の材料を、表にまとめます。

| 判断の材料 | CPUに傾く | GPUに傾く | TPUに傾く |
|---|---|---|---|
| 処理の中身 | 分岐が多い・行列積が少ない | 行列積＋独自の演算 | 行列積が大半・形が固定 |
| ソフトウェア | 既存の汎用コード | CUDA・PyTorchの資産が多い | JAX・XLAの資産がある |
| 需要とSLO | 少量・SLOが緩い | 幅広く対応 | 大規模・定常 |
| 規模 | 1台で足りる | 数基〜NVLinkドメイン規模 | Pod規模まで拡張したい |

ワークロード別に見ると、次のようになります。

| ワークロード | CPU | GPU | TPU |
|---|---|---|---|
| 前処理・トークナイズ・分岐の多い処理 | 向く | 不向き（warp divergence） | 不向き（Googleのドキュメントも分岐の多い処理は不向きとしている） |
| 小さなモデルの少量の推論 | 向く場合がある（SLOが緩ければ） | 向く | 規模によっては大きすぎる |
| 独自の演算・新しいカーネルの研究 | 試作には向く | 最も向く（独自のカーネルを書ける） | 不向き（学習ループ内の独自の演算は不向きとGoogleが明記） |
| 標準的なTransformerの大規模な学習 | 不向き | 向く | 向く（行列積が中心で、形が固定されている場合） |
| 大量・定常のLLM推論 | 不向き | 向く | 向く（XLAで形の変化に対処できる場合） |
| 巨大な埋め込みを使う推薦モデル | 不向き | 向く | 向く（SparseCoreという専用の回路を持つ） |
| 倍精度の科学技術計算 | 向く | SKUによる（B200は37 TFLOPS、B300は1.2 TFLOPS） | 不向き |

筆者が実務で扱ってきたのは、T4 1枚の上でvLLMとAWQ量子化のQwen3-8Bを動かす規模の推論基盤です（[AI動画ローカライズのGPUパイプライン](/blog/production-ai-video-localization-lipsync-gpu-pipeline)）。この規模でも、ステップ3のメモリの制約が設計を決めました。同時に複数のジョブを流すとVRAMが足りなくなるため、GPUを使う処理は1件ずつ直列に実行する設計にしています。チップの種類や規模が変わっても、「処理の形と制約を数値にしてから、実測で比べる」という順番は変わりません。

## 16. 限界と反例

この記事の比較には、次の限界があります。

- **公称値は理論ピークです。** 表の値はどれも各社が公表した上限で、実際の性能ではありません。TPUの値には密かスパースかの注記がありません。
- **ベンチマークの順位は扱っていません。** MLPerf Training v6.1にTPU7xとRubinが含まれたことは確認しましたが、結果の数値と順位はこの記事では比べていません。
- **価格は扱っていません。** クラウドの価格は地域・契約・時期で変わるため、Cost/Tokenは仮定の数値で示しました。
- **ソフトウェアの状況は速く変わります。** TorchTPUへの移行のように、半年前の常識が通用しないことがあります。この記事の内容は2026年11月17日時点のものです。
- **AMDのGPUや他社のアクセラレータは、ソフトウェアの観点以外では詳しく扱っていません。** GPUの比較では、NVIDIA以外の選択肢も同じ手順で評価できます。

反例も挙げておきます。

- 小さなモデルを少量だけ動かすなら、どのアクセラレータよりも、既にあるCPUが最も安いことがある。
- 大きな機材は満杯なら最も安いが、需要が小さければ最も高くつく（13節の[3]）。
- 公称値が同じ水準のチップでも、ソフトウェアの成熟度が違えば、実効性能は大きく違いうる。

## まとめ

- CPU・GPU・TPUは、どれも行列積を計算できる。違いは、柔軟性と効率をどう配分したか。CPUはキャッシュや分岐予測に、GPUはSIMTの多数のスレッドに、TPUはシストリックアレイにチップの面積を使っている。
- シストリックアレイは、大きな格子全体に重みを固定し、途中結果を隣の積和器に直接渡すことで、メモリの読み書きを減らす。その代わり、十分な量のデータを流し込まないと演算器が遊び、行列の形が合わないとパディングが要る。
- TPU v1の「15〜30倍速い」は、2015年の推論専用・8ビット整数のチップを、同時代のK80とHaswellに比べた結果で、今のTPUとGPUの比較には使えない。
- 現行世代の公称値は、TPU7xとB200で同じ水準にある。しかし公称値は実測ではない。比べるならMLPerfのように条件をそろえた実測を使い、結果IDと区分を確認する。
- ソフトウェアがロックインを決める。2026年11月時点で、TPUでPyTorchを動かす基盤はPyTorch/XLAからTorchTPUに移行している。
- Cost/Tokenは「時間単価 ÷（トークン/秒 × 稼働率）」で決まり、バッチサイズ・需要量・SLOによって、どの機材が安いかが入れ替わる。トークン/秒には、SLOを守った状態で測った値を使う。

チップの性能の数字は、選定の出発点にすぎません。処理の形と制約を数値にし、候補の機材で実測し、乗り換えのコストまで含めて比べることが、CPU・GPU・TPUを選ぶいちばん確実な方法です。

供給側から見た競争環境、つまりNVIDIA・AMD・Google・AWSのソフトウェアと供給網の違いは、[NVIDIAの強みはCUDA独占だけではない](/blog/nvidia-competitive-advantage-cuda-ecosystem-future-scenarios)で扱っています。
