Dragon Arrow written by Tatsuya Nakaji, all rights reserved 
updated on 2019-08-18
この章では、CNN のメカニズム について詳しく説明し、その処理内容を Python で実装する
CNNはこれまで見てきたニューラルネットワークと同じで、レゴブロックのようにレイヤを組み合わせて作ることが可能です。
新たに次が登場
これまで見てきたニューラルネットワークは隣接する層のすべてのニューロン間で結合があった。これを全結合と呼び、Affineレイヤとい名前で実装してきた。
一般的なCNNの特徴
全結合の問題点とは データの構造が"無視"されて、形状による情報を生かすことができない こと
形状には大切な情報が含まれていると思われるが、形状を無視して全てのデータを同じ次元のニューロンとして扱うので、形状による情報を生かすことができない。
例えば入力データが画像のとき、データは縦・横・チャンネル方向の３次元形状
MNIST データセットを使った例では、入力画像は (1, 28, 28)―― 1 チャンネル、縦 28 ピクセル、 横 28 ピクセル――の形状だったが、それを 1 列に並べた 784 個のデータを最初の Affine レイヤへ入力する
全結合層に入力するときに「3 次元のデータを平ら ―― 1 次元のデータ――にする」必要があるが、
平らにされて失うこの形状には大切な空間情報が含まれていると思われる。
など...
CNN では、画像などの形状を有したデータを正しく理解できる(可能性がある)
CNNの畳み込み層において、
畳み込み演算の例:畳み込み演算を「⊛」記号で表記
「畳み込み演算」
画像処理でいうところ「フィルター処理」に相当
文献によっては「フィルター」という用語は「カーネル」と言う表現されることもある
このフィルターに使用するパラメータが、全結合のニューラルネットワークにおける「重み」に対応する
畳み込み演算の計算手順
これにバイアスを加えると以下のようになる。
畳み込み演算のバイアス:フィルターの適用後の要素に固定の値(バイアス)を加算する
パティング：入力データの周囲に固定データ（例えば0）を埋めること
下図は周囲を幅1ピクセルの0で埋めています
畳み込み演算のパディング処理:入力データの周囲に 0 を埋める(図ではパディングを破線で表し、中身の「0」の記載は省略する)
パディングを使う主な理由は出力サイズを調整すること。
ストライドが2の畳み込み演算の例
入力サイズを(H, W)
フィルターサイズを(FH, FW)
出力サイズを(OH, OW)
パディングをP
ストライドをS
とした際の出力サイズは次の通り
$$OH= \frac{ H+2P-FH }{ S } + 1\\ OW= \frac{ W+2P-FW }{ S } + 1\\$$
計算例:
入力サイズ:(4, 4)、パディング:1、ストライド:1、フィルターサイズ:(3, 3)の時
$$OH= \frac{ 4+2 \cdot 1 -3 }{ 1 } + 1=4\\ OW= \frac{ 4+2\cdot 1 -3 }{ 1 } + 1=4$$
入力サイズ:(7, 7)、パディング:0、ストライド:2、フィルターサイズ:(3, 3)
$$OH= \frac{ 7+2 \cdot 0 -3 }{ 2 } + 1=3\\ OW= \frac{ 7+2\cdot 0 -3 }{ 2 } + 1=3$$
入力サイズ:(28, 31)、パディング:2、ストライド:3、フィルターサイズ: (5, 5)
$$OH= \frac{ 28+2 \cdot 2 -5 }{ 3 } + 1=10\\ OW= \frac{ 31+2\cdot 2 -5 }{ 3 } + 1=11$$
これまで見てきた畳み込み演算の例は、縦方向と横方向の 2 次元の形状を対象としたものでした。しかし、画像の場合、縦・横方向に加えてチャンネル方向も合わせた 3 次元のデータを扱う必要があります。チャンネル 方向も合わせた 3 次元データに対して畳み込み演算を行う例を見ていきます。
3次元データに対する畳み込み演算の例
3次元データに対する畳み込み演算の計算手順
3次元の畳み込み演算で注意するのは、入力データとフィルターのチャンネル数を同じ値にするということ。
チャンネル数C, 高さH, 横幅Wのデータの形状を(C, H, W)とかく。
畳み込み演算をブロックで考える。ブロックの形状に注意
複数のフィルターによる畳み込み演算の例
バイアス項を追加すると以下のようになる
畳み込み演算の処理フロー(バイアス項も追加)
畳み込み演算でのバッチ処理
N個のデータに対してバッチ処理を行う際にはデータの形状は同じ
畳み込み演算のバッチ処理のフロー
プーリング：縦・横方向の空烏瞰を小さくする演算
下図では2×2の領域を一つの要素に集約するような処理を行って、空間サイズを小さくする。
Max プーリングの処理手順
この例では、2×2のMaxプーリングをスライド2で行った場合の処理である。
Maxプーリング：対象領域から最大値を取る計算
Avarage プーリング : 対象領域の平均を計算
また一般的にプーリングのウィンドウサイズとスライドは同じ値に設定する。
対象領域から最大値(もしくは平均値)を取るだけの処理なので学習するパラメータを持たない
プーリングは、対象から最大値（もしくは平均値）をとるだけの処理なので学習すべきパラメータは存在しない
プーリングの演算によって、入力データを出力データのチャンネル数は変化しない。
チャンネル毎に独立して計算が行われる。
（OHとOWは変化するがFNは変化しません）
入力データの小さなズレに対して、プーリングは同じような結果を返す。
そのため、入力データの微小なズレに対してロバストです。
畳み込み層とプーリング層の二つの層をpythonで実装する。
CNNでは、各層を流れるデータは4次元のデータ。
たとえば、データの形状が (10, 1, 28, 28) だとすると、これは高さ 28・横幅 28 で 1 チャンネルのデータが 10 個ある場合に対応する。
Python での実装
# ランダムにデータを生成 x = np.random.rand(10,1,28,28) x.shape # (10, 1, 28, 28) x[0].shape # (1, 28, 28) x[1].shape # (1, 28, 28) x[0, 0].shape # もしくは、x[0][0] # (28, 28)
畳み込みの実装は、真面目に行うとfor文の幾重にも組み合わせた実装になるが、そのような実装はやや面倒であり、またNumPyではfor文を使うと処理が遅くなる。
そのためfor文ではなく、im2colという便利な関数を使った実装を行う。
im2colはフィルター(重み)にとって都合が良いように入力データを展開する関数である。
im2colのメリットデメリット
メリット：行列計算に帰着させることが可能のため、線形代数のライブラリを有効に活用可能(大きな行列の計算を高速に行う)
デメリット：通常よりも多くのメモリを消費する(展開後の要素の数は元のブロックの要素数よりも多くなるから)
畳み込み演算のフィルター処理の詳細:フィルターを縦方向に 1 列に展開して並べ、im2col で展開したデータと行列の内積を計算する。最後に、出力データのサイズに整形(reshape)する
im2colは次のインターフェースを持ちます。
im2col(input_data, filter_h, filter_w, stride=1, pad=0)
(common/util.py)
#----------------------------------------------------
# Parameters
# input_data : (データ数,チャンネル,高さ,横幅)の4次元配列からなる入力データ
# filter_h : フィルターの高さ
# filter_w : フィルターの横幅
# stride : ストライド
# pad : パディング
# Returns
# col : 2次元配列
#----------------------------------------------------
def im2col(input_data, filter_h, filter_w, stride=1, pad=0):
N, C, H, W = input_data.shape
out_h = (H + 2*pad - filter_h)//stride + 1
out_w = (W + 2*pad - filter_w)//stride + 1
img = np.pad(input_data, [(0,0), (0,0), (pad, pad), (pad, pad)], 'constant')
col = np.zeros((N, C, filter_h, filter_w, out_h, out_w))
for y in range(filter_h):
y_max = y + stride*out_h
for x in range(filter_w):
x_max = x + stride*out_w
col[:, :, y, x, :, :] = img[:, :, y:y_max:stride, x:x_max:stride]
col = col.transpose(0, 4, 5, 1, 2, 3).reshape(N*out_h*out_w, -1)
return colim2colを使って見る
import sys, os sys.path.append(os.pardir) from common.util import im2col x1 = np.random.rand(1, 3, 7, 7) col1 = im2col(x1, 5, 5, stride=1, pad=0) print(col1.shape) # (9, 75) x2 = np.random.rand(10, 3, 7, 7) col2 = im2col(x2, 5, 5, stride=1, pad=0) print(col2.shape) # (90, 75)
x1がバッチサイズが1で、チャンネル数が3の7×7のデータ
x2がバッチサイズが10で、チャンネル数が3の7×7のデータ
両方とも2次元目の要素数が75になるが、これはフィルターの要素数の総和にあたる。（チャンネル3、サイズ5×5）
im2colを使って畳み込み層を実装
(common/layers.py)
class Convolution: def __init__(self, W, b, stride=1, pad=0): self.W = W self.b = b self.stride = stride self.pad = pad # 中間データ（backward時に使用） self.x = None self.col = None self.col_W = None # 重み・バイアスパラメータの勾配 self.dW = None self.db = None def forward(self, x): FN, C, FH, FW = self.W.shape N, C, H, W = x.shape out_h = 1 + int((H + 2*self.pad - FH) / self.stride) out_w = 1 + int((W + 2*self.pad - FW) / self.stride) col = im2col(x, FH, FW, self.stride, self.pad) col_W = self.W.reshape(FN, -1).T out = np.dot(col, col_W) + self.b out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2) self.x = x self.col = col self.col_W = col_W return out def backward(self, dout): FN, C, FH, FW = self.W.shape dout = dout.transpose(0,2,3,1).reshape(-1, FN) self.db = np.sum(dout, axis=0) self.dW = np.dot(self.col.T, dout) self.dW = self.dW.transpose(1, 0).reshape(FN, C, FH, FW) dcol = np.dot(dout, self.col_W.T) dx = col2im(dcol, self.x.shape, FH, FW, self.stride, self.pad) return dx
Convolutionレイヤと同じく、im2colを使って入力データを展開して実装する
ただし、プーリングの場合は、チャンネル方向には独立である点が異なる
(common/layers.py)
class Pooling: def __init__(self, pool_h, pool_w, stride=1, pad=0): self.pool_h = pool_h self.pool_w = pool_w self.stride = stride self.pad = pad self.x = None self.arg_max = None def forward(self, x): N, C, H, W = x.shape out_h = int(1 + (H - self.pool_h) / self.stride) out_w = int(1 + (W - self.pool_w) / self.stride) col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad) col = col.reshape(-1, self.pool_h*self.pool_w) arg_max = np.argmax(col, axis=1) out = np.max(col, axis=1) out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2) self.x = x self.arg_max = arg_max return out def backward(self, dout): dout = dout.transpose(0, 2, 3, 1) pool_size = self.pool_h * self.pool_w dmax = np.zeros((dout.size, pool_size)) dmax[np.arange(self.arg_max.size), self.arg_max.flatten()] = dout.flatten() dmax = dmax.reshape(dout.shape + (pool_size,)) dcol = dmax.reshape(dmax.shape[0] * dmax.shape[1] * dmax.shape[2], -1) dx = col2im(dcol, self.x.shape, self.pool_h, self.pool_w, self.stride, self.pad) return dx
引数
– filter_num ―― フィルターの数
– filter_size ―― フィルターのサイズ
– stride ―― ストライド
– pad ―― パディング
(ch07/simple_convnet.py)
import sys, os
sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定
import pickle
import numpy as np
from collections import OrderedDict
from common.layers import *
from common.gradient import numerical_gradient
class SimpleConvNet:
"""単純なConvNet
conv - relu - pool - affine - relu - affine - softmax
Parameters
----------
input_size : 入力サイズ（MNISTの場合は784）
hidden_size_list : 隠れ層のニューロンの数のリスト（e.g. [100, 100, 100]）
output_size : 出力サイズ（MNISTの場合は10）
activation : 'relu' or 'sigmoid'
weight_init_std : 重みの標準偏差を指定（e.g. 0.01）
'relu'または'he'を指定した場合は「Heの初期値」を設定
'sigmoid'または'xavier'を指定した場合は「Xavierの初期値」を設定
"""
def __init__(self, input_dim=(1, 28, 28),
conv_param={'filter_num':30, 'filter_size':5, 'pad':0, 'stride':1},
hidden_size=100, output_size=10, weight_init_std=0.01):
filter_num = conv_param['filter_num']
filter_size = conv_param['filter_size']
filter_pad = conv_param['pad']
filter_stride = conv_param['stride']
input_size = input_dim[1]
conv_output_size = (input_size - filter_size + 2*filter_pad) / filter_stride + 1
pool_output_size = int(filter_num * (conv_output_size/2) * (conv_output_size/2))
# 重みの初期化
self.params = {}
self.params['W1'] = weight_init_std * \
np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
self.params['b1'] = np.zeros(filter_num)
self.params['W2'] = weight_init_std * \
np.random.randn(pool_output_size, hidden_size)
self.params['b2'] = np.zeros(hidden_size)
self.params['W3'] = weight_init_std * \
np.random.randn(hidden_size, output_size)
self.params['b3'] = np.zeros(output_size)
# レイヤの生成
self.layers = OrderedDict()
self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
conv_param['stride'], conv_param['pad'])
self.layers['Relu1'] = Relu()
self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)
self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
self.layers['Relu2'] = Relu()
self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
self.last_layer = SoftmaxWithLoss()
def predict(self, x):
for layer in self.layers.values():
x = layer.forward(x)
return x
def loss(self, x, t):
"""損失関数を求める
引数のxは入力データ、tは教師ラベル
"""
y = self.predict(x)
return self.last_layer.forward(y, t)
def accuracy(self, x, t, batch_size=100):
if t.ndim != 1 : t = np.argmax(t, axis=1)
acc = 0.0
for i in range(int(x.shape[0] / batch_size)):
tx = x[i*batch_size:(i+1)*batch_size]
tt = t[i*batch_size:(i+1)*batch_size]
y = self.predict(tx)
y = np.argmax(y, axis=1)
acc += np.sum(y == tt)
return acc / x.shape[0]
def numerical_gradient(self, x, t):
"""勾配を求める（数値微分）
Parameters
----------
x : 入力データ
t : 教師ラベル
Returns
-------
各層の勾配を持ったディクショナリ変数
grads['W1']、grads['W2']、...は各層の重み
grads['b1']、grads['b2']、...は各層のバイアス
"""
loss_w = lambda w: self.loss(x, t)
grads = {}
for idx in (1, 2, 3):
grads['W' + str(idx)] = numerical_gradient(loss_w, self.params['W' + str(idx)])
grads['b' + str(idx)] = numerical_gradient(loss_w, self.params['b' + str(idx)])
return grads
def gradient(self, x, t):
"""勾配を求める（誤差逆伝搬法）
Parameters
----------
x : 入力データ
t : 教師ラベル
Returns
-------
各層の勾配を持ったディクショナリ変数
grads['W1']、grads['W2']、...は各層の重み
grads['b1']、grads['b2']、...は各層のバイアス
"""
# forward
self.loss(x, t)
# backward
dout = 1
dout = self.last_layer.backward(dout)
layers = list(self.layers.values())
layers.reverse()
for layer in layers:
dout = layer.backward(dout)
# 設定
grads = {}
grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
return grads
def save_params(self, file_name="params.pkl"):
params = {}
for key, val in self.params.items():
params[key] = val
with open(file_name, 'wb') as f:
pickle.dump(params, f)
def load_params(self, file_name="params.pkl"):
with open(file_name, 'rb') as f:
params = pickle.load(f)
for key, val in params.items():
self.params[key] = val
for i, key in enumerate(['Conv1', 'Affine1', 'Affine2']):
self.layers[key].W = self.params['W' + str(i+1)]
self.layers[key].b = self.params['b' + str(i+1)](train_convnet.py)
import sys, os
sys.path.append(os.pardir) # 親ディレクトリのファイルをインポートするための設定
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from simple_convnet import SimpleConvNet
from common.trainer import Trainer
# データの読み込み
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
# 処理に時間のかかる場合はデータを削減
#x_train, t_train = x_train[:5000], t_train[:5000]
#x_test, t_test = x_test[:1000], t_test[:1000]
max_epochs = 20
network = SimpleConvNet(input_dim=(1,28,28),
conv_param = {'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},
hidden_size=100, output_size=10, weight_init_std=0.01)
trainer = Trainer(network, x_train, t_train, x_test, t_test,
epochs=max_epochs, mini_batch_size=100,
optimizer='Adam', optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000)
trainer.train()
# パラメータの保存
network.save_params("params.pkl")
print("Saved Network Parameters!")
# グラフの描画
markers = {'train': 'o', 'test': 's'}
x = np.arange(max_epochs)
plt.plot(x, trainer.train_acc_list, marker='o', label='train', markevery=2)
plt.plot(x, trainer.test_acc_list, marker='s', label='test', markevery=2)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()...
train loss:0.0008943811980456424
train loss:0.0007073603700735564
=============== Final Test Accuracy ===============
test acc:0.9868
Saved Network Parameters!
テストデータの認識率がおよそ 99% というのは、比較的小さなネットワークにしては、とても高い認識率ではないでしょうか。なお、次章 では、さらに層を重ねてディープにすることで、テストデータの認識率が 99% を超えるネットワークを実現します。
学習前：フィルターがランダムに初期化されているため白黒の濃淡に規則性がない
学習後：規則性がある
このような規則性があるフィルターは"何を見ている"のか
畳み込み層のフィルターは、エッジやブロブなどのプリミティブな情報を抽出する
・エッジ：色が変化する境目
・ブロブ：局所的に塊のある領域
(ch07/visualize_filter.python)
import numpy as np import matplotlib.pyplot as plt from simple_convnet import SimpleConvNet def filter_show(filters, nx=8, margin=3, scale=10): """ c.f. https://gist.github.com/aidiary/07d530d5e08011832b12#file-draw_weight-py """ FN, C, FH, FW = filters.shape ny = int(np.ceil(FN / nx)) fig = plt.figure() fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05) for i in range(FN): ax = fig.add_subplot(ny, nx, i+1, xticks=[], yticks=[]) ax.imshow(filters[i, 0], cmap=plt.cm.gray_r, interpolation='nearest') plt.show() network = SimpleConvNet() # ランダム初期化後の重み filter_show(network.params['W1']) # 学習後の重み network.load_params("params.pkl") filter_show(network.params['W1'])
学習前
学習後
1層目の畳み込み：エッジやブロブなどの低レベルの情報が抽出
畳み込み層を何層も重ねる：より複雑で抽象化された情報が抽出
[画像は以下文献より引用]
Donglai Wei, Bolei Zhou, Antonio Torralba, William T. Freeman(2015): mNeuron: A Matlab Plugin to Visualize Neurons from Deep Models (http://vision03.csail.mit.edu/cnn_art/index.html#v_single)
Cov1:エッジ、ブロブ（Edge+Blob）
Cov3:テキスチャ（Texture）
Cov5:物体のパーツ（Object Parts）
Fc8:犬や猫などの物体のクラス（Object Classes）
従って、層が深くなるに連れて、ニューロンは単純な形状から"高度"な情報へと変化していく。
特に重要なネットワークを2つ紹介
・1998年に初めて提案されたCNNの元祖LeNet
・ディープラーニングが注目を集めるに至った2012年のAlexNet
「現在のCNN」と比較すると次の点が異なる
・活性化関数にシグモイド関数を使用(現在はReLU関数)
・サブサンプリングによって中間データのサイズ縮小を行っている(現在はMaxプーリング)
AlexNetは畳み込み層とプーリング層を重ねて、最後に全結合層を経由して結果を出力する
LeNetとの以下の点が異なる
・活性化関数にReLU関数を用いる
・LRN(Local Response Normalization)と言う局所的正規化を行う層を用いる
・Dropoutを使用する
ネットワーク構成にはLeNet、AlexNeには大きな違いはありませんが、コンピュータ技術に大きな進歩があった
具体的には
・大量のデータを誰でも入手できるようになった
・大量の並列計算を得意とするGPUが普及し、大量の演算を高速に行うことが可能になった