深層学習day2

# 1．はじめに
　深層学習day2について学習した内容をまとめました．

# 2．勾配消失問題
　誤差逆伝搬法
　→損失関数の値から微分を逆算することで，
　 不要な再帰的計算を避けて微分を算出できる（チェインルール）．

### 確認テスト1
　問：連鎖律の原理を使い，dz/dxを求めよ．

```math
\begin{align}
z &= t^2 \\
t &= x + y
\end{align}
```
　解答：

```math
\frac{\partial{z}}{\partial{x}} = \frac{\partial{z}}{\partial{t}}\frac{\partial{t}}{\partial{x}} = 2t・1 =2(x+y)
```
### 勾配消失問題
　誤差逆伝播法が下位層に進んでいくに連れ，勾配がどんどん緩やかになっていく．
　そのため，勾配降下法による更新では下位層のパラメータはほとんど変わらず，
　訓練は最適値に収束しなくなる．
　シグモイド関数の微分係数は最大0.25
　→連鎖率でかけられる程，値は小さくなっていく（勾配が消失する）．

#### シグモイド関数の微分
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/36da69fd-17e2-0a42-d551-95ac421db901.png)

### 確認テスト2
　問：シグモイド関数を微分した時，入力値が0の時に最大値をとる．
　その値として正しいものを選択肢から選べ．
　（1）0.15（2）0.25（3）0.35（4）0.45

　解答：σ(1-σ)より，0.5×0.5が最大なので（1）0.25
　→上のグラフからも$ x \$が0の$ y \$の値を見れば分かる．

### 勾配消失問題の解決法
　・活性化関数の選択
　→ReLU関数（day1にて紹介した）は微分係数が1であるため，
　 勾配が消失しにくくなる．

　・重みの初期値設定
　①**Xavier**：重みの要素を，前の要素のノード数の平方根で除算した値
　→ReLU関数，シグモイド関数，双曲線正接関数

```math
\frac{1}{\sqrt{n}}
```
　②**He**：Xavierに√2をかけた値で除算した値
　→Relu関数

```math
\sqrt{\frac{2}{n}}
```

### 確認テスト3
　問：重みの初期値に0を設定するとどのような問題が発生するか簡潔に説明せよ．

　解答：重みを均一な値にすることで，誤差逆伝播法において，
　全ての重みの値が均一に更新されてしまうから．

　・バッチ正規化
　→ミニバッチ単位で入力値のデータの偏りを抑制する手法
　→平均0分散1になるように正規化する．

### 確認テスト4
　問：一般的に考えられるバッチ正規化の効果を2点挙げよ．

　解答：学習の安定化と高速化

### 実装演習
　mnistの学習において，バッチ正規化ありとなしで正答率の推移を比較する．

### ソースコード
```python
from google.colab import drive
drive.mount('/content/drive')

import sys
sys.path.append('/content/drive/My Drive/Colab Notebooks/DNN_code_colab_lesson_1_2/lesson_2')
sys.path.append('/content/drive/My Drive/Colab Notebooks/DNN_code_colab_lesson_1_2')

import numpy as np
from collections import OrderedDict
from common import layers
from data.mnist import load_mnist
import matplotlib.pyplot as plt
from multi_layer_net import MultiLayerNet
from common import optimizer

# バッチ正則化 layer
class BatchNormalization:
    '''
    gamma: スケール係数
    beta: オフセット
    momentum: 慣性
    running_mean: テスト時に使用する平均
    running_var: テスト時に使用する分散
    '''
    def __init__(self, gamma, beta, momentum=0.9, running_mean=None, running_var=None):
        self.gamma = gamma
        self.beta = beta
        self.momentum = momentum
        self.input_shape = None

        self.running_mean = running_mean
        self.running_var = running_var  
        
        # backward時に使用する中間データ
        self.batch_size = None
        self.xc = None
        self.std = None
        self.dgamma = None
        self.dbeta = None

    def forward(self, x, train_flg=True):
        if self.running_mean is None:
            N, D = x.shape
            self.running_mean = np.zeros(D)
            self.running_var = np.zeros(D)
                        
        if train_flg:
            mu = x.mean(axis=0) # 平均
            xc = x - mu # xをセンタリング
            var = np.mean(xc**2, axis=0) # 分散
            std = np.sqrt(var + 10e-7) # スケーリング
            xn = xc / std
            
            self.batch_size = x.shape[0]
            self.xc = xc
            self.xn = xn
            self.std = std
            self.running_mean = self.momentum * self.running_mean + (1-self.momentum) * mu # 平均値の加重平均
            self.running_var = self.momentum * self.running_var + (1-self.momentum) * var #分散値の加重平均
        else:
            xc = x - self.running_mean
            xn = xc / ((np.sqrt(self.running_var + 10e-7)))
            
        out = self.gamma * xn + self.beta 
        
        return out

    def backward(self, dout):
        dbeta = dout.sum(axis=0)
        dgamma = np.sum(self.xn * dout, axis=0)
        dxn = self.gamma * dout
        dxc = dxn / self.std
        dstd = -np.sum((dxn * self.xc) / (self.std * self.std), axis=0)
        dvar = 0.5 * dstd / self.std
        dxc += (2.0 / self.batch_size) * self.xc * dvar
        dmu = np.sum(dxc, axis=0)
        dx = dxc - dmu / self.batch_size
        
        self.dgamma = dgamma
        self.dbeta = dbeta

        return dx    


(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True)
print("データ読み込み完了")

# batch_normalizationの設定 =======================
# use_batchnorm = True
use_batchnorm = False
# ====================================================

network = MultiLayerNet(input_size=784, hidden_size_list=[40, 20], output_size=10,
                        activation='sigmoid', weight_init_std='Xavier', use_batchnorm=use_batchnorm)

iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100
learning_rate=0.01

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10


for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    grad = network.gradient(x_batch, d_batch)
    for key in ('W1', 'W2', 'W3', 'b1', 'b2', 'b3'):
        network.params[key] -= learning_rate * grad[key]

        loss = network.loss(x_batch, d_batch)
        train_loss_list.append(loss)        
        
    if (i + 1) % plot_interval == 0:
        accr_test = network.accuracy(x_test, d_test)
        accuracies_test.append(accr_test)        
        accr_train = network.accuracy(x_batch, d_batch)
        accuracies_train.append(accr_train)
        
        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))
                

lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend(loc="lower right")
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```

結果：バッチ正規化なし
　→iteration（学習回数）が増えても正答率は上がらず横ばいの傾向にある．
　→学習が上手くいってないと考えられる．
　→正答率がわずかに上がっている感じもするため，もっと学習回数を増やせば
　 それなりに上がる可能性がある．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/33248541-edd6-27b7-f5c0-cf15feeb84ac.png)

結果：バッチ決めたい時
　→学習回数約500回になると正答率が約80％に達しており，収束気味な様子が分かる．
　→学習が上手くμったと考えられる．
　（初心者からするとここまで差が出るとは驚きました．）
　→バッチ正規化なしの時の3番目の考察が正しいと仮定するならば，
　 確かにありの方が学習が速く進み，安定もしているといえる．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/2b2e0a7e-911f-eab4-bc86-f89a05a767f4.png)


# 3．学習率最適化手法
　勾配降下法：誤差関数Eを最小化するためのパラメータwを探索するための手法

```math
w^{t+1} = w^t - \eta\frac{\partial{E}}{\partial{w}} = w^t - \eta ∇E
```
　ηは学習率である．
　→大きい場合：学習は早く進むが，最適解にたどり着けず発散する．
　→小さい場合：学習に時間がかかり，局所最適解から抜け出しにくい．
　良い具合に学習率を調整したいということで考えられたのが以下の最適化アルゴリズムである．

　・**モメンタム**：慣性μを用いることで，勢いをつける．
　 →谷間についてから最も低い位置（最適解）にいくまでの時間が速い．
　 →局所的最適解にはならず，大域的最適解となる．

```math
\begin{align}
V_t &= μV_{t-1}-\eta ∇E \\
w^{t+1} &= w^t + V_t
\end{align}
```
　・**AdaGrad**：勾配に基づいて学習率を調整する．
　 →勾配の緩やかな斜面において有効であり，最適解に近づける．
　 →学習率が徐々に小さくなるため，鞍点問題を引き起こす可能性がある．

```math
\begin{align}
h_0 &= θ \\
h_t &= h_{t-1}+(∇E)^2 \\
w^{t+1} &= w^t - \eta \frac{1}{\sqrt{h_t + θ}}∇E
\end{align}
```

　・**RMSProp**：Adagradの急速に学習率が低下する問題を解決した手法
　 →Adagradは過去の勾配情報を全て均等に考慮していたが，
　  この手法では，より直近の勾配情報だけを考慮する．
　 →局所的最適解にはならず，大域的最適解となる．
　 →ハイパーパラメータの調整が必要な場合は少ない

```math
\begin{align}
h_t &= αh_{t-1}+(1-α)(∇E)^2 \\
w^{t+1} &= w^t - \eta \frac{1}{\sqrt{h_t+ θ}}∇E
\end{align}
```

　・**Adam**：モメンタムとRMSPropの融合手法
　 →モメンタムとRMSPropのメリットが両方活かせる．

```math
\begin{align}
v_t &= α_1v_{t-1}+(1-α_1)∇E \\
s_t &= α_2s_{t-1}+(1-α_2)(∇E)^2 \\
w^{t+1} &= w^t - \eta \frac{v_t}{\sqrt{s_t+ θ}}
\end{align}
```

### 確認テスト5
  問：モメンタム・AdaGrad・RMSPropの特徴をそれぞれ簡潔に説明せよ．

  解答：
  モメンタム：勢いがつくため学習が速く進む．
  AdaGrad：勾配がゆるやな場合において有効である．
  RMSProp：ハイパーパラメータの調整が必要な場合が少ない．

### 実装演習
　 　それぞれの最適化アルゴリズムで学習を行い，正答率の推移を比較する．

#### モメンタム
```python
import sys, os
sys.path.append(os.pardir)  # 親ディレクトリのファイルをインポートするための設定
import numpy as np
from collections import OrderedDict
from common import layers
from data.mnist import load_mnist
import matplotlib.pyplot as plt
from multi_layer_net import MultiLayerNet

# データの読み込み
(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)

print("データ読み込み完了")

# batch_normalizationの設定 ================================
# use_batchnorm = True
use_batchnorm = False
# ====================================================

network = MultiLayerNet(input_size=784, hidden_size_list=[40, 20], output_size=10, activation='sigmoid', weight_init_std=0.01,
                       use_batchnorm=use_batchnorm)

iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.01
# 慣性
momentum = 0.9

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    # 勾配
    grad = network.gradient(x_batch, d_batch)
    if i == 0:
        v = {}
    for key in ('W1', 'W2', 'W3', 'b1', 'b2', 'b3'):
        if i == 0:
            v[key] = np.zeros_like(network.params[key])
        v[key] = momentum * v[key] - learning_rate * grad[key]
        network.params[key] += v[key]

        loss = network.loss(x_batch, d_batch)
        train_loss_list.append(loss)
        
    if (i + 1) % plot_interval == 0:
        accr_test = network.accuracy(x_test, d_test)
        accuracies_test.append(accr_test)        
        accr_train = network.accuracy(x_batch, d_batch)
        accuracies_train.append(accr_train)

        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))
        
        
lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
あまり上手く学習ができなかった．
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/7c87b689-5842-1769-ec85-89137e1f57a9.png)

#### Adagrad

```python
# AdaGradを作ってみよう
# データの読み込み
(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)

print("データ読み込み完了")

# batch_normalizationの設定 ================================
# use_batchnorm = True
use_batchnorm = False
# ====================================================

network = MultiLayerNet(input_size=784, hidden_size_list=[40, 20], output_size=10, activation='sigmoid', weight_init_std=0.01,
                       use_batchnorm=use_batchnorm)

iters_num = 1000
# iters_num = 500 # 処理を短縮

train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.01

# AdaGradでは不必要
# =============================

momentum = 0.9 

# =============================

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    # 勾配
    grad = network.gradient(x_batch, d_batch)
    if i == 0:
        h = {}
    for key in ('W1', 'W2', 'W3', 'b1', 'b2', 'b3'):
            
        # 変更しよう  
        # ===========================================
        if i == 0:
            h[key] = np.zeros_like(network.params[key])        
        h[key] = momentum * h[key] - learning_rate * grad[key]
        network.params[key] += h[key]

        # ===========================================
        
        loss = network.loss(x_batch, d_batch)
        train_loss_list.append(loss)
        
    if (i + 1) % plot_interval == 0:
        accr_test = network.accuracy(x_test, d_test)
        accuracies_test.append(accr_test)        
        accr_train = network.accuracy(x_batch, d_batch)
        accuracies_train.append(accr_train)

        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))
        
        
lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
　Adagradも学習が上手くいかなかったと考えられる．
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/821d5fbd-db37-eb96-758a-f78d87129f72.png)

####　RMSProp

```python

# データの読み込み
(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)

print("データ読み込み完了")

# batch_normalizationの設定 ================================
# use_batchnorm = True
use_batchnorm = False
# ====================================================

network = MultiLayerNet(input_size=784, hidden_size_list=[40, 20], output_size=10, activation='sigmoid', weight_init_std=0.01,
                       use_batchnorm=use_batchnorm)

iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.01
decay_rate = 0.99

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    # 勾配
    grad = network.gradient(x_batch, d_batch)
    if i == 0:
        h = {}
    for key in ('W1', 'W2', 'W3', 'b1', 'b2', 'b3'):
        if i == 0:
            h[key] = np.zeros_like(network.params[key])
        h[key] *= decay_rate
        h[key] += (1 - decay_rate) * np.square(grad[key])
        network.params[key] -= learning_rate * grad[key] / (np.sqrt(h[key]) + 1e-7)

        loss = network.loss(x_batch, d_batch)
        train_loss_list.append(loss)                
        
    if (i + 1) % plot_interval == 0:
        accr_test = network.accuracy(x_test, d_test)
        accuracies_test.append(accr_test)        
        accr_train = network.accuracy(x_batch, d_batch)
        accuracies_train.append(accr_train)
        
        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))
        
        
lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
こちらは学習がかなり上手くいった．
テストデータの正答率は約90％を超えていると考えられる．
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/5a586d0a-52f4-d09d-295a-e344379e9786.png)

#### Adam
```python

# データの読み込み
(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)

print("データ読み込み完了")

# batch_normalizationの設定 ================================
# use_batchnorm = True
use_batchnorm = False
# ====================================================

network = MultiLayerNet(input_size=784, hidden_size_list=[40, 20], output_size=10, activation='sigmoid', weight_init_std=0.01,
                       use_batchnorm=use_batchnorm)

iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.01
beta1 = 0.9
beta2 = 0.999

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    # 勾配
    grad = network.gradient(x_batch, d_batch)
    if i == 0:
        m = {}
        v = {}
    learning_rate_t  = learning_rate * np.sqrt(1.0 - beta2 ** (i + 1)) / (1.0 - beta1 ** (i + 1))    
    for key in ('W1', 'W2', 'W3', 'b1', 'b2', 'b3'):
        if i == 0:
            m[key] = np.zeros_like(network.params[key])
            v[key] = np.zeros_like(network.params[key])
            
        m[key] += (1 - beta1) * (grad[key] - m[key])
        v[key] += (1 - beta2) * (grad[key] ** 2 - v[key])            
        network.params[key] -= learning_rate_t * m[key] / (np.sqrt(v[key]) + 1e-7)                
        
        
    if (i + 1) % plot_interval == 0:
        accr_test = network.accuracy(x_test, d_test)
        accuracies_test.append(accr_test)        
        accr_train = network.accuracy(x_batch, d_batch)
        accuracies_train.append(accr_train)
        loss = network.loss(x_batch, d_batch)
        train_loss_list.append(loss)        
        
        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))
                

lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
こちらも学習が上手くいった．
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/bb35c774-b2be-b74f-0307-21b447647a80.png)

### 結果まとめ
・モーメンタム：×
・Adagrad：×
・RMSProp：〇
・Adam　 ：〇

　収束速度をAdamとRMSPropで比べるとちょっと遅いと考えられる．
　しかし，RMSPropの訓練データの正答率は高めであるため，
　データセットを大規模な視点で考えると，汎化性能としてはAdamの方が
　高いのではないかと考えられる．
　データセットによって適切な最適化手法はあるかと思うが，
　小規模な視点から見ると，今回はRMSPropの方が向いていたのかもしれない．

# 4．過学習
　モデルが訓練データに適合しすぎて，
　テストデータに対する性能（汎化性能）が低くなる現象
　以下の図における右側のパターンが過学習であると考えられる．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/5ae62c07-8724-4ebb-a22b-a0966421b908.png)

　原因：
　①パラメータの数が多い
　②パラメータの値が適切ではない
　③似たような特徴を持つもの（ほぼ同じデータ）でしか学習していない
　解決手法として，ドロップアウトと正則化が挙げられる．

### ドロップアウト
　ランダムにノードを削除して学習する．
　→データ量を変化させずに，異なるモデルを学習させていると解釈できる．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/55f7f831-966a-4cc1-50f0-cc38d74d8d2b.png)



### 正則化
　ネットワーク（モデル）の自由度を制約すること．
　誤差に対して正則化項を加算することで重みを抑制する．

　pノルムの計算

```math
\| x \|_p = (|x_1|^p + ・・・ + |x_n|^p)^{\frac{1}{p}}
```

　誤差関数にpノルムを加える．

```math
E_n(\boldsymbol{W}) = \frac{1}{λ} \| x \|_p 
```

　p = 1　→　**L1正則化**　（**Lasso推定量**）
　p = 2　→　**L2正則化**　（**Ridge推定量**）

### 確認テスト6
　問：下図について，L1正則化を表しているグラフはどちらか答えよ．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/a8371156-4f66-d426-acd8-5307fe1365aa.png)

　解答：右

### 確認テスト7
　問：機械学習で使われる線形モデル（線形回帰，主成分分析…etc）の正則化は，
　モデルの重みを制限することで可能となる．
　前述の線形モデルの正則化手法の中にリッジ回帰という手法があり，
　その特徴として正しいものを選択しなさい．
　（a）ハイパーパラメータを大きな値に設定すると，すべての重みが限りなく0に近づく．
　（b）ハイパーパラメータを0に設定すると，非線形回帰となる．
　（c）バイアス項についても，正則化される．
　（d）リッジ回帰の場合，隠れ層に対して正則化項を加える．

　解答：（a）

### 実装演習
　 　ドロップアウト，L1正則化，L2正則化それぞれで学習を行い正答率の推移の比較を行う．

過学習の実行

```python
import numpy as np
from collections import OrderedDict
from common import layers
from data.mnist import load_mnist
import matplotlib.pyplot as plt
from multi_layer_net import MultiLayerNet
from common import optimizer


(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True)

print("データ読み込み完了")

# 過学習を再現するために、学習データを削減
x_train = x_train[:300]
d_train = d_train[:300]

network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10)
optimizer = optimizer.SGD(learning_rate=0.01)

iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10


for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    grad = network.gradient(x_batch, d_batch)
    optimizer.update(network.params, grad)

    loss = network.loss(x_batch, d_batch)
    train_loss_list.append(loss)
        
    if (i+1) % plot_interval == 0:
        accr_train = network.accuracy(x_train, d_train)
        accr_test = network.accuracy(x_test, d_test)
        accuracies_train.append(accr_train)
        accuracies_test.append(accr_test)

        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))        

lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
　訓練データの正答率が100％に達しており，
　テストデータの正答率が400epochあたりからあまり上がらなくなっていることから
　過学習が起こっていると考えることができる．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/e07ee8d7-4101-fb55-8875-81a1e9fda3d7.png)

L2正則化

```python
from common import optimizer

(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True)

print("データ読み込み完了")

# 過学習を再現するために、学習データを削減
x_train = x_train[:300]
d_train = d_train[:300]


network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10)


iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100
learning_rate=0.01

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10
hidden_layer_num = network.hidden_layer_num

# 正則化強度設定 ======================================
weight_decay_lambda = 0.1
# =================================================

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    grad = network.gradient(x_batch, d_batch)
    weight_decay = 0
    
    for idx in range(1, hidden_layer_num+1):
        grad['W' + str(idx)] = network.layers['Affine' + str(idx)].dW + weight_decay_lambda * network.params['W' + str(idx)]
        grad['b' + str(idx)] = network.layers['Affine' + str(idx)].db
        network.params['W' + str(idx)] -= learning_rate * grad['W' + str(idx)]
        network.params['b' + str(idx)] -= learning_rate * grad['b' + str(idx)]        
        weight_decay += 0.5 * weight_decay_lambda * np.sqrt(np.sum(network.params['W' + str(idx)] ** 2))

    loss = network.loss(x_batch, d_batch) + weight_decay
    train_loss_list.append(loss)        
        
    if (i+1) % plot_interval == 0:
        accr_train = network.accuracy(x_train, d_train)
        accr_test = network.accuracy(x_test, d_test)
    過学習 accuracies_train.append(accr_train)
        accuracies_test.append(accr_test)
        
        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))               


lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
　前の結果と比べて，訓練データの正答率が下がっているため，
　過学習が和らいでいる様子が分かる．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/05204a7e-3c8a-b1b7-6a35-665f1372fa32.png)

L1正則化

```python
(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True)

print("データ読み込み完了")

# 過学習を再現するために、学習データを削減
x_train = x_train[:300]
d_train = d_train[:300]

network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10)


iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100
learning_rate=0.1

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10
hidden_layer_num = network.hidden_layer_num

# 正則化強度設定 ======================================
weight_decay_lambda = 0.005
# =================================================

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    grad = network.gradient(x_batch, d_batch)
    weight_decay = 0
    
    for idx in range(1, hidden_layer_num+1):
        grad['W' + str(idx)] = network.layers['Affine' + str(idx)].dW + weight_decay_lambda * np.sign(network.params['W' + str(idx)])
        grad['b' + str(idx)] = network.layers['Affine' + str(idx)].db
        network.params['W' + str(idx)] -= learning_rate * grad['W' + str(idx)]
        network.params['b' + str(idx)] -= learning_rate * grad['b' + str(idx)]        
        weight_decay += weight_decay_lambda * np.sum(np.abs(network.params['W' + str(idx)]))

    loss = network.loss(x_batch, d_batch) + weight_decay
    train_loss_list.append(loss)        
        
    if (i+1) % plot_interval == 0:
        accr_train = network.accuracy(x_train, d_train)
        accr_test = network.accuracy(x_test, d_test)
        accuracies_train.append(accr_train)
        accuracies_test.append(accr_test)
        
        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))               
                
lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
　正答率が振動していることから，学習が上手くいっていないと考えられる．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/bed750a7-3c5c-5a24-71ea-3230d1a65c2f.png)

ドロップアウト

```python
class Dropout:
    def __init__(self, dropout_ratio=0.5):
        self.dropout_ratio = dropout_ratio
        self.mask = None

    def forward(self, x, train_flg=True):
        if train_flg:
            self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)

    def backward(self, dout):
        return dout * self.mask

from common import optimizer
(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True)

print("データ読み込み完了")

# 過学習を再現するために、学習データを削減
x_train = x_train[:300]
d_train = d_train[:300]

# ドロップアウト設定 ======================================
use_dropout = True
dropout_ratio = 0.15
# ====================================================

network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10,
                        weight_decay_lambda=weight_decay_lambda, use_dropout = use_dropout, dropout_ratio = dropout_ratio)
optimizer = optimizer.SGD(learning_rate=0.01)
# optimizer = optimizer.Momentum(learning_rate=0.01, momentum=0.9)
# optimizer = optimizer.AdaGrad(learning_rate=0.01)
# optimizer = optimizer.Adam()

iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10


for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]

    grad = network.gradient(x_batch, d_batch)
    optimizer.update(network.params, grad)

    loss = network.loss(x_batch, d_batch)
    train_loss_list.append(loss)    
    
    if (i+1) % plot_interval == 0:
        accr_train = network.accuracy(x_train, d_train)
        accr_test = network.accuracy(x_test, d_test)
        accuracies_train.append(accr_train)
        accuracies_test.append(accr_test)

        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))        
        
lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
　過学習対策ができており，かつ正答率が順調に増加しているため，
　学習が上手くいっていると考えられる．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/d5c8b168-6d32-12fe-fe84-0f1ff71acf60.png)

###　結果まとめ
　・L2正則化：〇
　・L1正則化：×
　・ドロップアウト：〇
　
　今回の学習では，ドロップアウトが一番学習に向いていたと考えられる．
　→テストデータだけに着目してみると，正答率が特に増加したわけではない．
　→あくまで訓練データに適合しすぎないようにするための手法．

# 5．畳み込みニューラルネットワークの概念

　畳み込みニューラルネットワーク（CNN：Convolutional Neural Network）
　→二次元的な特徴を学習することを可能にしたニューラルネットワーク
　→畳み込み層，プーリング層で二次元的な特徴を抽出し，
　 一次元化を行った後に全結合層へ渡すことで最終的に分類や回帰を行うことが可能

### 畳み込み層
　→重みパラメータで構成されたフィルタを用いて，
　画像処理における空間フィルタリングを用いて特徴抽出を行う．
  →畳み込み層を通った後の画像を特徴マップと呼ぶ．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/4d705c58-5db1-c256-de8c-1a0a066bfbc8.png)

　演算の方法は以下になる．
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/1f2b29c9-c5d0-4e14-5ee2-0ba87cbdde6d.png)

　・ストライド：フィルターが移動する間隔
　・パディング：画像周りにピクセル情報を追加する手法
　→以下はゼロパディングの手法になる．
　※Tensorflowでのゼロパディングは右側と下側にしか拡張されない．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/08c3642f-7985-10cf-5dfb-84831e8d4a71.png)

### プーリング層
　重みによる演算をせずに圧縮を行う手法

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/1d556173-1e09-a4b3-e481-7ddabe619255.png)

### 確認テスト8
　問：サイズ6×6の入力画像を，サイズ2×2のフィルタで
　畳み込んだ時の出力画像のサイズを答えよ．
　なおストライドとパディングは1とする．

　解答：画像サイズを求める公式より
　・P：パディング
　・S：ストライド
　・F：フィルタサイズ

```math
\begin{align}
Output \ Size &= \frac{Input \ Size+2P-F}{S}+1　\\
     &= \frac{6 +2×1-2}{1}+1 \\
     &= 6 + 1 = 7
\end{align}
```
　7×7が答えとなる．

### 実装演習
・im2colの実装

```python
import pickle
import numpy as np
from collections import OrderedDict
from common import layers
from common import optimizer
from data.mnist import load_mnist
import matplotlib.pyplot as plt

# 画像データを２次元配列に変換
'''
input_data: 入力値
filter_h: フィルターの高さ
filter_w: フィルターの横幅
stride: ストライド
pad: パディング
'''
def im2col(input_data, filter_h, filter_w, stride=1, pad=0):
    # N: number, C: channel, H: height, W: width
    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) # (N, C, filter_h, filter_w, out_h, out_w) -> (N, filter_w, out_h, out_w, C, filter_h)    
    
    col = col.reshape(N * out_h * out_w, -1)
    return col

# im2colの処理確認
input_data = np.random.rand(2, 1, 4, 4)*100//1 # number, channel, height, widthを表す
print('========== input_data ===========\n', input_data)
print('==============================')
filter_h = 3
filter_w = 3
stride = 1
pad = 0
col = im2col(input_data, filter_h=filter_h, filter_w=filter_w, stride=stride, pad=pad)
print('============= col ==============\n', col)
print('==============================')
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/4890e4e8-614c-62d6-7304-a83abd33cec8.png)

　　・CNN実装

```python
# ２次元配列を画像データに変換
def col2im(col, input_shape, filter_h, filter_w, stride=1, pad=0):
    # N: number, C: channel, H: height, W: width
    N, C, H, W = input_shape
    # 切り捨て除算    
    out_h = (H + 2 * pad - filter_h)//stride + 1
    out_w = (W + 2 * pad - filter_w)//stride + 1
    col = col.reshape(N, out_h, out_w, C, filter_h, filter_w).transpose(0, 3, 4, 5, 1, 2) # (N, filter_h, filter_w, out_h, out_w, C)

    img = np.zeros((N, C, H + 2 * pad + stride - 1, W + 2 * pad + stride - 1))
    for y in range(filter_h):
        y_max = y + stride * out_h
        for x in range(filter_w):
            x_max = x + stride * out_w
            img[:, :, y:y_max:stride, x:x_max:stride] += col[:, :, y, x, :, :]

    return img[:, :, pad:H + pad, pad:W + pad]

class Convolution:
    # W: フィルター, b: バイアス
    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: filter_number, C: channel, FH: filter_height, FW: filter_width
        FN, C, FH, FW = self.W.shape
        N, C, H, W = x.shape
        # 出力値のheight, width
        out_h = 1 + int((H + 2 * self.pad - FH) / self.stride)
        out_w = 1 + int((W + 2 * self.pad - FW) / self.stride)
        
        # xを行列に変換
        col = im2col(x, FH, FW, self.stride, self.pad)
        # フィルターをxに合わせた行列に変換
        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)
        # dcolを画像データに変換
        dx = col2im(dcol, self.x.shape, FH, FW, self.stride, self.pad)

        return dx

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)
        
        # xを行列に変換
        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

class SimpleConvNet:
    # conv - relu - pool - affine - relu - affine - softmax
    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'] = layers.Convolution(self.params['W1'], self.params['b1'], conv_param['stride'], conv_param['pad'])
        self.layers['Relu1'] = layers.Relu()
        self.layers['Pool1'] = layers.Pooling(pool_h=2, pool_w=2, stride=2)
        self.layers['Affine1'] = layers.Affine(self.params['W2'], self.params['b2'])
        self.layers['Relu2'] = layers.Relu()
        self.layers['Affine2'] = layers.Affine(self.params['W3'], self.params['b3'])

        self.last_layer = layers.SoftmaxWithLoss()

    def predict(self, x):
        for key in self.layers.keys():
            x = self.layers[key].forward(x)
        return x
        
    def loss(self, x, d):
        y = self.predict(x)
        return self.last_layer.forward(y, d)

    def accuracy(self, x, d, batch_size=100):
        if d.ndim != 1 : d = np.argmax(d, axis=1)
        
        acc = 0.0
        
        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            td = d[i*batch_size:(i+1)*batch_size]
            y = self.predict(tx)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == td) 
        
        return acc / x.shape[0]

    def gradient(self, x, d):
        # forward
        self.loss(x, d)
        
        # backward
        dout = 1
        dout = self.last_layer.backward(dout)
        layers = list(self.layers.values())
        
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        # 設定
        grad = {}
        grad['W1'], grad['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
        grad['W2'], grad['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grad['W3'], grad['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grad

from common import optimizer

# データの読み込み
(x_train, d_train), (x_test, d_test) = load_mnist(flatten=False)

print("データ読み込み完了")

# 処理に時間のかかる場合はデータを削減 
x_train, d_train = x_train[:5000], d_train[:5000]
x_test, d_test = x_test[:1000], d_test[:1000]


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)

optimizer = optimizer.Adam()

iters_num = 1000
train_size = x_train.shape[0]
batch_size = 100

train_loss_list = []
accuracies_train = []
accuracies_test = []

plot_interval=10



for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    d_batch = d_train[batch_mask]
    
    grad = network.gradient(x_batch, d_batch)
    optimizer.update(network.params, grad)

    loss = network.loss(x_batch, d_batch)
    train_loss_list.append(loss)

    if (i+1) % plot_interval == 0:
        accr_train = network.accuracy(x_train, d_train)
        accr_test = network.accuracy(x_test, d_test)
        accuracies_train.append(accr_train)
        accuracies_test.append(accr_test)
        
        print('Generation: ' + str(i+1) + '. 正答率(トレーニング) = ' + str(accr_train))
        print('                : ' + str(i+1) + '. 正答率(テスト) = ' + str(accr_test))               

lists = range(0, iters_num, plot_interval)
plt.plot(lists, accuracies_train, label="training set")
plt.plot(lists, accuracies_test,  label="test set")
plt.legend()
plt.title("accuracy")
plt.xlabel("iteration")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
# グラフの表示
plt.show()
```
結果
　かなり高い精度となった．
　訓練データはもちろんのこと，
　テストデータに対しても約90％を超える結果となった．
　演算量は多くなるため，比較的学習に時間がかかった．

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/4fb76ca4-fb11-e008-80b4-439a011eebb6.png)



# 6．最新のCNN（※2022年2月では最新ではない）

###　Alexnet
　・2012年の画像分類コンテスト
　（ILSVRC：ImageNet Large Scale Visual Recognition Challenge）で優勝して注目を浴びた．
　・過学習対策として，サイズ4096の全結合層の出力にドロップアウトを使用している．
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2522643/9e5b1ce4-9f94-8c73-e0af-5a3dfc55895e.png)
　
　・最近（2022年2月20日）では，Vision TransformerやSwin Transformerなどの
　自然言語処理の深層学習に出てくる**Transformer**を利用した画像認識モデルが
　よく用いられている傾向がある．



# 7．参考
・重みの初期値について：
https://www.takapy.work/entry/2018/06/14/221633

・深層学習／バッチ正規化：
https://qiita.com/jun40vn/items/2105467cea35f179ea45

・Optimizer　深層学習における勾配法について：
https://qiita.com/tokkuman/items/1944c00415d129ca0ee9

・TechCrowd　過学習を防ぐ正則化
https://www.techcrowd.jp/machinelearning/regularization/

・定番のConvolutional Neural Networkをゼロから理解する：
https://deepage.net/deep_learning/2016/11/07/convolutional_neural_network.html#convolution%E5%B1%A4

・農学情報科学　AlexNet
https://axa.biopapyrus.jp/deep-learning/cnn/image-classification/alexnet.html

・Swin Transformerを超える最先端画像認識モデルDeformable Attention Transformerを詳細解説！
https://deepsquare.jp/2022/01/deformable-vision-transformer/