loss.backward() が実際に行っていること
What loss.backward() actually does (oraziorillo.com)
要約
このブログ記事は、PyTorchのような深層学習フレームワークにおける `loss.backward()` の内部メカニズムを解説しています。ニューラルネットワークの訓練において、損失関数(loss)の勾配を計算するために、計算グラフを逆方向にたどる逆伝播(バックプロパゲーション)の原理を、簡単な例とカスタム自動微分エンジン「micrograd」を用いて説明しています。これにより、多数のパラメータに対する勾配を効率的に計算する方法を理解できます。
全文翻訳
loss.backward() が実際に行っていること
ニューラルネットワークをトレーニングしたことがあるなら、内部で何が起こっているのか正確には説明できないまま loss.backward() と入力したことがあるでしょう。この記事の終わりまでには、PyTorchのようなエンジンの背後にあるコアメカニズムを、自分で書けるくらい十分に理解できるようになります。
実践的な理解のために、最近私が書いたスカラー値自動微分エンジンである microcrad を頻繁に参照します。これは Andrej Karpathy の micrograd に触発されたものです。
理解のためにC言語を知っている必要はありません。簡単なコードが読めて、ニューラルネットワークと微積分に関する基本的な知識があれば大丈夫です。
そもそも何を計算しているのか?
ニューラルネットワークのトレーニングとは、損失を最小化することです。損失とは、現在のネットワークがどれだけ間違っているかを示す単一の数値です。勾配降下法でこれを最小化します。つまり、損失が減少する方向に各パラメータを少しずつ調整し、それを繰り返します。そのためには、各パラメータ p について、以下のことを知る必要があります。
pをわずかに動かすと、損失はどれだけ、どの方向に変化するか?
その量が微分係数 dLoss/dp です。すべてのパラメータについてこれを計算し、その逆方向に小さなステップを踏み出せば、学習の1ステップが完了します。
p->data -= learning_rate * p->grad; /* 勾配降下の一歩 */
したがって、問題全体は一つの質問に集約されます。すべての p について、一度に dLoss/dp をどのように取得するか? 実際のネットワークには数千から数兆のパラメータがありますが、損失は一つです。その形状 — 多数の入力、一つの出力 — を覚えておいてください。なぜなら、後述するすべてがその通りに機能する理由だからです。
一度に一つの操作:局所微分と連鎖律
巨大なネットワーク全体の微分を知る必要はありません。個々の操作の微分を、それぞれ独立に知るだけで十分です。この記事で使い続ける2つの操作について見てみましょう。
- 加算
a+bについて:aを1だけ増やせば、結果は1だけ増えます。したがって∂(a+b)/∂a = 1です。 - 乗算
a・bについて:aを動かすと、結果はbだけ変化します。したがって∂(a・b)/∂a = bです — もう一方のオペランドです。
減算、双曲線正接関数など、他のすべての演算子も同様に機能します。簡単にするために、ここでは加算と乗算のみを示し、他はこれら2つのバリエーションとします。
これらは局所微分です。つまり、他の入力を固定した状態で、ある操作の出力をその直接の入力の1つを動かしたときにどのように変化するかを示します。
興味深いのは、それらを繋ぎ合わせること、それが連鎖律です。z が y に依存し、y が x に依存する場合、次のようになります。
dz/dx = dz/dy * dy/dx
微分は、パスに沿って乗算することで合成されます。遠く離れた z に x がどのように影響するかを知るには、z から x まで逆方向にパスをたどり、通過する局所微分を掛け合わせます。それがバックプロパゲーションの原動力です。
もう一つ重要な点があります。x が複数のパスを通って z に到達する場合、それらの寄与は加算されます。
dz/dx = (dz/dx)path 1 + (dz/dx)path 2 + ...
例題
この記事全体で使う例を以下に示します。
Value *a = value_create_leaf(2.0);
Value *b = value_create_leaf(3.0);
Value *e = value_mul(a, b); /* e = a * b = 6 */
Value *L = value_mul(e, a); /* L = e * a = 12 */
Value は microcrad の唯一の基本的な型です — 単一の倍精度浮動小数点数をラップします。関数の正確な名前は一旦無視して、数学を読んでください。まず e = a * b を計算し、次に L = e * a を計算します。代入すると、L = a * b * a = a^2 * b となります。a = 2、b = 3 の場合、L = 12 です。
a が2回使用されていることに注意してください — 一度は e を作るために、もう一度は直接 L のためにです。これは上記の複数パスの場合であり、4行のコードに隠れています。手計算で L を微分してみましょう。
dL/da と dL/db を求めたいです。出力から始めて逆方向に連鎖させます。
L = e * aなので、局所微分は∂(e*a)/∂e = a = 2と∂(e*a)/∂a = e = 6です。e = a * bなので、∂e/∂a = b = 3と∂e/∂b = a = 2です。
次に連鎖律でそれらを組み立てます。b は簡単です — e を通してのみ L に到達します。
dL/db = dL/de * ∂e/∂b = a * a = 2 * 2 = 4
a は興味深いケースです — 2つのパスを通って L に到達するため、それらを加算します。
dL/da = (dL/de * ∂e/∂a) + (∂L/∂a)directly = a * b + e = 2 * 3 + 6 = 12
e を通るパスからの6と、直接のパスからの6を合わせて、合計12です。
なぜ逆方向に進むのか
これで微分を計算するためのすべてのピースが揃いました。しかし、どのように計算するかが非常に重要です。
連鎖律を適用するには2つの方向があります。
順方向(Forward)。一つの入力、例えば a を選び、その影響をグラフを通して順方向に伝播させます。de/da を計算し、次に dL/da を計算します。1回のスキャンで、すべての a に対する微分が得られます。しかし、a についてしか学べませんでした。b についても知るには、もう一度全体のスキャンを行う必要があります。入力ごとに1回のスキャンです。
逆方向(Backward)。出力 L から開始し、dL/dL = 1 でシードし、逆方向に入力に向かって影響を伝播させます。1回のスキャンで、dL/de、dL/da、dL/db — すべてに対する出力の微分 — が埋められます。1回のスキャンで、すべての入力です。
ここで、問題の形状を思い出してください — 多数のパラメータ、一つの損失です。順方向モードはパラメータごとに1回のスキャンが必要となり、パラメータが百万個ある場合は壊滅的です。逆方向モードは1回のスキャンで済み、すべてのパラメータの勾配を一度に提供します。この非対称性が、ニューラルネットワークが学習可能であることの唯一の理由です。
これは逆モード自動微分であり、「バックプロパゲーション」は単にMLの世界でのその名前です。microcrad がグラフ構築後に行うことはすべて、単一の逆方向スキャンです。
ノードの勾配が後続のノードにフィードされる前に、その勾配が完了している必要があることに注意してください。例えば、dL/da を見てみましょう。e を通るパスと直接のパスの両方が寄与を統合するまで、それは完了しませんでした。ノードが間違った順序で訪問されると、半加算された勾配を伝播させてしまいます。これを避けるために、グラフをソートします。これにより、各ノードが依存するノードの後にリストに配置され、次にリストを逆順にウォークします。これが逆トポロジカル順序であり、バックプロパゲーションアルゴリズムに従った逆方向パスの最初のステップです。
グラフは自己構築される
したがって、逆方向パスにはグラフが必要です — どの操作がどのオペランドからどの値を生み出したかの記録です。しかし、そのグラフを明示的に構築することはありません。順方向計算を行うだけで、グラフは副作用として自然に生成されます。
秘密は、Value が単なる数値ではないことです。それは、どこから来たかを覚えている数値です。
typedef struct Value {
double data; /* このノードが持つスカラー値 */
double grad; /* dLoss/dThisValue, 逆方向パスで埋められる */
struct Value **prev; /* オペランド (グラフ内の前のノード) */
int32_t op_code; /* このValueを生み出した操作コード */
/* メモリ管理フィールドは省略 */
} Value;
操作によって生成された Value は、prev を通して計算元のオペランドを指し、op_code で自身をタグ付けします。任意のノードからこれらの prev ポインタをたどると、計算グラフを逆方向にウォークすることになります。
しかし、ノードはどのように配線されるのでしょうか? 単一の操作が何をするかを見てみましょう。乗算の例です(エラー処理は省略しています)。
Value *value_mul(Value *v1, Value *v2) {
Value **prev = malloc(2 * sizeof(Value *));
prev[0] = v1; value_retain(v1);
prev[1] = v2; value_retain(v2);
Value *result = value_create(v1->data * v2->data, 2, prev);
result->op_code = MUL_OP_CODE;
return result;
}
3つのことが起こり、これら3つはエンジンのすべての操作で同じように起こります。
- 操作
v1->data * v2->dataの結果が計算され、新しいノードに格納されます。 - オペランドが
prevに記録されます。 - 結果のノードは、それを生成した操作(この場合は
MUL_OP_CODE)でタグ付けされます。これにより、逆方向パスは後でどの微分ルールを適用すべきかを知ることができます。
(2つの value_retain 呼び出しは、Cのメモリ管理のためのブックキーピングです。今は無視してください。後で戻ります。)
したがって、例の4行を書いたとき、単に 12 を計算しただけではありません。各操作は、その入力を指すノードを静かに残し、L を手にしたときには、L がどのように生成されたかの全履歴を記録したグラフのルートも保持していました。
a = 2
b = 3
e = a * b = 6
L = e * a = 12
a をよく見てください。これは、e への矢印と、直接 L への矢印の2つの矢印が出ている単一のノードです。その分岐は、手計算で微分した「2つのパス」と全く同じであり、dL/da に2つの寄与が加算される理由です。その履歴は、逆方向パスが必要とするすべてです。
逆方向パス、コードで
value_backward は、私たちが推論した2つのステップを正確に行います。
- グラフのトポロジカル順序を構築します。これにより、各ノードが依存するノードの後に配置されます。自然に、損失はグラフの出力ノードになります。
- 出力の勾配を
1でシードし、リストを逆順にウォークして、ノードごとに1つの局所微分ルールを適用します。
ステップ2は操作コードに対する単一の switch です。完全版にはさらに多くのケースがありますが、重要なのは形状であり、カタログではありません。
v->grad = 1;
/* インデックス0の手前で停止: topo->data[0] は常にリーフ — 伝播するものは何もない */
for (size_t i = topo->size - 1; i != 0; i--) {
Value *node = topo->data[i];
switch (node->op_code) {
case ADD_OP_CODE:
for (uint32_t j = 0; j < node->n_prevs; j++)
node->prev[j]->grad += node->grad;
break;
case MUL_OP_CODE:
for (uint32_t j = 0; j < node->n_prevs; j++)
node->prev[j]->grad += node->grad * node->prev[1-j]->data;
break;
/* ... 他のオペレーションも同様のパターン ... */
}
}
各ケースは、同じ高レベルのことを行います。ノードにある勾配 (node->grad) を取得し、操作の局所ルールで乗算し、結果をオペランドに累積します。
- 加算 (
a+b):局所微分は1なので、勾配はそのまま変更されずに通過します。 - 乗算 (
a・b):一方のオペランドに対する局所微分は、もう一方のオペランドです。
動作の確認
例を実際のエンジンに流し込み、手計算で求めた勾配を要求してみましょう。
Value *a = value_create_leaf(2.0);
Value *b = value_create_leaf(3.0);
Value *e = value_mul(a, b); /* e = a * b = 6 */
Value *L = value_mul(e, a); /* L = e * a = 12 */
value_backward(L); /* すべての grad フィールドを埋める */
printf("dL/de = %f\n", e->grad);
printf("dL/da = %f\n", a->grad);
printf("dL/db = %f\n", b->grad);
microcrad に対してコンパイルして実行すると、次のようになります。
dL/de = 2.000000
dL/da = 12.000000
dL/db = 4.000000
dL/da = 12 と dL/db = 4 — ペンと紙で求めたものと全く同じです。12に注目してください。これは、e を通るパスからの6と、直接のパスからの6が合計されたものです。
Python が隠していること
value_retain 呼び出しに戻ると約束しました。Python では、グラフを構築し、backward を呼び出し、ガベージコレクタにクリーンアップを任せます。C にはコレクタがなく、計算グラフはポインタの絡み合いなので、同じ重みが数千のノードのオペランドになる可能性があります。
microcrad はこれを参照カウントで処理します。各 Value は、どれだけのものがそれを指しているかをカウントし、各操作はオペランドを保持し、カウントがゼロになるとノードは自身を解放し、順番にオペランドを解放します。グラフのルートを解放すると、すべてが連鎖的に解放され、他の何も保持していない中間体だけが解放され、重みは生き残ります。これは満足のいく特性ですが、バックプロパゲーションとはほとんど関係がないため、「グラフがリークするのを防ぐもの」として安全に分類できます。詳細は リポジトリ の README にあります。
それだけです
これが全体のアイデアです。学習にするには、ループで囲みます。Value ベースのニューロンは、w・x + b の上にアクティベーションを計算します。ニューロンを層に、層をニューラルネットワークに積み重ねると、すべての重みが Value であるため、順方向パスは自動的にバックプロパゲーションできるグラフを構築します。その後、各トレーニングステップは同じ4つの移動になります。
for (size_t i = 0; i < params->size; i++) /* 1. 古い勾配をゼロにする */
vector_get(params, i)->grad = 0.0;
value_backward(loss); /* 2. バックプロパゲーション: すべての勾配を埋める */
for (size_t i = 0; i < params->size; i++) {
Value *p = vector_get(params, i);
p->data -= learning_rate * p->grad; /* 3. 勾配に対してステップを踏む */
}
/* 4. グラフを解放して繰り返す */
これが、おもちゃの回帰から GPT まで、すべてをトレーニングするループ全体です。テンソルは大きくなり、ハードウェアはより洗練されますが、4つのステップは変わりません。microcrad は、y = max(0, x1 + x2) を学習する小さなネットワークをトレーニングする小さな例を提供します。make example_toy_regression を実行して、損失が減少するのを見てください。
次のステップ
ここまで読んだなら、loss.backward() が何をするか(ほぼ)正確にわかっています。それは、順方向パスの副作用としてグラフを構築し、すべてのノードが依存関係の後に来るようにソートし、逆順にウォークして、+= を使用して各ノードの勾配をオペランドに散布し、多変数連鎖律を静かに実装します。
それを定着させる最良の方法は、読むのをやめて、自分で別のオペレーション(例えばシグモイド)を実装することです。リポジトリをフォークし、順方向オペレーションを追加し、switch に1つの case を追加し、L = a^2 * b のようにペンで勾配を確認してください。
ギャップについて明確にしておきます。microcrad はスカラーのみ、数個のオペレーション、CPUのみです。PyTorch がその上に加えるもの — テンソル、GPUカーネル、数百のオペレーション — は、エンジニアリングの山です。しかし、バックプロパゲーションの数学は、実際に見えるほど単純です。「PyTorch を使える」と「(PyTorch の小さな基本的な部分を)実装できる」との間にある唯一のものは、座って一度書いてみることです。 microcrad は、その一歩に近づくための私の試みでした。