ブログに戻る
一般記事

図解・勾配降下法

1847 年、Cauchy は天体の軌道を計算するために「負の勾配に沿って一歩進む」と書いた。今日、大規模言語モデルを学習させるときも、optimizer.step() がしているのは同じことだ。ただ、この一歩の踏み出し方からは、SGD、Adam、AdamW、Lion、Muon という一大ファミリーが生まれた。12 個の荷物の送料で斜めの谷を描き、リアルタイムに計算する 30 枚以上の動く図とともに、各手法が前の手法のどの穴を埋めたのかを見ていく。

PyTorch の学習コードを開くと、ループの中にはほぼ必ずこの 2 行がある。

python
loss.backward()
optimizer.step()

backward() は各パラメータをどの方向へ動かすべきかを計算し、step() が実際に動かす。この記事で扱うのは、その step() の中にある数行だ。

方向はもう計算してあるのだから、そのとおりに進めばいいのでは? 話すことなどなさそうに聞こえる。ところが「この一歩をどう踏み出すか」だけで、SGD、Momentum、AdaGrad、Adam、AdamW から Lion、Muon まで、一大ファミリーができあがった。新しい手法が現れるのは、たいてい前の手法がある種の地形でうまく進めなかったからだ。

いちばん基本的なところから始めよう。使うのは直線 1 本と、12 個の荷物だ。まず「勾配」を図にし、それから細長い谷、ランダムなノイズ、崖、鞍点を通らせて、各手法が前の手法のどの穴を埋めたのかを見ていく。

出発の前に、ルート全体をざっと眺めておこう。1 行が 1 つの手法で、その後ろに、その手法が埋める穴を書いてある。

各手法が埋める穴BGD から出発し、各行にその手法が補う欠点を書いた。

基本形

  1. BGD出発点:毎ステップ全データを読む。
  2. SGD · MBGD毎ステップ全データを読むのは遅い → 1 件かミニバッチを抽出。
  3. SGDMジグザグとノイズ → 速度を溜める。
  4. NAGモーメンタムが行き過ぎる → 先の位置で勾配を計算。

パラメータごとの歩幅

  1. AdaGrad全パラメータで学習率が 1 つ → 累積した勾配で個別にスケーリング。
  2. RMSProp · AdaDeltaAdaGrad の学習率は下がる一方 → 忘れられる移動平均に替える。
  3. Adam · Nadamモーメンタムと個別の歩幅を合わせ、0 から始まる偏りを補正。

Adam の修正

  1. AMSGradAdam は誤った点に収束しうる → v を小さくさせない。
  2. AdamWL2 正則化が Adam の中で割られてしまう → 重み減衰を切り離す。
  3. Warmup · Cosine · SGDR · RAdam · Schedule-Free学習率をどう変える? Adam はなぜウォームアップ? → スケジュール、分散の修正、またはスケジュールなし。

規模と幾何

  1. LARS · LAMB超大バッチで層ごとの ‖w‖/‖g‖ が大きく違う → 層ごとの信頼比。
  2. Adafactor · GaLoreオプティマイザの状態がメモリを食う → 分解するか、低ランク部分空間に置く。
  3. SAM損失は低いが狭い谷 → ρ 以内の最悪の損失で比べる。
  4. Shampoo · SOAP · Sophia対角スケーリングでは斜めの谷を救えない → 行列前処理、または曲率+クリッピング。
  5. Lion状態と計算を減らす → 符号だけを取る。
  6. Muon重みは行列で、長い数字の列ではない → 更新全体を直交化。

記事中の動く図は、どれもブラウザ上でリアルタイムに計算していて、各ステップで使っているのは本文に書いた式そのものだ。一時停止を押せば、スライダーをドラッグして 1 ステップずつ確かめられる。

一本の直線から始める

ネットで小さな店を開いていて、最近 12 個の荷物を発送したとしよう。重さは 0.5 kg から 1.5 kg まで、送料は 92 元から 150 元(台湾ドル)までまちまちだ。

送料はおおむね「基本料金+1 kg あたりの加算」に見えるので、1 本の直線で書ける。

y^=wx+b\hat y = w x + b

xx は重さ(kg)、y^\hat y は予測した送料(100 元単位)、ww は 1 kg あたりの加算額、bb は基本料金だ。この 12 件の記録から、いちばん合う ww と bb を見つけたい。

まず適当に一組当ててみる。1 kg あたり 210 元、基本料金 20 元、つまり w=2.1w = 2.1、b=0.2b = 0.2 だ。この直線は傾きが急すぎて、12 個すべての荷物で予測が実際より高くなる。いちばん軽い荷物では 32 元、いちばん重い荷物では 185 元も高く見積もっている。

「どれくらい外れているか」はどう測ればいいか。各荷物の誤差を二乗し、平均を取る。

L(w,b)=12n∑i=1n(wxi+b−yi)2L(w,b) = \frac{1}{2n}\sum_{i=1}^{n}\left(w x_i + b - y_i\right)^2

二乗すれば正と負の誤差が打ち消し合わず、大きく外れた荷物ほど重く罰せられる。前に付いた 12\frac{1}{2} は、あとで微分するときに二乗から下りてくる 2 を消すためだけのものだ。

この LL を損失関数(loss function)と呼ぶ。当てずっぽうの一組を代入すると、L=0.71L = 0.71 になる。

ここからが、この記事でいちばん大事な考え方だ。

(w,b)(w, b) の組はどれも 1 本の直線であり、それぞれ 1 つの損失の値に対応する。ww を横軸、bb を縦軸にとって、平面上の各点にその損失を書き込めば、1 枚の地形図ができる。損失が低いほど、地形も低くなる。いちばんよい直線を探すことは、この地形の最も低い点を探すことだ。

どの直線も、地形の上の 1 点左は 12 個の荷物と現在の直線、右は各 (w, b) の損失。右の図をタップするかドラッグすると、自分で直線を選べる。
0.511.5012重さ(kg)送料(100 元)
012-1012w(1 kg あたり)b(基本料金)
1 kg あたり 0 元+基本料金 120 元L = 0.016

地形図に何重にも描かれた曲線は等高線で、同じ線の上ではどの点も損失が等しい。中央の星印に近いほど、損失は低い。星印は w≈0.59w \approx 0.59、b≈0.61b \approx 0.61、つまり 1 kg あたり 59 元、基本料金 61 元のところにあり、このとき L≈0.0005L \approx 0.0005 だ。

この地形の形に注目してほしい。斜めに傾いた、細長い谷になっている。この形は記事の最後までついて回り、後半の多くの手法は、なんとかしてこれに対処しようとしている。

傾きと勾配

地形のある点に立っているとき、どちらが下り坂かはどうすればわかるか。

まず単純にしよう。bb を最適値に固定して ww だけを動かすと、地形は 1 本の曲線になる。曲線上の各点での接線の傾きが、微分 dLdw\frac{dL}{dw} だ。

傾きが、下り坂の向きを教えてくれるb を最適値に固定し、w だけを動かす。オレンジの線は接線で、その傾きが微分 dL/dw だ。
012012w(1 kg あたり)損失 L
w = -0.40dL/dw = -1.08傾き < 0:下り坂は右

傾きが正なら、ww を大きくすると損失も大きくなるので、下り坂は左にある。傾きが負なら下り坂は右、傾きが 0 なら谷底に着いている。傾きと逆向きに進めば、坂を下ることになる。

2 つのパラメータをどちらも動かせるときは、パラメータごとに偏微分がある。「そのパラメータだけを動かし、ほかは動かさない」ときの傾きだ。この損失関数で計算してみよう。

∂L∂w=1n∑i=1n(wxi+b−yi) xi\frac{\partial L}{\partial w} = \frac{1}{n}\sum_{i=1}^{n} (w x_i + b - y_i)\,x_i ∂L∂b=1n∑i=1n(wxi+b−yi)\frac{\partial L}{\partial b} = \frac{1}{n}\sum_{i=1}^{n} (w x_i + b - y_i)

これを 1 つのベクトルに並べたものが勾配(gradient)だ。

∇L=(∂L∂w, ∂L∂b)\nabla L = \left(\frac{\partial L}{\partial w},\ \frac{\partial L}{\partial b}\right)

この 2 つの式は難しくない。各荷物の誤差に、そのパラメータがその荷物に及ぼす影響の大きさを掛けて、平均を取っている。bb がどの荷物に及ぼす影響も 1 だ。ww の影響は荷物の重さ xx で、重い荷物ほど ww への発言力が大きい。

出発点 (2.1, 0.2)(2.1,\ 0.2) では 12 個の荷物がすべて高く見積もられていて、計算すると ∇L≈(1.24, 1.10)\nabla L \approx (1.24,\ 1.10) になる。2 つの成分はどちらも正なので、ww と bb のどちらをさらに大きくしても、損失は大きくなる。

勾配は等高線と直交し、上り坂を指す矢印は向きだけを表す。破線はこの点を通る等高線で、−∇L が最も急な下り方向。
012-1012w(1 kg あたり)b(基本料金)∇L−∇L
∇L = (1.04, 0.95)‖∇L‖ = 1.41

図から、勾配の 2 つの性質がわかる。

  1. 上り坂がいちばん急な方向を指す。だから −∇L-\nabla L は下り坂がいちばん急な方向だ。
  2. その点を通る等高線と直交する。

なぜか。点 θ=(w,b)\theta = (w, b) の近くで小さく一歩 Δ\Delta 進むと、損失の変化はおよそ次のようになる。

L(θ+Δ)≈L(θ)+∇L⋅ΔL(\theta + \Delta) \approx L(\theta) + \nabla L \cdot \Delta

これは一次のテイラー展開だ。内積は ∇L⋅Δ=∥∇L∥ ∥Δ∥cos⁡φ\nabla L \cdot \Delta = \lVert\nabla L\rVert\,\lVert\Delta\rVert \cos\varphi と書け、φ\varphi は勾配とこの一歩のなす角だ。歩幅が一定なら、φ=180∘\varphi = 180^\circ、つまり勾配と逆向きに進むときに損失がいちばん大きく下がる。等高線に沿って進めば損失は変わらず、∇L⋅Δ=0\nabla L \cdot \Delta = 0 で、なす角は 90∘90^\circ になる。だから勾配は等高線と直交する。

BGD:負の勾配に沿って進む

下り坂の方向がわかれば、あとは簡単だ。毎回 −∇L-\nabla L の方向へ少しだけ進み、それを繰り返す。

θt+1=θt−η ∇L(θt)\theta_{t+1} = \theta_t - \eta\, \nabla L(\theta_t)

η\eta(イータ)は学習率(learning rate)で、一歩でどこまで進むかを決める。これが勾配降下法だ。各ステップで 12 個の荷物すべてを使って勾配を計算するので、バッチ勾配降下法(Batch Gradient Descent、BGD)とも呼ぶ。

この考え方はコンピュータよりも古い。今たどれる最古の文書記録は、Cauchy が 1847 年 10 月 18 日のフランス科学アカデミーの会合で発表した 3 ページの短い論文〈Méthode générale pour la résolution des systèmes d'équations simultanées〉で、『Comptes Rendus』第 25 巻の 536〜538 ページに載っている。彼が解こうとしたのは天体の軌道を決める連立方程式で、各方程式を二乗して足し合わせ、負の偏微分の方向に沿って、この和をどんどん小さくしていくやり方だった。当時はまだ固定した学習率というものはなく、Cauchy はいくつかの選び方を示している。その一つは、この方向に沿ってずっと探し、関数が最小になる点まで来たら止まるというものだ。

η=0.5\eta = 0.5 で最初の一歩を踏み出す。

θ1=(2.1, 0.2)−0.5×(1.24, 1.10)=(1.48, −0.35)\begin{aligned} \theta_1 &= (2.1,\ 0.2) - 0.5 \times (1.24,\ 1.10) \\ &= (1.48,\ -0.35) \end{aligned}

損失は 0.71 から 0.040 に下がり、一歩で 9 割以上減った。

負の勾配に沿って、一歩ずつバッチ勾配降下法、η = 0.5。「1 kg あたり 210 元+基本料金 20 元」から出発。
0.511.5012重さ(kg)送料(100 元)
012-1012w(1 kg あたり)b(基本料金)
1 kg あたり 60 元+基本料金 60 元L = 0.0005

最初の一歩は見事だ。では、その次は?

点は谷に落ちたあと、谷底に沿ってのろのろと進む。荷物の図の直線はとっくにデータに沿っていて、その後の 100 ステップあまりはただの微調整にすぎない。最小点から 0.03 以内の範囲に入るのは、168 ステップ目になってからだ。

なぜこんなに遅いのか。η\eta をもう少し大きくすれば、よくなるだろうか。

学習率:一歩でどこまで進むか

まず最も単純な場合に戻ろう。1 次元のお椀 f(u)=12au2f(u) = \frac{1}{2} a u^2 だ。aa はお椀の曲率、つまり二階微分で、大きいほどお椀は急になる。勾配は aua u なので、各ステップは次のようになる。

ut+1=ut−η a ut=(1−ηa) utu_{t+1} = u_t - \eta\, a\, u_t = (1 - \eta a)\, u_t

一歩進むごとに、uu に (1−ηa)(1 - \eta a) が 1 回掛かる。

同じお椀、4 つの歩幅f(u) = ½u²、曲率は 1。4 つとも u = −2.4 から出発する。
η = 0.1:のろのろ
η = 0.9:速い
η = 1.6:左右に振れる
η = 2.1:発散
画面の外へ

図では a=1a = 1 で、4 つの設定は η\eta だけが違う。

  • η=0.1\eta = 0.1:1 ステップで 10% しか縮まず、のろのろ進む。
  • η=0.9\eta = 0.9:1 ステップで 10% しか残らず、すぐに底に着く。
  • η=1.6\eta = 1.6:1−ηa=−0.61 - \eta a = -0.6 で、毎回向こう側へ跳び越えるが、跳ぶたびに近づき、振動しながら収束する。
  • η=2.1\eta = 2.1:1−ηa=−1.11 - \eta a = -1.1 で、毎回向こう側へ跳び越えるうえにさらに遠ざかり、振れ幅がどんどん大きくなって発散する。

つまり収束の条件は ∣1−ηa∣<1|1 - \eta a| < 1、すなわち η<2/a\eta < 2/a だ。お椀が急なほど、学習率は小さくしなければならない。

細長い谷

私たちの地形は 2 次元で、厄介なのは曲率が 2 種類あることだ。

谷を横切る方向では地形はとても急で、谷底に沿って進む方向ではとても平らだ。線形代数の言葉でいえば、これは損失の二階微分を並べた行列(ヘッセ行列、Hessian)の 2 つの固有値で、この例ではそれぞれ 2.05 と 0.045、46 倍の差がある。この比を条件数(condition number)と呼び、κ\kappa と書く。

同じ η\eta で、2 つの方向の面倒を同時に見なければならない。急な方向で発散しないためには、η\eta を 2/2.05≈0.982/2.05 \approx 0.98 より小さくする必要がある。ところが平らな方向では、1 ステップで縮むのはせいぜい 0.98×0.045≈4.4%0.98 \times 0.045 \approx 4.4\% で、少なくとも数十ステップはかかる。η\eta を大きくすれば急な方向で行ったり来たり跳ね回り、η\eta を小さくすれば平らな方向で進まない。

細長い谷同じ荷物、同じ η = 0.9。変えるのは重さの表し方だけ。
-1012-1012wb
η = 0.993 ステップ目に最小点から 0.03 以内

η=0.9\eta = 0.9 のとき、点は急な方向で行ったり来たり跳ねてジグザグを描きながら、谷底に沿ってゆっくり前進し、93 ステップ目にようやく到達する。

この谷はなぜ斜めなのか。谷底の方向はおよそ (1,−1)(1, -1)、つまり ww を 1 増やして bb を 1 減らす方向だ。1 kg の荷物なら、予測送料 w×1+bw \times 1 + b はまったく変わらない。この 12 個の荷物の平均の重さはちょうど 1 kg なので、この方向に調整しても全体の予測はほとんど変わらず、損失もほとんど変わらない。傾きと切片が打ち消し合って、斜めの谷ができる。

図の「平均を引く」を押すと、各荷物の重さから 1 kg を引き、モデルは y^=w(x−1)+b′\hat y = w(x - 1) + b' になる。描ける直線はまったく同じだが、ww と新しい切片 b′b' はもう互いに縛り合わない。谷はまっすぐになり、条件数は 10.9 まで下がって、46 ステップ目に到達する。さらに標準偏差で割る、つまり「標準化」すると、傾きも新しい w′w' に置き換わり、2 方向の曲率が等しくなる。谷は丸いお椀になり、条件数は 1 で、2 ステップで到達する。

これが、学習の前に入力を標準化することが多い理由だ。しかし深層ネットワークでは、パラメータは軽く億を超え、各層の入力も絶えず変わり続けるので、地形の形を一つひとつ整えてやることはできない。

後半の手法は、おおむね 3 つの方向から攻めている。

  1. さっき進んだ方向を覚えておき、行ったり来たりの跳ね返りを打ち消し合わせる(モーメンタム)。
  2. パラメータごとに異なる歩幅を使う(AdaGrad、RMSProp、Adam)。
  3. 地形の形を推定するか、一歩を測る物差しを取り替える(ニュートン法、Shampoo、Muon)。

崖にぶつかる

学習率が大きすぎると発散する。学習率が大きくなくても、一歩で放り出されることがある。

崖にぶつかる一歩緩やかな坂が u = 2.4 で急な壁にぶつかる。どちらも η = 0.6 で、右は勾配の大きさを 1 以内に制限する。
クリップなし
-2-1012024uL
1 にクリップ
-2-1012024uL

この地形は、緩やかな坂の先に急な壁がある。点は坂に沿って壁際まで進み、ある一歩でちょうど壁面に乗る。壁の上の勾配はとても大きく、次の一歩で u=−5.8u = -5.8 まで弾き飛ばされ、画面の外へ出てしまう。壁際まで戻るのに 10 ステップ近くかかり、また壁面に乗って、また弾き飛ばされる。40 ステップのうちに 3 回弾かれ、そのうち 2 回は画面の外まで飛んだ。

現実の RNN にも、こういう壁がある。Pascanu、Mikolov、Bengio は 2013 年、RNN がなぜ学習しにくいかを分析したときに、一つの仮説を立てた。勾配が爆発する方向では曲率もたいてい大きく、損失曲面に急な壁ができる。そこへ一歩乗ると、もとの谷から放り出される。彼らは On the difficulty of training recurrent neural networks で、隠れユニットが 1 つだけの RNN を使ってこの壁を描いてみせた。

解決策は単純で、勾配が大きすぎるときは縮めればいい。最もよく使われるのは、ノルムによるクリッピング(clip by norm)だ。

g←g⋅min⁡ ⁣(1, c∥g∥)g \leftarrow g \cdot \min\!\left(1,\ \frac{c}{\lVert g \rVert}\right)

勾配の長さが cc を超えたら、方向はそのままで長さを cc に縮める。「1 にクリップ」のパネルでは勾配の大きさを 1 に制限していて、点は壁際で小さく行き来し続け、飛んでいかない。PyTorch なら torch.nn.utils.clip_grad_norm_ がこれにあたる。

cc はいくつにすべきか。Pascanu らの提案では、まずしばらくのあいだ勾配ノルムの平均を観察し、その半分から 10 倍のあいだに取れば、どれでも収束はする。ただし速度には影響が出る。

SGD と MBGD:一度に数件だけ見る

BGD は一歩進むたびに、データをすべて一通り見なければならない。荷物 12 個なら問題ない。だが ImageNet の 128 万枚の訓練画像になると、一歩進むたびに、まず 128 万枚すべてに順伝播と逆伝播を一度ずつ通す必要がある。

確率的勾配降下法(Stochastic Gradient Descent、SGD)は、各ステップでデータを 1 件だけランダムに選び、その勾配で全体の勾配を代用する。

θt+1=θt−η ∇ℓit(θt)\theta_{t+1} = \theta_t - \eta\, \nabla \ell_{i_t}(\theta_t)

ℓi\ell_i は ii 番目のデータ自身の損失、iti_t は第 tt ステップで選ばれた 1 件だ。

1 件しか見ないのだから、勾配はもちろん不正確だ。しかし、どのデータも選ばれる確率が等しければ、その期待値はちょうど全体の勾配になる。

Ei[∇ℓi(θ)]=1n∑i=1n∇ℓi(θ)=∇L(θ)\mathbb{E}_{i}\big[\nabla \ell_i(\theta)\big] = \frac{1}{n}\sum_{i=1}^{n} \nabla \ell_i(\theta) = \nabla L(\theta)

平均すれば方向は正しく、ただ各ステップにノイズが乗っている。

折衷案は、毎回小さなまとまり(batch)、たとえば 4 件を選び、その勾配を平均することだ。これをミニバッチ勾配降下法(Mini-Batch Gradient Descent、MBGD)と呼ぶ。バッチが大きいほどノイズは小さく、勾配の分散はおおむねバッチサイズに反比例する。

1 ステップで 12 件、4 件、それとも 1 件3 つとも η = 0.5。左の図は 1 件版の現在の直線で、丸で囲んだのはこのステップで選ばれた荷物。
0.511.5012重さ(kg)送料(100 元)
012-1012w(1 kg あたり)b(基本料金)
BGD(12 件):読んだデータ 2400 件 · 168 ステップ目に最小点から 0.03 以内MBGD(4 件):読んだデータ 800 件 · 169 ステップ目に最小点から 0.03 以内SGD(1 件):読んだデータ 200 件 · 178 ステップ目に最小点から 0.03 以内

3 つのルートは同じ η=0.5\eta = 0.5 を使っている。BGD がいちばん滑らかに進み、MBGD はずっと小刻みに揺れ、SGD がいちばん激しく震える。荷物の図で丸で囲まれているのが、SGD がこのステップで選んだ荷物だ。

ところが、読んだデータの量を見てほしい。3 つとも 170 ステップ前後で最小点から 0.03 以内に入るが、BGD は 1 ステップで 12 件読むので、到達までに 2,016 件読んでいる。MBGD は 676 件、SGD はわずか 178 件だ。読んだデータの量で比べれば、いちばん激しく震えるルートがいちばん少なくて済む。

学習率は徐々に小さくする

SGD には BGD にない厄介な点がある。最小点に着いたとき、全体の勾配は 0 だが、荷物一つひとつの勾配は 0 ではない。12 個の荷物がすべてぴったり同じ直線に乗ることはありえず、どのデータもパラメータを自分の側へ引っ張り続けている。どれを選んだかで、そちらへ少しずれる。

固定の学習率では止まらない1 件ずつの SGD を最小点から出発させ、最小点の周囲 ±0.12 を拡大表示。左右で選ぶ荷物の順番は同じ。
固定 η = 0.5
減衰 η = 0.5/(1+t/20)
固定 η = 0.500:直近 50 ステップの最小点からの平均距離 4.2/100減衰 η = 0.031:直近 50 ステップの最小点からの平均距離 1.5/100

この図は最小点から直接出発し、毎回 1 件だけを見る。学習率が固定だと、パラメータは最小点の周りをずっとさまよい、最後の 50 ステップの最小点からの平均距離は 0.042 だ。学習率を ηt=0.5/(1+t/20)\eta_t = 0.5/(1 + t/20) に従ってステップ数とともに小さくすると、さまよう範囲も縮み、平均距離は 0.015 まで下がる。

学習率はどう小さくすればいいのか。早く小さくしすぎると、たどり着く前に止まってしまう。小さくするのが遅すぎると、ノイズがいつまでも消えない。

最小点を探すことは、∇L=0\nabla L = 0 となる点、つまりある方程式の根を求めることだ。Robbins と Monro が 1951 年の〈A Stochastic Approximation Method〉で研究したのはまさにこの種の問題で、ただし毎回ノイズの乗った結果しか観測できない状況だった。後の研究者は、彼らの歩幅の条件を 2 つにまとめた。

∑t=1∞ηt=∞,∑t=1∞ηt2<∞\sum_{t=1}^{\infty} \eta_t = \infty, \qquad \sum_{t=1}^{\infty} \eta_t^2 < \infty

1 つ目の条件は歩幅の総和を十分長くし、出発点がどれだけ遠くてもたどり着けるようにする。2 つ目はノイズの累積総量を有限にし、最後に止まれるようにする。ηt∝1/t\eta_t \propto 1/t は両方を満たし、上の図の減らし方もこの部類に入る。

ノイズにも使い道がある

SGD のノイズも、悪いことばかりではない。

鞍点で立ち往生f(u, v) = ½u² − ½v² + ¼v⁴、η = 0.2、(1.8, 0) から出発。オレンジのルートは毎回の勾配に大きさ約 0.0001 のノイズを加える。
012-101uv鞍点最小点最小点
勾配降下法:f = 0.000、‖∇f‖ = 0.000ノイズを少し加える:f = -0.250、‖∇f‖ = 0.000

この地形は f(u,v)=12u2−12v2+14v4f(u, v) = \frac{1}{2}u^2 - \frac{1}{2}v^2 + \frac{1}{4}v^4 だ。原点は鞍点で、uu 方向に見れば谷底、vv 方向に見れば山頂で、勾配は 0 になる。本当の谷底は v=±1v = \pm 1 の 2 か所だ。

GD は (1.8, 0)(1.8,\ 0) から出発する。vv 方向の勾配は最初から 0 で、その後もずっと 0 のままなので、鞍点まで滑り込んでそこで止まる。ほんの少しノイズ(標準偏差わずか 0.0001)を加えると、点は鞍点の近くで尾根から軽く押し出され、64 ステップ目に (0,−1)(0, -1) の谷底に落ちる。

2 次元の図では、鞍点は特殊な例に見える。Dauphin らは 2014 年の〈Identifying and attacking the saddle point problem in high-dimensional non-convex optimization〉で、次元が高いほど局所最小値に対する鞍点の数が多くなり、学習が遅くなるのは、悪い局所最小値に落ちたためではなく、鞍点の周りの平らな高原で足止めされているためであることが多い、と主張した。

ノイズは脱出を助けるが、理論的には条件が付く。Ge らは 2015 年、どの鞍点にもはっきりした下り方向(負の曲率)があり、関数が十分に滑らかで、ノイズがあらゆる方向に分散を持つなら、ノイズ付きの SGD は多項式ステップ数で鞍点を抜け出せることを証明した。この例は尾根の真上から出発していて、わざと選んだ最悪のケースだ。ランダムな地点から出発すれば、GD がちょうど鞍点で止まることはほとんどない。ただ、平らな高原では進みがとても遅くなることがある。

SGDM:さっきの方向を覚えておく

細長い谷に戻ろう。ジグザグの問題は、谷を横切る方向の勾配が毎ステップ正負を反転させることにある。このステップで谷の一方へ押し、次のステップでもう一方へ押し戻す。谷底に沿う方向の勾配は小さいが、ずっと同じ側を指している。

各ステップで今の勾配だけでなく、数ステップ前までの勾配も参考にすれば、行ったり来たり反転する成分は打ち消し合い、同じ側を指し続ける成分は積み上がっていく。

指数移動平均

「数ステップ前まで参考にする」最も一般的なやり方は、指数移動平均(Exponential Moving Average、EMA)だ。

mt=β mt−1+(1−β) gtm_t = \beta\, m_{t-1} + (1 - \beta)\, g_t

新しい平均値は、古い平均値に β\beta を掛け、新しい勾配に 1−β1 - \beta を掛けて足したものだ。β=0.9\beta = 0.9 なら新しい勾配の比重は 1 割で、10 ステップ前の勾配にはまだ 0.910≈35%0.9^{10} \approx 35\% の影響力が残り、古いものほど薄れていく。過去の勾配を一つひとつ保存しておく必要はなく、数を 1 つ覚えておけばいい。

ジグザグを平均するη = 0.9 のジグザグ経路の勾配を、谷を横切る方向と谷に沿う方向の 2 つに分ける。オレンジの線は β = 0.9 の移動平均。
谷を横切る:毎ステップ正負が反転
0102030-1.701.7ステップ
谷に沿う:小さいが向きは一定
010203000.06ステップ
各ステップの勾配移動平均

谷の中での GD の勾配を、谷を横切る成分と谷に沿う成分の 2 つに分けてみた。横切る成分は最初のステップで約 1.7、その後は正負が交互に入れ替わり、EMA はすぐに 0 付近まで抑え込む。谷底に沿う成分は約 0.06 しかないが、向きはずっと一定で、EMA にしっかり残る。

モーメンタム

この平均を使ってパラメータを更新するのが、モーメンタム法(momentum)だ。モーメンタム付きの SGD は、よく SGDM と略される。

vt=β vt−1+gt,θt+1=θt−η vtv_t = \beta\, v_{t-1} + g_t, \qquad \theta_{t+1} = \theta_t - \eta\, v_t

この vv には (1−β)(1 - \beta) の係数がないので、上の EMA の 11−β\frac{1}{1-\beta} 倍になる。勾配がずっと同じ側を指していれば、vv は g1−β\frac{g}{1-\beta} まで積み上がり、β=0.9\beta = 0.9 なら 10 倍だ。平らな方向で進めなかった小さな勾配が、こうして増幅される。

このたとえは物理から来ている。vv はボールの速度のようなもので、勾配は坂がボールに与える推進力、β\beta は各ステップで速度をどれだけ残すかを決める。

この考え方も、深層学習よりずっと古い。Polyak は 1964 年にこれを次のように書いた。

xn+1=xn−α∇f(xn)+β (xn−xn−1)x^{n+1} = x^n - \alpha \nabla f(x^n) + \beta\,(x^n - x^{n-1})

つまり勾配の一歩に加えて、「前回の変位」に β\beta を掛けたものを足す。上の 2 行から vv を消去すると、まったく同じ式が得られ、α\alpha がちょうど η\eta にあたる。Polyak 自身はこれを重球法(heavy ball)と名付け、ポテンシャル場の中を物体が運動する様子の離散版とみなした。そして β\beta はふつう 0.8 から 0.99 に取るよう勧めている。

彼は加速の度合いも計算した。条件数 κ\kappa の二次関数では、GD に必要なステップ数はおよそ κ\kappa に比例するが、重球法なら κ\sqrt{\kappa} に比例するだけで済む。私たちの谷は κ≈46\kappa \approx 46 で、κ≈6.8\sqrt{\kappa} \approx 6.8 だ。ただしこの結果が成り立つのは、二次関数か、極小点の近くで十分に二次関数に近い場所だけだ。Lessard らは 2016 年に条件数 25 の 1 次元関数を構成し、二次関数向けの最適なパラメータで重球法を走らせると、いつまでも減衰しない振動に陥ることを示している。

同じ η に、モーメンタムを加えるオレンジのルートの先端の矢印は、次の一歩の変位 −ηv。
012-1012w(1 kg あたり)b(基本料金)
勾配降下法(η = 0.9):93 ステップ目に最小点から 0.03 以内モーメンタム(η = 0.9、β = 0.7):19 ステップ目に最小点から 0.03 以内

同じ η=0.9\eta = 0.9 でも、GD は 93 ステップ目にようやく到達するのに対し、β=0.7\beta = 0.7 のモーメンタムを加えると 19 ステップ目に着く。

モーメンタムのルートをよく見ると、最初からおとなしいわけではなく、むしろ何度も大きく谷を横切っている。モーメンタムが打ち消すのは、毎ステップ正負が反転するタイプの跳ね返りだ。ボールがすでに溜めた速度は、止まるまでにやはり何ステップもかかる。

β\beta が大きすぎるとどうなるか。

過去をどれだけ覚えておくかモーメンタム、η = 0.1、3 種類の β。勾配が一定なら、歩幅は最終的に η/(1 − β) まで積み上がる。
β = 0.5 · η/(1 − β) = 0.2
β = 0.9 · η/(1 − β) = 1.0
β = 0.99 · η/(1 − β) = 10.0
β = 0.5:200 ステップ後も最小点から 0.03 以内に入らないβ = 0.9:51 ステップ目に最小点から 0.03 以内β = 0.99:200 ステップ後も最小点から 0.03 以内に入らない

3 つの図はどれも η=0.1\eta = 0.1 だ。β=0.5\beta = 0.5 は記憶が短すぎて効果が薄く、200 ステップ以内に到達しない。β=0.9\beta = 0.9 は 51 ステップ目に到達する。β=0.99\beta = 0.99 は摩擦がほとんどなく、ボールは谷底の近くでぐるぐる回り続け、こちらも 200 ステップ以内には止まらない。

NAG:先を見てから踏む

モーメンタムは反応が鈍い。谷底が近づくと、ボールは溜めた速度のまま行き過ぎ、勾配が逆向きに何ステップも押し続けて、ようやく向きを変える。

Nesterov モーメンタム(Nesterov Accelerated Gradient、NAG)が変えたのは 1 か所だけだ。このステップでどうせ速度に沿って前へ進むのなら、先にそこまで行って向こうの坂の具合を見てから、どう修正するかを決める。

vt=β vt−1+∇L(θt−ηβ vt−1)θt+1=θt−η vt\begin{aligned} v_t &= \beta\, v_{t-1} + \nabla L(\theta_t - \eta\beta\, v_{t-1}) \\ \theta_{t+1} &= \theta_t - \eta\, v_t \end{aligned}

違いは、勾配をどこで計算するかだけだ。モーメンタムは現在の位置で計算し、NAG は「今の速度で一歩進んだ後」の先読み点で計算する。前方がすでに上り坂になりかけていれば、NAG はこのステップでそれを早めに感じ取り、先に少しブレーキをかける。

先を見てから坂を測る青はその場で勾配を測る。オレンジはまず慣性で −ηβv 動き、白抜きの先読み点で測る。矢印は向きだけを表す。
012-1012w(1 kg あたり)b(基本料金)
モーメンタム:37 ステップ目に最小点から 0.03 以内Nesterov:22 ステップ目に最小点から 0.03 以内η = 0.5、β = 0.8

白抜きの丸が NAG の先読み点だ。同じ η=0.5\eta = 0.5、β=0.8\beta = 0.8 で、モーメンタムは 37 ステップ目、NAG は 22 ステップ目に到達する。

なぜ谷の中で特に効くのか。Sutskever らは 2013 年、二次関数では NAG が、固有方向ごとに異なるモーメンタム β(1−ηλ)\beta(1 - \eta\lambda) を使うのと等価であることを示した。λ\lambda はその方向の曲率で、曲率が大きい方向ほどモーメンタムは小さくなる。この図の設定を代入すると、谷を横切る方向は λ=2.05\lambda = 2.05 で、実効モーメンタムは 0.8×(1−0.5×2.05)≈−0.020.8 \times (1 - 0.5 \times 2.05) \approx -0.02 しか残らず、勢いはほとんどない。谷底に沿う方向は λ=0.045\lambda = 0.045 で、0.78 が保たれる。行ったり来たりしやすい方向は抑えられ、加速が必要な方向はそのまま加速される。

この手法は Nesterov の 1983 年の論文に由来し、もとは凸最適化の理論的な結果で、誤差が 1/k21/k^2 の速さで減ることを保証するものだった。「先読み点で勾配を計算する」という書き方は、Sutskever、Martens、Dahl、Hinton が〈On the importance of initialization and momentum in deep learning〉で書き直したものだ。彼らはモーメンタムを小さな値から徐々に 0.99、さらには 0.999 まで上げ、注意深く設計した初期化と組み合わせて、モーメンタム付き SGD を、深層オートエンコーダで当時のより複雑な二次の手法と肩を並べるところまで持っていった。

AdaGrad:パラメータごとに歩幅を変える

ここまで、すべてのパラメータが同じ η\eta を共有してきた。

多くの問題では、これは理にかなわない。AdaGrad の著者 Duchi、Hazan、Singer が挙げたのは、テキストデータの例だ。よく使われる単語はどのデータにも現れ、対応するパラメータはずっと更新され続ける。まれな単語はたまにしか現れないが、現れたときにはしばしば強い予測力を持つ。同じ学習率では、前者には大きすぎ、後者には小さすぎるかもしれない。

AdaGrad は各パラメータに、自分の過去すべての勾配の二乗和を覚えさせ、その平方根で割る。

Gt=Gt−1+gt2θt+1=θt−ηGt+ϵ gt\begin{aligned} G_t &= G_{t-1} + g_t^2 \\ \theta_{t+1} &= \theta_t - \frac{\eta}{\sqrt{G_t} + \epsilon}\, g_t \end{aligned}

ここでの二乗、平方根、割り算は、すべてパラメータごとに別々に計算する。ϵ\epsilon はゼロ除算を避けるためのごく小さな数だ。

勾配がずっと大きいパラメータは GG が速く育ち、歩幅が小さくなる。めったに更新されないパラメータは GG が小さく、勾配が来れば大きく踏み出せる。最初の一歩はもっと面白い。G1=g12G_1 = g_1^2 なので、どのパラメータも最初の一歩は ±η\pm\eta で、勾配そのものの大きさとは関係ない。

AdaGrad:座標ごとに専用の学習率η = 0.5。G はこれまでの勾配の二乗の総和なので、η/√G は小さくなる一方だ。最初の一歩で w と b はそれぞれちょうど η 進む。
012-1012w(1 kg あたり)b(基本料金)
実効学習率
00.250.5η/√Gη = 0.5w:0.392b:0.445
G = (1.624, 1.261)η/√G = (0.392, 0.445)G の 97% は最初の 5 ステップ由来

η=0.5\eta = 0.5 で、最初の一歩で ww と bb はそれぞれちょうど 0.5 ずつ進む。その後、2 つのパラメータの実効学習率は 0.39 と 0.45 でほぼ止まり、二度と動かない。GG の 97% は最初の 5 ステップから来ている。最初は最小点から遠く勾配が大きいので、二乗を足すと大きな量になる。その後は勾配がどんどん小さくなり、いくら足してもたいして増えない。この図では 0.03 以内に入るのが 203 ステップ目で、BGD の 168 ステップよりも遅い。

GG は増える一方なので、各パラメータの実効学習率 η/Gt\eta/\sqrt{G_t} は小さくなる一方で、しかも主に最初の数ステップで決まってしまう。凸問題では、これこそが収束させる仕組みになる。ところが深層ネットワークの学習は数十万ステップに及び、地形もずっと変わり続けるので、よい場所にたどり着く前に、学習率が小さくなりすぎて進めなくなることが多い。

RMSProp と AdaDelta:忘れることを覚える

厄介さの原因が「過去の勾配をすべて足し合わせる」ことにあるなら、最近のものだけを覚えておけばいい。

AdaGrad の累積を指数移動平均に置き換えたのが、RMSProp だ。

vt=ρ vt−1+(1−ρ) gt2θt+1=θt−ηvt+ϵ gt\begin{aligned} v_t &= \rho\, v_{t-1} + (1 - \rho)\, g_t^2 \\ \theta_{t+1} &= \theta_t - \frac{\eta}{\sqrt{v_t} + \epsilon}\, g_t \end{aligned}

ρ\rho はふつう 0.9 に取る。ここでの vv が記録するのは勾配の二乗の平均で、モーメンタムの節の速度 vv とは別物だ。ずっと前の大きな勾配は徐々に忘れられ、実効学習率は小さくもなれるし、また大きく戻ることもできる。

RMSProp には珍しい出自がある。論文がないのだ。出どころは、Hinton が 2012 年に Coursera で開講した〈Neural Networks for Machine Learning〉の第 6 講第 5 節(Lecture 6e)のスライドだ。スライドにはまさに 0.9 MeanSquare+0.1 g20.9\,\mathit{MeanSquare} + 0.1\,g^2 と書かれ、その平方根で勾配を割るとあり、これは Tijmen Tieleman の未発表の研究だと注記されている。後の論文がこれを引用するときは、この講義資料を引用するしかなかった。

急な坂の先に、長い緩やかな坂u < 0 では傾き 1、その先は 0.1 だけで、谷底は u ≈ 10。AdaGrad は η = 0.5、RMSProp は η = 0.1、ρ = 0.9。どちらも u = −3 から出発する。
それぞれの現在地
-20246810uLAdaGradRMSProp
歩幅 |Δu|(対数目盛)
060120180240ステップ|Δu|0.0010.010.11AdaGradRMSProp
AdaGrad u = 3.45RMSProp u = 10.10

この図の地形は、まず傾き 1 の急な坂があり、続いて傾きわずか 0.1 の長い緩やかな坂があって、谷底は u≈10u \approx 10 にある。どちらも u=−3u = -3 から出発し、AdaGrad は η=0.5\eta = 0.5、RMSProp は η=0.1\eta = 0.1、ρ=0.9\rho = 0.9 を使う。

急な坂では、どちらも分母が大きな勾配で押し広げられる。緩やかな坂に入ったあと、AdaGrad の GG は急な坂での一歩一歩をまだ覚えていて、歩幅は約 0.01 まで落ちる。RMSProp はすぐに忘れ、分母が勾配に合わせて小さくなり、歩幅は約 0.1 に戻る。100 ステップ目の時点で、AdaGrad はやっと u≈1.7u \approx 1.7 まで来たところだが、RMSProp はもう 5.1 にいる。RMSProp はおよそ 150 ステップ目に谷底に着くが、AdaGrad は 240 ステップ目でもまだ 3.45 だ。学習率を大きく与えたほうが、かえって遅い。

同じ年、Zeiler が提案した AdaDelta も同じ移動平均を使い、さらに一歩踏み込んで考えた。彼は、SGD や AdaGrad の更新量では単位がそろっていないことに気づいた。勾配の単位は「損失 ÷ パラメータ」で、それでパラメータを更新すると単位が合わない。さらに二階微分で割れば(あとでニュートン法を扱うときにまた出てくる)、単位は「パラメータ」に戻る。AdaDelta は実際に二階微分を計算するのではなく、分子の η\eta を「過去の更新量」の二乗平均平方根に置き換えた。

Δθt=−RMS[Δθ]t−1RMS[g]t gt\Delta\theta_t = -\frac{\mathrm{RMS}[\Delta\theta]_{t-1}}{\mathrm{RMS}[g]_t}\, g_t

分子と分母の単位が約分され、更新量の単位がパラメータと一致する。学習率を設定する必要すらなくなる。

Adam:2 つを 1 つに

ここまでで、道具が 2 つそろった。モーメンタムは勾配の移動平均で、方向がころころ変わる問題に対処する。RMSProp は勾配の二乗の移動平均で、パラメータごとに歩幅を調整する。

Kingma と Ba が 2014 年に提案した Adam は、この 2 つを組み合わせたものだ。

mt=β1 mt−1+(1−β1) gtvt=β2 vt−1+(1−β2) gt2m^t=mt1−β1t,v^t=vt1−β2tθt=θt−1−α m^tv^t+ϵ\begin{aligned} m_t &= \beta_1\, m_{t-1} + (1 - \beta_1)\, g_t \\ v_t &= \beta_2\, v_{t-1} + (1 - \beta_2)\, g_t^2 \\ \hat m_t &= \frac{m_t}{1 - \beta_1^t}, \qquad \hat v_t = \frac{v_t}{1 - \beta_2^t} \\ \theta_t &= \theta_{t-1} - \alpha\, \frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon} \end{aligned}

mm は勾配の一次モーメントの推定、つまり平均で、vv は二次モーメントの推定、つまり二乗の平均だ。学習率は Adam の論文では α\alpha と書かれ、役割は前の η\eta と同じだ。論文のデフォルト値は α=0.001\alpha = 0.001、β1=0.9\beta_1 = 0.9、β2=0.999\beta_2 = 0.999、ϵ=10−8\epsilon = 10^{-8} で、この組み合わせは今も PyTorch のデフォルトになっている。

最初の 2 行はもう見た。3 行目が新しい。

バイアス補正

mm と vv はどちらも 0 から始まる。最初のステップでは m1=0.1 g1m_1 = 0.1\, g_1 で、本当の勾配の 1 割しかない。v1=0.001 g12v_1 = 0.001\, g_1^2 で、1000 分の 1 しかない。どちらの推定も、出発点の 0 に引っ張られて小さくなっている。

mtm_t を展開し、勾配の期待値がずっと E[g]\mathbb{E}[g] だと仮定すると、E[mt]=(1−β1t) E[g]\mathbb{E}[m_t] = (1 - \beta_1^t)\,\mathbb{E}[g] と計算できる。だから 1−β1t1 - \beta_1^t で割れば偏りが元に戻る。vv も同様だ。

なぜ補正しなければならないのか。2 つの推定は偏りの程度が違う。β2=0.999\beta_2 = 0.999 のせいで vv は mm よりずっと強く引っ張られるので、補正しないと分母が小さすぎ、歩幅が大きくなりすぎる。

Adam の移動平均は 0 から始まる勾配は 1 で一定、β₁ = 0.9、β₂ = 0.999。破線は記録された m と v、実線は 1 − βᵗ で割ったもの。時間軸は対数目盛。
m と v
110100100000.51tmvm̂ = v̂
歩幅の倍率
110100100001357t補正前 m/√vt = 12 で最大 6.6 倍補正後 m̂/√v̂
mt = 1.000vt = 0.6323補正前 m/√v = 1.26補正後 m̂/√v̂ = 1.00

勾配がずっと 1 で一定だとしよう。補正後の m^t/v^t\hat m_t / \sqrt{\hat v_t} は最初のステップから 1 で、歩幅はちょうど α\alpha だ。補正しないと、最初のステップで 0.1/0.001≈3.160.1/\sqrt{0.001} \approx 3.16 倍、12 ステップ目あたりで 6.6 倍まで跳ね上がり、1,000 ステップ目でもまだ 1.26 倍ある。Kingma と Ba は変分オートエンコーダの実験で、β2\beta_2 が 1 に近いほど、バイアス補正なしの学習は序盤が不安定になることを確かめている。

歩幅はおよそ α\alpha

補正後の m^t/v^t\hat m_t / \sqrt{\hat v_t} は、おおむね ±1\pm 1 付近に収まる。損失全体を 100 倍すると勾配も 100 倍になるが、m^\hat m と v^\sqrt{\hat v} がそろって大きくなるので、ごく小さな ϵ\epsilon を除けば更新量はほとんど変わらない。各パラメータは一歩でおよそ α\alpha だけ進み、勾配そのものの大きさとは関係ない。

これが、Adam が使いやすい主な理由だ。SGD の学習率は、勾配のスケールに合わせて調整しなければならない。Adam の α\alpha は「1 ステップでパラメータをどれだけ動かしたいか」に近く、モデルを替えてもデフォルト値がそのまま使えることが多い。

4 つの更新規則、同じ谷4 つとも 12 個の荷物の完全な勾配を使い、違うのは更新規則だけ。学習率はそれぞれここでうまく動く値を選び、Adam はデフォルトの β₁ = 0.9、β₂ = 0.999。数字は最小点から 0.03 以内に初めて入ったステップ。
GD · η = 0.9
モーメンタム · η = 0.3, β = 0.9
RMSProp · η = 0.02, ρ = 0.9
Adam · η = 0.2
GD:93 ステップ目に到達モーメンタム:47 ステップ目に到達RMSProp:130 ステップ目に到達Adam:87 ステップ目に到達

4 つの手法を同じ谷に置き、学習率はそれぞれここでうまく動く値に調整した。数字は、最小点から 0.03 以内に初めて入ったステップ数だ。4 つとも 12 個の荷物すべての勾配を使うので、最初の 2 つはサンプリングしない GD と、モーメンタム付きの GD だ。GD(η=0.9\eta = 0.9)は 93 ステップ目、モーメンタム(η=0.3\eta = 0.3、β=0.9\beta = 0.9)は 47 ステップ目、RMSProp(η=0.02\eta = 0.02)は 130 ステップ目、Adam(α=0.2\alpha = 0.2)は 87 ステップ目に到達する。

Adam でも、たいして速くはならない。理由はあとの「谷を丸くする」の節に回すが、谷が斜めであることと関係している。

Adam は Nesterov モーメンタムに置き換えることもできる。Dozat は 2016 年、NAG の「先を見る」を Adam に書き込み、Nadam と名付けた。NAG はまずモーメンタムに沿って一歩進んでから勾配を測る。Nadam は勾配をもう一度計算するのではなく、更新のときに「次のステップのモーメンタム」β1m^t\beta_1 \hat m_t をそのまま使い、そこにこのステップの勾配を足す。後に AlgoPerf(学習アルゴリズムの速さを比べる公開ベンチマークで、あとの「どれがいちばん速い?」の節で改めて紹介する)がベースラインに使った NAdamW は、Nadam に次の節の AdamW の重み減衰を加えたものだ。

Adam もつまずく

Adam はすぐにデフォルトの選択肢になった。しかしその後の数年で、次々と問題が指摘された。

大事な大きい勾配を忘れる

Reddi、Kale、Kumar はごく小さな例を作った。パラメータ xx は [−1,1][-1, 1] の範囲しか取れず、3 ステップで 1 周期になる。1 ステップ目の損失は CxCx、残りの 2 ステップは −x-x だ。C=3C = 3 なら 1 周期の勾配の合計は 3−1−1=1>03 - 1 - 1 = 1 > 0 なので、xx を −1-1 の方へ押すべきだ。

ここで Adam の分母が誤りを起こす。まれな大きい勾配 3 が現れると、vv はすぐに大きくなり、このステップの g/vg/\sqrt{v} は約 1.05 まで押しつぶされる。続く 2 ステップは勾配が −1-1 しかなく、vv はすぐにまた小さくなるので、この 2 ステップはそれぞれ −0.76-0.76 と −0.97-0.97 に増幅される。1 周期で、αt\alpha_t を単位として、間違った方向へ 0.68 余分に進んでしまう。

Adam が逆方向へ進むReddi らの例。x は [−1, 1] に制限され、3 ステップに 1 回は勾配が +3、残り 2 回は −1 なので、最小点は x = −1。β₁ = 0、β₂ = 0.1、α_t = 0.5/√t で、どちらも x = 1 から出発する。
0100200300-101tx最小点 x = −1AdamAMSGrad
勾配:3 ステップに 1 回 +3、それ以外は −1
t = 300, gt = -1Adam:x = 1.00、g/√v = -0.97AMSGrad:x = -0.98、g/√v = -0.35

どちらも x=1x = 1 から出発し、学習率は 0.5/t0.5/\sqrt{t} だ。Adam は 3 ステップごとに +1+1 へ押し戻され、ずっと間違った端に居座る。AMSGrad は 100 ステップ目で約 −0.40-0.40、300 ステップ目で −0.98-0.98 に達する。

ここでの β1=0\beta_1 = 0、β2=1/(1+C2)=0.1\beta_2 = 1/(1 + C^2) = 0.1 は、論文が証明のために選んだ設定だ。根本の原因は、Adam の実効学習率 α/vt\alpha/\sqrt{v_t} が大きくなりうることにある。最近の勾配が小さくなると、過去の大きな勾配は忘れられてしまう。

彼らの修正版 AMSGrad が変えたのは 1 点だけで、分母に vv の過去最大値を使う。

v^t=max⁡(v^t−1, vt)\hat v_t = \max(\hat v_{t-1},\ v_t)

これで実効学習率は小さくなる一方になり、大きくなることはない。上の例では 3 ステップとも同じ v^\hat v を使うので、1 周期の正味の効果は、正しい方向へ 0.35 進むことになる。

汎化が劣る?

もう一つの疑問は、Wilson らの 2017 年の〈The Marginal Value of Adaptive Gradient Methods in Machine Learning〉から出た。彼らは線形分類の問題を構成した。SGD が見つけた解はテスト誤差が 0 なのに、AdaGrad、RMSProp、Adam が見つけた解は、新しいサンプルをすべて同じクラスに分類してしまう。

CIFAR-10 では、学習率と減衰のさせ方だけを調整した結果、SGD のテスト誤差は 7.65%、RMSProp は 9.60%、Adam は 9.78% だった。訓練損失は速く下がるのに、テストの成績は劣る。この論文を受けて、少なからぬコンピュータビジョンの研究がモーメンタム付き SGD を使い続けた。

2 年後、Choi らは Wilson らが公開したコードで再実験し、モーメンタムと ϵ\epsilon まで含めて調整した。すると 4 つの手法のテスト誤差は、ほぼ同じになった。差がどれだけ出るかは、どのハイパーパラメータを調整したかに大きく左右される。

重み減衰が縮められていた

3 つ目の問題が最も見えにくく、影響も最も大きい。

重み減衰(weight decay)は、各ステップでパラメータを少しだけ 0 の方へ引き戻し、パラメータが大きくなりすぎるのを防ぐ。SGD では、これは L2 正則化と等価だ。損失に λ2∥θ∥2\frac{\lambda}{2}\lVert\theta\rVert^2 を加えると勾配に λθ\lambda\theta の項が増え、その効果は、各ステップでパラメータを少し縮めることになる。

そこで初期の Adam の実装は、λθ\lambda\theta を勾配に加えていた。ところが Adam では、この項も v^\sqrt{\hat v} で割られてしまう。勾配がずっと大きいパラメータは v^\sqrt{\hat v} が大きいので、減衰がとても小さく縮められる。Loshchilov と Hutter の言葉を借りれば、過去の勾配が大きい重みほど、正則化が弱くなる。

彼らの解決策は、減衰を外に出して Adam の分母を通さないことだ。

θt=θt−1−ηt(α m^tv^t+ϵ+λ θt−1)\theta_t = \theta_{t-1} - \eta_t \left( \alpha\, \frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon} + \lambda\, \theta_{t-1} \right)

これが AdamW だ。式中の α\alpha は学習率で、ηt\eta_t は第 tt ステップでの学習率スケジュールの倍率、学習率が固定なら 1 だ。

重み減衰は Adam の中か、外か2 つの重みはどちらも 1 から出発し、勾配は平均 0 のノイズ。ノイズの大きさは w₁ が 1、w₂ はわずか 0.001。α = 0.002、λ = 0.004。0 へ引き寄せるのは正則化だけだ。
L2 を勾配に加える
025050000.51ステップww₁(勾配が大きい)w₂(勾配が小さい)
AdamW(分離)
025050000.51ステップww₁(勾配が大きい)w₂(勾配が小さい)
L2 を勾配に加える:w₁ = 0.96、w₂ = 0.28AdamW(分離):w₁ = 0.13、w₂ = 0.14

2 つの重みはどちらも 1 から出発し、勾配はノイズだけで、大きさが 1000 倍違う。α=0.002\alpha = 0.002、λ=0.004\lambda = 0.004 だ。L2 を勾配に加える版では、勾配の大きい w1w_1 はほとんど減衰せず、500 ステップ走らせてもまだ 0.96 ある。勾配の小さい w2w_2 はむしろ毎ステップ約 0.002 ずつ引き下げられ、500 ステップ目には 0.28 まで落ちる。AdamW は 2 つの重みを分け隔てなく扱い、毎ステップ 0.996 を掛けるので、500 ステップ目にはどちらも 0.13 前後しか残らない。

CIFAR-10 の実験では、Adam+L2 のよい結果は、学習率と λ\lambda の平面で 1 本の斜めの線に沿って並ぶ。片方を調整すると、もう片方も合わせて調整しなければならない。AdamW のよい領域はおおむね 2 つの軸に平行で、2 つのハイパーパラメータを別々に調整でき、最高の成績も SGD に追いついた。今日 Transformer や大規模言語モデルを学習させるとき、AdamW はほぼデフォルトになっている。

学習率スケジュール

前に述べたとおり、SGD の学習率は徐々に小さくする必要がある。では、どう小さくするのか。

階段からコサインへ

最も古く、最もよく使われてきたのは階段状のやり方で、一定期間ごとに 10 で割る。ResNet-50 を学習させる定番のレシピは 90 エポック(訓練セット全体をひととおり見ることを 1 エポックという)で、30、60、80 エポック目にそれぞれ 10 で割る。欠点は、最後に割り終わるまでよいモデルが得られないことだ。いつ割るかも、自分で決めなければならない。

2016 年の SGDR は代わりにコサイン曲線を使い、最大値から最小値へ滑らかに下げる。

ηt=ηmin⁡+12(ηmax⁡−ηmin⁡)(1+cos⁡TcurTiπ)\eta_t = \eta_{\min} + \frac{1}{2}\left(\eta_{\max} - \eta_{\min}\right)\left(1 + \cos\frac{T_{\text{cur}}}{T_i}\pi\right)

TcurT_{\text{cur}} はこのサイクルで進んだ量、TiT_i はこのサイクルの長さだ。1 サイクル終わると、学習率はいきなり最大値に戻って次のサイクルを始める。これをウォームリスタート(warm restart)と呼ぶ。次のサイクルの長さは、TmultT_{\text{mult}} を掛けてどんどん延ばすこともできる。提案したのは、後に AdamW を書いたあの Loshchilov と Hutter だ。

5 つの学習率スケジュール高さは η を最大値で割ったもの。Step は Goyal らの 90 エポックのレシピ。SGDR は T₀ = 10、T_mult = 2 で計 150 エポック。ウォームアップと WSD のウォームアップはどちらも最初の 5%、WSD は最後の 10% で減衰する。
Step
100%100%
Cosine
100%100%
SGDR
100%100%
ウォームアップ+Cosine
100%100%
WSD
100%100%
Step 0Cosine 0SGDR 0ウォームアップ+Cosine 0WSD 0

図の 5 つのスケジュールは、カーソルが連動して動く。SGDR の図は T0=10T_0 = 10、Tmult=2T_{\text{mult}} = 2 で、10、30、70 エポック目にリスタートする。

リスタートは、結局広まらなかった。SGDR 自身の実験でも、CIFAR-10 の WRN-28-10 で最もよい単一モデルの 3.86% は、まったくリスタートせず 1 サイクルだけ走らせたコサインから得られている。その後の GPT-3 や LLaMA の学習設定も、どれも単一サイクルのコサインだ。残ったのはあの滑らかな曲線で、その代わり、総ステップ数を前もって知っておく必要がまた生じた。Chinchilla(DeepMind がモデルの大きさと訓練データ量の組み合わせ方を研究した論文)の実験では、コサインのサイクルが実際の学習ステップ数より 25% 以上長いと、結果がはっきり悪化した。

ゴールを先に決めたくない

コサインスケジュールでは、合計でどれだけ学習させるかを先に知っておく必要がある。しかし大規模言語モデルの学習では、途中まで進めてから、もう少し学習させるかどうかを決めることがよくある。

MiniCPM は 2024 年に、WSD(Warmup-Stable-Decay)と呼ばれる 3 段階のスケジュールを使った。最初にウォームアップ(次の節で扱う)をし、その後は学習率を長いあいだ一定に保ち、最後のおよそ 1 割の学習量でだけ下げる。下げる前に保存したチェックポイント(学習の途中で保存したモデル)からは、いつでも学習を続けられる。

Defazio らは 2024 年にさらに踏み込み、スケジュールそのものをやめてしまった。Schedule-Free は 3 組のパラメータを同時に保持する。

yt=(1−β) zt+β xtzt+1=zt−γ ∇f(yt)xt+1=(1−1t+1)xt+1t+1 zt+1\begin{aligned} y_t &= (1-\beta)\, z_t + \beta\, x_t \\ z_{t+1} &= z_t - \gamma\, \nabla f(y_t) \\ x_{t+1} &= \left(1 - \tfrac{1}{t+1}\right) x_t + \tfrac{1}{t+1}\, z_{t+1} \end{aligned}

ここでの xx、yy、zz は 3 組のパラメータで、荷物の重さ xx とは関係ない。zz はふつうの SGD で、歩幅 γ\gamma は固定だ。xx はすべての zz の平均で、最終的に使うモデルでもある。勾配は両者のあいだにある yy で計算する。過去の zz を平均することは、終点がいつも現在のステップ数についてくる線形減衰と同じ効果を持つ。

Schedule-Free:3 つの点と 1 つの平均毎回荷物を 4 個抽出、γ = 0.3、β = 0.9。z は SGD の歩みを進め、x はこれまでのすべての z の平均で、勾配は y = 0.1·z + 0.9·x で計算する。最初は x が遅れる。遠く離れていた序盤の z もまだ平均に入っているからだ。
012-1012w(1 kg あたり)b(基本料金)zxy
x(平均):最小点まで 0.007z(SGD の歩み):最小点まで 0.461y(勾配を計算する位置)

各ステップで荷物を 4 個選び、γ=0.3\gamma = 0.3、β=0.9\beta = 0.9 を使う。最初の 100 ステップあまりは、xx が zz に明らかに遅れている。すべての zz を等しく扱うので、最小点から遠く離れていた序盤の zz も平均に含まれているからだ。長く進むほど、xx は安定する。

2024 年の学習アルゴリズムのコンペティション AlgoPerf では、Schedule-Free AdamW が、外部からのハイパーパラメータ調整を認めない部門で優勝した。ベースラインより平均で約 8% 速く、その部門でベースラインに勝った唯一の提出でもあった。ただしウォームアップはやはり必要で、論文の実験の多くはウォームアップを総学習量の 5% に設定している。結局、総学習量はウォームアップを経由して入り込んでくる。

ウォームアップ

今ではほぼどの学習設定にも、最初の数千ステップは学習率をごく小さい値からゆっくり上げる、と書いてある。これをウォームアップ(warmup)と呼ぶ。なぜ最初から大きな学習率を使えないのか。

線形スケーリングとウォームアップ

ウォームアップが最初に一つのレシピとして書かれたのは、Goyal らの 2017 年の〈Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour〉だ。彼らはバッチを 256 から 8,192 に広げ、256 基の GPU で ResNet-50 を 1 時間で学習させようとした。

1 つ目のルールは線形スケーリングで、バッチを kk 倍にしたら学習率も kk 倍にする。そのためバッチ 8,192 の学習率は 3.2 になる。ところが学習の序盤はネットワークが急速に変化するので、この大きな学習率をいきなり使うと、モデルが壊れてしまう。そこで最初の 5 エポックで、学習率をもとの 0.1 から 3.2 まで線形に上げる。

ウォームアップなしでは、top-1 誤り率(最初の予測を外した割合)は 24.84% だ。一定の小さな学習率でウォームアップすると、かえって悪化して 25.88% になる。徐々に上げるウォームアップでは 23.74% で、バッチ 256 の 23.60% に追いつく。バッチが 8,192 までなら、誤り率はほとんど変わらない。16k から悪化しはじめ、32k で 27.55%、64k で 33.96% になる。

Adam はなぜウォームアップが要るのか

Adam の歩幅はおよそ α\alpha なので、理屈のうえでは勾配が大きすぎても怖くないはずだ。なのに Transformer を学習させるとき、ウォームアップなしの Adam はなぜ序盤でしばしば壊れるのか。

RAdam の著者 Liu らは 2019 年に一つの説明を示した。学習の始めには、vv はまだ勾配をいくつも見ておらず、それで推定した「勾配の大きさ」はとても不正確だ。最初のステップはもっと極端で、v^1=g12\hat v_1 = g_1^2 なので、適応的学習率 ψ=1/v^1=1/∣g1∣\psi = 1/\sqrt{\hat v_1} = 1/|g_1| はたった 1 サンプルから推定され、分散は発散さえする。

最初の数ステップの適応的学習率は当てにならない2,000 回のシミュレーションで、勾配は N(0, 1) から抽出、β₂ = 0.999。帯は各ステップの ψ = 1/√v̂ の中央 50% と 90%、線は中央値。▲ は 100 を超えたシミュレーションが少なくとも 1 回あることを示す。両軸とも対数目盛。
12481632641282560.3110100tψ = 1/√v̂最初の 4 ステップ:モーメンタムのみ1/σ = 1▲
90% の試行:0.93〜1.1最大値 1.2ρt = 245.1RAdam の修正係数 rₜ = 0.346

図は 2,000 回のシミュレーションで、勾配は標準正規分布から抽出し、β2=0.999\beta_2 = 0.999 だ。シミュレーションでは、1 ステップ目の 1/v^1/\sqrt{\hat v} の 90% が 0.50 から 14.4 のあいだに散らばり、30 倍近い開きがある。10 ステップ目には、0.73 から 1.6 まで収まっている。

RAdam は、この分散がどれだけ大きいかを推定し、修正係数 rtr_t を掛ける。最初の数ステップで分散が大きすぎるときは、適応的学習率をいっそ使わない。β2=0.999\beta_2 = 0.999 なら、最初の 4 ステップはモーメンタムだけを使い、その後 rtr_t がごく小さい値から 1 までゆっくり上がっていく。効果は、組み込みのウォームアップのようなものだ。

同じ年の 10 月、Ma と Yarats は、rtr_t がステップ数 tt と β2\beta_2 だけで決まり、データとは関係ないことを指摘した。だから RAdam はおおよそ固定長のウォームアップと同じだ。彼らが示した経験則は 2/(1−β2)2/(1-\beta_2) ステップで、β2=0.999\beta_2 = 0.999 なら 2,000 ステップになる。ImageNet 上の ResNet-50 で比べると、この長さで線形ウォームアップをしただけで、RAdam との差は 0.5 ポイント未満だった。

バッチが大きくなったら:LARS と LAMB

Goyal らのレシピはバッチ 8,192 以内ならとても安定しているが、それを超えると持ちこたえられない。16k の誤り率は 24.79%、32k は 27.55%、64k は 33.96% だ。バッチをさらに大きくすると、どんな問題にぶつかるのか。

一つの説は、大きなバッチはより鋭い谷底を見つける、というものだ。Keskar らは 2017 年、訓練セットの 10% をバッチにして学習させたモデルは谷底が鋭く、テスト正解率も低いことを観察した。この説には、後に異論が出た。Dinh らは、ReLU ネットワークのシャープネスは関数を変えずにいくらでも大きくできることを証明した。Hoffer らは、学習率をバッチの平方根に比例して大きくし、学習ステップ数を補えば、この差は消えることを見出した。

もう一つの問題は、もっと直接的だ。LARS の著者 You、Gitman、Ginsburg は、AlexNet-BN の最初のステップで各層の重みノルムと勾配ノルムを測った。両者の比 ∥w∥/∥∇L∥\lVert w\rVert/\lVert\nabla L\rVert は、最初の畳み込み層で 5.76、最初の全結合層で 1,345 と、200 倍以上の差がある。

同じ学習率でも、層ごとの動きは大違い棒は 1 回の更新でその層がどれだけ変わるか(‖Δw‖/‖w‖、対数目盛)。‖w‖ と ‖∇L‖ は LARS 論文 Table 2 の AlexNet-BN、1 回目の反復の値。アニメーションでグローバル学習率 γ を徐々に上げる。LARS の信頼係数は η = 0.001。
グローバル学習率(SGD)
10⁻⁵10⁻⁴10⁻³10⁻²10⁻¹110¹更新=重みconv1.w174%fc6.w0.74%
層ごとの信頼比(LARS)
10⁻⁵10⁻⁴10⁻³10⁻²10⁻¹110¹更新=重みconv1.w1.00%fc6.w1.00%
‖w‖/‖∇L‖:conv1.w 5.76、fc6.w 1345グローバル学習率では、conv1.w の相対変化は fc6.w の 234 倍

同じグローバル学習率のもとでは、最初の畳み込み層の各ステップの相対変化は、全結合層の 234 倍になる。学習率をある程度まで大きくすると、最初の層の更新は重みそのものより大きくなり、学習が崩れる。ところが全結合層にとっては、その学習率でもまだずっと小さい。

LARS は層ごとに専用の学習率 λl\lambda^{l} を計算し、更新量がその層の重みの大きさに比例するようにする。

λl=τ ∥wl∥∥∇L(wl)∥\lambda^{l} = \tau\, \frac{\lVert w^{l}\rVert}{\lVert\nabla L(w^{l})\rVert}

τ\tau はごく小さな信頼係数で、論文では η\eta と書いて 0.001 に取る。ここでは学習率と混同しないよう、文字を替えた。こうすると各層の相対変化がそろい、いちばん敏感な層に足を引っ張られなくなる。AlexNet はバッチ 8k のとき、LARS を使わずウォームアップだけに頼ると、学習率をどう調整しても大きくできず、top-1 正解率は最高でも 44.8% だ。LARS を使うと 58.2% に戻り、バッチ 512 の 58.7% に近づく。

LAMB は同じ層ごとのスケーリングを Adam に適用する。まず Adam のやり方でこの層の更新 rr を計算し、重み減衰 λx\lambda x を加えてから、更新全体の長さを、この層の重みの長さに比例するように置き換える。

x(l)←x(l)−η ϕ(∥x(l)∥)∥r(l)+λx(l)∥ (r(l)+λx(l))x^{(l)} \leftarrow x^{(l)} - \eta\, \frac{\phi\big(\lVert x^{(l)}\rVert\big)}{\lVert r^{(l)} + \lambda x^{(l)}\rVert}\,\big(r^{(l)} + \lambda x^{(l)}\big)

x(l)x^{(l)} は第 ll 層の重みで、ϕ\phi は重みのノルムを上限と下限のあいだに制限する関数だ。You らは 2019 年にこれを使って、BERT-Large の事前学習を、TPUv3 16 チップで 81.4 時間かかっていたところから、TPUv3 1,024 チップで 76 分にまで縮めた。バッチは第 1 段階で 64k、第 2 段階で 32k だ。

この話には続きがある。Nado らは 2021 年に Adam を調整し直し、BERT のオープンソースコードにあった 2 つの問題、つまりバイアス補正がないことと、学習率スケジュールに崖のような急落があることを直した。すると同じバッチとステップ数で、Adam は LAMB に追いつき、わずかに上回りさえした。よく調整した Nesterov モーメンタムも、MLPerf(業界の学習速度ベンチマーク)の ResNet-50 設定で LARS と並んだ。

平らな谷底を探す:SAM

Keskar らのあの観察に戻ろう。鋭い谷底は、本当に劣っているのか。

ここまでの手法はどれも、「どうすれば谷底に早く着けるか」に答えようとしてきた。Foret らは 2020 年に問いを替えた。どの谷底のほうがよいのか。

谷底が 2 つあり、一方は深くて狭く、もう一方は浅くて広いとする。訓練損失では、狭いほうが低い。しかしテストデータは訓練データといつも少し違っていて、パラメータが少しずれただけで、狭い谷の損失は急激に上がるが、広い谷はほとんど変わらない。

SAM(Sharpness-Aware Minimization)は、目的を「近くでの最悪のケース」に置き換える。

min⁡w max⁡∥ϵ∥≤ρ L(w+ϵ)\min_{w}\ \max_{\lVert\epsilon\rVert \le \rho}\ L(w + \epsilon)

ここでの ww はモデルの全パラメータを表す。ϵ\epsilon はパラメータの摂動で、前に出てきたゼロ除算を避ける ϵ\epsilon とは別物だ。ρ\rho は摂動の半径で、RMSProp の ρ\rho とも関係ない。半径 ρ\rho 以内で損失がいちばん高い点を探し、その点の損失を小さくする。内側の max は一次近似で解き、最悪の方向は勾配の方向、ϵ^=ρ ∇L/∥∇L∥\hat\epsilon = \rho\, \nabla L / \lVert\nabla L\rVert になる。だから各ステップでは、まず上り坂の方へ ϵ^\hat\epsilon だけ押し、そこで勾配を計算して、その勾配で元の位置を更新する。

ρ 以内の最悪の損失で谷底を比べる実線は損失 L、破線は距離 ρ 以内で最悪の損失で、SAM が押し下げる対象。アニメーションで ρ を徐々に広げる。各谷底の矢印は、近くで最悪の位置を指す。
0123400.511.5L狭い谷広い谷
谷底の L:狭い谷 0.33、広い谷 0.58ρ 以内の最悪:狭い谷 1.36、広い谷 0.80この基準では、広い谷の勝ち

実線は元の損失、破線は ρ\rho の範囲内で最悪の損失で、SAM が本当に押し下げようとしているものだ。ρ=0\rho = 0 では 2 本の線が重なり、狭い谷の底は 0.33 で、広い谷の 0.58 より低い。ρ\rho を 0.1 まで広げると、狭い谷の近くの最悪の損失は 0.63 に上がり、広い谷は 0.60 にとどまって、順位が入れ替わる。ρ=0.45\rho = 0.45 では、差は 1.36 対 0.80 まで広がる。SAM が変えるのは、谷底を比べる基準だ。

代償として、各ステップで勾配を 2 回計算する必要がある。ImageNet では、ResNet-152 の標準的な学習での最良の top-1 誤り率が 20.3% なのに対し、SAM は 18.4% だ。ラベルノイズがひどいときは、効果がもっとはっきりする。後に Andriushchenko と Flammarion は、ミニバッチごとに別々に摂動を加えたときにしか効かず、論文の汎化境界が描く全データ版はほとんど役に立たないことを見出した。シャープネスと汎化のあいだにどんな関係があるのかは、今も議論が続いている。

メモリが足りない:Adafactor と GaLore

Adam はパラメータ 1 つにつき、mm と vv の 2 つの数を余分に保存する必要がある。パラメータが多いと、この 2 つの状態はかなりの量になる。

7B モデルの学習メモリ(順伝播の中間結果を除く)LLaMA-7B の形状で計算(32 層、d = 4096、FFN 11008、語彙 32000)。すべて fp32 で保存し、1 GB = 10⁹ バイト。Adafactor は一次モーメントを保存しない。GaLore はアテンションと MLP の行列だけを射影し(r = 1024)、残りのパラメータは通常どおり Adam。勾配はすべてフルサイズで計上。
04080120160GBAdamWAdafactorGaLore(r = 1024)107.8 GB53.9 GB72.7 GB
パラメータ勾配オプティマイザの状態オプティマイザの状態:AdamW 53.9 GB、Adafactor 0.011 GB、GaLore 18.8 GB

LLaMA-7B の形状で計算すると、67 億個のパラメータをすべて fp32 で保存した場合、パラメータ自体が 27 GB、勾配が 27 GB、AdamW の 2 つの状態がさらに 54 GB で、合計約 108 GB になる。ここには、順伝播で残る中間結果(activation)はまだ含まれていない。

行和と列和だけを記録する

Adafactor の著者 Shazeer と Stern が目をつけたのは vv だ。n×mn \times m の重み行列なら、vv も n×mn \times m になる。彼らは各行の和 RR と各列の和 CC だけを保存し、必要なときに組み立て直す。

V^=R CΣR\hat V = \frac{R\, C}{\Sigma R}

ΣR\Sigma R はすべての行和をさらに足したもの、つまり行列全体の総和だ。これはランク 1 の行列で元の vv を近似することに等しい。ランク 1 とは、どの行も同じベクトルの定数倍にすぎない、という意味だ。保存量は nmnm から n+mn + m に下がる。

行和と列和だけ残し、残りは復元する6×8 の二次モーメント行列 V。Adafactor は行和 R = V·1 と列和 C = 1ᵀ·V だけを保存し、V の代わりに V̂ = R·C / ΣR を使う。
V(完全)RCV̂ = R·C / ΣR(復元)
保存する数:48 → 14 個V̂ の平均相対誤差:21%

6×8 の行列は、もともと 48 個の数を保存する必要があったが、今は 14 個で済む。組み立て直した行列はもちろん完全には一致せず、この例の平均相対誤差は 21% だ。それでも vv が担うのは各パラメータの歩幅のおおよその大きさを決めることだけなので、この程度の誤差の影響は限られる。WMT'14 英独翻訳では、分解の前後で BLEU(翻訳品質のスコアで、高いほどよい)は 25.6 対 25.4 だった。

Adafactor はモーメンタムも取り除き、mm すら保存しない。これが問題を起こした。モーメンタムもウォームアップもないと、BLEU は 0.1 まで落ち、学習は完全に失敗した。調べてみると、β2=0.999\beta_2 = 0.999 では vv が勾配の変化についていけず、更新量が 800 ステップ目あたりで通常の 2 倍以上に跳ね上がっていた。解決策は更新クリッピング(update clipping)で、更新全体の二乗平均平方根を 1 以内に制限し、さらに β2\beta_2 をステップ数とともにゆっくり上げる。T5 が使ったのはまさに Adafactor で、PaLM も使ったが、モーメンタムは残し、分解は外した。

小さな空間で Adam を走らせる

2024 年の GaLore は、別の角度から攻めた。著者の Zhao らは、重み行列の勾配がしばしば少数の方向に集中している、つまり低ランクであることに注目した。それなら勾配をまず小さな空間に射影し、その小さな空間で Adam を走らせてから、射影して戻せばいい。

Rt=Pt⊤Gt,G~t=α Pt NtR_t = P_t^\top G_t, \qquad \tilde G_t = \alpha\, P_t\, N_t

PtP_t は勾配の特異値分解(行列をいくつかの方向と、方向ごとの伸縮量に分解すること)から得られ、最も重要な上位 rr 個の方向を取る。NtN_t は小さな行列 RtR_t 上で Adam が計算した更新、α\alpha は GaLore 独自のスケーリング係数だ。Adam の状態は m×nm \times n ではなく、r×nr \times n だけ保存すればいい。TT ステップごとに特異値分解をやり直し、部分空間を切り替える。

小さな部分空間で Adam を走らせ、射影して戻す6×10 の勾配 G で、主要な方向がゆっくりずれていく。10 ステップごとに G の上位 2 つの左特異ベクトルから P を計算し直す。Adam の 2 つのモーメントは R = PᵀG の上にだけ持つ。折れ線グラフは、部分空間が ‖G‖² をどれだけ保っているか。
GPR = PᵀGAdam はここで更新α·P·N で 6×10 に戻す0%50%100%010203040保たれた ‖G‖² の割合
オプティマイザの状態:完全な Adam は 120 個、GaLore は 52 個(P と 2 つの r×n モーメント)現在 99% を保持

LoRA(低ランクの小さな行列の組だけを学習させるファインチューニング手法)と違い、GaLore では重み自体はフルランクのままで、制限されるのはオプティマイザの状態だけだ。C4 で LLaMA 1B を事前学習させると、GaLore のパープレキシティ(言語モデルが次のトークンについてどれだけ迷っているかを表し、低いほどよい。トークンはモデルが文章を読む基本単位)は 15.64、フルランクの学習は 15.56、LoRA は 19.21 だった。

論文の要旨は、8-bit 版なら RTX 4090 のような 24 GB のコンシューマ向け GPU で 7B モデルを事前学習できるとしている。これは 1 バッチがわずか 256 トークンのときに測ったメモリで、約 22 GB だ。実際に最後まで走らせた 7B の実験では、A100 を 64 基使っている。代償は、部分空間を切り替えるたびに特異値分解が必要になることだ。1B モデルでは、論文の見積もりで 8-bit Adam より約 17% 遅い。7B モデルの特異値分解 1 回にかかる時間は、LLaMA-Factory の実測で約 10 分、GaLore チームが後に出した GaLore 2 の論文では最大 20 分とされている。

谷を丸くする:ニュートン法、Shampoo、SOAP、Sophia

Adam がなぜたいして速くならないのか、という問題に戻ろう。同じ谷で、GD は 93 ステップ目、Adam は 87 ステップ目に到達し、ほんの少し速いだけだった。

ニュートン法

地形の形がわかっていれば、谷を直接丸くできる。ニュートン法は、ヘッセ行列の逆行列で勾配を補正する。

θt+1=θt−H−1∇L(θt)\theta_{t+1} = \theta_t - H^{-1} \nabla L(\theta_t)

二次関数なら、この一歩で最小点に直行する。見方を変えれば、H−1H^{-1} を掛けることは座標系を取り替えることに等しく、新しい座標では谷は丸く、勾配はまっすぐ谷底を指す。こうした「先に地形を丸くしてから進む」やり方を、前処理(preconditioning)と呼ぶ。

座標を変えて、谷を丸くする荷物の谷を、最小点を中心に表示。各座標系で勾配降下法(η = 0.9)を走らせてから、次の座標系へ変形する。順に、元の座標、各軸を曲率で個別に伸縮(対角)、行列 H^½ 全体で変換。
行列全体:まっすぐ到達
κ = 1.0元の座標:κ = 45.7対角スケーリング:κ = 45.6行列全体:κ = 1.0

この図は、3 つの座標系のあいだを変形していく。元の座標の条件数は 45.7 だ。座標軸に沿ってそれぞれ伸縮させるだけ、つまり対角前処理をすると、条件数は 45.6 で、ほとんど変わらない。ヘッセ行列の 2 つの対角成分が、もともと 1.09 と 1 でほぼ同じだからだ。ヘッセ行列全体で座標を変換して、はじめて条件数は 1 になる。

これが、私たちの谷で Adam がたいして速くならない理由だ。Adam、RMSProp、AdaGrad はどれもパラメータごとに別々に歩幅を決めるだけで、座標軸に沿った伸縮しかできないのと同じだ。私たちの谷の問題は「斜め」であることに尽きていて、軸に沿った伸縮では救えない。

では、なぜニュートン法をそのまま使わないのか。nn 個のパラメータを持つモデルでは、ヘッセ行列は n×nn \times n になる。パラメータが 10 億個なら、101810^{18} 個の数を保存し、さらに逆行列を求めなければならない。地形が凸でないとき(凸関数には谷が 1 つしかなく、山頂も鞍点もない)、ヘッセ行列は負の固有値を持つことがあり、ニュートン法はそのまま山頂へ向かってしまう。

Shampoo と SOAP

折衷案を見つけたのが Shampoo で、著者は Gupta、Koren、Singer だ。ニューラルネットワークのパラメータの多くは行列で、m×nm \times n の重み行列なら、完全な前処理には mn×mnmn \times mn が必要になる。Shampoo は代わりに左右 2 つの小さな行列を使い、それぞれ GG⊤GG^\top と G⊤GG^\top G を累積する。

Lt=Lt−1+GtGt⊤Rt=Rt−1+Gt⊤GtWt+1=Wt−η Lt−1/4 Gt Rt−1/4\begin{aligned} L_t &= L_{t-1} + G_t G_t^\top \\ R_t &= R_{t-1} + G_t^\top G_t \\ W_{t+1} &= W_t - \eta\, L_t^{-1/4}\, G_t\, R_t^{-1/4} \end{aligned}

Lt−1/4L_t^{-1/4} は行列の −1/4-1/4 乗で、LtL_t を固有値分解し、各固有値をその −1/4-1/4 乗に置き換えて計算する。1,024×1,024 の層なら、完全な前処理は約 1.1×10121.1 \times 10^{12} 個の要素になるが、Shampoo は約 2.1×1062.1 \times 10^{6} 個で済む。Meta が後に作った Distributed Shampoo は多くの工学的な改良を加え、2024 年の AlgoPerf で、外部からのハイパーパラメータ調整を認める部門で優勝した。NAdamW のベースラインより平均で約 28% 速かったが、8 つのワークロードのうち最速だったのは 2 つだけで、ResNet では時間予算内に目標へ届かなかった。

Shampoo は一定の間隔でしか行列の根を計算し直さず、そのあいだ前処理は丸ごと凍結される。SOAP の著者 Vyas らは、指数を 1/2 にした Shampoo が、Shampoo の固有基底で Adafactor を走らせるのと等価であることを見出した。そこで SOAP は、まず勾配を Shampoo の固有基底に移し、その座標系で Adam を走らせてから、更新を元の座標に戻す。基底は相変わらずたまにしか更新しないが、二次モーメントは毎ステップ更新する。3.6 億パラメータの言語モデルで、再計算の頻度を 1 ステップごとから 100 ステップごとまで緩めると、Shampoo の最終損失は 2.824 から 2.932 に上がり、AdamW の 2.943 に近づいてしまう。SOAP は 2.820 から 2.870 に上がるだけだ。

Sophia

Sophia は対角の道を行くが、見るのは勾配の二乗ではなく、ヘッセ行列の対角成分だ。10 ステップごとに対角ヘッセ行列 hh を推定し、座標ごとにクリッピングする。

θt+1=θt−η clip ⁣(mtmax⁡(γht, ϵ), 1)\theta_{t+1} = \theta_t - \eta\, \mathrm{clip}\!\left(\frac{m_t}{\max(\gamma h_t,\ \epsilon)},\ 1\right)

曲率が正で十分に大きければ、ニュートン法の比率で進む。曲率が負か小さすぎれば、分母は ϵ\epsilon で下支えされ、クリッピングによってこのステップは最大でも η\eta しか進まない。

曲率が負になる場所f(x) = x⁴/4 − x² + 0.6x + 2、f″ < 0 の x = 0.1 から出発。ニュートン法は山頂へ向かう。Sophia は m / max(γh, ε) を [−1, 1] にクリップする。デモ用の設定は β₁ = β₂ = 0.9、毎ステップ真の f″ を使用、γ = 1、η = 0.15(論文は β₁ = 0.96、β₂ = 0.99 で、ヘッセ行列は 10 ステップごとに推定)。
GD(η = 0.1)
f″ < 0
ニュートン法
f″ < 0
Sophia 式クリッピング
f″ < 0
GD(η = 0.1):x = -1.55ニュートン法:x = 0.32Sophia 式クリッピング:x = -1.49

この 1 次元関数は、出発点の付近で曲率が負だ。ニュートン法は局所最大値 x=0.316x = 0.316 に収束し、山頂へ向かってしまう。Sophia は負の曲率の領域で毎ステップ 0.15 ずつ進み、坂を下って谷底の近くまで行く。いちばん左のパネルの GD は傾きしか見ないので、やはり坂をずっと下り、−1.55-1.55 付近で止まる。GD はそもそも曲率を使わないので負の曲率にだまされることはないが、歩幅も曲率に合わせて調整されない。

論文の著者 Liu らは GPT-2 で、同じ損失に達するステップ数が AdamW の半分で済むと主張した。その後の独立評価では、どれもそこまで大きな差は見られなかった。Defazio は GitHub で、AdamW の学習率を上げれば 1.25 億パラメータのモデルでは互角になると指摘した。Sophia の原著者 3 人も加わった 2025 年の〈Fantastic Pretraining Optimizers〉も、5 億パラメータ以下では有意な高速化を測定できなかった。

符号だけを見る:Lion

メモリの話に戻ろう。Adam はパラメータごとに mm と vv の 2 つの状態を保存する必要がある。1 つ減らせないだろうか。

Lion は、Google の Chen らがプログラム探索で見つけたものだ。基本演算から成るプログラム空間でコンピュータに進化させ、選び出された規則は次のとおりだ。

ct=β1 mt−1+(1−β1) gtθt=θt−1−η (sign(ct)+λ θt−1)mt=β2 mt−1+(1−β2) gt\begin{aligned} c_t &= \beta_1\, m_{t-1} + (1 - \beta_1)\, g_t \\ \theta_t &= \theta_{t-1} - \eta\,\big(\mathrm{sign}(c_t) + \lambda\, \theta_{t-1}\big) \\ m_t &= \beta_2\, m_{t-1} + (1 - \beta_2)\, g_t \end{aligned}

更新方向は符号だけを取るので、各パラメータは毎ステップちょうど η\eta だけ進む。保存するのはモーメンタム mm の 1 つだけで、Adam より状態が 1 つ少ない。β1=0.9\beta_1 = 0.9 はこのステップの方向を、β2=0.99\beta_2 = 0.99 は長期のモーメンタムの記憶を受け持ち、2 つの役割が分けられている。各ステップの大きさが固定なので、Lion の学習率は AdamW より 3〜10 倍小さく、重み減衰は 3〜10 倍大きくする必要がある。

Lion は符号しか見ないどちらも「1 kg あたり 210 元+基本料金 20 元」から出発し、学習率は 200 ステップかけてコサインで下げる(ピーク:Adam 0.2、Lion 0.05)。Lion は毎ステップ、各座標をちょうど ±η 動かす。
012-1012w(1 kg あたり)b(基本料金)
最初の 40 ステップを拡大
Adam:最小点まで 0.022Lion:最小点まで 0.023現在の学習率:Adam 0.000、Lion 0.0000

Adam と Lion はどちらもコサインスケジュールで 200 ステップ進み、最後はどちらも最小点から約 0.02 の位置にいる。「最初の 40 ステップを拡大」のパネルを見ると、最初は 2 つの勾配成分の符号が同じで、Lion は各ステップで ww と bb にまったく同じだけ進み、45° の斜線に沿って前進している。

JFT で事前学習した ViT では、Lion は約 3 分の 1 の計算量で AdamW に追いつく。しかし 11 億から 75 億パラメータの言語モデルでは、パープレキシティは最初から最後まで Adafactor と差がなかった。その後のいくつかの独立評価でも、大半は AdamW と同程度という結果だった。

物差しを取り替える

sign という操作はずいぶん粗く見えるが、その裏にはすっきりした解釈がある。

「最も急な下降方向」は、長さをどう測るかで決まる。ふだん使う長さは L2 ノルムで、単位円の上で損失をいちばん大きく下げる方向は −g/∥g∥-g/\lVert g\rVert だ。これを L∞ ノルム、つまり最大の座標で測ることにすると、単位「円」は正方形になり、最も急な方向は角に落ちる。それがちょうど −sign(g)-\mathrm{sign}(g) だ。

最も急な一歩は、長さの測り方で決まる長さ 1 以下の一歩のうち、損失をいちばん速く下げる(⟨g, d⟩ が最小の)ものを選ぶ。ふつうの長さ(円)なら答えは −g/‖g‖。最大の座標で測る(正方形)と、答えはいつも角の −sign(g)。
L2 ノルム:円
g
L∞ ノルム:正方形
g
g = (0.94, 0.34)L2:(-0.94, -0.34)L∞:(-1, -1)

Bernstein と Newhouse は 2024 年の〈Old Optimizer, New Norm〉で、この見方を一般化した。指数移動平均を切れば、Adam は L∞ ノルムのもとでの最急降下になる。Shampoo から累積を外すと、ちょうどスペクトルノルムのもとでの最急降下になる。スペクトルノルムは、行列がベクトルを最大で何倍に引き伸ばせるかを測るもので、次の節の Muon はここから出発する。

重みを行列として扱う:Muon

Shampoo の系統を除けば、多くの手法は歩幅を座標ごとに決めている。パラメータを長い数字の列に広げて、一つひとつ別々に処理しているのと同じだ。しかしニューラルネットワークの重みの多くは行列だ。

重み行列の勾配は少数の方向に支配されることが多く、特異値の大きさがかけ離れている。勾配どおりに更新すると、その少数の方向は大きく変わるが、ほかの方向はほとんど動かない。Muon のやり方は、モーメンタム行列を「直交化」することだ。モーメンタム行列 MM を特異値分解して M=UΣV⊤M = U\Sigma V^\top とし、特異値をすべて 1 に置き換えて UV⊤UV^\top だけを残す。どの方向も同じだけ動く。

Keller Jordan は 2024 年 10 月から NanoGPT の学習速度を競うコンテストで Muon を使い、何度も記録を塗り替えた。ブログ記事にまとめたのは 12 月になってからだ。使うのはネットワークの中間にある 2 次元の重み行列だけで、埋め込み層、出力層、ベクトル型のパラメータには引き続き AdamW を使う。

正確な特異値分解は高くつきすぎるので、Muon は Newton–Schulz 反復で近似する。まず行列をその Frobenius ノルムで割り、すべての特異値を 0 から 1 のあいだに収めてから、次の反復を 5 回繰り返す。

X←aX+b (XX⊤)X+c (XX⊤)2XX \leftarrow aX + b\,(XX^\top)X + c\,(XX^\top)^2 X

係数は (a,b,c)=(3.4445, −4.7750, 2.0315)(a, b, c) = (3.4445,\ -4.7750,\ 2.0315) だ。

この多項式は、小さな特異値をぐんぐん押し上げ、大きな特異値を引き下げる。

5 回の Newton–Schulz 反復2×2 の更新行列を、まず Frobenius ノルムで割り、X ← aX + b(XXᵀ)X + c(XXᵀ)²X を反復する。(a, b, c) = (3.4445, −4.7750, 2.0315)。左は行列が単位円をどんな形に変えるか、右はその 2 つの特異値。
X を通した単位円
特異値
5 回後は約 0.68–1.2(本記事の計算)00.511.5σ₁σ₂
元の行列:σ₁ = 2.05、σ₂ = 0.083σ₁ = 0.940, σ₂ = 0.697

この 2×2 の行列は、もともと単位円をぺしゃんこの楕円に押しつぶすもので、特異値は 2.05 と 0.083 だ。ノルムで割ると 0.999 と 0.040 になる。5 ステップ後には 0.94 と 0.70 になり、楕円は円に近づくが、ぴったり円にはならない。Jordan はコードのコメントで、この係数は特異値をおよそ 0.5 から 1.5 のあいだに押し込むことだけを狙ったもので、その不正確さと引き換えに反復回数を減らしていると明記している。本記事で計算すると、5 ステップ後の実際の範囲は約 0.68 から 1.2 だった。

Moonshot AI は 2025 年の〈Muon is Scalable for LLM Training〉で、これを大規模モデルにまで押し広げた。彼らは重み減衰を加え、各行列の更新に 0.2max⁡(r,c)0.2\sqrt{\max(r, c)}(rr、cc は行列の行数と列数)を掛けて、更新の二乗平均平方根を 0.2 前後に固定した。これは AdamW の典型的な大きさにそろえたもので、AdamW の学習率と重み減衰をそのまま流用できる。彼らのスケーリング則の実験では、Muon は AdamW のおよそ 52% の計算量で同じ損失に達した。その後、Moonshot の Kimi K2 や DeepSeek の V4 は、どちらもパラメータの大部分に Muon を使っている。

どれがいちばん速い?

新しいオプティマイザの論文は、どれも自分が AdamW より速いことを示す図を載せている。どれが本当なのか。

AlgoPerf は、この問いにルールで答えようとしている。比べるのは「固定したハードウェアで、固定した目標に達するまでにかかる時間」だ。ワークロードは全部で 8 つ、ハードウェアは V100 8 基に固定し、2 つの部門に分かれる。一方は外部からのハイパーパラメータ調整を限定的に認め、もう一方は認めない代わりに時間予算が 3 倍だ。2024 年の第 1 回では、Distributed Shampoo と Schedule-Free AdamW がそれぞれ一方の部門で優勝した。どちらも前に紹介したとおりだ。外部からのハイパーパラメータ調整を認める部門では、同じチームの Schedule-Free が 2 位にも入っている。

言語モデルの事前学習については、Wen、Hall、Ma、Liang が 2025 年の〈Fantastic Pretraining Optimizers and Where to Find Them〉で、AdamW と 10 種類の新しいオプティマイザのハイパーパラメータをすべて丁寧に一通り調整した。彼らがまず見つけたのは、GPT-3 のレシピにある AdamW の学習率を 6e-4 から 8e-3 に変えるだけで、1.3 億パラメータのモデルでは約 2 倍速くなるということだった。多くの論文がうたう 2 倍は、調整不足の AdamW と比べたものだ。

ベースラインを調整したあとでは、Muon や SOAP のような行列型のオプティマイザは、1.3 億から 5.2 億パラメータで約 1.3〜1.4 倍速いが、12 億パラメータでは約 1.1 倍まで下がる。Lion や Sophia のような座標ごとのオプティマイザは、AdamW と大差ない。彼らは、学習途中の損失はあてにならないとも注意している。Muon は序盤に大きくリードすることが多いが、学習率が下がると AdamW と同じところに落ち着く。

さらに大きな規模では、また話が変わる。NVIDIA は 2026 年 7 月の〈SOAP, Muon, and Beyond〉で、数十億パラメータのモデルを兆単位のトークンで学習させて比較し、それでも SOAP と Muon が AdamW を上回ることを確認した。彼らの基準バッチは 1 ステップあたり約 2,500 万トークンで、これを 2〜3 倍に広げると AdamW は悪化するが、Muon は安定したままだった。元の SOAP も大きなバッチでは損失が突然跳ね上がることがあり、毎ステップ基底を直交化し直す版に変えて、ようやく持ちこたえた。2 つの結果はモデルの大きさ、データ量、バッチがどれも違うので、両方とも成り立ちうる。

最後にまとめておこう

1847 年の Cauchy のあの 3 ページから、勾配降下法の核はずっと、負の勾配に沿って進むことだった。今日ではこれを次の 1 行で書くのが習慣になっている。

θt+1=θt−η ∇L(θt)\theta_{t+1} = \theta_t - \eta\, \nabla L(\theta_t)

後の手法は、どれもこの式のどこか一か所の足りない部分を補っている。

  1. SGD、MBGD:データが多すぎるので、毎回小さなバッチだけを見る。代償はノイズで、学習率を徐々に小さくする必要がある。
  2. SGDM、NAG:谷の中で行ったり来たり跳ねるので、さっきの方向を覚えておいて打ち消し合わせる。NAG はさらに一歩早くブレーキをかける。
  3. AdaGrad、RMSProp、Adam:すべてのパラメータが 1 つの歩幅を共有するのは理にかなわないので、パラメータごとに歩幅を変える。RMSProp は忘れることを覚え、Adam はモーメンタムとバイアス補正をまとめて取り込んだ。
  4. AMSGrad、AdamW:Adam が大きな勾配を忘れる問題と、重み減衰が縮められる問題を直す。
  5. コサイン、WSD、Schedule-Free、ウォームアップ:学習率を時間とともにどう変えるか、終点を前もって知らずに済ませられるか、そして最初になぜゆっくり加速するのか。
  6. LARS、LAMB:バッチが大きくなったら、層ごとに歩幅を調整する。
  7. SAM:低い谷底だけでなく、平らな谷底も探す。
  8. Adafactor、GaLore、Lion:状態が多すぎてメモリが足りないので、保存するものを減らす。
  9. Shampoo、SOAP、Sophia、Muon:地形の形を推定するか、一歩の長さを測る物差しを取り替える。

今日モデルを一つ学習させるなら、AdamW にウォームアップと、コサインか WSD のスケジュールを組み合わせるのが、今も最も堅実な出発点だ。モデルが十分に大きく、重み行列が十分に多ければ、Muon や SOAP は試す価値がある。どれを選ぶにしても、まず学習率をきちんと調整しよう。

次に、2 倍速いとうたう新しいオプティマイザを見かけたら、まずひと言聞いてみよう。「AdamW の学習率、調整した?」