cnnのクラス分類の精度を上げたい

Question

経緯

訳あってTensorflow1.5でKerasを使わずにクラス分類のCNNを実装したのですが、このコードを実行しても５エポックあたりで過学習が始まってしまい、訓練データに対する精度が100%になる時の検証データに対する精度は35%程度です。

学習に用いている画像データは32x32のrgb３チャネルの画像です。クラスは10クラスあり、各クラス500枚ずつ画像が与えられています。

最初はシンプルでコンパクトなネットワークにドロップアウト層を加えて過学習の抑制をしようと試みるも汎化性能は上がらず。
次に、ResNetに実装されているshortcut connectionを実装してみるも精度は上がらずといったところです。

他にも、学習データを3倍に水増ししたり、最適化に用いる手法を変えたりしてはみましたが、一向に精度が上がりません。

精度向上のためのアイデアがございましたら、お教えいただけると幸いです。

以下がソースコードになります。拙いコードですがよろしくお願いします。

import numpy as np
import tensorflow as tf
from PIL import Image
import os

img_list = []
label = {"airplane":0, "cat":1, "frog":2, "automobile":3, "deer":4,
         "horse":5, "ship":6 ,"bird":7, "dog":8, "truck":9}

for key in label:
    images = os.listdir("ディレクトリのパス" + key)
    for i in images:
        if i == ".DS_Store":
            continue
        
        else:
            image = np.array(Image.open("ディレクトリのパス" + key + "/"+i))/255
            img_list.append(image)

x_train_list = [];
t_train_list = [];
x_test_list = [];
t_test_list = [];
target = 0
train_num = 400
test_num = 100 #画像を4:1に分けて学習
for i in range(10):
        x_train_list += [img_list[500 * i + j] for j in range(train_num)]
        t_train_list += [target] * train_num
        x_test_list += [img_list[500 * i + 400 + j] for j in range(test_num)] #testと名前をつけていますが検証用データのことです
        t_test_list  += [target] * test_num;
        target += 1

x_train = np.array(x_train_list)
t_train = np.array(t_train_list)
t_train = np.identity(10)[t_train]
x_test = np.array(x_test_list)
t_test = np.array(t_test_list)
t_test = np.identity(10)[t_test]

shuffle_train = np.random.permutation(4000)
shuffle_test = np.random.permutation(1000)
x_train = x_train[shuffle_train[:4000]]
t_train = t_train[shuffle_train[:4000]]
x_test = x_test[shuffle_test[:1000]]
t_test = t_test[shuffle_test[:1000]]

# Global contrast normalization
mean = np.mean(x_train, axis=(1, 2, 3), keepdims=True)
std = np.std(x_train, axis=(1, 2, 3), keepdims=True)
x_train = (x_train - mean)/std

# 画像を[0,1]にする
x_min = np.min(x_train)
x_max = np.max(x_train)
x_train = (x_train - x_min)/(x_max - x_min)

rng = np.random.RandomState(1234)
#畳み込み層
class Conv:
    def __init__(self, filter_shape, strides, function=lambda x: x, padding="SAME"):
        self.W = tf.Variable(tf.truncated_normal(filter_shape, stddev = np.sqrt(2/np.prod(filter_shape[:3]))), name = "W")
        self.W = tf.Variable(rng.uniform(
                            low=-np.sqrt(6/(np.prod(filter_shape[:3]) + np.prod(filter_shape[:2]) * filter_shape[3])),
                            high=np.sqrt(6/(np.prod(filter_shape[:3]) + np.prod(filter_shape[:2]) * filter_shape[3])),
                            size=filter_shape
                            ).astype('float32'), name='W')
        self.b = tf.Variable(np.zeros((filter_shape[3]), dtype = "float32"), name = "b")
        self.function = function
        self.strides = strides
        self.padding = padding

    def f_prop(self, x):
        u = tf.nn.conv2d(x, self.W, strides=self.strides, padding=self.padding) + self.b
        return self.function(u)
    
#プーリング層
class Pooling:
    def __init__(self, ksize=[1,2,2,1], strides=[1,2,2,1], padding="SAME"):
        self.ksize = ksize
        self.strides = strides
        self.padding = padding
    
    def f_prop(self, x):
        return tf.nn.max_pool(x, ksize=self.ksize, strides=self.strides, padding=self.padding)
    
class Avg_Pooling:
    def __init__(self, ksize=[1,2,2,1], strides=[1,2,2,1], padding="SAME"):
        self.ksize = ksize
        self.strides = strides
        self.padding = padding
    
    def f_prop(self, x):
        return tf.nn.avg_pool(x, ksize=self.ksize, strides=self.strides, padding=self.padding)


#平滑化層
class Flatten:
    def f_prop(self, x):
        return tf.reshape(x, (-1, np.prod(x.get_shape().as_list()[1:])))

#全結合層
class Dense:
    def __init__(self, in_dim, out_dim, function=lambda x: x):
        self.W = tf.Variable(rng.uniform(
                            low=-np.sqrt(6/(in_dim + out_dim)),
                            high=np.sqrt(6/(in_dim + out_dim)),
                            size=(in_dim, out_dim)
                        ).astype('float32'), name='W')
        self.b = tf.Variable(np.zeros([out_dim]).astype('float32'), name = "b")
        self.function = function

    def f_prop(self, x):
        return self.function(tf.matmul(x, self.W) + self.b)

#BatchNormalizationの層
class BatchNorm:
    def __init__(self, shape, epsilon=np.float32(1e-5)):
        self.gamma = tf.Variable(np.ones(shape, dtype='float32'), name='gamma')
        self.beta  = tf.Variable(np.zeros(shape, dtype='float32'), name='beta')
        self.epsilon = epsilon

    def f_prop(self, x):
        if len(x.get_shape()) == 2:
            mean, var = tf.nn.moments(x, axes=0, keepdims=True)
            std = tf.sqrt(var + self.epsilon)
        elif len(x.get_shape()) == 4:
            mean, var = tf.nn.moments(x, axes=(0,1,2), keep_dims=True)
            std = tf.sqrt(var + self.epsilon)
        normalized_x = (x - mean) / std
        return self.gamma * normalized_x + self.beta
    
#活性化層
class Activation:
    def __init__(self, function=lambda x: x):
        self.function = function
    
    def f_prop(self, x):
        return self.function(x)

#shortcut connection
class rescell:
    def __init__(self, filter_shape):
        self.filter_shape = filter_shape
        
    def f_prop(self, input_data):
        strides=[1,1,1,1]
            
        x = Conv(self.filter_shape, strides).f_prop(input_data)
        x = BatchNorm((int(x.shape[1]), int(x.shape[2]), self.filter_shape[3])).f_prop(x)
        x = Activation(tf.nn.relu).f_prop(x)
        
        data = Conv((1,1, self.filter_shape[2],self.filter_shape[3]), strides).f_prop(input_data)
        
        x = Conv((self.filter_shape[0], self.filter_shape[1], self.filter_shape[3], self.filter_shape[3]), strides).f_prop(x)
        x = BatchNorm((int(x.shape[1]), int(x.shape[2]), self.filter_shape[3])).f_prop(x)
        x = tf.add(x, data)
        x = Activation(tf.nn.relu).f_prop(x)
        return x
                  
layers = [
    
    Conv((3, 3, 3, 32), [1,1,1,1]),
    Activation(tf.nn.relu),
    Pooling((1, 2, 2, 1)),
    
    rescell((3, 3, 32, 64)),
    rescell((3, 3, 64, 64)),
    rescell((3, 3, 64, 64)),
    
    Avg_Pooling((1, 2, 2, 1)),
    
    Flatten(),
    Dense(8*8*64, 8*8*64, tf.nn.relu),
    Dense(8*8*64, 10, tf.nn.softmax)
]
    
x = tf.placeholder(tf.float32, [None, 32, 32, 3])
t = tf.placeholder(tf.float32, [None, 10])


def f_props(layers, x):
    for layer in layers:
        x = layer.f_prop(x)
    return x

out = f_props(layers, x)

#損失関数
loss = tf.reduce_mean(-tf.reduce_sum(t * tf.log(out + 1e-5), axis = [1])) 

#訓練
train_step = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)

#評価
correct = tf.equal(tf.argmax(out,1), tf.argmax(t,1))
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    saver = tf.train.Saver()

    epoch_num = 51
    data_num = x_train.shape[0] #50000
    batch_size = 40
    batch_num = x_train.shape[0] // batch_size
    best_test_acc = 0
    for epoch in range(epoch_num):
 
        shuffle_idx = np.random.permutation(data_num)
        x_train = x_train[shuffle_idx[:12000]]
        t_train = t_train[shuffle_idx[:12000]]
 
        for i in range(batch_num):
            start = i * batch_size
            end = i * batch_size + batch_size
            sess.run(train_step, feed_dict = {x: x_train[start:end], t: t_train[start:end]})
            
        
        if epoch%5 == 0:    
            train_loss = sess.run(loss, feed_dict = {x: x_train, t: t_train})
            train_acc = sess.run(accuracy, feed_dict = {x: x_train, t: t_train})
            test_loss = sess.run(loss, feed_dict = {x: x_test, t: t_test})
            test_acc = sess.run(accuracy, feed_dict = {x: x_test, t: t_test})
            if best_test_acc < test_acc:
                best_test_acc = test_acc
                saver.save(sess, "テェックポイント保存用のディレクトリパス")
                print("best_test_acc: " + str(best_test_acc))
                
            print('epoch:{} \n \
                   tr_loss:{}\n \
                   tr_acc:{} \n \
                   tes_loss:{} \n \
                   tes_acc:{}'.format(epoch,
                                      train_loss,
                                      train_acc,
                                      test_loss,
                                      test_acc))

Comments

[Q71]

畳み込み層は1層？

Answer 1

精度向上のためのアイデアがございましたら、お教えいただけると幸いです。

ImageNet の学習済みモデルを使って、転移学習してはどうでしょうか。
モデルも自作するのではなく、VGG や ResNet など実績のあるものをパラメータ変更せずにそのまま流用するのがいいと思います。
TensorFlow に同梱されている Keras では、学習済みモデルが簡単に利用できるような API が提供されています。

Applications - Keras Documentation