Convolutional Neural Network

15. Convolutional Neural Network#

CNN, 畳み込みニューラルネットワーク [貴之, 2016]

CNNのイメージ出典：畳み込みニューラルネットワーク(CNN) – ニューラルネットワーク・DeepLearningなどの画像素材　プレゼン・ゼミなどに【WTFPL】

from src import utils

utils.set_seed(SEED)

15.1. CNNとは#

15.1.1. CNNの歴史#

動物の視覚屋の神経細胞の二つの動き：

画像の濃淡パターンを検出する機能
物体の位置ズレを許容して同一物体だとみなす機能

を再現したモデルがCNNです．これを組み込んだ最初期のモデルはネオコグニトロン（Negcognitron）と呼ばれ，福島邦彦氏によって発表されました[Fukushima, 1980]．訓練は自己組織化によって行われます．

出典：視覚パターン認識とネオコグニトロン |福島邦彦

現在主流のCNNはネオコグニトロンをベースに，訓練方法を誤差逆伝播法に変えられています．そしてその後にCNNは更に深層化し，様々な画像認識タスクで当時のSoTA（State-of-the-Art, 現時点での最先端レベルの性能）を叩き出しました．特に有名なのが2012年のILSVRC（ImageNet Large Scale Visual Recognition Challenge）という画像認識コンペティションでしょう．ここでGeoffrey Everest HintonらのチームがAlexNetというCNNで，これまでの誤差率を10%以上を改善し，大成功を収めたのが有名です．[Krizhevsky, Sutskever, and Hinton, 2012]

15.1.2. 初期のCNNの有名なモデル#

15.1.2.1. LeNet#

基本的なCNNアーキテクチャのモデルです．

関係する論文：

[LeCun, Boser, Denker, Henderson, Howard, Hubbard, and Jackel, 1989]
[Cun, Boser, Denker, Howard, Habbard, Jackel, and Henderson, 1990]
[Lecun, Bottou, Bengio, and Haffner, 1998]

15.1.2.2. AlexNet#

前述した通り，2012年のILSVRC（ImageNet Large Scale Visual Recognition Challenge）で優勝したモデル[Krizhevsky, Sutskever, and Hinton, 2012]．
これまでの誤差率を10%以上を改善し，Deep Learningブームを引き起こしました．

また，ImageNetという大規模画像データセット[Deng, Dong, Socher, Li, Li, and Fei-Fei, 2009]自体の登場も，CNNの発展に大きく寄与しました．

15.1.2.3. VGG#

2014年のILSVRCにおけるImageNetを用いた画像認識精度のコンペティションで画像分類部門で2位、物体のローカライゼーション部門で1位を記録したモデルです．[Simonyan and Zisserman, 2014]
当時では大きな数である（Conv, MaxPool, Linearを合計して）16層のモデルです．

15.1.2.4. GoogLeNet#

InceptionNetと名付けられたモデルの中の最初のバージョン，Inception v1はGoogLeNetとも呼ばれています．[Szegedy, Liu, Jia, Sermanet, Reed, Anguelov, Erhan, Vanhoucke, and Rabinovich, 2015]

複数の畳み込み層やpooling層から構成されるInceptionモジュールと呼ばれる小さなネットワーク (micro networks) を定義し，これを通常の畳み込み層のように重ねていくことで1つの大きなCNNを作り上げている点である．
引用：畳み込みニューラルネットワークの最新研究動向 (〜2017)

15.2. 画像データ#

15.2.1. 画像データの配列#

iris datasetは一つのデータが一次元配列で表現されていました．これに対してこれから扱う画像データは：

各ピクセルがグレースケールの色情報を持っている時，一つのデータは2次元配列として表現されます．
各ピクセルがRGBの色情報を持っている時，一つのデータは3次元配列として表現されます．

出典：Python Tutorial

_images/e667debf54045186c4599513468fdbda66f35eeba91a719b5accfd1a6bb75120.png

このようなグレースケールの画像ならば，二次元配列で表現することができます：
(512, 512)
[[40 40 40 ... 67 67 67]
 [42 42 41 ... 67 67 67]
 [44 44 43 ... 68 68 68]
 ...
 [74 80 75 ... 37 46 44]
 [62 74 74 ... 37 46 52]
 [58 67 74 ... 51 53 59]]

_images/86a571f5b330a6f11334d0950c49152b31cb54454f820fa7423893258c043217.png

このようなカラー画像だとRGBの3チャネルが必要なので，三次元配列になります：
(512, 512, 3)
[[[118 146 181]
  [129 157 192]
  [129 156 193]
  ...
  [102  94  87]
  [108 100  93]
  [104  96  89]]

 [[113 141 176]
  [124 152 187]
  [126 153 190]
  ...
  [ 99  91  84]
  [100  92  85]
  [ 97  89  82]]]

15.3. CNNのアーキテクチャ#

15.3.1. 画像データのためのニューラルネットワーク#

さて，MLPでは二次元配列の位置情報をうまく扱うことができませんので，仮にMLPにgrayスケールの画像を入力したいならば，一つのデータが一次元配列で表現されるようにshapeを変える必要があります．

print("オリジナル：", gray_img.shape)
print("変換後：", gray_img.flatten().shape)

オリジナル： (512, 512)
変換後： (262144,)

しかし画像ですからこの二次元配列は位置情報自体が意味を持っています．これでは画像データをうまく扱うことはできないでしょう．そこでCNNの登場です．

出典：Lesson 2　機械学習やディープラーニングには、どんな手法があるの？

15.3.2. 畳み込み#

畳み込み（convolution）は画像データから特徴を抽出するためによく用いられる操作です．
あるカーネルに着目して，入力画像が1チャネルの場合の計算の様子を見てみましょう．

図：畳み込み処理の仕組み（簡単のためにバイアスを描いていませんが，使われる場合もあります．）

フィルタ と呼ばれる行列を使って，画像の特徴を抽出する作業を 畳み込み と呼びます．画像左上から，フィルタとそれに対応するピクセルを掛け合わせて，総和をとります．この操作を画像の右下まで続けて新しい二次元配列を得ます．
これを 特徴マップ と呼びます．
尚，ウィンドウを動かす幅を ストライド（stride） と呼びます．上の図ではStrideが1，カーネルサイズが3x3です．

数式にして少し整理してみましょう．特徴マップのある要素を\(a_{i,j}^{(k)}\)と書くことにします．これを求める手順をおさらいします．

高さ\(H\), 幅\(W\)とします．インプットデータが1チャネルだとすると：

\[\begin{split} \mathbf{X} = \left( \begin{array}{c|ccc} x_{1,1}^{(c)} & x_{1,2}^{(c)} & \dots & x_{1,W}^{(c)} \\ \hline x_{2,1}^{(c)} & x_{2,2}^{(c)} & \dots & x_{2,W}^{(c)} \\ \vdots & \vdots & \ddots & \vdots \\ x_{H,1}^{(c)} & x_{H,2}^{(c)} & \dots & x_{H,W}^{(c)} \end{array} \right) \in \mathbb{R}^{H \times W}\end{split}\]

また，カーネルサイズを\(m \times n\)として，\(K\)個のカーネルのカーネル\(k\)に着目すると：

\[\begin{split} \mathbf{W}^{(k)} = \left( \begin{array}{c|ccc} w_{1,1}^{(k)} & w_{1,2}^{(k)} & \dots & w_{1,n}^{(k)} \\ \hline w_{2,1}^{(k)} & w_{2,2}^{(k)} & \dots & w_{2,n}^{(k)} \\ \vdots & \vdots & \ddots & \vdots \\ w_{m,1}^{(k)} & w_{m,2}^{(k)} & \dots & w_{m,n}^{(k)} \end{array} \right) \in \mathbb{R}^{m \times n} \end{split}\]

最後に，biasは\(K\)個あるので：

\[\begin{split} \mathbf{b} = \begin{pmatrix} b^{(1)} \\ b^{(2)} \\ \vdots \\ b^{(k)} \\ \vdots \\ b^{(K)} \end{pmatrix} \in \mathbb{R}^{K} \end{split}\]

畳み込み層では行列の左上から右下にカーネルを走査させていきますが，\(x_{i,j}\)に着目すると，その時点の畳み込み処理の結果\(a_{i,j}^{(k)}\)は以下のように求まります．

\[ a_{i,j}^{(k)} = \sum_{s=1}^{m}\sum_{t=1}^{n}w_{s,t}^{(k)}x_{i+s,j+t}+b^{(k)} \]

畳み込み層をエクセルで実装すると以下のようになります．

また，普通は入力画像がRGBの3チャネルであることが多いので，その場合の畳み込み演算の様子も見ておきましょう．

出典：Everything you need to know about Convolutional Neural Networks (CNNs)

一つのカーネルは\(\text{縦} \times \text{横} \times \text{チャネル}\)の配列を持っていることになり，これを任意の個数だけ用意することで畳み込み層が実装できます．

15.3.3. パディング#

画像によっては，端にあるピクセルに重要な特徴があることが考えられます．そんな時，画像の周りに適当な数字を敷き詰めることで画像を大きくする（枠をつける）ことで対応します．これを パディング（padding） と呼びます．

15.3.4. プーリング#

プーリング は，任意のサイズ（例えば2x2）ごとに対象の範囲を何かしらの代表値に置き換える処理です．処理の流れはカーネルサイズとストライドサイズが同じ畳み込みのように見えます．基本的にここでのスライディングウィンドウは前後で被りがないので，特徴マップはチャネル数は変わらないままでサイズ（縦と横）だけが小さくなります．

Max Pooling:
- 特徴マップに対してスライディングウィンドウ処理を行い，各カーネルごとにその範囲を最大値に置き換えてダウンサンプリングします．
Average Pooling:
- 特徴マップに対してスライディングウィンドウ処理を行い，各カーネルごとにその範囲を平均値に置き換えてダウンサンプリングします．

図：Pooling処理の仕組み

15.4. CNNの実装#

15.4.1. 作成するアプリケーションのイメージ#

ここでは0~9の数字の手描き文字認識アプリをCNNで実装します．言い換えると，手書きの数字の画像データを受け取って，それを0~9のクラスに分類するタスクです． Hugging Face Spaces （機械学習のデモアプリが投稿されるサービス）にちょうど良いアプリが公開されていたので，実装例を確認しておきましょう．

左枠に手書きで0~9のうち，どれかの数字を書いてみてください．右枠に認識結果が表示されます．

ここではWeb UIから実際に手書きで文字を書けるようになっていますが，今回はそこまでは行わずにベンチマークデータセットから画像データを取ってきて訓練とテストを行います．

15.4.2. データの準備#

今回はMNISTという手書き文字データセットを利用します．これはCVの世界でのirisのような有名なデータセットなので，pytorchに収録されています．

ここで，データは[Batch size,Channel,Height,Width]という順番になっている事に注意してください．Channelは色の数です．ここではグレースケールなので1です．

def load_MNIST(batch=128):
    transform = transforms.Compose([
        transforms.ToTensor(),
        #transforms.Normalize((0.1307,), (0.3081,)),
        ])

    train_set = torchvision.datasets.MNIST(root="./data",
                                           train=True,
                                           download=True,
                                           transform=transform)
    train_loader = torch.utils.data.DataLoader(train_set,
                                               batch_size=batch,
                                               shuffle=True,
                                               num_workers=2)

    val_set = torchvision.datasets.MNIST(root="./data",
                                         train=False,
                                         download=True,
                                         transform=transform)
    val_loader =torch.utils.data.DataLoader(val_set,
                                            batch_size=batch,
                                            shuffle=True,
                                            num_workers=2)

    return {"train":train_loader, "validation":val_loader,"train_dataset": train_set, "val_dataset":val_set}

訓練データセットの最初の一枚を取り出して表示してみましょう．28x28の画像で，中身は手書きの数字になっています．

data_loader = load_MNIST(batch=1)
train_loader= data_loader["train"]
img,label = next(iter(train_loader))
print("img:",type(img), img.size(), img.dtype)
print("label:", type(label), label.size(), label.dtype)
print("\t",label, )
plt.imshow(img.view(-1,28), cmap='gray')

img: <class 'torch.Tensor'> torch.Size([1, 1, 28, 28]) torch.float32
label: <class 'torch.Tensor'> torch.Size([1]) torch.int64
	 tensor([5])

<matplotlib.image.AxesImage at 0x1552cea70>

_images/4966ebd558c943e890e1cb7939ffd43cf02f97f7d5845ab740a4e702463e9c5e.png

0~9の数字があるので，全部で10クラスの分類を行います．

15.4.3. CNNクラス#

PyTorchを使って実装するならば，これまで考えてきた難しいアーキテクチャのことは一度忘れて，ブロックを重ねるようにネットワークを作ることができます．ただし，MLPとは異なり，レイヤーを通った後のテンソルの形状がわかりにくいことに注意してください．

例えば，畳み込み→プーリング→畳み込み→プーリング→MLP のようなネットワークの場合，入力されたテンソルには以下のような形状の変化が起こります．

x = torch.from_numpy(np.random.random([64,1,28,28]).astype(np.float32))
print(x.shape)
y = nn.Conv2d(1,32 ,3,1)(x) # 第一引数（入力チャネル数）を決め打ちしておかないといけない
print(y.shape)
y = nn.MaxPool2d(2,2)(y)
print(y.shape)
y = nn.Conv2d(32,64, 3,1)(y)
print(y.shape)
y = nn.MaxPool2d(2,2)(y)
print(y.shape)
y = nn.Flatten()(y)
print(y.shape)
y = nn.Linear(1600,10) # 第一引数を決めうちしておかないといけない．

torch.Size([64, 1, 28, 28])
torch.Size([64, 32, 26, 26])
torch.Size([64, 32, 13, 13])
torch.Size([64, 64, 11, 11])
torch.Size([64, 64, 5, 5])
torch.Size([64, 1600])

入力画像を最初に適用するnn.Conv2dの第一引数と，畳み込みやプーリングを繰り返した後にnn.Flattenした際の特徴数の計算が難しそうです．以下のような関数でConv層の出力する画像の縦横サイズを求められるので，使ってみてください．

def get_output_shape(
        height:int, 
        padding:int,
        kernel_size:int, 
        stride:int,
        )->int: 
    new_height = (height+2*padding-kernel_size)/stride + 1
    return int(np.floor(new_height))

h = get_output_shape(28,0,3,1)
print(h)
h = get_output_shape(h, 0, 2,2)
print(h)
h = get_output_shape(h,0,3,1)
print(h)
h = get_output_shape(h,0,2,2)
print(h)

では，単純なCNNをnn.Sequentialで作成します．

def build_cnn(in_channels:int=1, n_classes:int=10):
    """
    28*28の画像だけ受け付ける
    """
    return nn.Sequential(
        nn.Conv2d(in_channels, # 入力されるチャネル数
                  32, # 出力したいチャネル数
                  3, # カーネルサイズ
                  1, # ストライド
                  0, # パディング
                  ), 
        nn.ReLU(),
        nn.MaxPool2d(2, # カーネルサイズ 
                     2, # ストライド
                     ),
        nn.Conv2d(32,64, 3, 1, 0),
        nn.ReLU(),
        nn.MaxPool2d(2, 2),               
        nn.Dropout2d(0.25),
        nn.Flatten(),
        nn.Linear(64*5*5,128),
        nn.ReLU(),
        nn.Linear(128,n_classes)
    )

cnn = build_cnn(3)
x = torch.from_numpy(np.random.random([64,3,28,28]).astype(np.float32))
cnn(x).shape

torch.Size([64, 10])

また，テンソルの形状を考えるのが面倒な場合は，以下のようなLazyHogehoge（nn.LazyConv2d, nn.LazyLinearなど）を使うことで入力チャネルや入力特徴数の計算を省けます．

def build_lazy_cnn(n_classes:int=10):
    """
    28*28の画像だけ受け付ける
    """
    return nn.Sequential(
        nn.LazyConv2d(#in_channels, # 入力されるチャネル数
                  32, # 出力したいチャネル数
                  3, # カーネルサイズ
                  1, # ストライド
                  0, # パディング
                  ), 
        nn.ReLU(),
        nn.MaxPool2d(2, # カーネルサイズ 
                     2, # ストライド
                     ),
        nn.Conv2d(32,64, 3, 1, 0),
        nn.ReLU(),
        nn.MaxPool2d(2, 2),               
        nn.Dropout2d(0.25),
        nn.Flatten(),
        nn.LazyLinear(128),
        nn.ReLU(),
        nn.Linear(128,n_classes)
    )

# 例1
_cnn = build_lazy_cnn(10)
x = torch.from_numpy(np.random.random([64,4,15,15]).astype(np.float32))
print(x.shape, "->", _cnn(x).shape)
# 例2
_cnn = build_lazy_cnn(10)
x = torch.from_numpy(np.random.random([64,3,53,53]).astype(np.float32))
print(x.shape, "->", _cnn(x).shape)

torch.Size([64, 4, 15, 15]) -> torch.Size([64, 10])
torch.Size([64, 3, 53, 53]) -> torch.Size([64, 10])

/Users/mriki/.pyenv/versions/miniforge3-4.10.3-10/envs/datasci/lib/python3.10/site-packages/torch/nn/modules/lazy.py:180: UserWarning: Lazy modules are a new feature under heavy development so changes to the API or functionality can happen at any moment.
  warnings.warn('Lazy modules are a new feature under heavy development '

15.4.4. 学習スクリプト#

ここまで来ればMLPと同じような学習スクリプトで訓練することができます．

## ハイパーパラメータなどの設定

#エポック数，バッジサイズ
max_epochs = 20
batch_size = 64

#データのロード
data_loader = load_MNIST(batch=batch_size)

#GPUが使えるときは使う
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
#ネットワーク構造の構築
net = build_cnn(1,10)
print(net)

cpu
Sequential(
  (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1))
  (1): ReLU()
  (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))
  (4): ReLU()
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): Dropout2d(p=0.25, inplace=False)
  (7): Flatten(start_dim=1, end_dim=-1)
  (8): Linear(in_features=1600, out_features=128, bias=True)
  (9): ReLU()
  (10): Linear(in_features=128, out_features=10, bias=True)
)

15.4.4.1. skorchを使った簡易版#

以下のコードはこちらを参考にしました．

import skorch
from skorch import NeuralNetClassifier

trainer = NeuralNetClassifier(
    net, 
    max_epochs=max_epochs,
    batch_size=batch_size,
    lr=0.01,
    criterion=nn.CrossEntropyLoss,
    optimizer= torch.optim.Adam,
    device=device,
)
train_dataset = data_loader["train_dataset"]
y_train = np.array([y for x, y in iter(train_dataset)])
trainer.fit(train_dataset, y_train)

fig = plt.figure(figsize=[10,5])
ax = fig.add_subplot(1,2,1)
ax.set_title("loss")
ax.plot(trainer.history[:,"train_loss"], label="train_loss")
ax.plot(trainer.history[:,"valid_loss"], label="valid_loss")

ax2 = fig.add_subplot(1,2,2)
ax2.set_title("acc")
ax2.plot(trainer.history[:,"valid_acc"], label="valid_acc")
fig.suptitle("training history")

Text(0.5, 0.98, 'training history')

_images/486667095afc041da6c5f00ad66fa93e9f3934fbfa23cf1cfd2d0eec4096934a.png

15.4.4.2. フルスクラッチ#

cnn = cnn.to(device)

#学習結果の保存
history = {
    "train_loss": [],
    "validation_loss": [],
    "validation_acc": []
}

#最適化方法の設定
optimizer = torch.optim.Adam(params=net.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

学習コードです．

for epoch in range(max_epochs):
    # training step
    loss = None
    train_loss = 0.0
    net.train()
    print("\nTrain start")
    for i,(x,y) in enumerate(data_loader["train"]):
        x,y = x.to(device),y.to(device)
        # 勾配の初期化
        optimizer.zero_grad()
        # 順伝搬 -> 逆伝搬 -> 最適化
        output = net(x)
        loss = criterion(output, y)
        train_loss += loss.item()
        loss.backward()
        optimizer.step()
        # 途中経過の表示
        if (i+1) % 100 == 0:
            print("Training: {} epoch. {} iteration. Loss:{}".format(epoch+1,i+1,loss.item()))
    train_loss /= len(data_loader["train"])
    print("Training loss (ave.): {}".format(train_loss))
    history["train_loss"].append(train_loss)

    """validation step"""
    print("\nValidation start")
    net.eval()
    val_loss = 0.0
    accuracy = 0.0

    with torch.no_grad():
        for x,y in data_loader["validation"]:
            x,y = x.to(device),y.to(device)

            output = net(x)
            val_loss = criterion(output,y)
            pred_y = output.argmax(dim=1,keepdim=True)
            accuracy += pred_y.eq(y.view_as(pred_y)).sum().item()

    val_loss /= len(data_loader["validation"])
    accuracy /= len(data_loader["validation"].dataset)

    print("Validation loss: {}, Accuracy: {}\n".format(val_loss,accuracy))
    history["validation_loss"].append(val_loss)
    history["validation_acc"].append(accuracy)

15.5. 課題#

[課題1] このノートではmnistデータセットのクラス分類を行うCNNを実装しました．これを主要なパラメータをCLIのオプションで変更できる形にしたプログラムcnn_mnist.pyを作成してください．

Hint

MLPやw2vの実装を参考にしながら，必要なハイパーパラメータやモデルの保存場所などを変更できるようなCLIのオプション（引数）を用意してください．（多分正解はない）

[課題2] CIFAR-10データセットのクラス分類を行うCNNを実装して，訓練とテストデータによる評価までを行うプログラムcnn_cifar10.pyを作成してください．主要なパラメータをCLIのオプションで変更できるようにすること．また，できるだけテスト正解率が高くなるようにモデルをチューニングして，デフォルトの引数として設定すること．