メインコンテンツへスキップ
見出し画像

第16回 勾配消失 ―― 深い網はなぜ学べなかったか

    連載「手を動かす機械学習 ―― 数式とPythonで仕組みから」 第16回
    ← 前 第15回 多層パーセプトロンと誤差逆伝播法 / 次 → 第17回 制限付きボルツマンマシン ―― エネルギーで確率を書き、サンプリングで学ぶ
    連載トップ(目次)


    この回で持ち帰ってほしいこと

    • 逆伝播では、層を1つさかのぼるたびに「活性化関数の微分 × 重み」が掛かる。シグモイドの微分は最大でも 1/4 なので、20層のシグモイドの網では入力側の勾配が出力側の約 10−1210^{-12} 倍になった(1層あたり約 0.23 倍)

    • 掛け算なので、係数が1より大きければ逆に勾配爆発が起こる。tanh の網で重みを Xavier の初期化の 0.5 倍にすると勾配は層ごとに約半分、4 倍にすると約 1.5 倍になる。30層さかのぼると、前者は約 2×10−92 \times 10^{-9} 倍、後者は約20万倍

    • 対策の筋は「係数を1付近に保つ」こと。ReLU(正の側で微分が1)、Xavier / He の初期化(重みの分散を入力の数 nn に合わせて 1/n1/n・2/n2/n にする)、バッチ正規化、残差接続。20層のシグモイドの網は学習できなかったが、残差接続を足すとテスト正解率 0.956 まで学習した

    • 勾配クリッピングは爆発への安全弁。学習率が大きめで発散(NaN)した設定が、勾配のノルムの上限を 1 にすると最後まで学習した


    1. 深い網は、長いあいだ学べなかった

    第15回では、多層パーセプトロン(MLP)の勾配を誤差逆伝播法で求めました。
    逆伝播の式はどの深さでも同じ形なので、層をいくらでも重ねて学習できそうに見えます。
    ところが、1990年代から2000年代の半ばまで、何層も重ねた網を勾配法だけでうまく学習させるのは難しいとされていました。

    その理由を最初にはっきり分析したのが、Hochreiter の1991年の卒業論文(ドイツ語)と、Bengio・Simard・Frasconi の1994年の論文です。
    どちらも主な対象は、時間方向に同じ層を何度も通す再帰型ニューラルネットワーク(RNN)でした。
    誤差の信号は、層(時刻)をさかのぼるたびに同じような係数を掛けられるので、指数関数的に小さくなるか、大きくなるかのどちらかになりやすい。
    これが勾配消失(vanishing gradient)と勾配爆発(exploding gradient)です。
    同じことは、層を深く重ねた全結合の網でも起こります。

    第15回の最後に、10層の網で入力側の勾配が出力側より何桁も小さくなる例を見ました。
    この回はそこから出発して、なぜ縮むのか、どれくらい縮むのか、どうすれば縮まないのかを、PyTorch で実際に測りながら確かめます。


    2. 逆伝播は掛け算の連鎖 ―― シグモイドの微分は最大 1/4

    第15回と同じ記号で、第 ll 層を Zl=Al−1Wl+blZ_l = A_{l-1} W_l + b_l、Al=ϕ(Zl)A_l = \phi(Z_l) と書きます(ϕ\phi は活性化関数)。
    損失 LL の ZlZ_l についての勾配を Δl=∂L/∂Zl\Delta_l = \partial L / \partial Z_l とすると、逆伝播は次の漸化式でした。

    Δl=(Δl+1Wl+1⊤)⊙ϕ′(Zl)\Delta_l = \left( \Delta_{l+1} W_{l+1}^\top \right) \odot \phi'(Z_l)

    ⊙\odot は要素ごとの積です。重みの勾配は ∂L/∂Wl=Al−1⊤Δl\partial L / \partial W_l = A_{l-1}^\top \Delta_l なので、Δl\Delta_l が小さくなれば、その層の重みの勾配も小さくなります。

    いちばん単純な、各層にユニットが1つしかない網で考えます。zl=wlal−1+blz_l = w_l a_{l-1} + b_l、al=ϕ(zl)a_l = \phi(z_l) とすると、漸化式は δl=δl+1 wl+1 ϕ′(zl)\delta_l = \delta_{l+1} \thinspace w_{l+1} \thinspace \phi'(z_l) で、これを繰り返すと

    δ1=δL∏l=1L−1wl+1 ϕ′(zl)\delta_1 = \delta_L \prod_{l=1}^{L-1} w_{l+1} \thinspace \phi'(z_l)

    になります。勾配は「重み × 活性化関数の微分」の積です。
    各項の大きさが1より小さければ、層の数 LL に対して指数関数的に 0 に近づき、1より大きければ指数関数的に大きくなります。
    足し算ではなく掛け算であることが、この問題の根です。

    では、活性化関数の微分はどれくらいの大きさでしょうか。
    シグモイド σ(x)=1/(1+e−x)\sigma(x) = 1/(1 + e^{-x}) の微分は σ′(x)=σ(x)(1−σ(x))\sigma'(x) = \sigma(x)(1 - \sigma(x)) です。
    σ(x)\sigma(x) は 0 と 1 の間の値なので、s(1−s)s(1 - s) が最大になるのは s=1/2s = 1/2、つまり x=0x = 0 のときで、最大値は 1/2×1/2=1/41/2 \times 1/2 = 1/4 です。
    tanh の微分は 1−tanh⁡2(x)1 - \tanh^2(x) で、最大値は x=0x = 0 での 1 です。

    import numpy as np
    
    x = np.linspace(-10, 10, 200001)
    s = 1 / (1 + np.exp(-x))
    d_sig = s * (1 - s)                 # シグモイドの微分 σ'(x) = σ(x)(1 - σ(x))
    d_tanh = 1 - np.tanh(x) ** 2        # tanh の微分
    print(f"σ'(x) の最大値 {d_sig.max():.4f}(x = {x[d_sig.argmax()]:.1f})")
    print(f"tanh'(x) の最大値 {d_tanh.max():.4f}(x = {x[d_tanh.argmax()]:.1f})")
    for v in [1, 2, 5]:
        sv = 1 / (1 + np.exp(-v))
        print(f"x = {v}:  σ'(x) = {sv * (1 - sv):.4f}"
              f"   tanh'(x) = {1 - np.tanh(v) ** 2:.4f}")
    for L in [5, 10, 20]:
        print(f"0.25 の {L} 乗 = {0.25 ** L:.2e}")
    σ'(x) の最大値 0.2500(x = 0.0)
    tanh'(x) の最大値 1.0000(x = 0.0)
    x = 1:  σ'(x) = 0.1966   tanh'(x) = 0.4200
    x = 2:  σ'(x) = 0.1050   tanh'(x) = 0.0707
    x = 5:  σ'(x) = 0.0066   tanh'(x) = 0.0002
    0.25 の 5 乗 = 9.77e-04
    0.25 の 10 乗 = 9.54e-07
    0.25 の 20 乗 = 9.09e-13
    画像

    図1:青が活性化関数、赤の破線がその微分。シグモイドの微分は最大 0.25、tanh は最大 1、ReLU は正の側でつねに 1。

    シグモイドでは、入力がちょうど 0 のいちばん良い場合でも、1層通るごとに勾配が 1/41/4 倍になります。
    重みが 1 程度なら、10層で約 10−610^{-6}、20層で約 10−1210^{-12} です。
    さらに入力の絶対値が大きくなると微分は急に小さくなり、x=5x = 5 では 0.0066 しかありません。
    このように関数が平らになって微分がほぼ 0 になる状態を飽和と呼びます。

    tanh は最大値が 1 なので、入力が 0 付近にあれば勾配を縮めません。
    ただし tanh⁡(x)=2σ(2x)−1\tanh(x) = 2\sigma(2x) - 1 なので、tanh はシグモイドを横に半分に縮めた形で、飽和もシグモイドより早く始まります。
    x=2x = 2 では tanh⁡′(2)=0.0707\tanh'(2) = 0.0707 で、シグモイドの 0.1050 より小さくなっています。
    tanh が有利なのは「入力が 0 付近に保たれていれば」という条件つきで、その条件を保つのが第6節の初期化の役目です。

    ちなみに、単純パーセプトロンのステップ関数は、0 以外のすべての点で微分が 0 なので、逆伝播では勾配がまったく伝わりません。
    なめらかなシグモイドに置き換えたことで誤差逆伝播法が使えるようになりましたが、そのシグモイドの微分の小ささが、今度は深い網での勾配消失の原因になったわけです。


    3. 20層の網で、層ごとの勾配を測る

    式の上の話を、実際の網で確かめます。
    幅100の全結合層を20枚重ね、最後に10クラスの出力層を置きます。
    入力(64次元の標準正規乱数、256サンプル)とラベルはランダムに作り、学習はせずに、初期状態で1回だけ逆伝播して、各層の重みの勾配のノルム ∥∂L/∂Wl∥\lVert \partial L / \partial W_l \rVert を測ります。
    重みの初期化は、それぞれの活性化関数で推奨される方法(シグモイドと tanh は Xavier、ReLU は He。中身は第6節)にそろえます。
    こうしておくと、差は活性化関数の違いから来ていると言えます。

    import torch
    import torch.nn as nn
    
    def make_mlp(act, depth=20, width=100, d_in=64, n_cls=10, init="xavier",
                 gain=1.0):
        """全結合の深い網。init は 'xavier'(Glorot)か 'he'(Kaiming)。
        gain で重みの大きさを何倍かにする"""
        layers, d = [], d_in
        for _ in range(depth):
            lin = nn.Linear(d, width)
            if init == "xavier":
                nn.init.xavier_normal_(lin.weight)
            else:
                nn.init.kaiming_normal_(lin.weight, nonlinearity="relu")
            with torch.no_grad():
                lin.weight.mul_(gain)
            nn.init.zeros_(lin.bias)
            layers += [lin, act()]
            d = width
        layers.append(nn.Linear(d, n_cls))
        return nn.Sequential(*layers)
    
    def layer_grad_norms(model, X, y):
        """1回の逆伝播で、各層の重みの勾配のノルム(フロベニウス)を返す。
        最後の出力層は除く"""
        model.zero_grad()
        nn.functional.cross_entropy(model(X), y).backward()
        return [m.weight.grad.norm().item()
                for m in model if isinstance(m, nn.Linear)][:-1]
    
    torch.manual_seed(0)
    X = torch.randn(256, 64)
    y = torch.randint(0, 10, (256,))
    for name, act, init in [("sigmoid", nn.Sigmoid, "xavier"),
                            ("tanh", nn.Tanh, "xavier"), ("ReLU", nn.ReLU, "he")]:
        torch.manual_seed(1)
        g = layer_grad_norms(make_mlp(act, init=init), X, y)
        # 比 = 第1層 / 第20層
        print(f"{name:8s} 第1層 {g[0]:.2e}  第10層 {g[9]:.2e}"
              f"  第20層 {g[19]:.2e}  比 {g[0] / g[19]:.1e}")
    sigmoid  第1層 5.90e-14  第10層 2.76e-08  第20層 5.87e-02  比 1.0e-12
    tanh     第1層 4.59e-02  第10層 4.80e-02  第20層 4.99e-02  比 9.2e-01
    ReLU     第1層 1.25e-01  第10層 1.57e-01  第20層 1.44e-01  比 8.7e-01
    画像

    図2:20層の MLP の学習前の、各層の重みの勾配のノルム(縦軸は対数目盛り)。右が出力に近い層。赤がシグモイド、青が tanh、緑が ReLU。

    シグモイドの網では、出力側の第20層の勾配 5.87×10−25.87 \times 10^{-2} に対して、入力側の第1層は 5.90×10−145.90 \times 10^{-14} で、比はちょうど 10−1210^{-12} です。
    図2の赤い線は対数目盛りでほぼ直線なので、層ごとに一定の割合で縮んでいます。
    19層で 10−1210^{-12} 倍ということは、1層あたり (10−12)1/19≈0.23(10^{-12})^{1/19} \approx 0.23 倍で、第2節の上限 1/41/4 にほぼ張りついています。
    Xavier の初期化は重みの大きさを「1層通っても信号の大きさが変わらない」ように選ぶので、残った縮みはほとんどシグモイドの微分の分です。

    この状態で勾配法を使うと、第20層の重みが 1 動くあいだに、第1層の重みは 10−1210^{-12} しか動きません。
    入力に近い層は、初期化したときの乱数のまま、事実上まったく学習されないことになります。

    一方、tanh と ReLU では、第1層と第20層の比が 0.92 倍・0.87 倍で、20層を通っても勾配の大きさがほぼ保たれています。
    tanh は入力が 0 付近にあるかぎり微分が 1 に近く、ReLU は正の側で微分がちょうど 1 だからです。


    4. 重みの大きさ ―― 消失の裏返しの「爆発」

    第2節の積 ∏wl+1ϕ′(zl)\prod w_{l+1} \phi'(z_l) には、微分だけでなく重みも入っています。
    活性化関数の微分が 1 に近くても、重みが小さすぎれば勾配は消え、大きすぎれば爆発します。

    これを確かめるため、tanh の30層の網で、Xavier の初期化の重みを gain 倍(0.5, 1, 2, 4 倍)にして比べます。
    今度は重みの勾配ではなく、各層の出力 AlA_l についての勾配 ∂L/∂Al\partial L / \partial A_l の大きさ(サンプルごとのノルムの平均)を測ります。
    逆伝播で層から層へ受け渡される信号そのもので、伝わり方が見やすいからです。

    # 第3節のコードの続き(make_mlp を使う)
    def signal_norms(model, X, y):
        """各層の出力 a^l の大きさ(前向き)と、
        損失の a^l についての勾配 ∂L/∂a^l の大きさ(後ろ向き)"""
        outs, h = [], X
        for m in model:
            h = m(h)
            if not isinstance(m, nn.Linear):  # 活性化関数の出力 a^l を覚えておく
                h.retain_grad()
                outs.append(h)
        nn.functional.cross_entropy(h, y).backward()
        fwd = [o.norm(dim=1).mean().item() for o in outs]
        bwd = [o.grad.norm(dim=1).mean().item() for o in outs]
        return fwd, bwd
    
    torch.manual_seed(0)
    X = torch.randn(256, 64)
    y = torch.randint(0, 10, (256,))
    print("tanh・30層。Xavier 初期化の重みを gain 倍する")
    print("        ∂L/∂a の大きさ(第30層 → 第1層)  前向き a の大きさ")
    print("gain    第30層   第15層    第1層             第30層")
    for gain in [0.5, 1.0, 2.0, 4.0]:
        torch.manual_seed(1)
        model = make_mlp(nn.Tanh, depth=30, init="xavier", gain=gain)
        fwd, bwd = signal_norms(model, X, y)
        print(f"{gain:4.1f}   {bwd[29]:.1e}  {bwd[14]:.1e}  {bwd[0]:.1e}"
              f"            {fwd[29]:.1e}")
    tanh・30層。Xavier 初期化の重みを gain 倍する
            ∂L/∂a の大きさ(第30層 → 第1層)  前向き a の大きさ
    gain    第30層   第15層    第1層             第30層
     0.5   2.2e-03  8.2e-08  4.3e-12            6.2e-09
     1.0   2.2e-03  1.9e-03  6.1e-04            1.3e+00
     2.0   2.2e-03  2.2e-02  1.7e-01            7.3e+00
     4.0   2.2e-03  1.2e+00  4.8e+02            8.9e+00
    画像

    図3:tanh の30層の網で、各層の出力についての勾配 ∥∂L/∂Al∥\lVert \partial L / \partial A_l \rVert(対数目盛り)。逆伝播は右(第30層)から左(第1層)へ進む。gain は Xavier の初期化に掛けた倍率。

    出発点の第30層の値(2.2×10−32.2 \times 10^{-3})はどの gain でも同じですが、左へ進むにつれて大きく分かれます。

    • gain 0.5:1層ごとに約 0.50 倍に縮み、第1層では 4.3×10−124.3 \times 10^{-12}。勾配消失です。前向きの信号も第30層で 6.2×10−96.2 \times 10^{-9} まで縮み、出力は入力にほとんど依存しません

    • gain 1:第1層でも 6.1×10−46.1 \times 10^{-4} で、30層を通って縮んだのは4分の1程度

    • gain 2・4:逆に入力側へ行くほど大きくなります。gain 4 では1層ごとに約 1.5 倍、第1層では 4.8×1024.8 \times 10^2 と、出発点の約20万倍です。勾配爆発です

    gain 4 の網で注目してほしいのは、前向きの値は大きくなっていないことです。
    tanh の出力は −1-1 から 11 の間なので、幅100の層の出力のノルムは最大でも 10 で、実際 8.9 と、ほとんどのユニットが飽和しています。
    飽和したユニットの微分は小さいのに、それを上回るほど重みが大きいので、逆伝播の信号は爆発します。
    前向きの値が穏やかでも、勾配が爆発することはあるわけです。

    勾配が爆発すると、1回の更新で重みが大きく飛び、損失が跳ね上がったり、数値があふれて NaN になったりします。
    勾配消失と勾配爆発は、同じ「掛け算の連鎖」の表と裏です。


    5. ReLU に置き換える

    第2節の積で、活性化関数の側の係数を 1 にしてしまうのが ReLU、ReLU(x)=max⁡(0,x)\mathrm{ReLU}(x) = \max(0, x) です。
    正の側では微分がちょうど 1 なので、どんなに入力が大きくても飽和しません。
    図2の緑の線のように、適切に初期化した ReLU の網では、20層を通っても勾配の大きさが保たれます。

    ReLU はニューラルネットワークの活性化関数として、2010年前後に Nair と Hinton(制限付きボルツマンマシンの隠れユニットとして)や Glorot・Bordes・Bengio(深い全結合網で)が使い、2012年の画像認識コンテスト ILSVRC で優勝した AlexNet(Krizhevsky ら)が採用したことで広く知られるようになりました。

    ただし、ReLU で問題が全部片づくわけではありません。

    • 入力が負のユニットでは微分が 0 です。あるユニットの入力が、どのサンプルでも負になってしまうと、そのユニットには勾配が流れず、二度と更新されません(dying ReLU と呼ばれます)。負の側にも小さな傾きを持たせた Leaky ReLU などの変種は、これを避けるためのものです

    • 重みの大きさの問題は残ります。次の節で見るように、ReLU でも初期化を誤ると信号は指数関数的に消えます


    6. 初期化 ―― 分散を層ごとに保つ

    第4節で見たように、積の中の重みが大きすぎても小さすぎても困ります。
    「ちょうどよい大きさ」を、分散の計算で決めます。

    ある層の前活性の1つの成分は、nn 個の入力 aia_i と重み wiw_i の積の和 z=∑i=1naiwiz = \sum_{i=1}^{n} a_i w_i です。
    重みが平均 0・分散 Var(w)\mathrm{Var}(w) で独立に初期化され、入力とも独立なら、

    Var(z)=n Var(w) E[a2]\mathrm{Var}(z) = n \thinspace \mathrm{Var}(w) \thinspace \mathbb{E}[a^2]

    です。前の層の前活性の分散を vv とすると、E[a2]\mathbb{E}[a^2] は活性化関数によって次のようになります。

    • tanh(0 付近ではほぼ恒等関数):E[a2]≈v\mathbb{E}[a^2] \approx v。したがって Var(z)=v\mathrm{Var}(z) = v に保つには Var(w)=1/n\mathrm{Var}(w) = 1/n

    • ReLU:前活性が 0 について対称なら、半分が 0 に切られるので E[a2]=v/2\mathbb{E}[a^2] = v/2。したがって Var(w)=2/n\mathrm{Var}(w) = 2/n

    逆伝播についても同じ計算ができ、こちらは出力側のユニット数 noutn_{\mathrm{out}} が出てきます。
    Glorot と Bengio(2010)は、前向きと後ろ向きの両方の折り合いとして Var(w)=2/(nin+nout)\mathrm{Var}(w) = 2/(n_{\mathrm{in}} + n_{\mathrm{out}}) を提案しました(Xavier の初期化、Glorot の初期化とも)。入力と出力の数が同じなら 1/n1/n です。
    He ら(2015)は、ReLU では半分が切られる分を補って Var(w)=2/nin\mathrm{Var}(w) = 2/n_{\mathrm{in}} とすることを提案しました(He の初期化、Kaiming の初期化とも)。
    PyTorch では nn.init.xavier_normal_ と nn.init.kaiming_normal_ がこれにあたります。

    本当に分散が保たれるかを、幅512・50層の網に標準正規の入力を流して確かめます。今度は前向きだけです。

    import numpy as np
    
    def forward_std(act, w_std, depth=50, width=512, n=1000, seed=0):
        """重みの標準偏差 w_std(n_in) で初期化した網に標準正規の入力を流し、
        各層の前活性 z の標準偏差を返す"""
        rng = np.random.default_rng(seed)
        a = rng.standard_normal((n, width))
        stds = []
        for _ in range(depth):
            W = rng.standard_normal((width, width)) * w_std(width)
            z = a @ W
            stds.append(z.std())
            a = act(z)
        return np.array(stds)
    
    relu = lambda z: np.maximum(z, 0)
    cases = {
        "tanh, N(0, 0.01^2)":      (np.tanh, lambda n: 0.01),
        "tanh, Xavier 1/n":        (np.tanh, lambda n: np.sqrt(1 / n)),
        "ReLU, Xavier 1/n":        (relu,    lambda n: np.sqrt(1 / n)),
        "ReLU, He 2/n":            (relu,    lambda n: np.sqrt(2 / n)),
    }
    for name, (act, w_std) in cases.items():
        s = forward_std(act, w_std)
        print(f"{name:22s} 第1層 {s[0]:.3f}  第10層 {s[9]:.3g}"
              f"  第50層 {s[49]:.3g}")
    tanh, N(0, 0.01^2)     第1層 0.227  第10層 3.26e-07  第50層 4.83e-33
    tanh, Xavier 1/n       第1層 1.003  第10層 0.236  第50層 0.0974
    ReLU, Xavier 1/n       第1層 1.003  第10層 0.0402  第50層 2.99e-08
    ReLU, He 2/n           第1層 1.418  第10層 1.29  第50層 1
    画像

    図4:幅512・50層の網に標準正規の入力1000個を流したときの、各層の前活性の標準偏差(対数目盛り)。灰色の点線が標準偏差 0.01 の固定値、青が tanh と Xavier、橙の破線が ReLU と Xavier、緑が ReLU と He。

    • 標準偏差 0.01 で初期化した tanh:1層ごとに約 0.01×512≈0.230.01 \times \sqrt{512} \approx 0.23 倍に縮み、50層で 10−3310^{-33}。信号が消えてしまいます

    • ReLU に Xavier の分散 1/n1/n を使うと、半分が切られる分だけ1層ごとに分散が半分(標準偏差は 1/21/\sqrt{2} 倍)になり、50層で 3×10−83 \times 10^{-8} です。(1/2)49≈4×10−8(1/\sqrt{2})^{49} \approx 4 \times 10^{-8} とほぼ一致します

    • ReLU と He の初期化:50層を通っても標準偏差は 1 前後で、ちょうど保たれています

    • tanh と Xavier:50層で 0.0974 と、ゆっくり縮みます。tanh は 0 から離れると傾きが 1 より小さくなるので、上の「ほぼ恒等関数」の近似の分だけ少しずつ小さくなるためです。それでも、指数関数的に消える 0.01 の初期化とは比べものになりません

    前向きの信号が保たれることと、逆伝播の勾配が保たれることは、ほぼ同じ条件です(逆伝播でも同じ重みと同じ微分が掛かるため)。
    第3節で tanh と ReLU の勾配が保たれたのは、この初期化のおかげでした。


    7. バッチ正規化と残差接続

    初期化は「学習の出発点」で大きさをそろえる方法で、学習が進んで重みが変わると、そろっている保証はなくなります。
    学習の間ずっと効く工夫として、バッチ正規化と残差接続があります。

    バッチ正規化

    Ioffe と Szegedy(2015)のバッチ正規化(batch normalization、BN)は、各層の前活性を、ミニバッチの中の平均 μB\mu_B と分散 σB2\sigma_B^2 で標準化してから、学習するパラメータ γ,β\gamma, \beta で伸縮・平行移動します。

    BN(z)=γ z−μBσB2+ϵ+β\mathrm{BN}(z) = \gamma \thinspace \frac{z - \mu_B}{\sqrt{\sigma_B^2 + \epsilon}} + \beta

    前活性がつねに平均 0・分散 1 付近にそろうので、シグモイドの入力が飽和域に入りにくくなり、重みの大きさが変わっても次の層へ渡る値の大きさは変わりません。
    原論文は、学習中に各層の入力の分布が変わること(内部共変量シフト)を減らすことで学習を速める、と説明しました。
    ただし、なぜ効くのかには今も議論があり、Santurkar ら(2018)は、損失の地形をなめらかにする効果のほうが大きいと主張しています。
    学習時と推論時で使う平均・分散が違う(推論時は学習中の移動平均を使う)ことにも注意が要ります。

    残差接続

    He ら(2016)の ResNet は、層の出力に入力をそのまま足します。

    hl+1=hl+F(hl)h_{l+1} = h_l + F(h_l)

    FF は通常の層(ここでは「シグモイド → 全結合」)です。
    この層のヤコビ行列は ∂hl+1/∂hl=I+∂F/∂hl\partial h_{l+1} / \partial h_l = I + \partial F / \partial h_l なので、逆伝播で掛かる係数に単位行列 II がいつも含まれます。
    積 ∏(I+∂F/∂hk)\prod (I + \partial F / \partial h_k) を展開すると、∂F\partial F を1つも含まない項 II が残ります。
    つまり、出力側の勾配が途中の層の微分を通らずに、そのまま入力側まで届く道があるのです。
    FF の微分がどれほど小さくても、勾配がまるごと消えることはありません。
    ResNet はこの構造で152層の網を学習させ、2015年の ILSVRC で優勝しました。

    20層の網で学習させて比べる

    手書き数字のデータ(scikit-learn の digits。8×8 画素、10クラス、1,797枚。4分の3を訓練に)で、20層・幅64の網を4通り学習させます。
    最適化は第14回の Adam(学習率 10−310^{-3})、ミニバッチ 64、40エポックで、すべて同じ設定です。

    1. シグモイド(Xavier の初期化)

    2. ReLU(He の初期化)

    3. シグモイド + バッチ正規化(全結合 → BN → シグモイド)

    4. シグモイド + 残差接続(h+Wσ(h)h + W \sigma(h) の形のブロック)

    import numpy as np
    import torch
    import torch.nn as nn
    from sklearn.datasets import load_digits
    from sklearn.model_selection import train_test_split
    
    class DeepNet(nn.Module):
        """20層の全結合網。kind: 'plain'(そのまま)/
        'bn'(Linear の後に BatchNorm)/ 'res'(残差接続 h + W f(h))"""
        def __init__(self, act, kind="plain", init="xavier", depth=20, width=64,
                     d_in=64, n_cls=10):
            super().__init__()
            self.act, self.kind = act(), kind
            self.inp = nn.Linear(d_in, width)
            self.lins = nn.ModuleList(nn.Linear(width, width)
                                      for _ in range(depth - 1))
            self.bns = (nn.ModuleList(nn.BatchNorm1d(width) for _ in range(depth))
                        if kind == "bn" else None)
            self.out = nn.Linear(width, n_cls)
            for lin in [self.inp, *self.lins]:
                if init == "xavier":
                    nn.init.xavier_normal_(lin.weight)
                else:
                    nn.init.kaiming_normal_(lin.weight, nonlinearity="relu")
                nn.init.zeros_(lin.bias)
    
        def forward(self, x):
            h = self.inp(x)
            if self.kind == "bn":
                h = self.bns[0](h)
            h = h if self.kind == "res" else self.act(h)
            for i, lin in enumerate(self.lins):
                if self.kind == "res":
                    h = h + lin(self.act(h))  # 残差接続:入力をそのまま足す
                elif self.kind == "bn":
                    h = self.act(self.bns[i + 1](lin(h)))
                else:
                    h = self.act(lin(h))
            return self.out(self.act(h) if self.kind == "res" else h)
    
        def hidden_weights(self):
            return [self.inp.weight, *[l.weight for l in self.lins]]
    
    X, y = load_digits(return_X_y=True)
    X_tr, X_te, y_tr, y_te = train_test_split(X / 16.0, y, test_size=0.25,
                                              random_state=0, stratify=y)
    X_tr = torch.tensor(X_tr, dtype=torch.float32)
    X_te = torch.tensor(X_te, dtype=torch.float32)
    y_tr, y_te = torch.tensor(y_tr), torch.tensor(y_te)
    
    def train(model, opt, epochs=40, clip=None):
        """ミニバッチ 64 で学習し、エポックごとの訓練損失
        (ミニバッチ損失の平均)と、各ステップの勾配ノルムを返す"""
        hist, norms = [], []
        for epoch in range(epochs):
            model.train()
            perm, total = torch.randperm(len(X_tr)), 0.0
            for i in range(0, len(X_tr), 64):
                idx = perm[i:i + 64]
                opt.zero_grad()
                loss = nn.functional.cross_entropy(model(X_tr[idx]), y_tr[idx])
                loss.backward()
                g = nn.utils.clip_grad_norm_(
                    model.parameters(), max_norm=clip if clip else float("inf"))
                norms.append(g.item())
                opt.step()
                total += loss.item() * len(idx)
            hist.append(total / len(X_tr))
        model.eval()
        with torch.no_grad():
            acc = (model(X_te).argmax(1) == y_te).float().mean().item()
        return hist, norms, acc
    
    configs = {
        "sigmoid":            (nn.Sigmoid, "plain", "xavier"),
        "ReLU + He":          (nn.ReLU,    "plain", "he"),
        "sigmoid + BN":       (nn.Sigmoid, "bn",    "xavier"),
        "sigmoid + residual": (nn.Sigmoid, "res",   "xavier"),
    }
    # 訓練損失は第10・第40エポックの値
    print("                       学習前の勾配        訓練損失       テスト")
    print("                       第1層   第20層      第10     第40  正解率")
    for name, (act, kind, init) in configs.items():
        torch.manual_seed(0)
        model = DeepNet(act, kind, init)
        model.zero_grad()
        # 学習前の勾配
        nn.functional.cross_entropy(model(X_tr), y_tr).backward()
        g = [w.grad.norm().item() for w in model.hidden_weights()]
        hist, _, acc = train(model, torch.optim.Adam(model.parameters(), lr=1e-3))
        print(f"{name:19s} {g[0]:8.1e} {g[-1]:8.1e}"
              f"  {hist[9]:8.3f} {hist[-1]:8.3f}  {acc:6.3f}")
                           学習前の勾配        訓練損失       テスト
                           第1層   第20層      第10     第40  正解率
    sigmoid              1.5e-13  6.4e-02     2.307    2.308   0.098
    ReLU + He            4.7e-01  5.2e-01     0.087    0.048   0.944
    sigmoid + BN         2.1e-01  1.4e-01     0.954    0.617   0.829
    sigmoid + residual   7.1e-02  5.0e-02     0.569    0.063   0.956
    画像

    図5:左は学習前の各層の重みの勾配のノルム(対数目盛り)、右は40エポックの訓練損失の推移。20層・幅64の網を digits で学習。

    素のシグモイドの網は、40エポックたっても訓練損失が 2.308 のままで、テスト正解率は 0.098 です。
    10クラスを当てずっぽうで答えたときの損失は ln⁡10≈2.303\ln 10 \approx 2.303、正解率は 0.1 なので、まったく学習していません。
    第1層の勾配は 1.5×10−131.5 \times 10^{-13} で、第3節と同じく第20層の約 10−1210^{-12} 倍です。

    Adam は勾配を過去の勾配の大きさで割るので(第14回)、小さな勾配でも一定の歩幅で進めそうに思えます。
    しかし、第1層の勾配は要素あたり 10−1510^{-15} 程度で、Adam の分母に足す ϵ=10−8\epsilon = 10^{-8} よりはるかに小さいため、歩幅は学習率 × 勾配 ÷ ϵ\epsilon 程度にしかなりません。
    それに、出力側の層まで学習できていないのには、もう1つ理由があります。

    # 上のコードの続き:学習前の sigmoid の網で、
    # 各層の出力がサンプルごとにどれだけ違うか
    torch.manual_seed(0)
    model = DeepNet(nn.Sigmoid, "plain", "xavier")
    with torch.no_grad():
        h = model.act(model.inp(X_tr))
        print(f"第 1層の出力: サンプル間の標準偏差 {h.std(0).mean():.1e}")
        for l, lin in enumerate(model.lins, start=2):
            h = model.act(lin(h))
            if l in (5, 10, 20):
                print(f"第{l:2d}層の出力: サンプル間の標準偏差"
                      f" {h.std(0).mean():.1e}")
    第 1層の出力: サンプル間の標準偏差 6.3e-02
    第 5層の出力: サンプル間の標準偏差 2.0e-04
    第10層の出力: サンプル間の標準偏差 1.5e-07
    第20層の出力: サンプル間の標準偏差 5.1e-09

    前向きでも、入力の違いが層ごとに同じ割合で縮んでいるのです。
    1つのユニットの出力の差は、入力の差に「重み × シグモイドの傾き」を掛けたもので、逆伝播と同じ係数が掛かるからです。
    第20層の出力のサンプル間の標準偏差は 5.1×10−95.1 \times 10^{-9} で、0.5 付近の float32 の刻み(約 6×10−86 \times 10^{-8})より小さく、事実上どの画像を入れても同じ値が出ています。
    出力側の層は、入力の区別がつかない特徴しか受け取れないので、いくら勾配があっても学習できません。

    これに対して、3つの対策はどれも第1層の勾配を第20層と同じ桁(0.07〜0.5)まで取り戻し(図5の左)、実際に学習が進みました。

    • ReLU + He:訓練損失 0.048、テスト正解率 0.944。10エポックで損失 0.087 と、いちばん速く下がりました

    • シグモイド + 残差接続:テスト正解率 0.956 で、4つの中でいちばん高くなりました。活性化関数はシグモイドのままでも、「そのまま通る道」があれば20層を学習できます

    • シグモイド + バッチ正規化:テスト正解率 0.829。勾配の大きさは保たれましたが、40エポックでは損失が 0.617 までしか下がりませんでした。勾配が消えないことは学習できるための条件の1つで、それだけで学習が速くなるとは限りません


    8. 勾配クリッピング ―― 爆発への安全弁

    勾配爆発には、もっと直接的な対処があります。
    勾配のノルムが上限 cc を超えたら、向きはそのままで、ノルムが cc になるように縮めるのです。

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

    これを勾配クリッピング(ノルムによるクリッピング)と呼びます。
    Pascanu・Mikolov・Bengio(2013)が RNN の勾配爆発への対処として論じた方法で、PyTorch では nn.utils.clip_grad_norm_ の1行で使えます(戻り値は切る前のノルム)。
    勾配を大きくする仕組みではないので、勾配消失には効きません。

    第7節の ReLU + He の網を、今度は大きめの学習率(0.03、モメンタム 0.9)の SGD で学習させ、クリッピングなし・上限 5・上限 1 を比べます。

    # 第7節のコードの続き(DeepNet・train・データを使う)。
    # ReLU + He の20層を、大きめの学習率の SGD で学習する
    # 訓練損失は第10・第40エポックの値
    print("        勾配ノルム   切られた      訓練損失       テスト")
    print("上限      最大 中央値    割合      第10     第40  正解率")
    for clip in [None, 5.0, 1.0]:
        torch.manual_seed(0)
        model = DeepNet(nn.ReLU, "plain", "he")
        opt = torch.optim.SGD(model.parameters(), lr=0.03, momentum=0.9)
        hist, norms, acc = train(model, opt, clip=clip)
        norms = np.array(norms)
        clipped = np.mean(norms > clip) if clip else 0.0
        mx, md = np.nanmax(norms), np.nanmedian(norms)
        print(f"{str(clip):4s}  {mx:8.1e} {md:6.2f}  {clipped:6.2f}"
              f"  {hist[9]:8.3f} {hist[-1]:8.3f}  {acc:6.3f}")
            勾配ノルム   切られた      訓練損失       テスト
    上限      最大 中央値    割合      第10     第40  正解率
    None       inf   1.89    0.00     1.542      nan   0.100
    5.0    7.0e+01   2.59    0.16     1.019    0.375   0.900
    1.0    4.6e+01   4.88    0.87     0.270    0.061   0.944
    画像

    図6:左は各ステップの勾配のノルム(切る前、対数目盛り)、右はエポックごとの訓練損失。赤がクリッピングなし、橙が上限 5、青が上限 1。

    クリッピングなしの赤は、損失が上下に暴れたあと、34エポック目(731ステップ目)に勾配のノルムが無限大になり、損失は NaN になりました。
    図6の左で、その直前に勾配のノルムがふだんの数(中央値 1.89)から 10510^5 を超えるまで跳ね上がっているのが見えます。
    大きな勾配で重みが飛び、飛んだ先でさらに大きな勾配が出る、という悪循環です。

    上限 1 にすると、最後まで発散せずに訓練損失 0.061、テスト正解率 0.944 まで学習しました。
    ただし、このとき87%のステップで勾配が切られています。
    ほとんど毎回、勾配を長さ 1 にそろえて進んでいることになり、実質的には学習率を小さくしたのに近い働きです。
    クリッピングの上限は、ふだんの勾配のノルムを見たうえで、まれな跳ね上がりだけを切るように選ぶのが基本で、上限 5(切られたのは16%)でも発散は防げています(テスト正解率 0.900)。
    RNN や Transformer の学習では、クリッピングは今も標準的に使われる安全弁です。


    9. やってみよう

    1. 第3節のコードで、シグモイドの網の depth を 5, 10, 20 と変え、第1層と最終層の勾配の比が「1層あたり約 0.23 倍」の予想どおりになるか確かめてください。

    2. 第6節の forward_std で、ReLU の重みの標準偏差を 1.5/n\sqrt{1.5/n} と 3/n\sqrt{3/n} にすると、50層で前活性の標準偏差はどうなるでしょうか。1層あたりの倍率を予想してから実行してください。

    3. 第7節の DeepNet で、残差接続の網の活性化関数をシグモイドから ReLU に替え(初期化は He)、学習の速さとテスト正解率を比べてください。


    まとめ

    • 逆伝播の勾配は「重み × 活性化関数の微分」の積。係数が1より小さければ層の数に対して指数関数的に消え、大きければ爆発する

    • シグモイドの微分は最大 1/4。20層のシグモイドの網では、入力側の勾配が出力側の 10−1210^{-12} 倍(1層あたり約 0.23 倍)になり、前向きの信号も同じ割合で縮んで、学習はまったく進まなかった

    • 重みの大きさも同じ積に入る。tanh の30層の網で重みを 0.5 倍にすると勾配は約 10−910^{-9} 倍に、4 倍にすると約20万倍になった。前向きの値が穏やかでも勾配は爆発しうる

    • 対策:ReLU(正の側で微分1)、Xavier / He の初期化(Var(w)=1/n\mathrm{Var}(w) = 1/n、2/n2/n で分散を層ごとに保つ)、バッチ正規化(前活性を毎回標準化)、残差接続(ヤコビ行列に II が入り、勾配の「近道」ができる)。20層の digits の学習で、テスト正解率は素のシグモイドの 0.098 から、ReLU + He で 0.944、シグモイド + 残差接続で 0.956 になった

    • 勾配クリッピングは爆発への安全弁。発散した設定が、上限 1 で最後まで学習した。消失には効かない

    ReLU・よい初期化・バッチ正規化・残差接続がそろったのは2010年代に入ってからです。
    それより前、2006年に深い網の学習の道を開いたのは、Hinton・Osindero・Teh の層ごとの事前学習でした。
    勾配を深い網の端から端まで流す代わりに、1層ずつ教師なしで学習させて良い初期値を作り、最後に全体を誤差逆伝播法で微調整する、という方法です。
    その1層ぶんの部品として使われたのが、次回の制限付きボルツマンマシン(RBM)です。


    参考文献

    • S. Hochreiter, Untersuchungen zu dynamischen neuronalen Netzen, Diploma thesis, Technische Universität München, 1991.(勾配消失・爆発の最初の分析)

    • Y. Bengio, P. Simard and P. Frasconi, "Learning long-term dependencies with gradient descent is difficult," IEEE Transactions on Neural Networks, 5(2), 157–166, 1994.

    • X. Glorot and Y. Bengio, "Understanding the difficulty of training deep feedforward neural networks," Proc. AISTATS, 2010.(Xavier の初期化)

    • K. He, X. Zhang, S. Ren and J. Sun, "Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification," Proc. ICCV, 2015.(He の初期化)

    • K. He, X. Zhang, S. Ren and J. Sun, "Deep residual learning for image recognition," Proc. CVPR, 2016.(ResNet)

    • K. He, X. Zhang, S. Ren and J. Sun, "Identity mappings in deep residual networks," Proc. ECCV, 2016.(残差接続の恒等写像の経路と勾配の伝わり方)

    • S. Ioffe and C. Szegedy, "Batch normalization: Accelerating deep network training by reducing internal covariate shift," Proc. ICML, 2015.

    • S. Santurkar, D. Tsipras, A. Ilyas and A. Madry, "How does batch normalization help optimization?," Proc. NeurIPS, 2018.

    • R. Pascanu, T. Mikolov and Y. Bengio, "On the difficulty of training recurrent neural networks," Proc. ICML, 2013.(勾配クリッピング)

    • V. Nair and G. E. Hinton, "Rectified linear units improve restricted Boltzmann machines," Proc. ICML, 2010.

    • X. Glorot, A. Bordes and Y. Bengio, "Deep sparse rectifier neural networks," Proc. AISTATS, 2011.

    • A. Krizhevsky, I. Sutskever and G. E. Hinton, "ImageNet classification with deep convolutional neural networks," Proc. NIPS, 2012.(AlexNet)

    • G. E. Hinton, S. Osindero and Y.-W. Teh, "A fast learning algorithm for deep belief nets," Neural Computation, 18(7), 1527–1554, 2006.(層ごとの事前学習)

    • I. Goodfellow, Y. Bengio and A. Courville, Deep Learning, MIT Press, 2016. https://www.deeplearningbook.org/(6章:深い順伝播型ネットワーク、8章:深いモデルの学習のための最適化、10章:系列のモデル化)

    • PyTorch ドキュメント「torch.nn.init」「torch.nn.utils.clip_grad_norm_」 https://pytorch.org/docs/stable/nn.init.html

    • 元のノートブック(VanishingGradient.ipynb)は出典未特定。angeloyeo「공돌이의 수학정리노트」には対応する記事が見つからなかった。本記事は構成・例・図・コードを独自に作ったもの


    ← 前 第15回 多層パーセプトロンと誤差逆伝播法 / 次 → 第17回 制限付きボルツマンマシン ―― エネルギーで確率を書き、サンプリングで学ぶ
    連載トップへ戻る

    #機械学習 #Python #ニューラルネットワーク #深層学習 #PyTorch #手を動かす機械学習

     
     
    高専現役教員|AI・ものづくり教育|学生伴走&技術コンテスト指導|研究室のリアルな日常から、高専の進路・学習法、先端テックの社会実装まで発信しています。「手を動かしてつくる面白さ」を伝えたい。

    あなたへのおすすめ