マイコン君　Ｅ資格の勉強メモ

（第１０回）重みの初期値

学習をすすめると重みが変更されていきます。学習の目標は汎化性能を高くすることですが、重みの初期値によって学習がすすまなくなることもあります。今回は、この重みの初期値について調べてみます。

＜Ｓｉｇｍｏｉｄ、ＲｅＬＵ、Ｔａｎｈの初期値＞

Ｓｉｇｍｏｉｄ、ＲｅＬＵ、Ｔａｎｈの初期値を０．０１～１にへ変更したときの差を比較します。重み結果（アクティベーション）のヒストグラムのグラフを確認してみます。
次のプログラムを実行すると、それぞれの関数のグラフを作成できるようになっています。

print('---重みの初期値')
# coding: utf-8
import numpy as np
import matplotlib.pyplot as plt


def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def ReLU(x):
    return np.maximum(0, x)


def tanh(x):
    return np.tanh(x)
    

for j in range(21):
    input_data = np.random.randn(1000, 100)  # 1000個のデータ
    node_num = 100  # 各隠れ層のノード（ニューロン）の数
    hidden_layer_size = 5  # 隠れ層が5層
    activations = {}  # ここにアクティベーションの結果を格納する

    x = input_data
    if j==0:
        MyNo=0.01
    else:
        MyNo= j/20
    for i in range(hidden_layer_size):
        if i != 0:
            x = activations[i-1]

        # 初期値の値を変更
        w = np.random.randn(node_num, node_num) * MyNo
        a = np.dot(x, w)


        # 活性化関数の種類
        z = sigmoid(a)
        #z = ReLU(a)
        #z = tanh(a)

        activations[i] = z

    # ヒストグラムを描画
    fig = plt.figure(figsize=(10.00, 5.00))
    for i, a in activations.items():


        
        plt.suptitle("sigmoid_" +'{:.2f}'.format(MyNo))
        plt.subplot(1, len(activations), i+1)
        plt.title(str(i+1) + "-layer")
        if i != 0: plt.yticks([], [])
        # plt.xlim(0.1, 1)
        plt.ylim(0, 5000)
        plt.hist(a.flatten(), 30, range=(0,1))
    fig.savefig("sigmoid_" +'{:.2f}'.format(MyNo)+".png")

実行すると以下のグラフが作成されます。（１種類づつ出力）

Ｓｉｇｍｏｉｄは０．０１の時は中央に集中していますが、初期値を１になると０と１に偏った分布になっており、勾配消失が発生してしまっています。ＲｅＬＵは０に分布が集中し、Ｔａｎｈは－１～１の曲線なので、０に集中した状態から１に集中するような分布になっています。
重みの初期値によっても活性化関数の種類でも分布が変わるので、学習の結果に差異が生まれることが良くわかります。

〇Ｘａｖｉｅｒ初期値
ＳｉｇｍｏｉｄやＴａｎｈの場合は、左右対称で中央付近が線形関数となっているので、この関数をつかって初期値にします。
$\sqrt{\frac{1}{n}}$　　*)ｎは前層のノード数
〇Ｈｅ初期値
ＲｅＬＵ関数専用の初期値です。
$\sqrt{\frac{2}{n}}$　　*)ｎは前層のノード数
ｎ＝１００の場合は、上のグラフでは。Ｘａｖｉｅｒ→０．１、Ｈｅ→０．１４１程度なので、近いグラフをみると、良さそうなグラフになっています。

＜ＭＮＩＳＴ学習でのＲｅＬＵによる初期値の影響＞

実際にＭＮＩＳＴのデータセットで学習をするときに初期値による変化をみてみます。以下がプログラムです。ライブラリはこの圧縮ファイルをダウンロードし、解凍したディレクトリに下のプログラムを保存します。またＭＮＩＳＴの展開済みの「mnist.pkl」も同じフォルダに保存します。

# coding: utf-8
import os
import sys
import numpy as np
import matplotlib.pyplot as plt
from mnist import load_mnist
from util import smooth_curve
from multi_layer_net import MultiLayerNet
from optimizer import SGD


# 0:MNISTデータの読み込み==========
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

train_size = x_train.shape[0]
batch_size = 128
max_iterations = 2000


# 1:実験の設定==========
weight_init_types = {'std=0.01': 0.01, 'Xavier': 'sigmoid', 'He': 'relu'}
optimizer = SGD(lr=0.01)

networks = {}
train_loss = {}
for key, weight_type in weight_init_types.items():
    networks[key] = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100],
                                  output_size=10, weight_init_std=weight_type)
    train_loss[key] = []


# 2:訓練の開始==========
for i in range(max_iterations):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    for key in weight_init_types.keys():
        grads = networks[key].gradient(x_batch, t_batch)
        optimizer.update(networks[key].params, grads)
    
        loss = networks[key].loss(x_batch, t_batch)
        train_loss[key].append(loss)
    
    if i % 100 == 0:
        print("===========" + "iteration:" + str(i) + "===========")
        for key in weight_init_types.keys():
            loss = networks[key].loss(x_batch, t_batch)
            print(key + ":" + str(loss))
            

# 3.グラフの描画==========
markers = {'std=0.01': 'o', 'Xavier': 's', 'He': 'D'}
x = np.arange(max_iterations)
for key in weight_init_types.keys():
    plt.plot(x, smooth_curve(train_loss[key]), marker=markers[key], markevery=100, label=key)
plt.xlabel("iterations")
plt.ylabel("loss")
plt.ylim(0, 2.5)
plt.legend()
plt.show()


i=0
plt.suptitle('W5')
plt.subplot(1, 3, i+1)
plt.title("std=0.01")
MyW1=networks['std=0.01'].params['W5'] 
plt.hist(MyW1.flatten(), 30, range=(0,1))
i=i+1
plt.subplot(1, 3, i+1)
plt.title("Xavier")
MyW1=networks['Xavier'].params['W5'] 
plt.hist(MyW1.flatten(), 30, range=(0,1))
i=i+1
plt.subplot(1, 3, i+1)
plt.title("He")
MyW1=networks['He'].params['W5'] 
plt.hist(MyW1.flatten(), 30, range=(0,1))

plt.show()

実行すると以下のグラフが作成されます。

初期値が０．０１の場合は、ほとんど学習が進んでいないため、誤差が減りません。Ｘａｖｉｅｒ、Ｈｅは進んでいきます。

初期値が０．０１での学習率が進まない理由は、Ｗ５の最後のアクティベーションの分布がほとんど０になっているためで、他の２つと全然違うことがわかりました。
これは、仕事でも同じで、最初がダメだとうまくいきません。以前、財務状態が悪い会社へ設備投資をしたテーマでは、あっという間に撤退に追い込まれました。機械学習で判断したら、きっと投資自体をやめるだろうなと思います。機械学習を調べるとよく考えられているなぁと実感します。

＜Batch Normalization＞

Batch Normalizationは重みの初期値にあまり影響しないように対応した学習方法です。ミニバッチ毎に平均０、分散１のデータ分布になるようにしています。
上と同じディレクトリに下のプログラムを保存します。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 親ディレクトリのファイルをインポートするための設定
import numpy as np
import matplotlib.pyplot as plt
from mnist import load_mnist
from multi_layer_net_extend import MultiLayerNetExtend
from optimizer import SGD, Adam

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

# 学習データを削減
x_train = x_train[:1000]
t_train = t_train[:1000]

max_epochs = 20
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.01
MyGraphNo=1

def __train(weight_init_std,MyGraphNo):
    bn_network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100], output_size=10, 
                                    weight_init_std=weight_init_std, use_batchnorm=True)
    network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100], output_size=10,
                                weight_init_std=weight_init_std)
    optimizer = SGD(lr=learning_rate)
    
    train_acc_list = []
    bn_train_acc_list = []
    
    iter_per_epoch = max(train_size / batch_size, 1)
    epoch_cnt = 0
    
    for i in range(1000000000):
        batch_mask = np.random.choice(train_size, batch_size)
        x_batch = x_train[batch_mask]
        t_batch = t_train[batch_mask]
    
        for _network in (bn_network, network):
            grads = _network.gradient(x_batch, t_batch)
            optimizer.update(_network.params, grads)
    
        if i % iter_per_epoch == 0:
            train_acc = network.accuracy(x_train, t_train)
            bn_train_acc = bn_network.accuracy(x_train, t_train)
            train_acc_list.append(train_acc)
            bn_train_acc_list.append(bn_train_acc)
    
            print("epoch:" + str(epoch_cnt) + " | " + str(train_acc) + " - " + str(bn_train_acc))
    
            epoch_cnt += 1
            if epoch_cnt >= max_epochs:
                break
    """Batch Normalization重みヒスト描画
    fig = plt.figure(figsize=(10.00, 5.00))
    plt.suptitle("network_" +"W:" + '{:.4f}'.format(w))
    plt.subplot(1,5,1)
    plt.title("W1")
    MyW1=bn_network.params['W1']
    plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,2)
    plt.title("W2")
    MyW1=bn_network.params['W2']
    plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,3)
    plt.title("W3")
    MyW1=bn_network.params['W3']
    plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,4)
    plt.title("W4")
    MyW1=bn_network.params['W4']
    plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,5)
    plt.title("W5")
    MyW1=bn_network.params['W5']
    plt.hist(MyW1.flatten(), 30, density=True)
    fig.savefig("Batch Normalization_" +"W_" + str(MyGraphNo).zfill(2)+".png")
    """
    """Normal(without BatchNorm)重みヒスト描画
    fig = plt.figure(figsize=(10.00, 5.00))
    plt.suptitle("Normal(without BatchNorm)_" +"W:" + '{:.4f}'.format(w))
    plt.subplot(1,5,1)
    plt.title("W1")
    MyW1=network.params['W1']
    if MyGraphNo!=1 and MyGraphNo!=2 : plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,2)
    plt.title("W2")
    MyW1=network.params['W2']
    if MyGraphNo!=1 and MyGraphNo!=2 : plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,3)
    plt.title("W3")
    MyW1=network.params['W3']
    if MyGraphNo!=1 and MyGraphNo!=2 : plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,4)
    plt.title("W4")
    MyW1=network.params['W4']
    if MyGraphNo!=1 and MyGraphNo!=2 : plt.hist(MyW1.flatten(), 30, density=True)
    plt.subplot(1,5,5)
    plt.title("W5")
    MyW1=network.params['W5']
    if MyGraphNo!=1 and MyGraphNo!=2 : plt.hist(MyW1.flatten(), 30, density=True)
    fig.savefig("Normal(without BatchNorm)_" +"W_" + str(MyGraphNo).zfill(2)+".png")
    """
    return train_acc_list, bn_train_acc_list
    

# 3.グラフの描画==========
weight_scale_list = np.logspace(0, -4, num=16)
x = np.arange(max_epochs)

for i, w in enumerate(weight_scale_list):
    print( "============== " + str(i+1) + "/16" + " ==============")
    train_acc_list, bn_train_acc_list = __train(w,MyGraphNo)
    MyGraphNo=MyGraphNo+1
   
    plt.subplot(4,4,i+1)
    plt.title("W:" + str(w))

    if i == 15:
        plt.plot(x, bn_train_acc_list, label='Batch Normalization', markevery=2)
        plt.plot(x, train_acc_list, linestyle = "--", label='Normal(without BatchNorm)', markevery=2)
    else:
        plt.plot(x, bn_train_acc_list, markevery=2)
        plt.plot(x, train_acc_list, linestyle="--",label='_', markevery=2)

    plt.ylim(0, 1.0)
    if i % 4:
        plt.yticks([])
    else:
        plt.ylabel("accuracy")
    if i < 12:
        plt.xticks([])
    else:
        plt.xlabel("epochs")

plt.legend(loc='upper right')
    
plt.show()

実行すると以下のグラフが作成されます。

Batch Normalizationでは条件が悪い状態（重みの初期値が極端に大いor小さい）でも学習が進みますが、Normal ではほとんど進まない場合があります。

それぞれの重み（Ｗ１～Ｗ５）のヒストグラムをみると、分布の幅が小さくても学習できているし、Normalよりも幅が狭くならないようになっています。
条件が悪くても頑張って結果をだせる優秀な「Batch Normalization」でした。

－－－－－－－－－－－－－

（第１０回）重みの初期値

＜Ｓｉｇｍｏｉｄ、ＲｅＬＵ、Ｔａｎｈの初期値＞

＜ＭＮＩＳＴ学習でのＲｅＬＵによる初期値の影響＞

＜Batch Normalization＞

機械学習のメモ

メニュー