終了済み: 「くずし字」識別チャレンジ

β版ProbSpaceコンペ第2弾!

賞金: 100,000 参加チーム数: 139 6ヶ月前に終了

Kaggle MNISTの人気チュートリアル の適用

Kaggle MNISTの人気チュートリアル の適用

MCTK

2019/12/01

KaggleのDigit Recognizer(MNIST)のYassine Ghouzam氏のノートブック Introduction to CNN Keras - 0.997 (top 6%) をそのままくずし字識別チャレンジ(KMNIST)に適用しました。

ディープラーニング初心者の自分の勉強のために翻訳してみましたが、他の人の役に立つかもしれないと思い投稿します。

  • 1. はじめに
  • 2. データの準備
    • 2.1 データの読み込み
    • 2.2 NULL値と欠落値のチェック
    • 2.3 正規化
    • 2.4 データの変形
    • 2.5 ラベルエンコーディング
    • 2.6 学習データと検証データの分割
  • 3. CNN
    • 3.1 モデルの定義
    • 3.2 オプティマイザーとアニーラーの設定
    • 3.3 データの水増し(augmentation)
  • 4. モデルの評価
    • 4.1 学習曲線と検証曲線
    • 4.2 混同行列
  • 5. 予測と提出
    • 5.1 予測と結果の提出

1. はじめに

このノートブックは、くずし字データセット(KMNIST)の文字認識用の、5層の一続きの畳み込みニューラルネットワーク(CNN)です。 非常に直感的であるkeras API(Tensorflowバックエンド)で構築することにしました。 まず、データ(くずし字の画像)を準備し、次にCNNのモデリングと評価に焦点を当てます。

このノートブックは、次の3つの主要部分で構成されます。

  • データ準備
  • CNNのモデリングと評価
  • 結果の予測と提出
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import seaborn as sns
%matplotlib inline

np.random.seed(2)

from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import itertools

from keras.utils.np_utils import to_categorical # convert to one-hot-encoding
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras.optimizers import RMSprop
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import ReduceLROnPlateau


sns.set(style='white', context='notebook', palette='deep')
Using TensorFlow backend.

2. データ準備

2.1 データの読み込み

# Load the data
Train_imgs = np.load("./data/kmnist-train-imgs.npz")['arr_0']
Train_labels = np.load("./data/kmnist-train-labels.npz")['arr_0']
Test_imgs = np.load("./data/kmnist-test-imgs.npz")['arr_0']
# 文字対応リストと日本語対応フォントの設定
labels = { 0: 'お', 1: 'き', 2: 'す', 3: 'つ', 4: 'な', 
          5: 'は', 6: 'ま', 7: 'や', 8 : 'れ', 9 : 'を'}
# plt.rcParams['font.family'] = 'IPAPGothic'
plt.rcParams['font.family'] = 'Malgun Gothic'
# Train_labelsをpandas.DataFrame形式に変形
Y_train = pd.DataFrame(Train_labels, columns=['label'])
Y_train = Y_train['label']
g = sns.countplot(Y_train)

Y_train.value_counts()
9    6000
8    6000
7    6000
6    6000
5    6000
4    6000
3    6000
2    6000
1    6000
0    6000
Name: label, dtype: int64

10文字がそれぞれ6,000個ずつ含まれています。

2.2 NULL値と欠落値のチェック

# Train_imgsとTest_imgsをいったん一次元データにしてDataFrame形式に変形
Train_imgs_x = Train_imgs.reshape(-1,784)
Test_imgs_x = Test_imgs.reshape(-1,784)

X_train = pd.DataFrame(Train_imgs_x)
test = pd.DataFrame(Test_imgs_x)
#Check the data
X_train.isnull().any().describe()
count       784
unique        1
top       False
freq        784
dtype: object
test.isnull().any().describe()
count       784
unique        1
top       False
freq        784
dtype: object

破損した画像(欠落値が含まれている)の有無をチェックしました。

学習及びテストのデータセットに欠落値はなく、安全に先に進めることができます。

2.3 正規化

イルミネーションディファレンスの影響を減らすため、グレイスケール正規化をします。

また、CNNは「0~255」のデータより「0~1」のデータの方が早く収束します。

# Normalize the data
X_train = X_train / 255.0
test = test / 255.0

2.4 データの変形

# Reshape image in 3 dimensions (height = 28px, width = 28px , canal = 1)
X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1)

学習画像及びテスト画像(28px x 28px)は、要素数784個の一次元ベクトルとして、pandas.Dataframeに収められています。ここで、すべてのデータを28×28×1の3次元配列に変形しました。

Kerasは、配列の最後に、チャンネル数と同じ要素数の追加の次元を必要とします。KMNIST画像はグレイスケールなので、1チャンネルのみ使用します。RGB画像では、3チャンネルあるため、784pxを28×28×3の3次元配列に変形します。

2.5 ラベルエンコーディング

# Encode labels to one hot vectors (ex : 2 -> [0,0,1,0,0,0,0,0,0,0])
Y_train = to_categorical(Y_train, num_classes = 10)

正解データのラベルは0~9の10個の数字です。これらのラベルをOne-Hotベクトルにエンコードする必要があります。(ex : 2 -> [0,0,1,0,0,0,0,0,0,0]).

2.6 学習データと検証データの分割

# Set the random seed
random_seed = 2
# Split the train and the validation set for the fitting
X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=random_seed, stratify = Y_train)

学習データセットを2分割することを選択しました。一部(10%)は検証データセットとしてモデルの評価し、残り(90%)はモデルの学習のために使用します。

ラベルが均等に分散した(2.1データの読み込み参照)60,000個の学習用画像があるので、学習データセットのランダムな分割により、いくつかのラベルが検証データセットに過剰に分類されることはありません。ラベルが均等に分散していないデータセットでは、単純なランダム分割では検証で不正確な評価を引き起こす可能性があることに注意しなければなりません。

このことを避けるために、train_test_split関数のstratify = Trueオプションを使用することができます。(バージョン0.17以上の sklearn のみ)

学習データの画像例を示します。

# Some examples
g = plt.imshow(X_train[0][:,:,0])

3. CNN

3.1 モデルの定義

Keras Sequential APIを使用しました。入力から始めて、一度に1つの層を追加するだけです。

1つ目は畳み込み(Conv2D)層です。学習可能なフィルタのセットのようなものです。最初の2つのconv2D層に32個のフィルタを、最後の2つの層に64個のフィルタを設定することにしました。各フィルタは、カーネルフィルタを使用して、画像の一部(カーネルサイズで定義)を変換します。カーネルフィルタ配列は画像全体に適用されます。フィルタは、画像の変形として見ることができます。

CNNは、これらの変換された画像(機能マップ)からどこでも役立つ機能を分離できます。

CNNの2番目の重要な層は、プーリング(MaxPool2D)層です。この層は、単にダウンサンプリングフィルタとして機能します。隣接する2つのピクセルを見て、最大値を選択します。これらは計算コストを削減するために使用され、ある程度、過学習を削減します。プーリングサイズ(つまり、一回でプールされるエリアのサイズ)を選択する必要があります。プーリング次元が大きいほど、ダウンサンプリングが重要になります。畳み込み層とプーリング層を組み合わせることで、CNNは画像の局所的な特徴を組み合わせて、より大きな特徴を学習できます。

ドロップアウトは正則化方法で、各学習サンプルについて、層内のある割合のノードがランダムに無視されます(重みをゼロに設定)。これにより、ある割合のネットワークがランダムに削除され、ネットワークが分散された方法で特徴を学習します。また、この手法は汎化を改善し、過学習を減らします。

「relu」は整流器です(活性化関数 max(0、x))。整流器活性化関数は、ネットワークに非線形性を追加するために使用されます。

平坦化層は、最終的な特徴マップを1つの単一の一次元ベクトルに変換するために使用されます。畳み込み/最大プーリング層の後に全結合層を使用できるように、この平坦化手順が必要です。これは、前の畳み込み層で見つかったすべての局所特徴を結合します。

最後に、仮想的なニューラルネットワーク(ANN)分類器である2つの全結合(高密度)層の機能を使用しました。最後の層(Dense(10、activation = "softmax"))で、ネットは各クラスの確率分布を出力します。

# Set the CNN model 
# my CNN architechture is In -> [[Conv2D->relu]*2 -> MaxPool2D -> Dropout]*2 -> Flatten -> Dense -> Dropout -> Out

model = Sequential()

model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same', 
                 activation ='relu', input_shape = (28,28,1)))
model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same', 
                 activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))


model.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', 
                 activation ='relu'))
model.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', 
                 activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
model.add(Dropout(0.25))


model.add(Flatten())
model.add(Dense(256, activation = "relu"))
model.add(Dropout(0.5))
model.add(Dense(10, activation = "softmax"))
WARNING:tensorflow:From C:\Users\mctki\Anaconda3\lib\site-packages\tensorflow\python\framework\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Colocations handled automatically by placer.
WARNING:tensorflow:From C:\Users\mctki\Anaconda3\lib\site-packages\keras\backend\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.
Instructions for updating:
Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.

3.2 オプティマイザーとアニーラーの設定

層をモデルに追加したら、スコア関数、損失関数、最適化アルゴリズムを設定する必要があります。

損失関数を定義して、既知のラベルを持つ画像でモデルがどの程度パフォーマンスが悪いかを測定します。これは、観察されたラベルと予測されたラベルとの間のエラー率です。 「categorical_crossentropy(交差エントロピー)」と呼ばれるカテゴリ分類(> 2クラス)は特定の形式を使用します。

最も重要な機能はオプティマイザーです。この関数は、損失を最小化するために、パラメータを繰り返し改善します(カーネル値、ニューロンの重みとバイアスをフィルターします)。

RMSprop(デフォルト値)を選択しました。これは非常に効果的なオプティマイザーです。 RMSPropの更新プログラムは、攻撃的な単調減少の学習率を減らすために、非常に簡単な方法でAdagradメソッドを調整します。 確率的勾配降下法( 'sgd')オプティマイザーを使用することもできましたが、RMSpropよりも低速です。

計測関数「accuracy」は、モデルのパフォーマンスを評価するために使用されます。この計測関数は損失関数に似ていますが、モデルを学習するときに計測評価の結果が使用されない点が異なります(評価のみ)。

# Define the optimizer
optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
# Compile the model
model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])

オプティマイザをより速く収束させ、損失関数の大域的な最小値に最も近づけるために、学習率(LR)のアニーリング手法を使用しました。

LRは、オプティマイザーが「損失関数分布」を通過するステップです。 LRが高いほど、ステップは大きくなり、収束は速くなります。 ただし、LRが高いとサンプリングが非常に悪くなり、オプティマイザーは極小値になる可能性があります。

損失関数の大域的な最小値に効率的に到達するには、学習中に学習率を低下させることが望ましいです。

高いLRでの高速な計算時間の利点を維持するために、必要に応じて(accuracyが向上しない場合)に応じて、Xステップ(エポック)ごとにLRを動的に減少させました。

Keras.callbacksのReduceLROnPlateau関数を使用して、3エポック後に精度が改善されない場合、LRを半分に減らすことを選択します。

# Set a learning rate annealer
learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc', 
                                            patience=3, 
                                            verbose=1, 
                                            factor=0.5, 
                                            min_lr=0.00001)
epochs = 30
batch_size = 86

3.3 データの水増し(augmentation)

過学習の問題を回避するために、KMNISTデータセットを人工的に拡張する必要があります。既存のデータセットをさらに大きくすることができます。アイデアは、学習データを小さな変換で変更して、誰かがくずし字を書いているときに発生する変動を再現することです。

たとえば、数字が中央に配置されていない、縮尺が同じではない(大きい/小さい字で書く人もいます)画像を回転などです。

ラベルを同じに保ちながら配列表現を変更する方法で学習データを変更するアプローチは、データ水増し技術(augmentation)として知られています。人々が使用する人気のある拡張機能には、グレースケール、水平反転、垂直反転、ランダムクロップ、色ジッター、変換、回転などがあります。

これらの変換を学習データに適用するだけで、学習サンプルの数を簡単に2倍または3倍にし、非常に堅牢なモデルを作成できます。

# Without data augmentation
history = model.fit(X_train, Y_train, batch_size = batch_size, epochs = epochs, validation_data = (X_val, Y_val), verbose = 2)
WARNING:tensorflow:From C:\Users\mctki\Anaconda3\lib\site-packages\tensorflow\python\ops\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use tf.cast instead.
Train on 54000 samples, validate on 6000 samples
Epoch 1/30
 - 133s - loss: 0.4190 - acc: 0.8707 - val_loss: 0.1117 - val_acc: 0.9672
Epoch 2/30
 - 135s - loss: 0.1256 - acc: 0.9631 - val_loss: 0.0591 - val_acc: 0.9828
Epoch 3/30
 - 131s - loss: 0.0909 - acc: 0.9739 - val_loss: 0.0559 - val_acc: 0.9812
Epoch 4/30
 - 130s - loss: 0.0762 - acc: 0.9777 - val_loss: 0.0508 - val_acc: 0.9840
Epoch 5/30
 - 133s - loss: 0.0742 - acc: 0.9796 - val_loss: 0.0584 - val_acc: 0.9847
Epoch 6/30
 - 127s - loss: 0.0663 - acc: 0.9814 - val_loss: 0.0552 - val_acc: 0.9857
Epoch 7/30
 - 133s - loss: 0.0722 - acc: 0.9804 - val_loss: 0.0476 - val_acc: 0.9858
Epoch 8/30
 - 136s - loss: 0.0724 - acc: 0.9805 - val_loss: 0.0440 - val_acc: 0.9867
Epoch 9/30
 - 135s - loss: 0.0737 - acc: 0.9809 - val_loss: 0.0479 - val_acc: 0.9870
Epoch 10/30
 - 133s - loss: 0.0771 - acc: 0.9802 - val_loss: 0.0467 - val_acc: 0.9883
Epoch 11/30
 - 131s - loss: 0.0792 - acc: 0.9801 - val_loss: 0.0519 - val_acc: 0.9877
Epoch 12/30
 - 134s - loss: 0.0793 - acc: 0.9803 - val_loss: 0.0693 - val_acc: 0.9820
Epoch 13/30
 - 134s - loss: 0.0864 - acc: 0.9791 - val_loss: 0.0515 - val_acc: 0.9873
Epoch 14/30
 - 129s - loss: 0.0877 - acc: 0.9796 - val_loss: 0.0477 - val_acc: 0.9878
Epoch 15/30
 - 129s - loss: 0.0834 - acc: 0.9794 - val_loss: 0.0458 - val_acc: 0.9893
Epoch 16/30
 - 131s - loss: 0.0913 - acc: 0.9791 - val_loss: 0.0431 - val_acc: 0.9882
Epoch 17/30
 - 131s - loss: 0.0887 - acc: 0.9791 - val_loss: 0.0451 - val_acc: 0.9885
Epoch 18/30
 - 129s - loss: 0.0959 - acc: 0.9784 - val_loss: 0.0467 - val_acc: 0.9882
Epoch 19/30
 - 133s - loss: 0.0935 - acc: 0.9782 - val_loss: 0.0478 - val_acc: 0.9885
Epoch 20/30
 - 131s - loss: 0.0955 - acc: 0.9787 - val_loss: 0.0498 - val_acc: 0.9888
Epoch 21/30
 - 131s - loss: 0.1012 - acc: 0.9773 - val_loss: 0.0512 - val_acc: 0.9867
Epoch 22/30
 - 135s - loss: 0.1066 - acc: 0.9767 - val_loss: 0.0492 - val_acc: 0.9868
Epoch 23/30
 - 131s - loss: 0.1028 - acc: 0.9767 - val_loss: 0.0694 - val_acc: 0.9828
Epoch 24/30
 - 134s - loss: 0.1006 - acc: 0.9771 - val_loss: 0.0527 - val_acc: 0.9872
Epoch 25/30
 - 135s - loss: 0.1061 - acc: 0.9761 - val_loss: 0.0693 - val_acc: 0.9845
Epoch 26/30
 - 107s - loss: 0.1008 - acc: 0.9765 - val_loss: 0.0565 - val_acc: 0.9877
Epoch 27/30
 - 128s - loss: 0.1076 - acc: 0.9759 - val_loss: 0.0549 - val_acc: 0.9890
Epoch 28/30
 - 132s - loss: 0.1144 - acc: 0.9752 - val_loss: 0.1788 - val_acc: 0.9730
Epoch 29/30
 - 123s - loss: 0.1103 - acc: 0.9756 - val_loss: 0.0621 - val_acc: 0.9838
Epoch 30/30
 - 108s - loss: 0.1147 - acc: 0.9751 - val_loss: 0.0559 - val_acc: 0.9858
# With data augmentation to prevent overfitting

datagen = ImageDataGenerator(
        featurewise_center=False,  # set input mean to 0 over the dataset
        samplewise_center=False,  # set each sample mean to 0
        featurewise_std_normalization=False,  # divide inputs by std of the dataset
        samplewise_std_normalization=False,  # divide each input by its std
        zca_whitening=False,  # apply ZCA whitening
        rotation_range=10,  # randomly rotate images in the range (degrees, 0 to 180)
        zoom_range = 0.1, # Randomly zoom image 
        width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
        height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
        horizontal_flip=False,  # randomly flip images
        vertical_flip=False)  # randomly flip images


datagen.fit(X_train)

データの水増し(Augmentation)のために、以下を選択しました:

  • 一部のトレーニング画像を10度ランダムに回転します
  • 一部のトレーニング画像を10%ランダムに拡大します
  • 画像を水平方向に全幅の10%ランダムに移動します
  • 画像を垂直方向に全高の10%ランダムに移動します

vertical_flip(垂直回転)やhorizontal_flip(水平回転)は適用しませんでした。

モデルの準備ができたら、学習データセットで学習します。

# Fit the model
history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
                              epochs = epochs, validation_data = (X_val,Y_val),
                              verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size
                              , callbacks=[learning_rate_reduction])
Epoch 1/30
 - 103s - loss: 0.3623 - acc: 0.9112 - val_loss: 0.0664 - val_acc: 0.9838
Epoch 2/30
 - 103s - loss: 0.3078 - acc: 0.9236 - val_loss: 0.0936 - val_acc: 0.9847
Epoch 3/30
 - 103s - loss: 0.2919 - acc: 0.9270 - val_loss: 0.0894 - val_acc: 0.9840
Epoch 4/30
 - 103s - loss: 0.2822 - acc: 0.9302 - val_loss: 0.0579 - val_acc: 0.9853
Epoch 5/30
 - 103s - loss: 0.2747 - acc: 0.9338 - val_loss: 0.0722 - val_acc: 0.9863
Epoch 6/30
 - 104s - loss: 0.2618 - acc: 0.9357 - val_loss: 0.0974 - val_acc: 0.9828
Epoch 7/30
 - 103s - loss: 0.2584 - acc: 0.9363 - val_loss: 0.0769 - val_acc: 0.9812
Epoch 8/30
 - 103s - loss: 0.2597 - acc: 0.9379 - val_loss: 0.0692 - val_acc: 0.9838

Epoch 00008: ReduceLROnPlateau reducing learning rate to 0.0005000000237487257.
Epoch 9/30
 - 103s - loss: 0.1916 - acc: 0.9513 - val_loss: 0.0607 - val_acc: 0.9880
Epoch 10/30
 - 103s - loss: 0.1825 - acc: 0.9535 - val_loss: 0.0513 - val_acc: 0.9865
Epoch 11/30
 - 103s - loss: 0.1854 - acc: 0.9517 - val_loss: 0.0897 - val_acc: 0.9867
Epoch 12/30
 - 103s - loss: 0.1851 - acc: 0.9520 - val_loss: 0.1099 - val_acc: 0.9858

Epoch 00012: ReduceLROnPlateau reducing learning rate to 0.0002500000118743628.
Epoch 13/30
 - 102s - loss: 0.1529 - acc: 0.9587 - val_loss: 0.0565 - val_acc: 0.9885
Epoch 14/30
 - 102s - loss: 0.1557 - acc: 0.9599 - val_loss: 0.0478 - val_acc: 0.9887
Epoch 15/30
 - 102s - loss: 0.1528 - acc: 0.9596 - val_loss: 0.0724 - val_acc: 0.9870
Epoch 16/30
 - 102s - loss: 0.1540 - acc: 0.9604 - val_loss: 0.0825 - val_acc: 0.9857
Epoch 17/30
 - 102s - loss: 0.1559 - acc: 0.9597 - val_loss: 0.0565 - val_acc: 0.9885

Epoch 00017: ReduceLROnPlateau reducing learning rate to 0.0001250000059371814.
Epoch 18/30
 - 8807s - loss: 0.1356 - acc: 0.9643 - val_loss: 0.0613 - val_acc: 0.9888
Epoch 19/30
 - 108s - loss: 0.1400 - acc: 0.9629 - val_loss: 0.0630 - val_acc: 0.9887
Epoch 20/30
 - 108s - loss: 0.1314 - acc: 0.9638 - val_loss: 0.0808 - val_acc: 0.9880
Epoch 21/30
 - 110s - loss: 0.1321 - acc: 0.9645 - val_loss: 0.0537 - val_acc: 0.9890
Epoch 22/30
 - 108s - loss: 0.1318 - acc: 0.9653 - val_loss: 0.0485 - val_acc: 0.9890
Epoch 23/30
 - 113s - loss: 0.1354 - acc: 0.9630 - val_loss: 0.0480 - val_acc: 0.9893
Epoch 24/30
 - 136s - loss: 0.1327 - acc: 0.9637 - val_loss: 0.0496 - val_acc: 0.9887
Epoch 25/30
 - 144s - loss: 0.1319 - acc: 0.9644 - val_loss: 0.0529 - val_acc: 0.9893
Epoch 26/30
 - 145s - loss: 0.1360 - acc: 0.9631 - val_loss: 0.0524 - val_acc: 0.9883

Epoch 00026: ReduceLROnPlateau reducing learning rate to 6.25000029685907e-05.
Epoch 27/30
 - 128s - loss: 0.1286 - acc: 0.9650 - val_loss: 0.0627 - val_acc: 0.9875
Epoch 28/30
 - 120s - loss: 0.1231 - acc: 0.9654 - val_loss: 0.0583 - val_acc: 0.9887
Epoch 29/30
 - 116s - loss: 0.1259 - acc: 0.9660 - val_loss: 0.0599 - val_acc: 0.9875

Epoch 00029: ReduceLROnPlateau reducing learning rate to 3.125000148429535e-05.
Epoch 30/30
 - 133s - loss: 0.1256 - acc: 0.9660 - val_loss: 0.0536 - val_acc: 0.9887

モデルの構造は以下の通りです。

model.summary()
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d_1 (Conv2D)            (None, 28, 28, 32)        832       
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 28, 28, 32)        25632     
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 14, 14, 32)        0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 14, 14, 32)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 14, 14, 64)        18496     
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 14, 14, 64)        36928     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 7, 7, 64)          0         
_________________________________________________________________
dropout_2 (Dropout)          (None, 7, 7, 64)          0         
_________________________________________________________________
flatten_1 (Flatten)          (None, 3136)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 256)               803072    
_________________________________________________________________
dropout_3 (Dropout)          (None, 256)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 10)                2570      
=================================================================
Total params: 887,530
Trainable params: 887,530
Non-trainable params: 0
_________________________________________________________________

4. モデルの検証

4.1 学習曲線と検証曲線

# Plot the loss and accuracy curves for training and validation 
fig, ax = plt.subplots(2,1)
ax[0].plot(history.history['loss'], color='b', label="Training loss")
ax[0].plot(history.history['val_loss'], color='r', label="validation loss",axes =ax[0])
legend = ax[0].legend(loc='best', shadow=True)

ax[1].plot(history.history['acc'], color='b', label="Training accuracy")
ax[1].plot(history.history['val_acc'], color='r',label="Validation accuracy")
legend = ax[1].legend(loc='best', shadow=True)

以下のコードは、学習と検証のための損失曲線と精度曲線をプロットするためのものです。

モデルは、2エポック後に検証データセットでほぼ99%(98.5 +%)の精度に達します。 検証の精度は、学習中のほぼすべての時間で学習の精度よりも高くなります。 これは、モデルが学習セットに過剰に適合していないことを意味します。

私たちのモデルは非常によく学習しています!!!

4.2 混同行列

混同行列は、モデルの欠点を確認するのに非常に役立ちます。 検証結果の混同行列を記載します。

# Look at confusion matrix 

def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):
    """
    This function prints and plots the confusion matrix.
    Normalization can be applied by setting `normalize=True`.
    """
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, cm[i, j],
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

# Predict the values from the validation dataset
Y_pred = model.predict(X_val)
# Convert predictions classes to one hot vectors 
Y_pred_classes = np.argmax(Y_pred,axis = 1) 
# Convert validation observations to one hot vectors
Y_true = np.argmax(Y_val,axis = 1) 
# compute the confusion matrix
confusion_mtx = confusion_matrix(Y_true, Y_pred_classes) 
# plot the confusion matrix
plot_confusion_matrix(confusion_mtx, classes = list(labels.values())) 
# plot_confusion_matrix(confusion_mtx, classes = range(10)) 

ここで、検証セットのサイズ(画像数6000)を考慮すると、CNNがすべての文字で非常に良好に機能し、エラーがほとんどないことがわかります。

エラーを調査しましょう。

最も重大なエラーを見たいです。 そのためには、正解値と予測値の確率の差を取得する必要があります。

# Display some error results 

# Errors are difference between predicted labels and true labels
errors = (Y_pred_classes - Y_true != 0)

Y_pred_classes_errors = Y_pred_classes[errors]
Y_pred_errors = Y_pred[errors]
Y_true_errors = Y_true[errors]
X_val_errors = X_val[errors]

def display_errors(errors_index,img_errors,pred_errors, obs_errors):
    """ This function shows 6 images with their predicted and real labels"""
    n = 0
    nrows = 3
    ncols = 6
    fig, ax = plt.subplots(nrows,ncols,sharex=True,sharey=True)
    for row in range(nrows):
        for col in range(ncols):
            error = errors_index[n]
            ax[row,col].imshow((img_errors[error]).reshape((28,28)))
            ax[row,col].set_title("P:{}T:{}".format(labels[pred_errors[error]],labels[obs_errors[error]]))
            n += 1

# Probabilities of the wrong predicted numbers
Y_pred_errors_prob = np.max(Y_pred_errors,axis = 1)

# Predicted probabilities of the true values in the error set
true_prob_errors = np.diagonal(np.take(Y_pred_errors, Y_true_errors, axis=1))

# Difference between the probability of the predicted label and the true label
delta_pred_true_errors = Y_pred_errors_prob - true_prob_errors

# Sorted list of the delta prob errors
sorted_delta_errors = np.argsort(delta_pred_true_errors)

# Top 6 errors 
sorted_delta_errors_inv = np.flipud(sorted_delta_errors)

# Show the top 18 errors
display_errors(sorted_delta_errors_inv[:18], X_val_errors, Y_pred_classes_errors, Y_true_errors)

「不正解予測ラベルPの予測確率」と「正解ラベルTの予測確率」の差異が大きいものから順に記載しています。

左上が差異が最大のもので、右に(下に)進むにしたがって、差異が小さくなります。

正解ラベルと画像が似ても似つかないものがありますが、くずし字には今のひらがなとは異なる「字母」があることに注意する必要があります。

例えば、「き」は「畿」を字母とするもの以外にも、「起」を字母とするものがあります。

5. 予測と提出

5.1 予測と結果の提出

# predict results
results = model.predict(test)

# select the indix with the maximum probability
results_classes = np.argmax(results,axis = 1)

results_classes_pd = pd.Series(results_classes,name="Label")
submission = pd.concat([pd.Series(range(1,10001),name = "ImageId"),results_classes_pd],axis = 1)

submission.to_csv("submit.csv",index=False)

追記

今回の計算(augmentationあり)で、検証データを使用したCVでは0.99程度の精度が得られますが、試験データを使用したLBでは0.97程度です。

したがって、学習データと試験データにくずし字の異なる傾向がある可能性があります。

添付データ

  • kaggle_CNN2.ipynb
  • Favicon
    new user
    コメントするには 新規登録 もしくは ログイン が必要です。