HN 日本語サマリー

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

loss.backward() が実際に行っていること

What loss.backward() actually does (oraziorillo.com)

9 pointsby oraziorillo3 コメント

要約

このブログ記事は、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つはエンジンのすべての操作で同じように起こります。

  1. 操作 v1->data * v2->data の結果が計算され、新しいノードに格納されます。
  2. オペランドが prev に記録されます。
  3. 結果のノードは、それを生成した操作(この場合は 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. グラフのトポロジカル順序を構築します。これにより、各ノードが依存するノードの後に配置されます。自然に、損失はグラフの出力ノードになります。
  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 は、その一歩に近づくための私の試みでした。