HN 日本語サマリー

← 一覧へ戻る
AI・機械学習

nanochatをTPUに移植する:PyTorchから引き継がれるものと壊れるもの

Porting nanochat to a TPU: what carries over from PyTorch, and what breaks (github.com)

44 pointsby tucan93899 コメント

要約

本記事は、Karpathy氏によるLLMプロジェクトnanochatをTPUに移植する過程を記録したものです。PyTorch版との設定やアーキテクチャの類似性を保ちつつ、モデル品質と学習パフォーマンスの再現を目指しました。結果として、モデル品質(COREスコア)は期待通り再現できましたが、TPU v6e-8での学習パフォーマンス(MFU約24%)はH100の数値(約47-48%)には及びませんでした。TPUのハードウェア仕様やJAX AIスタックの構成についても解説しています。

全文翻訳

nanochatをTPUに移植する:PyTorchから引き継がれるもの、壊れるもの #1

Karpathy氏のnanochatは通常、8×H100 GPUノードで実行されており、JAXへの移植版もいくつか存在します。その中でも、私の目標は、nanochatのできるだけ近い設定とアーキテクチャ(パリティ)を維持しつつ、モデルの品質とトレーニングパフォーマンスの両方を向上させることでした。品質(COREスコア)はクリーンに再現できましたが、パフォーマンスは部分的にしか達成できませんでした。nanochatが初めての方のために説明すると、これはKarpathy氏のフルスタックLLMプロジェクトです。トークナイザーのトレーニング、事前学習、SFT、RLを単一のリポジトリで行い、約4時間と8×H100ノード1台で約100ドルで独自のチャットボット(nanochatはしばしば「100ドルスピードラン」と呼ばれます;これらの数値はd20用です)。参考までに、GPT-2グレードのベースモデル(d24)で停止する場合、同じノードで約2時間と約48ドルかかります。この記事はその移植の記録であり、PyTorchからそのまま引き継がれたものと、TPUで壊れたものを記録します。

1. 再現結果

nanochat-jaxは現在、ベースモデルのトレーニングとSFTをカバーするspeedrun.shスクリプトを提供しています(アップストリームのnanochatはRLまで行いますが、この再現ではSFTで停止します)。上記の品質再現の主張は、COREスコアに基づいています。COREは22の評価タスクにおける精度の平均であり、各タスクはランダム推測が0、完璧なスコアが1となるように再スケーリングされています。同じ評価ハーネス内でモデル同士を比較できるため、nanochatはこのメトリックを使用して「GPT-2グレード」と見なすものを判断します。私たちが再現したのは、公式nanochatのLEADERBOARDのレシピ4(以下R4、深さ24 ≈ 14億パラメータのためd24とも呼ばれます)です。バンド(0.2512–0.2677)は、Karpathy氏が同じR4レシピを7回実行した際のスコア分布です。今回の実行結果0.2695はこのバンドのわずかに上に位置します。

パフォーマンスに関しては、まだギャップがあります。MFUは約24%(d24)であり、Karpathy氏が測定したH100の数値(d20で47–48%)の半分です。

以下では、speedrun.shの各スクリプトをTPU v6e-8で実行し、Karpathy氏が報告した品質が実際に出力されるかを確認します。

モデルチップCORE (ベース)トレーニング時間トレーニングコスト総コスト
GPT-2 (2019, 1.5B)TPU v3 x32 (推定)0.2565168 h~$43,000 (推定)-
nanochat R4 (d24)H100 x80.2571~2 h~$48 (推定)-
nanochat-jax (当社)TPU v6e-8 (スポット)0.26955.29 h (6.02 w)$30 ($130 od)$60.8 (~$263 od)

COREスコアとバンドはnanochat LEADERBOARDからのものです。w = チェックポインティングとコンパイルを含むウォールクロック時間; od = オンデマンドリスト価格。1

この投稿に間違いや不明な点があれば、または質問があれば、tucan.dev@gmail.comまたはコメントでお知らせください。フィードバックはいつでも歓迎します 🙂


2. TPUの基礎

今回の実行では、8つのv6eチップ(単一ホストスライス)を使用しました。世代ごとのチップあたりの仕様は以下の通りです。

v5pv6e (Trillium)7x (Ironwood)
HBM容量95 GB32 GB192 GB
HBM帯域幅2,765 GB/s1,638 GB/s7,380 GB/s
bf16計算459 TFLOPs918 TFLOPs2,307 TFLOPs
低精度計算Int8 918 TOPsInt8 1,836 TOPsFP8 4,614 TFLOPs
MXU (行列乗算ユニット)128×128256×256256×256
ホストあたりのチップ数484
1ホストトポロジー2×2×12×42×2×1
最大ポッド8,960 チップ256 チップ9,216 チップ

出典: Cloud TPU System Architecture, v6e, tpu7x (Ironwood)。bf16、Int8、HBMの数値は各世代の公式仕様シートからのものです。低精度計算はbf16の約2倍です。v5pとv6eはInt8までしかハードウェアアクセラレーションせず、ネイティブFP8サポートはIronwoodから始まります。

v6eのMXUは256×256に拡大しました。v5pまでのすべての世代の128×128から進化しています。テンソル次元が256の倍数でない場合、XLAはゼロでパディングするため、ユニットの一部が無駄になります(セクション4のインサイト5で詳述)。一方、チップあたりのHBMは32GBで、v5pの95GBの3分の1ですが、計算能力は2倍です。これは計算ヘビー、メモリライトな設計です。

当社のv6e-8スライスは合計7.34 bf16 PFLOPSで、スポット(us-central1)で約4〜5ドル/時間かかります。スポットはオンデマンドと比較して大幅に割引されますが、GCPがいつでも回収(プリエンプション)できるという交換条件があります。今回の実行は、12.19時間の合計でスポットで60.8ドル(オンデマンド料金では約263ドル)かかり、その間に1回のプリエンプションとリカバリがありました。ノードが存在する限り(トレーニング中かどうかにかかわらず)課金されます。削除を忘れると、8チップスライスで5ドル/時なので、1日は約120ドルになります。

[画像: JAX AIスタック:ハードウェア(CPU/GPU/TPU)、XLAコンパイラ、JAX、およびFlaxを含むライブラリ層]

図1. JAX AIスタック — ハードウェア(CPU/GPU/TPU)→ XLAコンパイラ → JAXコア → 上層のライブラリ(Flaxなど)。(出典: jaxstack.ai, © JAXチーム)

このスタックのうち、nanochat-jaxは3つのソフトウェアレイヤー(XLA、JAX、Flax)と、図にはないPallasを使用しています。

役割nanochat-jaxPyTorch相当
ニューラルネットワークモジュールFlax NNXtorch.nn
計算 + コンパイルJAX + XLA (jit・grad・vmap)eager + autograd + torch.compile
カスタムカーネルPallas (Splash Attention)Triton
オプティマイザーJAX (独自実装、torch依存なし)torch.optim
データローディングNumPy ( torch依存なし)torch.utils.data
チェックポイントPyTorch .pt (nanochat互換性のため)PyTorch .pt

3. スピードラン検証 — トークナイザーから成績表まで

パイプラインはトークナイザー(5.3分)→ベース(6.02時間 + 評価44.5分)→SFT(68.7分 + 評価約3.5時間)と実行され、私たちはspeedrun.shが実行するスクリプトをステージごとに実行します(すべてを一度に実行するには、付録Cを参照)。各ステージの深い理解については、Karpathy氏のウォークスルー投稿を参照してください(彼のものはd20、私たちのものはd24)。この記事は、測定値を参照値と比較することに焦点を当てています。ウォークスルー時代のトレーニング中間(会話形式とツール使用を事前学習する中間ステージ)は、アップストリームでは独立したステージとして存在しなくなりました(そのデータはSFT混合に折り込まれました)。そのため、ベースからSFTへ直接進みます。セットアップは付録Aで開始します。

[画像: nanochatスピードランパイプライン:トークナイザーをトレーニング → ベースモデルをトレーニング → SFTをトレーニング → RLをトレーニング(破線)]

図2. nanochatスピードランパイプライン — この再現ではトークナイザー、ベース、SFT(実線ボックス)を実行し、RL(破線)はスキップします。

ステップ1. トークナイザー(5.3分)
python -m nanochat_jax.dataset -n 170     # ClimbMix train 170 + val 1 shards
python -m scripts.tok_train --max-chars 100000000 --doc-cap 10000 --vocab-size 32768
python -m scripts.tok_eval

ClimbMixの1億文字で語彙サイズ32768のトークナイザーをトレーニングし、GPT-2と比較して同じテキストがいくつのトークンを必要とするかを比較します。トレーニングデータ(train行)では、当社のトークナイザーはGPT-2トークナイザーよりも1.5%少ないトークンを使用します。トークンが少ないということは、同じ予算でより多くのテキストを学習できることを意味します(圧縮の利点)。Karpathy氏のトークナイザーも同様のパターンを示しており、再現が順調に進んでいる兆候です(韓国語の場合、トレーニングデータにはハングルが含まれていないため、当社のトークナイザーはGPT-4の約2倍のトークンを使用します。ドメインごとの完全な表は付録Dにあります)。確認すべき数値:train +1.5%。

ステップ2. ベースモデル(6.02時間 + 44.5分)
# --recipe through --use-real-data: Karpathy's R4 config / --attn-impl through --splash-*: v6e-8 TPU-specific
python -m scripts.base_train \
  --recipe=324e69c --depth=24 --seq-len=2048 --vocab-size=32768 \
  --target-param-data-ratio=9.5 --total-batch-size=1048576 \
  --device-batch-size=2 --grad-accum-steps=32 --grad-accum-impl=fused \
  --warmup-steps=0 --warmdown-ratio=0.5 --final-lr-frac=0.0 \
  --weight-decay=0.2 --matrix-lr=0.02 --embedding-lr=0.3 \
  --unembedding-lr=0.004 --scalar-lr=0.5 \
  --bf16 --cast-embeddings-bf16 --use-real-data \
  --attn-impl=splash --splash-block-q=512 --splash-block-kv=512 --splash-block-kv-compute=256 \
  --matmul-precision=default --lm-head-precision=highest --ve-grad-impl=onehot \
  --checkpoint-every=200 --keep-last-checkpoints=2 \
  --model-tag=d24_speedrun_r4 --no-final-eval

これらの引数の前半部分はR4レシピそのまま(7億3000万パラメータ × 9.5 ≈ 69億トークン)3です。変更が必要なのは --splash-* カーネルブロックサイズだけかもしれません4。

[step  100] loss=4.517054 ... mfu=24.5%
[step 1000] loss=2.786205 ... mfu=24.7%

Karpathy氏のR4の2時間ベーストレーニングループ(8×H100)に対し、当社の実行時間は5.29時間(チェックポインティングとコンパイルを含むウォールクロック時間6.02時間)で、MFUは約24%です5。6(上記の2行は抜粋です。この実行の完全なトレーニングログをアップロードしました。ヘッダーにはflops/tokenとピークTFLOPSも表示されています)。

RESULTS_DIR=$HOME/.cache/nanochat-jax/results/d24_speedrun_r4 && mkdir -p $RESULTS_DIR

python -m scripts.base_eval --source base --model-tag d24_speedrun_r4 \
    --eval bpb,core --eval-steps 20 --device-batch-size 1 --max-per-task -1 \
    --out $RESULTS_DIR/base_eval.json --partial-out $RESULTS_DIR/base_eval_core_partial.json --bf16

CORE(セクション1の22タスクメトリック)は0.2695となり、GPT-2の0.2565を上回り、R4バンド(0.2512–0.2677)と同クラスです。検証用BPBの0.7343は、トークナイザーの違いが混入するため参照値のみです(R4: 0.7185)。

[画像: 3つのベーストレーニングメトリックチャート]

図3. 中央と右のパネルの破線はR4ベースラインです。トレーニング終了時には、両方のメトリックがベースラインに達し、R4レベルになります(曲線は以前の再現実行からのものです)。

ステップ3. SFT(68.7分 + 評価約3.5時間)
# SFTトレーニング(68.7分)
python -m scripts.chat_sft --model-tag d24_speedrun_r4 --output-model-tag d24_speedrun_r4_sft \
    --num-iterations -1 --device-batch-size 1 --max-seq-len 2048 --total-batch-size 524288 \
    --sft-scope full --eval-every 200 --eval-steps 4 \
    --chatcore-every -1 --chatcore-max-cat -1 --chatcore-max-sample 24 \
    --load-optimizer 1 --log-every 10 --bf16
# スコアリング — 3つの多肢選択タスクを一度に、3つの生成タスクを1つずつ
python -m scripts.chat_eval -i sft -g d24_speedrun_r4_sft --max-new-tokens 512 --batch-size 8 \
    --dtype bfloat16 --out $RESULTS_DIR/chat_eval_sft.json --task-name "ARC-Easy|ARC-Challenge|MMLU"
for task in SpellingBee HumanEval GSM8K; do
  python -m scripts.chat_eval -i sft -g d24_speedrun_r4_sft --task-name "$task" \
      --max-new-tokens 512 --dtype bfloat16 --num-samples 1 --temperature 0 --top-k 50 \
      --jit-gen 1 --out $RESULTS_DIR/chat_eval_$(echo "$task" | tr 'A-Z' 'a-z').json
done

SmolTalk、MMLU、GSM8K、SpellingBee7の混合(約107万行)と1,000のアイデンティティ会話8で68.7分間トレーニングし、質問を繰り返すだけだったベースモデルは、質問に答えるモデルに変わります。ChatCORE(6つのチャットタスクの中心平均)は0.3733です。ここでの比較対象はベースモデル自体です。同じ6つのタスクで、ベースモデルは生成タスクで実質的に0を記録したため、生成スコアのほとんどはSFTが追加した能力によるものです:SpellingBee 0.9961、GSM8K 0.1008(数学はRLの仕事です)。Karpathy氏のウォークスルーのレポートカードとは1対1で比較しません。そちらはd20で、古いトレーニング中間パイプラインで実行されました。

[画像: 3つのSFTメトリックチャート]

図4. 右パネル:SFT(青)はすべてのタスクでベース(灰色)を上回っています。生成タスク(ベースで0を記録した)がゼロ以上にスコアしているのがわかります。

スコアを超えて、実際のプロンプトで確認します。

JAX_PLATFORMS=cpu NANOCHAT_JAX_BASE_DIR=<checkpoint dir> PYTHONPATH=<nanochat-jax dir> \
python scripts/chat_cli.py -i sft -t 0.0 -p "How do I make coffee?"

ベースとSFTに同じプロンプトを与えると、その違いは明らかです。

Prompt: How do I make coffee?
  BASE : How do I make coffee? How do I make coffee? ...          (質問を繰り返す)
  SFT  : Making coffee is a simple process... you'll need a coffee maker, ...

Prompt: Spell the word 'banana' letter by letter.
  BASE : The word 'banana' is made up of two letters. ...          (スペルミス)
  SFT  : banana:b,a,n,a,n,a
成績表
python -m nanochat_jax.report generate
| Metric          | BASE     | SFT      | RL |
|-----------------|----------|----------|----|
| CORE metric     | 0.269486 | -        | -  |
| ARC-Challenge   | -        | 0.509386 | -  |
| ARC-Easy        | -        | 0.622896 | -  |
| GSM8K           | -        | 0.100834 | -  |
| HumanEval       | -        | 0.140244 | -  |
| MMLU            | -        | 0.369534 | -  |
| SpellingBee     | -        | 0.996094 | -  |
| train bpb       | 0.731504 | -        | -  |
| val bpb         | 0.734295 | -        | -  |
| ChatCORE metric | -        | 0.373265 | -  |

エンドツーエンド:ウォールクロック時間12時間14分(請求時間12.19時間)、スポットで60.8ドル(オンデマンドで約263ドル)、1回のプリエンプションと17分間のリカバリ(RLは範囲外のため、列は空のままです。nanochatのフォーマットに合わせるために保持しています)。COREの再現は完了しました。次の2つのセクションでは、そこに至るまでの誤りとそのコストについて説明します。


4. TPU/JAXポートから学んだ5つのこと

このポートから学んだ最も重要なことは、可能であれば避けるべきだということです。私はそれでも実行することにしましたが、そこで遭遇した問題と、私自身のいくつかの洞察を5つに絞って紹介します。各項目には、品質(CORE)またはパフォーマンス(MFU)のどちらに影響したかを示すタグが付いています。最初の項目は、最も長く私たちを惑わせたバグです。

インサイト1. [品質] 一部のバグはエラーなしで誤った結果を返す — NumPyの2行によるデータ破損

品質が崩壊したとき、最初に疑ったのはチップ、次にbf16埋め込みでした。しかし、静かに間違っていたのはモデルではなく、トレーニングループがデータをどのように供給していたかでした。エラー、NaN、形状の不一致はなく、品質低下としてのみ現れる種類のバグです。以下は、base_train.pyでグラッドアキュムレーションのマイクロバッチを収集するコードです。

idx_chunks, target_chunks = [], []
for _ in range(grad_accum_steps):
    inputs_np, targets_np = next(train_loader)
    idx_chunks.append(np.asarray(inputs_np))        # ← ビューをそのまま収集(バグ)
    target_chunks.append(np.asarray(targets_np))
idx_all = jnp.asarray(np.stack(idx_chunks, axis=0))         # 後でスタックされる
targets_all = jnp.asarray(np.stack(target_chunks, axis=0))

train_loaderをdataloader.pyにたどると、速度のために単一のバッファを再利用し、そこからのビュー(ゼロコピーのスライス)を渡すrow_buffer(112行目)が見つかります。しかし、上記のパスはマイクロバッチをリストに収集し、後でnp.stackを呼び出します。np.asarrayは、すでに配列であるものをコピーしないため9、収集された各マイクロバッチは、再利用されたバッファの最後の内容を指すことになります。つまり、1ステップのバッチは実質的に最後のマイクロバッチのN個のコピーになります。これはデータ破損です。トークン数は同じですが、内容が間違っています。

元のPyTorchコードは、1つのマイクロバッチを取得し、すぐにフォワード/バックワードを実行して勾配に蓄積してから、次のバッチを取得します。そのため、バッファが再利用される前にデータが消費され、そのトラップは存在しません。一方、私たちはすべてのマイクロバッチを収集し、単一のコンパイル済みステップ(lax.scan)に渡します。収集されている間にバッファが上書きされました(この新しいパスが必要になった理由は、以下のインサイト2で説明します)。修正は1行です。キャプチャ時にコピーします。

    idx_chunks.append(np.array(inputs_np, copy=True))       # キャプチャ時にコピー
    target_chunks.append(np.array(targets_np, copy=True))

このバグがあった期間のv6e実行は、COREバンド0.08–0.13に留まっていました。修正直後の実行では0.274を記録しました(その0.274は公開されている正規の実行であり、スピードランの0.2695とは別です。どちらもR4レベルです)。また、修正はすでにメインブランチに含まれているため、上記のスピードランセクションで実行するコマンドは安全です。(このデータ供給コードには、実際にもう1つ「兄弟バグ」がありました10)。

データローダーが再利用バッファのビューを渡せる場合、それらを後でスタックするパスでは、コピーされるかどうかを確認するのが安全な最初のステップです。

インサイト2. [パフォーマンス] トレーニングステップを単一のjitにマージする方が良い

compute_grads = jax.jit(compute_grads)          # コンパイルユニット1
accumulate    = jax.jit(accumulate)             # コンパイルユニット2
apply_update  = jax.jit(apply_update)           # コンパイルユニット3

acc = zero_grads
for mb in microbatches:                         # ダメ — Pythonループで連結された3つのプログラム
    acc = accumulate(acc, compute_grads(state, mb))
state = apply_update(state, acc)

@jax.jit                                        # 良い — ステップ全体が1つのプログラム
def train_step(state, microbatches):
    def micro_step(acc, mb):                    # 上記と同じロジック — 境界だけが内部に移動
        return accumulate(acc, compute_grads(state, mb)), None
    acc = lax.scan(micro_step, zero_grads, microbatches)[0]
    return apply_update(state, acc)

PyTorchコードをそのまま移植すると、上記の「ダメ」な構造になります。GPUでは、非同期CUDAとtorch.compileがホスト側のディスパッチコストを隠蔽するため、その構造は問題ありません。TPUでは、2つの構造のA/BテストでMFUが16%から22%に向上しました11。

原因は境界です。XLAは単一のjitプログラム内でのみ最適化するため、ステップを3つのプログラムに分割すると、プログラム間にデバイスがアイドル状態になり(最初の実装では、アイドル時間がステップの26.7%に達しました)、コンパイラはそれらの間で操作をオーバーラップできません。「MaxTextドキュメント」https://maxtext.readthedocs.io/en/latest/reference/core_concepts/jax_xla_and_pallas.htmlは、パフォーマンスの主要なメカニズムとしてステップ全体を単一のjitでラップすることを呼んでいます。一方、公式optaxグラッドアキュムレーション例の最初の(手動)方法は、警告なしにこの構造を示しているため、ページの下の方にあるscanの代替を見逃すとコピーしやすくなっています。

ルール:ステップあたり1つのコンパイル済みプログラム。パフォーマンスが低い場合は、カーネルを見る前にデバイスのアイドル時間を確認してください(XProfタイムラインに表示されます)。アイドル時間が目立つ場合は、まず構造(jit境界)を疑ってください。

インサイト3. [パフォーマンス] Splashアテンションカーネルのデフォルト設定の調整が必要

# jax/experimental/pallas/ops/tpu/splash_attention/splash_attention_kernel.py
# TODO(apaszke,sharadmv): Select better parameters based on a heuristic.
block_q: int = 128          # トラップ — すべての8つのタイルフィールドはデフォルトで128
block_kv: int = 128
block_q_dkv: int = 128      #   ...そのうち5つはバックワード専用
python scripts/base_train.py ... \
  --splash-block-q=512 --splash-block-kv=512 --splash-block-kv-compute=256   # 良い — シーケンス長2048で使用する値

SplashはJAXに同梱されているTPUフラッシュアテンションカーネルです。8つのタイルサイズフィールドがそのパフォーマンスを決定します。ソースを開くとソース、デフォルトはすべて128で、作者のTODOがそのすぐ上にあります。

タイルのみを変更したA/Bテストで、MFUは22.4%から41.2%に向上しました11。損失は小数点以下6桁まで一致しました。これはドキュメント文字列が述べている通りです。タイルは数値にほとんど影響せず、主にパフォーマンスを向上させます。実行時間の大部分はバックワードパスに費やされました。フラッシュアテンションのバックワードがフォワードよりもコストが高い理由については、FlashAttention-2論文で説明されています。Splashタイルのトレードオフについては、この解説を参照してください。MaxTextもJAXのデフォルトではなく独自の512を使用しています。

最適な値はシーケンス長に依存します。シーケンス長4096の実験では最適値は1024でした。公開された実行(シーケンス長2048)では512を使用しています。tpuchat、独立したポートのスイープも、その形状に対して同じ1024に収束しました。そして、2048タイルのほうが実際には遅かったです。大きい方が自動的に良いわけではありません。
損失はタイルに敏感ではない(ドキュメント文字列参照)ため、プロファイリングの前にタイルスイープを行うことは、合理的な最初のステップです。

インサイト4. [品質] デフォルトでは、TPUはfp32の行列乗算をbf16で計算する

トレーニングコマンドには--lm-head-precision highestというフラグがあります。しばらくの間、これが品質を保護していると信じていましたが、実際には何もしていませんでした。その仕組みは、TPU固有の動作に関連しています。

TPUでfp32の行列乗算を要求すると、dtypeはfp32のままでも、デフォルト設定では乗算はbf16で実行されます。これは隠された動作ではなく、文書化されたデフォルトです。そして、Googleの研究者がissueで書いたように、彼のチーム自身が約4回目のバグを踏んだほど、よく知られたトラップです。

a = np.random.default_rng(0).standard_normal((1024, 1024)).astype(np.float32)
ref = a.astype(np.float64) @ a.T.astype(np.float64)
out = jax.jit(jnp.dot)(a, a.T)                 # fp32入力、デフォルト精度
assert np.abs(np.asarray(out, np.float64) - ref).max() / np.abs(ref).max() < 1e-5
# 期待値 — CPUではパスします。TPUでは、上記のデフォルトのため失敗すると予想されます。

実際、ポートの早い段階でこれに遭遇しました。1つの語彙射影が1.67e-6の入力誤差を197倍に増幅し、その操作に対するパーオペレーションのprecision=highestが発散を止めました。それまでは、これは真の修正でした。間違いはその後でした。bf16トレーニングにもフラグを引き継ぎましたが、精度設定はfp32操作にのみ作用します(まさにこの質問に対するメンテナーの回答)。レイヤーは乗算前に重みをbf16にキャストするため、設定が作用するfp32操作は残っていません。

x = jnp.asarray(a[:8], jnp.bfloat16)
w = jnp.asarray(a, jnp.bfloat16)               # 重みは乗算前にbf16にキャストされる
assert jnp.all(jnp.dot(x, w, precision="default")
            == jnp.dot(x, w, precision="highest"))
# トラップ — これはパスします。2つのパスはビット単位で同一です = 設定が無効である証拠

品質ギャップは同じ期間に解消されたため、フラグがその功績を得ましたが、後でコミットをたどったところ、最もクリーンに分離された原因は、それと同時に着陸した別の修正でした。つまり、精度フラグではなく、欠落していたグラッドアキュムレーションループ(インサイト1の脚注の「兄弟バグ」)でした。フラグは、再現をアーカイブされたログと一致させるためにコマンドに残されており、次のリファクタリングで削除される予定です。
fp32精度が必要な作業(参照比較、fp32評価など)では、このデフォルトが問題になる可能性があります。参照:Cloud TPU bfloat16ドキュメント, PyTorch/XLA精度チュートリアル。

インサイト5. [パフォーマンス] 最適なhead_dimはTPU世代に依存 — v6eでは256の倍数が推奨

# nanocode/configs.py — d24: n_embed 2048, n_head 8 → head_dim 256
# "head_dim=256に調整し、256x256のtpuv6eシストリックアレイにより良く適合させるため"

当社のモデルはhead_dim=128を使用しています。nanochatとのパリティが目標だったので、参照値をそのまま維持しました。しかし、その値がどれだけ速く実行されるかは、チップ世代に依存します。TPUの行列乗算ユニット(MXU)は、v6eとIronwoodでは256×256、それ以前の世代では128×128です。行列乗算がピークスループットに達するには、次元がMXUサイズ以上である必要があります。したがって、Googleのモデル設計ガイドでは、Trillium (v6e) ではhead_dimを256の倍数でサイズ設定することを推奨しています。head_dim=128はv5pまでは完全に適合していましたが、v6eではもはやMXUを埋めません。

パラメータ数を同じに保ち(7億2980万)、headの分解のみを変更してMFUを測定しました。各設定を短い12ステップ実行しました(MFUは数ステップで安定します)。絶対値ではなく、2つの行の差を読み取ってください11。

シェイプMFU
12 ヘッド × 128 — nanochatそのまま(当社の設定)30.1%
6 ヘッド × 256 — v6e推奨アライメント35.2%

これは、同じパラメータ数で約17%高速化されます。ただし、その差のすべてがMXUアライメントから来るのかどうかは、個々の操作レベルで分離できていません。正確な記述は「MXUへの適合性が向上した結果」にとどまります。nanocode、nanochatベースのJAX/TPUプロジェクトは、同じ理由で256を選択しました(上記スニペット)。

今のところ、パリティのために128を維持していますが、アーキテクチャは後続の最適化作業のために開かれています。まず1つのチェックが残っています。同じパラメータ数で品質(CORE)が維持されるかどうかをA/Bテストしていません。速度は測定されましたが、品質は測定されていません。
同じ設定でも、チップ世代によってMXUへの適合性が異なる場合があります。

次に、これらすべてが実際にいくらかかったのか、誤りや試行錯誤を含めて合計してみましょう。


5. 約2,500ドルかかった理由

LLM事前学習の経験がほとんどない状態から始め、3ヶ月と約2,500ドル(TPUコンピューティング約2,350ドル + ストレージ)を費やして、上記の60.8ドルのスピードラン再現に到達しました。コーディングエージェントが多くの作業を行ったとしても、これほど高額な請求書には正直驚きました。内訳は以下の通りです。

費やした場所約コスト何が問題だったか
品質再現 — v5p期間~$730品質再現をv6e-8の約3倍のコストがかかるスライスであるv5p-32で実行しました。レシピの欠落要素(グラッドアキュムバグ、行列乗算精度など)の候補ごとに、確認または却下するためにフルートレインを繰り返し実行しました。
v6eへの移行後の品質低下~$275v6e移行のために書き直されたトレーニングループ(セクション4のインサイト2の融合構造)は、インサイト1のNumPyバグを抱えていました。そのため、各ステップのバッチは最後のマイクロバッチのコピーに収束し、COREが急落しました。私はそれを2回誤って特定しました — チップ、次にbf16埋め込み — そして発見に10日かかりました。
5回の運用インシデント~$585チェックポイントの喪失、データ不足による過学習、デッドノードでの課金、ゼロバイトチェックポイントのクラッシュ、マルチホストランチャーのインシデント — 合計5回。防止策はコード(アトミックセーブ)と運用ルール(付録C)に組み込まれました。
パフォーマンス(MFU)最適化~$375公開された実行の約24% MFUの背後にある作業(セクション4のインサイト2と3の結果)。多額の費用は、品質ゲートなしで速度のためだけに起動された2回のフルートレインに費やされました。
公開リハーサルと回帰ハンティング~$165リリース前のエンドツーエンド実行で、フルトレーニング実行でのみ発生する3つの問題(ディスクの枯渇、評価アテンション、SFT OOM)を修正しました。
最終再現の完了~$180最初のv6e再現、ChatEval、およびいくつかの最終クリーンクローン実行 — 最後の60.8ドルのスピードランはCORE 0.2695に達し、nanochatのR4レベルになりました。
ポートの正確性チェックとその他~$401〜16チップに分割された実行が同じ結果を生成することのチェック、および評価に費やされました。PyTorchテンソル比較はラップトップCPUで完了し、TPUコストはかかりませんでした。

要するに、ポート自体(最下段)は40ドルで、残りはそのポートで参照COREを再現するために費やされました。初期の頃、このレシピはv5pでしか実行できないと信じていました。v5pの設定をそのままv6e-8のHBM(チップあたり32GB vs v5pの95GB)に適用するとOOMが発生しました。現在の推測では、マイクロバッチサイズが原因でした。移行中にバッチ、埋め込み、トレーニングループすべてを同時に変更したため、どの変更が決定打となったのかを分離できませんでした。nanocodeが同じスケールのモデルを単一のv6e-8でトレーニングしたという報告を見た後、バッチと設定をv6eに移行しました。すると、1回のベーストレーニング実行はv5p時代には約200ドルかかっていたものが約50ドルに、MFU最適化(セクション4のインサイト2と3)で約30ドルに低下しました。今日の60.8ドルのフル実行は、その約30ドルのベーストレーニングにトークナイザー、SFT、評価を加えたものです。


6. まとめと次のステップ

ここまでお読みいただきありがとうございます。品質はCOREスコアで同じクラスに到達しました。残るはパフォーマンスです。MFUは約24%に向上しました(セクション4のインサイト2と3がそのレバーでした)。jitアイドル時間、Splashタイル、head_dimアライメント、またはアテンションHBMボトルネックのどれがKarpathy氏の47–48%との残りのギャップを支配しているのか — それを答えるには、ルーフライン/XProfの分解が必要です。それが次の作業です。もし以前にこのような問題に対処した経験があれば、コメントを歓迎します(同等のケースからのMFU数値は脚注5に収集されています)。

これは出発点です。深さを変更して独自のモデルを構築したり、異なるトークナイザーとデータセットに切り替えて望む知識を教えたり、最適化を途中で止めたりしてください。新しいGCPアカウントの300ドルのクレジットは、スポットで約61ドルかかるフル実行を3〜4回カバーします。しかし、新規アカウントの場合、まずv6eクォータのリクエストが必要です(付録B)。トレーニングなしでモデルを試したい場合は、この実行からのベースとSFTのチェックポイントがHugging Faceにあります。


7. 補足資料

nanochatとLLMトレーニングの基本

TPU & JAX

近隣プロジェクト

  • nanocode — v6e-8でトレーニングされたコーディングエージェント(Claude Codeクローン)。当社のものと同じ深さ24ですが、head_dim 256 / seq 4096設定のため、報告されているMFU 52.5%は当社の24%とは異なる条件下で測定されています11。
  • tpuchat + 著者の「50ドル」解説 — Colabの単一v6e-1で深さ8 / 1億6400万パラメータ(当社の約1/8)をトレーニングします。MFU 46.5%。
  • nor — JAX/TPUでのmodded-nanogpt — v6e-8で15→23% MFUを報告。modded-nanogpt GPT-2スピードランラインでは、d_model 1024(深さとパラメータ数は不明)。
  • rkstgr — d24 FP8 — 同じd24 / 14億を、FP8(GPU)の16×H100で実行。ベースCORE 0.247、MFU 47.6%。

リポジトリリンク


レビューしてくれたJaewook Kang、Joosung Yoon、Taekmin Kim、Xing Liu、そして匿名の友人、そして予算と時間をくれた妻に感謝します。

付録

付録A) セットアップ — TPU割り当てから環境まで

v6e-8 TPUを割り当てます。--spotはスポットインスタンスを要求します。

gcloud alpha compute tpus tpu-vm create <N> \
  --zone=<Z> --accelerator-type=v6e-8 --version=v6e-ubuntu-2404 --spot

READYと表示されたら、接続できます。通常は数分以内に表示され、失敗した場合は1分以内に通知されます。

READY以降、1時間あたり約5ドルの課金が発生します。すぐに接続してください。(a)はインタラクティブシェル、(b)と(c)はワンショットコマンドとバックグラウンド実行用です。

新規プロジェクトではTPUクォータが0の場合があります。まずコンソールのクォータページで対象地域のv6eクォータを確認し、リクエストしてください。付録Bに示すように、クォータは失敗した割り当ての#1の原因でした。

# (a) インタラクティブシェル — クイックコマンド用
gcloud compute tpus tpu-vm ssh <N> --zone=<Z>

# (b) ワンショットコマンド — マルチラインスクリプトはREMOTE変数に引用されたヒアドキュメント経由で配置
REMOTE=$(cat <<'EOF'
<VMで実行するスクリプト>
EOF
)
gcloud compute tpus tpu-vm ssh <N> --zone=<Z> --ssh-flag="-oConnectTimeout=30" --command="$REMOTE"

# (c) 長時間実行コマンド — セッションからデタッチしてsetsid nohupでバックグラウンド実行
REMOTE=$(cat <<'EOF'
setsid nohup bash -c '<VMで実行するスクリプト>' > ~/logs/command0.log 2>&1 &
echo LAUNCHED
EOF
)
gcloud compute tpus tpu-vm ssh <N> --zone=<Z> --ssh-flag="-oConnectTimeout=30" --command="$REMOTE"

マシンに接続したら、nanochat-jaxリポジトリをクローンし、依存関係をインストールします。

sudo rm -f /tmp/libtpu_lockfile   # 最初のjaxプロセス前に必要
git clone https://github.com/tucan9389/nanochat-jax.git
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv --python 3.12 ~/venv && source ~/venv/bin/activate
uv pip install "torch~=2.11.0" --index-url https://download.pytorch.org/whl/cpu
cd ~/nanochat-jax && uv pip install -e ".[tpu,dev]" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
python -c "import jax; print(jax.devices())"

8つのTPU v6 liteデバイスが表示されれば、セットアップは完了です。

付録B) TPUスポットインスタンス割り当て試行の履歴と統計

2026年4月〜7月の地域別TPUスポット試行統計。これは主要なチップと地域の組み合わせの抜粋であり、行の合計は完全な統計(2,885回の作成試行、1,632回の失敗)よりも少なくなっています。

チップ地域試行→成功失敗原因スライス価格(スポット、5月/7月)実際の使用量
v6e-8us-east4763→0クォータ 0 ×738$3.39/$2.90・h—
v6e-8us-central1575→208 (36%)容量 ×321, クォータ ×34$4.12/$4.99・h150.1h $659, 92回のプリエンプション
v6e-8asia-southeast1222→0容量 ×176, ゾーン未対応 ×46$2.14・h (最安)—
v6e-8us-west1110→0容量 ×105$4.12・h—
v6e-8asia-northeast188→85 (97%)容量 ×1$8.74・h (2.1倍)20.0h $175, 3回のプリエンプション
v6e-8us-east529→0容量 ×19, クォータ ×10$10.21・h—
v6e-8europe-west4 およびその他28→0混合$11.10・h—
v6e-32全6地域107→0すべてクォータ0($8.55+・h)5月3日と5月5日に試行、その後断念
v5p-32us-east558→10 (17%)クォータ ×40, 容量 ×8$25.54・h27.0h $691, 1回のプリエンプション
v5p-32us-central123→23 (100%)—$13.24・h16.3h $216, 2回のプリエンプション
v5p-32europe-west44→2ゾーン未対応 ×2$20.50・h7.4h $153
v5p-32us-east1/us-east415→0クォータ / ゾーン未対応——
v5p-8us-east527→27 (100%)—$6.38・h19.2h $123, 3回のプリエンプション
v5p-8europe-west44→3$5.12・h33.8h $173 (31.4h、最長実行時間)
v5p-16us-east513→4クォータ ×5, 容量 ×3$12.77・h4.7h $60
v6e-1europe-west417→17 (100%)—$1.39・h6.5h $9, 6回のプリエンプション
v6e-1us-east522→6容量 ×11, クォータ ×5$1.28・h0.7h $1
v6e-16asia-northeast1/ew48→6クォータ ×2$17.5–22.2・h1.8h $36

付録C) GCPコマンドチートシート

プレースホルダー:<N> = TPU名、<Z> = ゾーン(例: us-central1-b)、<BUCKET> = GCSバケット、<REGION> = バケット地域(TPUゾーンと同じ地域)。Mac上の非対話型シェルでは、最初にexport PATH=/Users/<you>/google-cloud-sdk/bin:$PATHを実行してください。

ローカルマシン(Mac)で

# TPUを割り当てる — 容量のあるゾーンに着地するまでゾーンをスイープします(成功率と価格:付録B)
for z in us-central1-b us-central1-a us-central1-c us-east4-a asia-southeast1-b; do
  gcloud alpha compute tpus tpu-vm create <N> \
    --zone=$z --accelerator-type=v6e-8 --version=v6e-ubuntu-2404 --spot --quiet && break
done

# マシンのステータスを確認
gcloud compute tpus tpu-vm describe <N> --zone=<Z> --format='value(state)'   # READY / PREEMPTED
gcloud compute tpus tpu-vm list --zone=<Z>

# TPUマシンでコマンドを実行
gcloud compute tpus tpu-vm ssh <N> --zone=<Z>                    # インタラクティブシェル
gcloud compute tpus tpu-vm ssh <N> --zone=<Z> --command="<CMD>"  # ワンショットコマンド(マルチラインスクリプトは付録Aのヒアドキュメントパターン参照)
gcloud compute tpus tpu-vm scp <N>:~/logs/31_base_train.log ./logs/ --zone=<Z>   # ログを取得

# TPUマシンを解放する(削除後、試したすべてのゾーンでゾンビインスタンスをスイープします。作成は非同期です)
gcloud compute tpus tpu-vm delete <N> --zone=<Z> --quiet
for z in us-central1-b us-central1-a us-central1-c us-east4-a asia-southeast1-b; do
  gcloud compute tpus tpu-vm list --zone=$z 2>&1 | grep -v "Listed 0"
done

# その他?
gcloud storage buckets create gs://<BUCKET> --location=<REGION>                        # TPUゾーンと同じ地域
gcloud storage rsync -r gs://<BUCKET>/base_checkpoints /path/to/ssd/base_checkpoints   # 結果の永続ミラー
gcloud auth login; gcloud config set project <PROJECT-ID>                              # 初回のみ

TPUインスタンス(VM)で

# speedrun.sh内のコアコマンド
sudo rm -f /tmp/libtpu_lockfile            # 最初のjaxプロセス前に必要
bash runs/speedrun.sh                       # プロダクションパイプラインを一度に実行
bash runs/runcpu.sh                         # d2/CPU配線チェック(終了まで実行されるかのみチェック)
# speedrun.shが順次実行するステージ(メインテキストのステップ1〜3と同じ):
python -m nanochat_jax.dataset -n 8                                                    # B-1 トークナイザー用
python -m nanochat_jax.dataset -n 170 &                                                # B-2 トレーニング用(バックグラウンド)
python -m scripts.tok_train --max-chars 100000000 --doc-cap 10000 --vocab-size 32768   # B-3
python -m scripts.tok_eval                                                             # B-4
python -m scripts.base_train  <メインテキストのステップ2引数>                    # B-5
python -m scripts.base_eval --source base --model-tag d24_speedrun_r4 --eval bpb,core ...   # B-6
python -m scripts.chat_sft    <メインテキストのステップ3引数>                    # B-7
python -m scripts.chat_eval -i sft -g d24_speedrun_r4_sft ...                          # B-8
python -m nanochat_jax.report generate                                                 # B-9

# ベーストレーニングの監視 — GCSチェックとプリエンプションリカバリは、チェックポイントを<BUCKET>にミラーリングしている場合にのみ機能します(定期的なgcloud storage rsyncを推奨)
tail -5 ~/logs/31_base_train.log | grep -E 'step|bpb'   # 最後のステップ行
ps -ef | grep '[b]ase_train'                            # プロセス生存確認([b]はgrep自身をマッチさせないため)
df -h / | tail -1                                        # ディスク
gcloud storage ls -l gs://<BUCKET>/base_checkpoints/d24_speedrun_r4/ | tail -8   # GCS内の最新チェックポイント

# SFTトレーニングの監視
tail -5 ~/logs/60_sft_chain.log | grep -E 'step|val_bpb'
ps -ef | grep '[c]hat_sft'

# その他? — プリエンプションリカバリ(GCSから復元し、続行)
# トレーニング: python -m scripts.base_train ... --resume-from-step <N>
# 評価: python -m scripts.chat_eval  ... --start-index <完了した問題数>

付録D) 完全なtok_eval圧縮テーブル

差分% = (ベースライントークン数 − 当社トークン数) ÷ ベースライントークン数。正の値は、同じバイト数をより少ないトークンに収めたことを意味します(圧縮の利点)。比率 = バイト/トークン。

GPT-2との比較

| テキスト    |   バイト数 | GPT-2 トークン | 比率 | 当社 トークン | 比率 |  差 %
|---------|---------|-----------|-------|----------|-------|---------|
| news    |    1803 |       392 |  4.60 |      406 |  4.44 |   -3.6% |
| korean  |     893 |       745 |  1.20 |      729 |  1.22 |   +2.1% |
| code    |    1259 |       576 |  2.19 |      410 |  3.07 |  +28.8% |
| math    |     690 |       348 |  1.98 |      338 |  2.04 |   +2.9% |
| science |    1098 |       253 |  4.34 |      238 |  4.61 |   +5.9% |
| train   | 2948778 |    631304 |  4.67 |   621881 |  4.74 |   +1.5% |
| val     | 3024593 |    653067 |  4.63 |   645862 |  4.68 |   +1.1% |

GPT-4との比較

| テキスト    |   バイト数 | GPT-4 トークン | 比率 | 当社 トークン | 比率 |  差 %
|---------|---------|-----------|-------|----------|-------|---------|
| news    |    1803 |       387 |  4.66 |      406 |  4.44 |   -4.9% |
| korean  |     893 |       364 |  2.45 |      729 |  1.22 | -100.3% |
| code    |    1259 |       309 |  4.07 |      410 |  3.07 |  -32.7% |
| math    |     690 |       295 |  2.34 |      338 |  2.04 |  -14.6% |
| science |    1098 |       245 |  4.48 |      238 |  4.61 |   +2.9% |
| train   | 2948778 |    611619 |  4.82 |   621881 |  4.74 |   -1.7% |
| val     | 3024593 |    631183 |  4.79 |   645862 |  4.68 |   -2.3% |

注釈

  1. GPT-2の~$43,000はKarpathy氏の事後推定値です(TPU v3 ×32 × 168h)。R4行の~2時間と~$48は私の推定値です。8×H100で1時間あたり約24ドルのレートで2時間のベーストレーニングループを想定しています。総額~$73はKarpathy氏の2026年のツイート(GPT-2グレードd24、8×H100、3.04時間)からのものです。その実行はデフォルトのd24(データ比率12)であり、当社のR4(比率9.5)と同じd24ですが、レシピは異なります。当社の正確なCORE値は0.269486です(レポートカード参照)。テキストでは0.2695を使用しています。↩
  2. 「語彙をハードウェアフレンドリーな倍数に丸めると高速になる」という一般的な考えは、Karpathy氏のGPU時代のツイート(50257→50304、64の倍数に丸められ、カーネル占有率により約25%高速化)に由来します。TPUでは、XLAは行列次元をMXUタイル(v5pでは128、v6eでは256)の倍数に自動的にパディングします(Cloud TPUパフォーマンスガイド)。32768はすでにそのような倍数であるため、パディングによる無駄はありません。モデルスケールと語彙サイズの関係については、語彙スケーリング則(Tao et al. 2024:より大きなモデルにはより大きな語彙が必要だが、サブ線形的に)を読むのが良いでしょう。↩
  3. 約69億トークンは、nanochatが使用するトークン:パラメータ比率から来ています。これはChinchillaによって確立された計算最適比率の概念に従っていますが(与えられた計算予算で最小損失を得るパラメータとトークンの組み合わせ)、その値自体はnanochat独自の測定値であり、Chinchillaの20ではありません。初期のスケーリングフィット約8(ミニシリーズ #420)は、後に計算最適約10.5に再測定され、スクリプトのデフォルト値12(#481)となり、R4は9.5を使用しており、それと比較してわずかにアンダートレーニングです。Karpathy氏が値が20を下回る理由として、Muonオプティマイザーの影響などを挙げています(#420)。この比率は、非埋め込み(スケーリング)パラメータ(d24 ≈ 7億3000万)に掛けられます:7億3000万 × 9.5 ≈ 69億トークン。ClimbMixシャードのうち、トレーニングには約150個が使用されます。171は、いくらかの余裕(170トレーニング + 1検証)を含めたダウンロード数です。↩ ↩2
  4. ブロックサイズはパフォーマンス用であり、数値にはほとんど影響しません(Pallas BlockSizesドキュメント文字列)。ハードな制約は主にPallas Splashカーネル(JAX 0.10.0、使用バージョン)にあり、当社のコードにはありません。block_kvはblock_kv_computeの整数倍である必要があり、block_kv_computeは128(= NUM_LANES)の倍数である必要があります(カーネルL967–970)。block_qとblock_kvも128の倍数である必要があります(L667およびL673)。ブロックはseq_len以下である必要があり(L1446–1449)、オンチップVMEMに収まる必要があります(超過するとコンパイル/割り当てエラーが発生します。Splash自体はこれをチェックしません)。当社ラッパーが直接強制する唯一の制約はblock_kv_compute % 128です(attention.py#L82-L85)。MaxTextのデフォルトも512(当社の開始値)であり、より大きなモデルではblock_qのみが増加します(v6e上のgemma2-9bはsa_block_q=2048を使用;block_kvは512のままです)。XProfで調整してください。SplashカーネルはブロックサイズをXProfメタデータとしてトレースにタグ付けします。↩
  5. 彼のホームラボでのd24再現(#710)で、matt-langstonは彼のDGX SparkでMFU 29.6%を報告し、一般的なH100の範囲を50〜65%としています(深さは不明。同じスレッドではGPU使用率とMFUの違いも説明されています)。Karpathy氏自身の測定アンカーは、d20スピードランで約47〜48%、d34で47.40%です。norは、modded-nanogptを同じv6e-8に移植し、15→23%に到達しました。GPT-3トレーニングMFUはPaLM論文の表で21.3%です。したがって、当社の24%はこの分布から大きく外れていません。とはいえ、これらの数値はseq_len、モデルアーキテクチャ、FLOPsのカウント方法が異なるため、直接比較することはできません。MFUは元々、同じモデルでのシステム効率を比較するためのメトリックでした(PaLM §4.1)。↩ ↩2
  6. TPUでのスケーリングとルーフラインについては、Google DeepMindのscaling-bookが教科書レベルのリソースです。↩
  7. このような狭い能力をミッドトレーニング/SFTで追加する一般的な方法は、Karpathy氏の「いちごのrを数える(そして一般的に能力を追加する方法)」(nanochat #164)で説明されています。↩
  8. Karpathy氏、「ガイド:nanochatにアイデンティティを注入する」(nanochat #139) — 1,000の合成アイデンティティ会話をミッドトレーニング/SFT混合に混ぜ込む。↩
  9. np.asarrayがすでにndarrayである入力をコピーしないのは、NumPyの文書化された動作です。スライスは同じバッファを共有するビューであり、ビューを通じた変更は元に反映されます。データパイプライン内のNumPyは、静かなバグのよく知られたソースです。Tanel Pärnamaaは、PyTorchをインポートする10万以上のGitHubリポジトリをダウンロードして監査し、カスタムデータセット、NumPyの乱数ジェネレーター、マルチプロセスローディングを組み合わせたリポジトリのうち、95%以上にその関連バグがあったと報告しました(PyTorchの公式チュートリアル、OpenAI、NVIDIAのコードも含む。投稿)。私たちのバグと全く同じではありませんが、同じファミリーです。↩
  10. ポートの以前のバージョンには「兄弟バグ」もありました — グラッドアキュムレーションループが完全に欠落していたため、モデルは設定されたトークン数の1/Nしかトレーニングされませんでした。LRスケジュールはフルバッチが消費されているかのように減衰しました(静かなアンダートレーニング — 初期損失は正常に見え、最終品質のみが悪化します)。アップストリームnanochatは、total_batch_sizeからgrad_accum_stepsを導出し、両者が均等に割り切れることをアサートするため、ソースでこの種のマッチングを防ぎます。グラッドアキュムは、静かに問題が発生しやすい場所です。HuggingFaceとUnslothも2024年に一時的にグラッドアキュムバグ(異なるメカニズム — 損失正規化)をリリースしました(修正前)(UnslothおよびHuggingFace)。nanoGPTでも混乱しやすい点です(#340)。↩
  11. このセクションのMFU比較は、構造とタイルの違いのみを分離するために、nanocode(head_dim 256、seq_len 4096、値埋め込み削除)に合わせた比較構成で測定されました。そのため、絶対値は公開実行(seq 2048、head 128、約24% MFU)とは異なります。この構成では、MFUはループ16.2% → 融合22.4% → Splashタイルチューニング41.2%と増加し、タイル(インサイト3)がより大きなレバーでした。インサイト2の2つの構造は、当社のリポジトリで--grad-accum-impl loop|fusedを使用して再現できます。nanocodeが同じチップで報告する52.5%のMFUは、この構成にコールパスとレイアウト最適化を追加したものであり、当社の24%とは直接比較できません(nanocode)。インサイト5の2つのMFU値(30.1%と35.2%)は、公開実行と同じseq 2048で測定されました。↩ ↩2 ↩3 ↩4