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

（第８回）ＭＮＩＳＴ(その２)

第６回でも使っていましたが、誤差逆伝播法を使うと高速で学習ができるようになります。さらに、OrderedDictを使って、より簡単に使えるように変更します。

（参考サイト）https://github.com/oreilly-japan/deep-learning-from-scratch

＜実装する＞

基本は第６回と同じです。

①データセット
同じ物を使います。
train-images-idx3-ubyte.gz
train-labels-idx1-ubyte.gz
t10k-images-idx3-ubyte.gz
t10k-labels-idx1-ubyte.gz

次に下の６つのファイルをダウンロードします。

mnist.py
two_layer_net.py
gradient_2.py
functions.py
layers.py
util.py

次は、メインのプログラムになります。下のプログラムと同じフォルダに上の１０個（４個のデータセット＋６個のプログラム）のファイルを保存しておきます。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)
import pickle
import numpy as np
from mnist import load_mnist
from two_layer_net import TwoLayerNet

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

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)


techacademy = network.params['W1']
with open('My_w1.pkl', 'wb') as pikle_w1:
  pickle.dump(techacademy , pikle_w1)
  
techacademy = network.params['W2']
with open('My_w2.pkl', 'wb') as pikle_w2:
  pickle.dump(techacademy , pikle_w2)
  
techacademy = network.params['b1']
with open('My_b1.pkl', 'wb') as pikle_b1:
  pickle.dump(techacademy , pikle_b1)
  
techacademy = network.params['b2']
with open('My_b2.pkl', 'wb') as pikle_b2:
  pickle.dump(techacademy , pikle_b2)

このプログラムを実行すると、最初は、「mnist.pkl」というデータセットのファイルが無いので、最初にダウンロードした４個のファイルを展開して、データセットを作成します。実際には、

Converting train-images-idx3-ubyte.gz to NumPy Array ...
Done
Converting train-labels-idx1-ubyte.gz to NumPy Array ...
Done
Converting t10k-images-idx3-ubyte.gz to NumPy Array ...
Done
Converting t10k-labels-idx1-ubyte.gz to NumPy Array ...
Done
Creating pickle file ...
Done!
0.15018333333333334 0.1453
0.90415 0.9074
0.9234333333333333 0.928
0.9358666666666666 0.934
0.9450333333333333 0.9459
0.9525 0.9496
0.9578333333333333 0.9544
0.9623833333333334 0.9573
0.9648833333333333 0.9602
0.96715 0.9611
0.96975 0.9618
0.97275 0.9657
0.9745166666666667 0.9675
0.9758166666666667 0.968
0.9777333333333333 0.9687
0.9776 0.9698
0.9800166666666666 0.9702

このような出力になっていると思います。学習用のデータセット「mnist.pkl」が作成されます。その後学習が進みます。（１万回学習）学習が完了すると、他に「My_w1.pkl」「My_w2.pkl」「My_b1.pkl」「My_b2.pkl」の４つのファイルが作成されます。
この４つが重み付けのモデルになります。学習済みですので、これを読みだせば、自分の書いた文字を判定してなんの数字なのか？判定できるようになります。

作成したモデルの利用するプログラムは以下のとおりです。（メインと同じフォルダに保存します）

# coding: utf-8
import sys, os
import pickle
import numpy as np
from layers import *
from PIL import Image
import matplotlib.pyplot as plt
from collections import OrderedDict

class TwoLayerNet2:

    def __init__(self, w1,b1,w2,b2):
        # 重みの初期化
        self.params = {}
        self.params['W1'] = w1
        self.params['b1'] = b1
        self.params['W2'] = w2
        self.params['b2'] = b2

        # レイヤの生成
        self.layers = OrderedDict()
        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
        self.layers['Relu1'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])

        self.lastLayer = SoftmaxWithLoss()
        
    def predict(self, x):
        
        for layer in self.layers.values():
            x = layer.forward(x)
        return x
        
    # x:入力データ, t:教師データ
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)

#モデルを読みだす
with open('My_w1.pkl', 'rb') as  pikle_w1:
  My_w1 = pickle.load( pikle_w1)
with open('My_b1.pkl', 'rb') as  pikle_b1:
  My_b1 = pickle.load( pikle_b1)
with open('My_w2.pkl', 'rb') as  pikle_w2:
  My_w2 = pickle.load( pikle_w2)
with open('My_b2.pkl', 'rb') as  pikle_b2:
  My_b2 = pickle.load( pikle_b2)
network2 = TwoLayerNet2(My_w1,My_b1,My_w2,My_b2)
print(My_w1.shape)
print(My_b1.shape)
print(My_w2.shape)
print(My_b2.shape)


#print(loss)
#自分で書いた文字を表示
myimg = Image.open('test.png').convert('L')
myimg.thumbnail((28, 28)) # 28*28に変換
myimg = np.array(myimg) # numpy arrayに変換
plt.imshow(myimg)
plt.show()

#自分で書いた文字を判定
myimg_array=np.array(myimg.flatten())
myimg_array=myimg_array/255
myimg_array=myimg_array.reshape(1,784)
print(myimg_array.shape)

y = network2.predict(myimg_array)
print(y)
p=np.argmax(y)
print(p)

同じフォルダに「test.png」という手書き文字の画像を保存して、上のプログラムを実行します。
手書き文字を２８ｘ２８に変換して、学習済みモデルに通した後の出力を計算することができます。

出力：[[-1.991 0.1099 1.199 0.710 -0.415 -0.869 -3.016 3.801 -1.052 1.493]] このように、「７」の可能性が最も高いとが出力できています。７に近い形の２や９の確率も高めなのもわかります。
今回のＭＮＩＳＴには「two_layer_net.py」にOrderedDictをインポートしています。「Affine１（ｗ１，ｂ１）」→「ＲｅＬＵ」→「「Affine２（ｗ２，ｂ２）」→「SoftmaxWithLoss」の順で計算をさせている部分にOrderedDictが利用されていて、簡単に呼び出すことができるように作られています。

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

（第８回）ＭＮＩＳＴ(その２)

＜実装する＞

機械学習のメモ