Dragon Arrow written by Tatsuya Nakaji, all rights reserved animated-dragon-image-0164

ゼロから作る Deep Learning 第7章

イメージ
Aug 13, 2019

畳み込みニューラルネットワーク


この章では、CNN のメカニズム について詳しく説明し、その処理内容を Python で実装する


全体の構造


CNNはこれまで見てきたニューラルネットワークと同じで、レゴブロックのようにレイヤを組み合わせて作ることが可能です。
新たに次が登場

  • Convolutionレイヤ(畳み込み層)
  • Poolingレイヤ(プーリング層)


これまで見てきたニューラルネットワークは隣接する層のすべてのニューロン間で結合があった。これを全結合と呼び、Affineレイヤとい名前で実装してきた。



一般的なCNNの特徴

  • 「Convolution - ReLU - (Pooling)」という流れ(Pooling レイヤは省略されることもある)
  • 「Affine - ReLU」というつながりが、「Convolution - ReLU - (Pooling)」 に置き換わったと考えることができる
  • 出力に近い層では「Affine - ReLU」という組み合わせが用いられる
  • 最後の出力層は「Affine - Softmax」の組み合わせ


畳み込み層


全結合層の問題点


全結合の問題点とは データの構造が"無視"されて、形状による情報を生かすことができない こと

形状には大切な情報が含まれていると思われるが、形状を無視して全てのデータを同じ次元のニューロンとして扱うので、形状による情報を生かすことができない。


例えば入力データが画像のとき、データは縦・横・チャンネル方向の3次元形状

MNIST データセットを使った例では、入力画像は (1, 28, 28)―― 1 チャンネル、縦 28 ピクセル、 横 28 ピクセル――の形状だったが、それを 1 列に並べた 784 個のデータを最初の Affine レイヤへ入力する

全結合層に入力するときに「3 次元のデータを平ら ―― 1 次元のデータ――にする」必要があるが、

平らにされて失うこの形状には大切な空間情報が含まれていると思われる。


  • 空間的に近いピクセルは似たような値なのでは?
  • RBGの各チャンネルの間にはそれぞれに密接な関係があるのでは?

など...


CNN では、画像などの形状を有したデータを正しく理解できる(可能性がある)


CNNの畳み込み層において、

  • 入出力データを特徴マップ(feature map)
  • 入力データを入力特徴マップ(feature map)
  • 出力データを出力特徴マップ(feature map)



畳み込み演算




畳み込み演算の例:畳み込み演算を「⊛」記号で表記


「畳み込み演算」

画像処理でいうところ「フィルター処理」に相当

文献によっては「フィルター」という用語は「カーネル」と言う表現されることもある

このフィルターに使用するパラメータが、全結合のニューラルネットワークにおける「重み」に対応する


畳み込み演算の計算手順

これにバイアスを加えると以下のようになる。


畳み込み演算のバイアス:フィルターの適用後の要素に固定の値(バイアス)を加算する


パディング


パティング:入力データの周囲に固定データ(例えば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$$


3次元データの畳み込み演算


これまで見てきた畳み込み演算の例は、縦方向と横方向の 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は変化しません)


微小な位置変化に対してロバスト(頑強)

入力データの小さなズレに対して、プーリングは同じような結果を返す。

そのため、入力データの微小なズレに対してロバストです。


Convolution/Poolingレイヤの実装


畳み込み層とプーリング層の二つの層をpythonで実装する。


4次元配列

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)


im2colによる展開

畳み込みの実装は、真面目に行うとfor文の幾重にも組み合わせた実装になるが、そのような実装はやや面倒であり、またNumPyではfor文を使うと処理が遅くなる。

そのためfor文ではなく、im2colという便利な関数を使った実装を行う。
im2colはフィルター(重み)にとって都合が良いように入力データを展開する関数である。




im2colのメリットデメリット

メリット:行列計算に帰着させることが可能のため、線形代数のライブラリを有効に活用可能(大きな行列の計算を高速に行う)

デメリット:通常よりも多くのメモリを消費する(展開後の要素の数は元のブロックの要素数よりも多くなるから)


畳み込み演算のフィルター処理の詳細:フィルターを縦方向に 1 列に展開して並べ、im2col で展開したデータと行列の内積を計算する。最後に、出力データのサイズに整形(reshape)する


Convolutionレイヤの実装


im2colは次のインターフェースを持ちます。

im2col(input_data, filter_h, filter_w, stride=1, pad=0)

  • input_data ―― (データ数, チャンネル, 高さ, 横幅) の 4 次元配列から なる入力データ 
  • filter_h ―― フィルターの高さ 
  • filter_w ―― フィルターの横幅 
  • stride ―― ストライド
  • pad ―― パディング


(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 col

im2colを使って見る

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



Poolingレイヤの実装

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


CNNの実装


引数

  • input_dim ―― 入力データの (チャンネル, 高さ, 幅) の次元
  • conv_param ―― 畳み込み層のハイパーパラメータ(ディクショナリ)。ディクショナリのキーは下記のとおり

– filter_num ―― フィルターの数 

– filter_size ―― フィルターのサイズ

– stride ―― ストライド 

– pad ―― パディング 

  • hidden_size ―― 隠れ層(全結合)のニューロンの数
  • output_size ―― 出力層(全結合)のニューロンの数
  • weight_init_std ―― 初期化の際の重みの標準偏差


(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% を超えるネットワークを実現します。



CNNの可視化


学習前:フィルターがランダムに初期化されているため白黒の濃淡に規則性がない

学習後:規則性がある


このような規則性があるフィルターは"何を見ている"のか

畳み込み層のフィルターは、エッジやブロブなどのプリミティブな情報を抽出する

エッジ:色が変化する境目

ブロブ:局所的に塊のある領域


(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)    


従って、層が深くなるに連れて、ニューロンは単純な形状から"高度"な情報へと変化していく。



代表的なCNN


特に重要なネットワークを2つ紹介

・1998年に初めて提案されたCNNの元祖LeNet
・ディープラーニングが注目を集めるに至った2012年のAlexNet


LeNet

「現在のCNN」と比較すると次の点が異なる
・活性化関数にシグモイド関数を使用(現在はReLU関数)
・サブサンプリングによって中間データのサイズ縮小を行っている(現在はMaxプーリング)


AlexNet

AlexNetは畳み込み層とプーリング層を重ねて、最後に全結合層を経由して結果を出力する
LeNetとの以下の点が異なる
・活性化関数にReLU関数を用いる
・LRN(Local Response Normalization)と言う局所的正規化を行う層を用いる
・Dropoutを使用する


当時と今

ネットワーク構成にはLeNet、AlexNeには大きな違いはありませんが、コンピュータ技術に大きな進歩があった
具体的には
・大量のデータを誰でも入手できるようになった
・大量の並列計算を得意とするGPUが普及し、大量の演算を高速に行うことが可能になった


本章で学んだこと


  • CNN は、これまでの全結合層のネットワークに対して、畳み込み層プーリング層が新たに加わる
  • 畳み込み層とプーリング層は、im2col(画像を行列に展開する関数)を用 いるとシンプルで効率の良い実装ができる
  • CNN の可視化によって、層が深くなるにつれて高度な情報が抽出されて いく様子が分かる
  • CNN の代表的なネットワークには、LeNetAlexNet がある
  • ディープラーニングの発展に、ビッグデータと GPU が大きく貢献している。