【E資格】第20回:パタメータの更新手法の比較【ゼロから作るDeep Learning】

# 必要なライブラリとモジュールをインポート
import numpy as np
import matplotlib.pyplot as plt
from collections import OrderedDict

# 勾配降下法(Stochastic Gradient Descent: SGD)のクラスを定義
class SGD:
    def __init__(self, lr=0.01):  # 初期化メソッドで学習率を設定
        self.lr = lr

    def update(self, params, grads):  # パラメータを更新するメソッド
        for key in params.keys():
            params[key] -= self.lr * grads[key]  # 勾配に学習率を掛けてパラメータを更新


# モメンタム法(Momentum)のクラスを定義
class Momentum:
    def __init__(self, lr=0.01, momentum=0.9):  # 初期化メソッドで学習率とモメンタムを設定
        self.lr = lr
        self.momentum = momentum
        self.v = None  # 速度を表す変数を初期化

    def update(self, params, grads):  # パラメータを更新するメソッド
        if self.v is None:
            self.v = {}
            for key, val in params.items():  # 初回時に速度をパラメータと同じ形状で初期化
                self.v[key] = np.zeros_like(val)

        for key in params.keys():
            self.v[key] = self.momentum*self.v[key] - self.lr*grads[key]  # 速度を更新
            params[key] += self.v[key]  # パラメータを更新


# AdaGrad法のクラスを定義
class AdaGrad:
    def __init__(self, lr=0.01):  # 初期化メソッドで学習率を設定
        self.lr = lr
        self.h = None  # 勾配の二乗和を保持する変数を初期化

    def update(self, params, grads):  # パラメータを更新するメソッド
        if self.h is None:
            self.h = {}
            for key, val in params.items():  # 初回時にhをパラメータと同じ形状で初期化
                self.h[key] = np.zeros_like(val)

        for key in params.keys():
            self.h[key] += grads[key] * grads[key]  # 勾配の二乗和を更新
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)  # パラメータを更新


# Adam法のクラスを定義
class Adam:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):  # 初期化メソッドで学習率とbeta1,beta2を設定
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0
        self.m = None  # 1次モーメント推定値を保持する変数を初期化
        self.v = None  # 2次モーメント推定値を保持する変数を初期化

    def update(self, params, grads):  # パラメータを更新するメソッド
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():  # 初回時にmとvをパラメータと同じ形状で初期化
                self.m[key] = np.zeros_like(val)
                self.v[key] = np.zeros_like(val)

        self.iter += 1
        lr_t = self.lr * np.sqrt(1.0 - self.beta2**self.iter) / (1.0 - self.beta1**self.iter)

        for key in params.keys():
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])  # mを更新
            self.v[key] += (1 - self.beta2) * (grads[key]**2 - self.v[key])  # vを更新

            params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)  # パラメータを更新


# 関数fとその微分dfを定義
def f(x, y):
    return x**2 / 20.0 + y**2

def df(x, y):
    return x / 10.0, 2.0*y

# 初期位置とパラメータ、勾配の初期化
init_pos = (-7.0, 2.0)
params = {}
params['x'], params['y'] = init_pos[0], init_pos[1]
grads = {}
grads['x'], grads['y'] = 0, 0

# 最適化手法の辞書を定義
optimizers = OrderedDict()
optimizers["SGD"] = SGD(lr=0.95)
optimizers["Momentum"] = Momentum(lr=0.1)
optimizers["AdaGrad"] = AdaGrad(lr=1.5)
optimizers["Adam"] = Adam(lr=0.3)

idx = 1

# 各最適化手法について
for key in optimizers:
    optimizer = optimizers[key]
    x_history = []
    y_history = []
    params['x'], params['y'] = init_pos[0], init_pos[1]

    # 30回のパラメータ更新を実行
    for i in range(30):
        x_history.append(params['x'])
        y_history.append(params['y'])

        grads['x'], grads['y'] = df(params['x'], params['y'])
        optimizer.update(params, grads)  # パラメータを更新

    # 関数fの値を格子点上で計算
    x = np.arange(-10, 10, 0.01)
    y = np.arange(-5, 5, 0.01)

    X, Y = np.meshgrid(x, y)
    Z = f(X, Y)

    # 等高線描画のためのマスクを作成
    mask = Z > 7
    Z[mask] = 0

    # プロットの準備
    plt.subplot(2, 2, idx)  # 2x2のサブプロットのidx番目を選択
    idx += 1
    plt.plot(x_history, y_history, 'o-', color="red")  # パラメータの更新履歴をプロット
    plt.contour(X, Y, Z)  # 関数fの等高線をプロット
    plt.ylim(-10, 10)
    plt.xlim(-10, 10)
    plt.plot(0, 0, '+')  # 最小値を示すプラスマークをプロット
    plt.title(key)  # タイトルに最適化手法の名前を表示
    plt.xlabel("x")  # x軸ラベル
    plt.ylabel("y")  # y軸ラベル

# 全てのサブプロットを表示
plt.show()

import numpy as np  # 数値計算を行うためのライブラリ
from collections import OrderedDict  # 順序付きディクショナリを使用するためのライブラリ
import matplotlib.pyplot as plt  # グラフ描画を行うためのライブラリ

# 多層のニューラルネットワークを定義するクラス
class MultiLayerNet:

    # 初期化関数
    # input_size: 入力層のノード数
    # hidden_size_list: 隠れ層のノード数のリスト（隠れ層の数はリストの長さで決まる）
    # output_size: 出力層のノード数
    # activation: 活性化関数の種類（'sigmoid'または'relu'）
    # weight_init_std: 重みの初期化時の標準偏差
    # weight_decay_lambda: 重み減衰を制御するパラメータ（L2正則化）
    def __init__(self, input_size, hidden_size_list, output_size,
                 activation='relu', weight_init_std='relu', weight_decay_lambda=0):

        # 引数をインスタンス変数に格納
        self.input_size = input_size
        self.output_size = output_size
        self.hidden_size_list = hidden_size_list
        self.hidden_layer_num = len(hidden_size_list)
        self.weight_decay_lambda = weight_decay_lambda
        self.params = {}  # 重みとバイアスを格納するためのディクショナリ

        # 重みの初期化
        self.__init_weight(weight_init_std)

        # 活性化関数の層を設定
        activation_layer = {'sigmoid': Sigmoid, 'relu': Relu}
        self.layers = OrderedDict()  # 順序付きディクショナリ（順序が重要なので通常のディクショナリではなく、順序付きディクショナリを使用）
        for idx in range(1, self.hidden_layer_num+1):
            # Affine層（全結合層）の追加
            self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
                                                      self.params['b' + str(idx)])
            # 活性化関数層の追加
            self.layers['Activation_function' + str(idx)] = activation_layer[activation]()

        # 出力層のAffine層の追加
        idx = self.hidden_layer_num + 1
        self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
            self.params['b' + str(idx)])

        # 最後の層（Softmax-with-Loss層）の設定
        self.last_layer = SoftmaxWithLoss()

    # 重みの初期化
    # 重みの初期化を行うメソッド
    def __init_weight(self, weight_init_std):
        # 全ての層のノード数のリストを作成（入力層、隠れ層、出力層）
        all_size_list = [self.input_size] + self.hidden_size_list + [self.output_size]
        for idx in range(1, len(all_size_list)):
            scale = weight_init_std
            if str(weight_init_std).lower() in ('relu', 'he'):
                # ReLUまたはHeの初期値を用いる場合
                scale = np.sqrt(2.0 / all_size_list[idx - 1]) 
            elif str(weight_init_std).lower() in ('sigmoid', 'xavier'):
                # SigmoidまたはXavierの初期値を用いる場合
                scale = np.sqrt(1.0 / all_size_list[idx - 1])  
            # 重み（W）とバイアス（b）の初期化
            self.params['W' + str(idx)] = scale * np.random.randn(all_size_list[idx-1], all_size_list[idx])
            self.params['b' + str(idx)] = np.zeros(all_size_list[idx])

    # 予測を行うメソッド
    def predict(self, x):
        # 各層を順に通過させる（順伝播）
        for layer in self.layers.values():
            x = layer.forward(x)

        return x

    # 損失関数の値（交差エントロピー誤差 + 重み減衰項）を計算するメソッド
    def loss(self, x, t):
        # 予測値の計算
        y = self.predict(x)

        # 重み減衰項（L2正則化）の計算
        weight_decay = 0
        for idx in range(1, self.hidden_layer_num + 2):
            W = self.params['W' + str(idx)]
            weight_decay += 0.5 * self.weight_decay_lambda * np.sum(W ** 2)

        # 損失関数の値を計算（交差エントロピー誤差 + 重み減衰項）
        return self.last_layer.forward(y, t) + weight_decay

    # 認識精度を計算するメソッド
    def accuracy(self, x, t):
        # 予測値の計算
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        if t.ndim != 1 : t = np.argmax(t, axis=1)

        # 認識精度の計算
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy

    # 勾配を数値的に計算するメソッド（確認用）
    def numerical_gradient(self, x, t):
        loss_W = lambda W: self.loss(x, t)

        grads = {}
        for idx in range(1, self.hidden_layer_num+2):
            grads['W' + str(idx)] = numerical_gradient(loss_W, self.params['W' + str(idx)])
                        # バイアスの勾配の計算
            grads['b' + str(idx)] = numerical_gradient(loss_W, self.params['b' + str(idx)])

        # 勾配のディクショナリを返す
        return grads

    # 勾配を誤差逆伝播法で計算するメソッド
    def gradient(self, x, t):
        # 順伝播
        self.loss(x, t)

        # 逆伝播
        dout = 1
        dout = self.last_layer.backward(dout)

        layers = list(self.layers.values())
        layers.reverse()  # 逆順にする（逆伝播なので）
        for layer in layers:
            dout = layer.backward(dout)

        # 勾配を保存するためのディクショナリ
        grads = {}
        for idx in range(1, self.hidden_layer_num+2):
            # 重みとバイアスの勾配を計算し、ディクショナリに保存
            grads['W' + str(idx)] = self.layers['Affine' + str(idx)].dW + self.weight_decay_lambda * self.layers['Affine' + str(idx)].W
            grads['b' + str(idx)] = self.layers['Affine' + str(idx)].db

        # 勾配のディクショナリを返す
        return grads

# SGDクラス: Stochastic Gradient Descentの実装
class SGD:

    def __init__(self, lr=0.01):
        # 学習率の初期化
        self.lr = lr
        
    def update(self, params, grads):
        # すべてのパラメータについて、勾配に学習率を掛けて更新する
        for key in params.keys():
            params[key] -= self.lr * grads[key] 


# Momentumクラス: Momentum SGDの実装
class Momentum:

    def __init__(self, lr=0.01, momentum=0.9):
        # 学習率とモメンタム係数の初期化
        self.lr = lr
        self.momentum = momentum
        self.v = None
        
    def update(self, params, grads):
        # 初回呼び出し時にモメンタムをパラメータと同じ形状で初期化する
        if self.v is None:
            self.v = {}
            for key, val in params.items():                                
                self.v[key] = np.zeros_like(val)
                
        # パラメータの更新
        for key in params.keys():
            self.v[key] = self.momentum*self.v[key] - self.lr*grads[key] 
            params[key] += self.v[key]

# AdaGradクラス: AdaGradの実装
class AdaGrad:

    def __init__(self, lr=0.01):
        # 学習率の初期化
        self.lr = lr
        self.h = None
        
    def update(self, params, grads):
        # 初回呼び出し時にhをパラメータと同じ形状で初期化する
        if self.h is None:
            self.h = {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)
            
        # パラメータの更新
        for key in params.keys():
            self.h[key] += grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)

# Adamクラス: Adamの実装
class Adam:

    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0
        self.m = None
        self.v = None
        
    def update(self, params, grads):
        # 初回呼び出し時にmとvをパラメータと同じ形状で初期化する
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():
                self.m[key] = np.zeros_like(val)
                self.v[key] = np.zeros_like(val)
        
        self.iter += 1
        lr_t  = self.lr * np.sqrt(1.0 - self.beta2**self.iter) / (1.0 - self.beta1**self.iter)         
        
        # パラメータの更新
        for key in params.keys():
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])
            self.v[key] += (1 - self.beta2) * (grads[key]**2 - self.v[key])
            
            params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)

# Sigmoidクラス: Sigmoid関数の実装
class Sigmoid:
    def __init__(self):
        self.out = None

    def forward(self, x):
        out = sigmoid(x)
        self.out = out
        return out

    def backward(self, dout):
        # Sigmoid関数の微分を計算
        dx = dout * (1.0 - self.out) * self.out

        return dx

# Reluクラス: Rectified Linear Unit関数の実装
class Relu:
    def __init__(self):
        self.mask = None

    def forward(self, x):
        # 順伝播では、0以下を0にする
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0

        return out

    def backward(self, dout):
        # 逆伝播では、順伝播時に0以下だった部分は逆伝播の際にも0にする
        dout[self.mask] = 0
        dx = dout

        return dx

# Affineクラス: 全結合層（Affineレイヤ）の実装
class Affine:
    def __init__(self, W, b):
        self.W = W
        self.b = b
        self.x = None
        self.original_x_shape = None
        self.dW = None
        self.db = None

    def forward(self, x):
        # 入力の形状を記憶（テンソル対応）
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)
        self.x = x

        # 順伝播の計算
        out = np.dot(self.x, self.W) + self.b

        return out

    def backward(self, dout):
        # 逆伝播の計算
        dx = np.dot(dout, self.W.T)
        self.dW = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0)
        
        dx = dx.reshape(*self.original_x_shape) 
        return dx

# SoftmaxWithLossクラス: Softmax関数とクロスエントロピー誤差を組み合わせたレイヤの実装
class SoftmaxWithLoss:
    def __init__(self):
        self.loss = None
        self.y = None
        self.t = None

    def forward(self, x, t):
        self.t = t
        self.y = softmax(x)
        self.loss = cross_entropy_error(self.y, self.t)
        
        return self.loss

    def backward(self, dout=1):
        # バッチの数で正規化して、上流から伝わった微分値（dout）を乗じる
        batch_size = self.t.shape[0]
        if self.t.size == self.y.size:
            dx = (self.y - self.t) / batch_size
        else:
            dx = self.y.copy()
            dx[np.arange(batch_size), self.t] -= 1
            dx = dx / batch_size
        
        return dx


# softmax関数
def softmax(x):
    x = x - np.max(x, axis=-1, keepdims=True)  # オーバーフロー対策
    return np.exp(x) / np.sum(np.exp(x), axis=-1, keepdims=True)

# クロスエントロピー誤差の計算
def cross_entropy_error(y, t):
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)

    # 教師データがone-hot-vectorの場合、正解ラベルのインデックスに変換
    if t.size == y.size:
        t = t.argmax(axis=1)
             
    batch_size = y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size

# データの平滑化（グラフの描画を滑らかにするため）
def smooth_curve(x):
    window_len = 11
    s = np.r_[x[window_len-1:0:-1], x, x[-1:-window_len:-1]]
    w = np.kaiser(window_len, 2)
    y = np.convolve(w/w.sum(), s, mode='valid')
    return y[5:len(y)-5]


# KerasからMNISTデータセットをインポート
from keras.datasets import mnist

# データセットのロードと前処理（正規化）
(x_train, t_train), (x_test, t_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0 

# 訓練データの数、バッチサイズ、最大イテレーション数を設定
train_size = x_train.shape[0]
batch_size = 128
max_iterations = 2000

# 最適化手法を辞書に格納
optimizers = {}
optimizers['SGD'] = SGD()
optimizers['Momentum'] = Momentum()
optimizers['AdaGrad'] = AdaGrad()
optimizers['Adam'] = Adam()

# 各最適化手法に対応するネットワークと訓練損失リストを作成
networks = {}
train_loss = {}
for key in optimizers.keys():
    networks[key] = MultiLayerNet(
        input_size=784, hidden_size_list=[100, 100, 100, 100],
        output_size=10)
    train_loss[key] = []    

# バッチを選択し、各最適化手法でネットワークを更新
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 optimizers.keys():
        grads = networks[key].gradient(x_batch, t_batch)
        optimizers[key].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 optimizers.keys():
            loss = networks[key].loss(x_batch, t_batch)
            print(key + ":" + str(loss))

# 各最適化手法の訓練損失をプロット
markers = {"SGD": "o", "Momentum": "x", "AdaGrad": "s", "Adam": "D"}
x = np.arange(max_iterations)
for key in optimizers.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, 1)
plt.legend()
plt.show()

===========iteration:0===========
SGD:2.4276812394863434
Momentum:2.4516900768248786
AdaGrad:2.035472182320865
Adam:2.192773885963459
===========iteration:100===========
SGD:1.594728870092728
Momentum:0.4863079555841739
AdaGrad:0.23163925508774433
Adam:0.35776769812400777
===========iteration:200===========
SGD:0.8506934692946964
Momentum:0.344054941938905
AdaGrad:0.15595700108962499
Adam:0.3214382211442086
===========iteration:300===========
SGD:0.5630854823663645
Momentum:0.254818908059543
AdaGrad:0.0933754895808952
Adam:0.16994710686622744
===========iteration:400===========
SGD:0.5322213104451474
Momentum:0.1488557980910587
AdaGrad:0.06255881550699702
Adam:0.12754309315174284
===========iteration:500===========
SGD:0.45566960092583597
Momentum:0.11202970452118899
AdaGrad:0.04593273376227268
Adam:0.052314645774982516
===========iteration:600===========
SGD:0.3672510321264767
Momentum:0.10123753725508124
AdaGrad:0.05720804612048199
Adam:0.09391926577341655
===========iteration:700===========
SGD:0.3578586337332641
Momentum:0.09517419623925397
AdaGrad:0.025034887545030745
Adam:0.03185441206982659
===========iteration:800===========
SGD:0.38498777345456403
Momentum:0.1508345475796861
AdaGrad:0.14330774347747016
Adam:0.09320873545503774
===========iteration:900===========
SGD:0.328788654706481
Momentum:0.2192815674061278
AdaGrad:0.09277974142229845
Adam:0.13373468853679854
===========iteration:1000===========
SGD:0.1836186817975457
Momentum:0.05137026845914548
AdaGrad:0.01698048638404168
Adam:0.022523844532702595
===========iteration:1100===========
SGD:0.13802783987029946
Momentum:0.02733474129324303
AdaGrad:0.01269158701029086
Adam:0.04461366616936174
===========iteration:1200===========
SGD:0.32972164650737484
Momentum:0.20227614077261627
AdaGrad:0.049148516058627176
Adam:0.08231145980905599
===========iteration:1300===========
SGD:0.2410041636847441
Momentum:0.10391665030563743
AdaGrad:0.036053594041144214
Adam:0.06535536709423506
===========iteration:1400===========
SGD:0.2946729828620252
Momentum:0.10139350873397797
AdaGrad:0.022150341301949136
Adam:0.03501532152601983
===========iteration:1500===========
SGD:0.37729490517339925
Momentum:0.12300667722232045
AdaGrad:0.07028989289480675
Adam:0.06323167939418362
===========iteration:1600===========
SGD:0.26599572494998275
Momentum:0.09616328682309455
AdaGrad:0.050871585124355995
Adam:0.10215028480467724
===========iteration:1700===========
SGD:0.4016358325065463
Momentum:0.16849667400353546
AdaGrad:0.07189490323423726
Adam:0.07987638328663768
===========iteration:1800===========
SGD:0.25003700025529596
Momentum:0.0877659547062771
AdaGrad:0.04389859591163443
Adam:0.06355017964925018
===========iteration:1900===========
SGD:0.24675687855545167
Momentum:0.09687066772334499
AdaGrad:0.048686855263636225
Adam:0.06846785554991137