NumPyでのニューラルネットワーク2 学習

import numpy as np

def numerical_gradient(f, x): # 関数ｆの勾配を、x の勾配を求める
    h = 1e-4 # 0.0001
    grad = np.zeros_like(x)
    
    it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
    while not it.finished:
        idx = it.multi_index
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x) # f(x+h)
        
        x[idx] = tmp_val - h 
        fxh2 = f(x) # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2*h)
        
        x[idx] = tmp_val # 値を元に戻す
        it.iternext()   
        
    return 
# 上記は、TwoLayerNetのnumerical_gradientメソッド定義に使っていたが、高速版では使わない。

def sigmoid(x): # 活性関数として0から１の滑らかな曲線で活性化させるシグモイド関数の定義
   return 1 / (1 + np.exp(-x))

def sigmoid_grad(x):
    return (1.0 - sigmoid(x)) * sigmoid(x)

def softmax(x):
   if x.ndim == 2: # バッチ処理の引数データか？
      x = x.T  # 転置行列を求る。
      x = x - np.max(x, axis=0) # オーバーフロー対策
      y = np.exp(x) / np.sum(np.exp(x), axis=0) # axis=0で、内部配列ごとに処理
      return y.T 
   x = x - np.max(x) # オーバーフロー対策
   return np.exp(x) / np.sum(np.exp(x))

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])) / batch_size # バッチサイズは、グローバルで与える。

class TwoLayerNet:
   # コンストラクタ
   def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
      # 重みの初期化
      self.params = {}
      self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
      self.params['b1'] = np.zeros(hidden_size)
      self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
      self.params['b2'] = np.zeros(output_size)
   #
   # 予測して、各出力層の確率を返す
   def predict(self, x):
      W1, W2 = self.params['W1'], self.params['W2']
      b1, b2 = self.params['b1'], self.params['b2']
      a1 = np.dot(x, W1) + b1
      z1 = sigmoid(a1)
      a2 = np.dot(z1, W2) + b2
      y = softmax(a2)
      return y
   #
   # x:入力データ, t:教師データ
   def loss(self, x, t):
      y = self.predict(x)  
      return cross_entropy_error(y, t)
   #
   def accuracy(self, x, t):
      y = self.predict(x)
      y = np.argmax(y, axis=1)
      t = np.argmax(t, axis=1)
      accuracy = np.sum(y == t) / float(x.shape[0])
      return accuracy
   #
   # 次のメソッドはこのリンクで作成したnumerical_gradientを利用するもので、使っていない。
   def numerical_gradient(self, x, t):# x:入力データ, t:教師データ 損失との勾配を求める。
      loss_W = lambda W: self.loss(x, t)
      grads = {}
      grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
      grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
      grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
      grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
      return grads
      # 以上は、下記高速版を作成する過程で作成したが、以降のソースでは削除の予定
   # 
   def gradient(self, x, t): #	x:入力データ, t:教師データ 損失との勾配を求める。（上記の処理を、このクラス専用で作った高速版）
      W1, W2 = self.params['W1'], self.params['W2']
      b1, b2 = self.params['b1'], self.params['b2']
      grads = {}
      batch_num = x.shape[0]
      # forward
      a1 = np.dot(x, W1) + b1
      z1 = sigmoid(a1)
      a2 = np.dot(z1, W2) + b2
      y = softmax(a2)
      # backward
      dy = (y - t) / batch_num
      grads['W2'] = np.dot(z1.T, dy)
      grads['b2'] = np.sum(dy, axis=0)
      #  
      da1 = np.dot(dy, W2.T)
      dz1 = sigmoid_grad(a1) * da1
      grads['W1'] = np.dot(x.T, dz1)
      grads['b1'] = np.sum(dz1, axis=0)
      return grads

import pickle
import numpy as np
import matplotlib.pyplot as plt

# 訓練用データの読み込み
with open('x_train.pkl', mode='rb') as fr: # 1つが[784]byteという入力データが、複数並ぶ訓練データを取得
    x_train=pickle.load( fr)

with open('t_train_a.pkl', mode='rb') as fr: # 上記の並びに対応する教師ラベル（1つがone-hot表現で10個の出力）が、複数並ぶ訓練データを取得
    t_train=pickle.load( fr)

train_size = x_train.shape[0] # 訓練データサイズ:60000
train_size = 10000
train_size = 1000
train_size = 100

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)#学習用のニューラルネットワーク生成

batch_size = 100
batch_size = 10
learning_rate = 0.1 # 学習率
iters_num = 10000  # 勾配法の算出繰り返しの回数
iters_num = 1000  # 勾配法の算出繰り返しの回数
train_loss_list = []  #予測と(訓練用教師ラベル)の損失

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask] # batch_maskの添え字群で指定される訓練データ群を抽出
    t_batch = t_train[batch_mask] # batch_maskの添え字群で指定される訓練データ群の訓練ラベル(訓練用教師ラベル)を抽出
    
    # 勾配の計算
    # grad = network.numerical_gradient(x_batch, t_batch) # コメントアウトして、新たに作った次の高速版を使う
    grad = network.gradient(x_batch, t_batch)
    
    # 「重みとバイアスのパラメタ」を更新
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    loss = network.loss(x_batch, t_batch)
    print(i, ":", loss)
    train_loss_list.append(loss)

plt.figure() # 2次元の図を初期化「1つshow()の前に必要」

plt.plot(np.arange(len(train_loss_list)),np.array(train_loss_list), label="回数")
print("訓練データ数：", train_size);
print("バッチ数：", batch_size);
print("計算回数：", iters_num);
plt.show()

import pickle

# データの読み込み
with open('x_train.pkl', mode='rb') as fr:
    x_train=pickle.load( fr)

with open('t_train_a.pkl', mode='rb') as fr:
    t_train=pickle.load( fr)

with open('x_test.pkl', mode='rb') as fr:
    x_test=pickle.load( fr)

with open('t_test_a.pkl', mode='rb') as fr:
    t_test=pickle.load( fr)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

iters_num = 10000  # 繰り返しの回数を適宜設定する
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1

train_loss_list = []
train_acc_list = []
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    # 勾配の計算
    #grad = network.numerical_gradient(x_batch, t_batch)
    grad = network.gradient(x_batch, t_batch)
    
    # パラメータの更新
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    
    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))

# グラフの描画
import matplotlib.pyplot as plt
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, label='train acc')
plt.plot(x, test_acc_list, label='test acc', linestyle='--')
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()