2020-01-25

【PyTorch始めました】MNISTで学習させたニューラルネットワークに自分の手書き数字を認識させてみるリターンズ（畳込みニューラルネットワークとドロップアウトの効果)

[technology]以前にやった自分の手書き数字をMNISTを学習させたネットワークで認識すると認識率が悪かったのは過学習のせいかもしれない

ちょっと長いタイトルですみません。

以前にchainerで作ったMNIST分類用のニューラルネットワークに自分の手書き数字(といってもお絵かきツールでマウス描き)を認識させるというエントリで、認識率が50〜60%で、これをデータ不足と判断し、自分で書いた文字を追加学習させる事で精度を上げるという実験をしました。
rc30-popo.hatenablog.com

この時、50個ほどの自作データをMNISTの学習データの一部と置き換える事で85%くらいの認識率を得たのですが、1つ前のエントリ、
rc30-popo.hatenablog.com
でFashion MNISTを使ったネットワークのチューニングを行った結果として、以前にやった自分の手書き文字の認識精度が悪い理由の一つは学習データ不足だけではなく、過学習による汎化性能不足もあるのでは？と今更ながらに思いました。(以前のものは全結合のみ、ドロップアウト無し)

ちなみに自分で書いた手書き数字は以下の様なもので100x100のキャンバス上にマウスで0〜9の文字を書いたものです。グレースケールのpngに保存し、0を書いたファイルなら0n.pngの様にファイル名先頭に0が付く様にしてラベリングしています。背景色が白、前景色が黒で、MNISTのデータと反転しているので、MNISTを学習させたネットワークに分類させる時は白黒反転をさせる必要があります。

で、前回のエントリで作成したネットワークを使って同じ自作手書き文字をMNISTだけを学習した結果を使い分類させてみました。
比較として以前に使った全結合ネットワークでも同じ事を試してみました。PyTorchへの移植がめんどくさかったので、以前使ったコードはChainerのままです。

1)以前に使った全結合ネットワーク(chainer)

# DNN class
class DNN(Chain):
    def __init__(self):
        super(DNN, self).__init__(
            l1 = L.Linear(784,100),
            l2 = L.Linear(100,100),
            l3 = L.Linear(100,10)
        )
    def forward(self,x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        h3 = self.l3(h2)
        return h3

2)今回使ったCNN+ドロップアウト(pytorch)

# DNN class
class DNN(nn.Module):
    def __init__(self):
        super(DNN,self).__init__()
        self.cv1 = nn.Conv2d(1,32,3)
        self.cv2 = nn.Conv2d(32,64,3)
        self.l1 = nn.Linear(64 * 5 * 5,500)
        self.l2 = nn.Linear(500,10)
    def forward(self,x,train=True):
        c = F.dropout(F.max_pool2d(F.relu(self.cv1(x)),2),training = train)
        c = F.dropout(F.max_pool2d(F.relu(self.cv2(c)),2),training = train)
        # Chainerと異なり、全結合層に入力する前にshape変換が必要
        c = c.view(-1,64 * 5 * 5)
        h = F.relu(self.l1(c))
        h = F.dropout(h,training = train)
        h = self.l2(h)
        return h

2つのネットワークを30エポック回して、自作データ50本を認識させた結果です。

1)以前に使った全結合ネットワーク(chainer)	2)今回使ったCNN+ドロップアウト(pytorch)
MNISTのテストデータ10000個の認識率: 97.73% 自作データ50個の認識率: 52%	MNISTのテストデータ10000個の認識率: 99.33% 自作データ50個の認識率: 82%

以前は自分で書いたデータを1)の全結合ネットワークの学習データに食わせて85%程度の認識率でしたが、今回はMNISTのデータの学習のみで自分の手書き文字の認識率を82%まで上げる事が出来ました。学習データの不足は事実としても、過学習の影響もかなりあった様です。CNNと学習時にドロップアウトを使う事で汎化性能をかなり上げられる事が判ります。

1)に使ったコード:Chainer

# -*- Coding: utf-8 -*-
# OS
import os
# OpenCV
import cv2

# Numpy
import numpy as np
# Chainer
import chainer
import chainer.links as L
import chainer.functions as F
from chainer import Chain,optimizers,Variable
from chainer import serializers
import matplotlib.pyplot as plt

train, test = chainer.datasets.get_mnist()

x_train = []
x_test  = []
t_train = []
t_test  = []

for line in train:
    x_train.append(line[0])
    t_train.append(int(line[-1]))

for line in test:
    x_test.append(line[0])
    t_test.append(int(line[-1]))

x_train = np.array(x_train,dtype=np.float32)
x_test = np.array(x_test,dtype=np.float32)
t_train = np.array(t_train,dtype=np.int32)
t_test = np.array(t_test,dtype=np.int32)

# DNN class
class DNN(Chain):
    def __init__(self):
        super(DNN, self).__init__(
            l1 = L.Linear(784,100),
            l2 = L.Linear(100,100),
            l3 = L.Linear(100,10)
        )
    def forward(self,x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        h3 = self.l3(h2)
        return h3

# Create DNN class instance
model = DNN()

# Set optimizer
optimizer = optimizers.Adam()
optimizer.setup(model)

# Number of epochs
n_epoch = 30

# batch size
batch_size = 1000

# Execute Training

for epoch in range(n_epoch):
    sum_loss = 0
    perm = np.random.permutation(60000)
    for i in range(0, 60000, batch_size):
        x = Variable(x_train[perm[i:i+batch_size]])
        t = Variable(t_train[perm[i:i+batch_size]])
        y = model.forward(x)
        model.cleargrads()
        loss = F.softmax_cross_entropy(y, t)
        loss.backward()
        optimizer.update()
        sum_loss += loss.data*batch_size

    print("epoch: {}, mean loss: {}".format(epoch, sum_loss/60000))

# Save Result
#serializers.save_npz("mnist_model2.npz", model)
# Execute Test
cnt = 0
for i in range(10000):
    x = np.array([x_test[i]], dtype=np.float32)
    t = t_test[i]
    y = model.forward(x)
    y = np.argmax(y.data[0])
    if t == y:
        cnt += 1

# Display Result
print("accuracy: {}".format(cnt/(10000)))

# Execute Test
# 自分の手書き文字の分類試験。./mydata/下にpngファイルを配置
mydata_dir = './mydata/'

mydata_files = os.listdir(mydata_dir)
mydata_files.sort()

testcnt = 0
testok  = 0
for test_file in mydata_files:
    if test_file.endswith('.png'):
        testcnt += 1
        x_test_data = []
        label = int(test_file[0])
        image = cv2.imread(mydata_dir + test_file)
        image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
        image_resized = cv2.resize(image,(28,28),interpolation=cv2.INTER_AREA)
        image_gs = image_resized.flatten()
        x_test_data.append(image_gs)

        x_test = np.array([image_gs],dtype=np.float32)
        x_test /= 255

        x = np.array([x_test[0]],dtype=np.float32)
        y = model.forward(x)
        res = np.argmax(y.data[0])
        if res == label:
            testok += 1
            test_res_str = 'OK'
        else:
            test_res_str = 'NG'

        print(' test file = %s ,label = %d,test result = %d,%s' % (test_file,label,res,test_res_str))

# Display result
print('OK %d,NG %d,Total %d' % (testok,(testcnt - testok),testcnt))
print('accuracy: {}'.format(testok/testcnt))

2)に使ったコード: PyTorch

# -*- Coding: utf-8 -*-

# OS
import os
# OpenCV
import cv2
# Numpy
import numpy as np
# Chainer
# ★Chainerのdatasetsからmnistを引っ張るためchainerは残す
import chainer
# ★Pytorchをインポート
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

print('MNIST Deep Learning sample by PyTorch')
print(' PyTorch Version: ',torch.__version__)

# GPU availability check
if torch.cuda.is_available():
    device = 'cuda'
else:
    device = 'cpu'
print(' Device: ',device)

train, test = chainer.datasets.get_mnist()
#train, test = chainer.datasets.get_fashion_mnist()

x_train = []
x_test  = []
t_train = []
t_test  = []

for line in train:
    x_train.append(line[0])
    t_train.append(int(line[-1]))

for line in test:
    x_test.append(line[0])
    t_test.append(int(line[-1]))

x_train = np.array(x_train,dtype=np.float32)
x_test = np.array(x_test,dtype=np.float32)
# ★PyTorchでは分類クラスはintではなくlong
t_train = np.array(t_train,dtype=np.int64)
t_test = np.array(t_test,dtype=np.int64)

x_train = x_train.reshape(len(x_train),1,28,28)
x_test = x_test.reshape(len(t_test),1,28,28)

        
# DNN class
class DNN(nn.Module):
    def __init__(self):
        super(DNN,self).__init__()
        self.cv1 = nn.Conv2d(1,32,3)
        self.cv2 = nn.Conv2d(32,64,3)
        self.l1 = nn.Linear(64 * 5 * 5,500)
        self.l2 = nn.Linear(500,10)
    def forward(self,x,train=True):
        c = F.dropout(F.max_pool2d(F.relu(self.cv1(x)),2),training = train)
        c = F.dropout(F.max_pool2d(F.relu(self.cv2(c)),2),training = train)
        # Chainerと異なり、全結合層に入力する前にshape変換が必要
        c = c.view(-1,64 * 5 * 5)
        h = F.relu(self.l1(c))
        h = F.dropout(h,training = train)
        h = self.l2(h)
        return h

# Create DNN class instance
model = DNN().to(device)

# Set optimizer
# ★optimizerをセット
optimizer = optim.Adam(model.parameters())

# Number of epochs
n_epoch = 30

# batch size
batch_size = 1000

# predict batch size
predict_batch_size = 1000 

# Execute Training
for epoch in range(n_epoch):
    sum_loss = 0
    perm = np.random.permutation(60000)
    for i in range(0, 60000, batch_size):
# ★x_trainとy_trainをpytorchのTensorに変換
#   ここで変換は効率悪い気もするけど..元のコードベースを崩さないため
        x = torch.from_numpy(x_train[perm[i:i+batch_size]]).to(device)
        t = torch.from_numpy(t_train[perm[i:i+batch_size]]).to(device)
        y = model.forward(x,train=True)
# ★cleargrads()はzero_grad()に
        model.zero_grad()
# ★softmax_cross_entropy()→cross_entropy()
        loss = F.cross_entropy(y,t)
        loss.backward()
#  ★optimizer.update()はoptimizer.step()に
        optimizer.step()
        sum_loss += loss.data*batch_size

    print("epoch: {}, mean loss: {}".format(epoch, sum_loss/60000))

# Execute Test
cnt = 0


# ★テストデータを纏めて推論
# GPUのメモリに入りきらない場合があるので、推論もミニバッチで実施
for si in range(0,10000,predict_batch_size):
    x = torch.from_numpy(x_test[si:si+predict_batch_size]).to(device)
    y = model.forward(x,train=False)
# ★照合用に推論結果yをCPUに戻し、numpyの行列に変換
    y = y.cpu().detach().numpy()
# ★1点づつ答え合わせ
    for i in range(predict_batch_size):
        t = t_test[si + i]
        yi = np.argmax(y[i])
        if t == yi:
            cnt += 1

# Display Result
print("accuracy: {}".format(cnt/(10000)))

# Start test
mydata_dir = './mydata/'

mydata_files = os.listdir(mydata_dir)
mydata_files.sort()

testcnt = 0
testok  = 0
for test_file in mydata_files:
    if test_file.endswith('.png'):
        testcnt += 1
        x_test_data = []
        label = int(test_file[0])
        image = cv2.imread(mydata_dir + test_file)
        image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
        image_resized = cv2.resize(image,(28,28),interpolation=cv2.INTER_AREA)
        image_gs = image_resized.flatten()
        x_test_data.append(image_gs)

        x_test = np.array([image_gs],dtype=np.float32)
        x_test /= 255

        x = torch.from_numpy(np.array([x_test[0]],dtype=np.float32).reshape(1,1,28,28)).to(device)
        y = model.forward(x,train=False)
        y = y.cpu().detach().numpy()
        res = np.argmax(y[0])
        if res == label:
            testok += 1
            test_res_str = 'OK'
        else:
            test_res_str = 'NG'

        print(' test file = %s ,label = %d,test result = %d,%s' % (test_file,label,res,test_res_str))
#        print(y[0])

# Display result
print('OK %d,NG %d,Total %d' % (testok,(testcnt - testok),testcnt))
print('accuracy: {}'.format(testok/testcnt))

2020-01-17

【PyTorch始めました】ChainerからPyTorchに移植した畳み込みニューラルネットワークでFashion MNISTを分類する+汎化性能改善を試す

[technology]Fashion MNISTをPyTorch版の畳み込みニューラルネットワークに掛けてみる

Fashion MNISTというのはMNISTと同じデータ形式で、画像を手書き数字ではなく、Tシャツやバッグ等の絵に置き換えたものです。
詳細を下記あたりの記事を参考にしてください。
qiita.com
github.com

弊ブログの記事、
rc30-popo.hatenablog.com
で、Chainer用に書いたMNISTの畳み込みニューラルネットワークによる学習スクリプトをPyTorchに移植しました。
このスクリプトを使って、Fashion MNISTを学習、分類してみます。

上記の記事に載せたコードはChainer用に用意したデータセットをPyTorchで記述したニューラルネットワークに入力する変則コードになっています。(もともとChainer用に書いたコードをPyTorchに移植、移行する実験のため)
MNISTのデータセットはchainer.datasets.get_mnist()で取得出来ますが、Fashion MNISTのデータセットもchainer.datasetsで取得できるので、下記の様に1行だけコードを書き換えます。

#train, test = chainer.datasets.get_mnist()
train, test = chainer.datasets.get_fashion_mnist()

これで実行してみると。

$ python f_mnist_cnn_test_torch_gpu.py
MNIST Deep Learning sample by PyTorch
 PyTorch Version:  1.3.1
 Device:  cuda
epoch: 0, mean loss: 1.602173089981079
epoch: 1, mean loss: 0.7937408685684204
epoch: 2, mean loss: 0.6959575414657593
epoch: 3, mean loss: 0.6460543274879456
epoch: 4, mean loss: 0.6101723313331604
epoch: 5, mean loss: 0.5832085609436035
epoch: 6, mean loss: 0.5586143136024475
epoch: 7, mean loss: 0.5385422706604004
epoch: 8, mean loss: 0.5222655534744263
epoch: 9, mean loss: 0.5040879249572754
epoch: 10, mean loss: 0.4896630644798279
epoch: 11, mean loss: 0.4790268540382385
epoch: 12, mean loss: 0.46714669466018677
epoch: 13, mean loss: 0.4546925723552704
epoch: 14, mean loss: 0.44705063104629517
epoch: 15, mean loss: 0.4386482834815979
epoch: 16, mean loss: 0.4348416328430176
epoch: 17, mean loss: 0.4228558838367462
epoch: 18, mean loss: 0.41755232214927673
epoch: 19, mean loss: 0.413984477519989
accuracy: 0.8429

こんな感じで正解率は84%。MNISTが割と簡単に96〜98%とか出るのに比べると正解率低めです。
エポック数を100まで増やしてみます。

$ python f_mnist_cnn_test_torch_gpu.py
MNIST Deep Learning sample by PyTorch
 PyTorch Version:  1.3.1
 Device:  cuda
epoch: 0, mean loss: 1.4492143392562866
epoch: 1, mean loss: 0.7108485698699951
epoch: 2, mean loss: 0.6192865967750549
epoch: 3, mean loss: 0.5673171281814575
epoch: 4, mean loss: 0.5317571759223938
〜中略〜
epoch: 95, mean loss: 0.18008953332901
epoch: 96, mean loss: 0.17909875512123108
epoch: 97, mean loss: 0.1781744360923767
epoch: 98, mean loss: 0.17554377019405365
epoch: 99, mean loss: 0.17671321332454681
accuracy: 0.8907

エポック数100でも正解率90%を超えられません。

[technology]ニューラルネットワークの汎化性能改善

そこで畳み込みニューラルネットワークのチャンネル数と中間層のノード数を増やしてみます。

前回記事のネットワーク	強化したネットワーク
class DNN(nn.Module): def __init__(self): super(DNN,self).__init__() self.cv1 = nn.Conv2d(1,5,4) self.cv2 = nn.Conv2d(5,10,4) self.l1 = nn.Linear(10 * 4 * 4,100) self.l2 = nn.Linear(100,10) def forward(self,x): c = F.max_pool2d(F.relu(self.cv1(x)),2) c = F.max_pool2d(F.relu(self.cv2(c)),2) c = c.view(-1,10 * 4 * 4) h = F.relu(self.l1(c)) h = self.l2(h) return h	class DNN(nn.Module): def __init__(self): super(DNN,self).__init__() self.cv1 = nn.Conv2d(1,16,4) self.cv2 = nn.Conv2d(16,32,4) self.l1 = nn.Linear(32 * 4 * 4,500) self.l2 = nn.Linear(500,10) def forward(self,x): c = F.max_pool2d(F.relu(self.cv1(x)),2) c = F.max_pool2d(F.relu(self.cv2(c)),2) c = c.view(-1,32 * 4 * 4) h = F.relu(self.l1(c)) h = self.l2(h) return h

前回記事のネットワーク

強化したネットワーク

class DNN(nn.Module):
    def __init__(self):
        super(DNN,self).__init__()
        self.cv1 = nn.Conv2d(1,5,4)
        self.cv2 = nn.Conv2d(5,10,4)
        self.l1 = nn.Linear(10 * 4 * 4,100)
        self.l2 = nn.Linear(100,10)
    def forward(self,x):
        c = F.max_pool2d(F.relu(self.cv1(x)),2)
        c = F.max_pool2d(F.relu(self.cv2(c)),2)
        c = c.view(-1,10 * 4 * 4)
        h = F.relu(self.l1(c))
        h = self.l2(h)
        return h

class DNN(nn.Module):
    def __init__(self):
        super(DNN,self).__init__()
        self.cv1 = nn.Conv2d(1,16,4)
        self.cv2 = nn.Conv2d(16,32,4)
        self.l1 = nn.Linear(32 * 4 * 4,500)
        self.l2 = nn.Linear(500,10)
    def forward(self,x):
        c = F.max_pool2d(F.relu(self.cv1(x)),2)
        c = F.max_pool2d(F.relu(self.cv2(c)),2)
        c = c.view(-1,32 * 4 * 4)
        h = F.relu(self.l1(c))
        h = self.l2(h)
        return h

畳み込みとMAX POOLINGを2段掛けていますが、1段目の畳み込みの出力を5チャンネル→16チャンネル、2段目の畳み込みの出力を10チャンネル→32チャンネルに増やしています。合わせて、それを受ける中間層のノード数を100→500ノードに増やしました。これで試します。

$ python f_mnist_cnn_test_torch_gpu.py
MNIST Deep Learning sample by PyTorch
 PyTorch Version:  1.3.1
 Device:  cuda
epoch: 0, mean loss: 1.0667693614959717
epoch: 1, mean loss: 0.6207329034805298
epoch: 2, mean loss: 0.5368128418922424
epoch: 3, mean loss: 0.4838525950908661
epoch: 4, mean loss: 0.44583263993263245
〜中略〜
epoch: 45, mean loss: 0.16773974895477295
epoch: 46, mean loss: 0.1631971299648285
epoch: 47, mean loss: 0.1589423418045044
epoch: 48, mean loss: 0.15731170773506165
epoch: 49, mean loss: 0.1543945074081421
accuracy: 0.9053

50エポック学習して正解率90%を超えました。同じネットワークで150エポック回してみると、

$ python f_mnist_cnn_test_torch_gpu.py
MNIST Deep Learning sample by PyTorch
 PyTorch Version:  1.3.1
 Device:  cuda
epoch: 0, mean loss: 1.0521917343139648
epoch: 1, mean loss: 0.6028405427932739
epoch: 2, mean loss: 0.5300793051719666
epoch: 3, mean loss: 0.48052194714546204
epoch: 4, mean loss: 0.4372819662094116
〜中略〜
epoch: 145, mean loss: 0.011501261964440346
epoch: 146, mean loss: 0.00985863246023655
epoch: 147, mean loss: 0.008198190480470657
epoch: 148, mean loss: 0.009277496486902237
epoch: 149, mean loss: 0.008205198682844639
accuracy: 0.9054

こんな感じで損失は減るのですが、正解率はほとんど変化しません。単に学習データを過学習しているだけの様です。
精度を上げるにはネットワークの構成自体をチューニングする必要がありそうです。

色々試行錯誤の上、下記の様なモデルを作りました。

class DNN(nn.Module):
    def __init__(self):
        super(DNN,self).__init__()
        self.cv1 = nn.Conv2d(1,32,3)
        self.cv2 = nn.Conv2d(32,64,3)
        self.l1 = nn.Linear(64 * 5 * 5,500)
        self.l2 = nn.Linear(500,10)
    def forward(self,x,train=True):
        c = F.dropout(F.max_pool2d(F.relu(self.cv1(x)),2),training = train)
        c = F.dropout(F.max_pool2d(F.relu(self.cv2(c)),2),training = train)
        # Chainerと異なり、全結合層に入力する前にshape変換が必要
        c = c.view(-1,64 * 5 * 5)
        h = F.relu(self.l1(c))
        h = F.dropout(h,training = train)
        h = self.l2(h)
        return h

変更点は以下の通りです。

カーネルサイズを4→3に変更。
1段目、2段目の畳み込みの出力チャンネル数を16→32,32→64と倍増。
畳み込み+MAX POOLINGと全結合の各層の出力に過学習を防ぐためのドロップアウトを入れる。ドロップアウトは学習時有効、推論時無効とする。(ドロップアウト制御用フラグ引数trainをforward()に追加)

このモデルで200エポック回した時の結果は以下の通り。

$ python f_mnist_cnn_test_torch_gpu.py
MNIST Deep Learning sample by PyTorch
 PyTorch Version:  1.3.1
 Device:  cuda
epoch: 0, mean loss: 1.005088210105896
epoch: 1, mean loss: 0.6146973967552185
epoch: 2, mean loss: 0.5396274328231812
epoch: 3, mean loss: 0.4939133822917938
epoch: 4, mean loss: 0.46335190534591675
〜中略〜
epoch: 195, mean loss: 0.16906757652759552
epoch: 196, mean loss: 0.16961127519607544
epoch: 197, mean loss: 0.16971048712730408
epoch: 198, mean loss: 0.16554950177669525
epoch: 199, mean loss: 0.16842873394489288
accuracy: 0.9278

正解率92.78%まで上がりました。ネットで探すと94%ぐらい出している人も居るのですが、なかなか精度上げるの難しいです。
畳み込みを3段にしたモデルも試しましたが最適化が進まなくなり、2段の方が簡単に精度が出る感じです。

ローリングコンバットピッチなう！

AIとか仮想化とかペーパークラフトとか