酷酷是懒虫

这个屌丝很懒，什么也没留下！

热门标签

深度学习入门——卷积神经网络

作者：酷酷是懒虫 | 2024-08-04 20:13:26

踩

深度学习入门——卷积神经网络

本章的主题是卷积神经网络（Convolutional Neural Network，CNN）。CNN被用于图像识别、语音识别等各种场合，在图像识别的比赛中，基于深度学习的方法几乎都以CNN为基础。本章将详细介绍CNN的结构，并用Python实现其处理内容。

整体结构

CNN中新出现了卷积层（Convolution 层）和池化层（Pooling 层）。

之前介绍的神经网络中，相邻层的所有神经元之间都有连接，这称为全连接（fully-connected）

在图7-2 的CNN中，靠近输出的层中使用了之前的“Affine - ReLU”组合。此外，最后的输出层中使用了之前的“Affine-Softmax”组合。这些都是一般的CNN中比较常见的结构。

卷积层

全连接层存在的问题

全连接层存在什么问题呢？那就是数据的形状被“忽视”了

图像是3 维形状，这个形状中应该含有重要的空间信息。比如，空间上邻近的像素为相似的值、RBG的各个通道之间分别有密切的关联性、相距较远的像素之间没有什么关联等，3 维形状中可能隐藏有值得提取的本质模式

全连接层会忽视形状，而卷积层可以保持形状不变。

CNN中，有时将卷积层的输入输出数据称为特征图（feature map）。其中，卷积层的输入数据称为输入特征图（input feature map），输出数据称为输出特征图（output feature map）。

卷积运算

卷积运算相当于图像处理中的“滤波器运算”。

有的文献中也会用“核”这个词来表示这里所说的“滤波器”

CNN中，滤波器的参数就对应之前的权重。并且，CNN中也存在偏置

填充

在进行卷积层的处理之前，有时要向输入数据的周围填入固定的数据（比如0 等），这称为填充（padding），是卷积运算中经常会用到的处理

[!IMPORTANT]

使用填充主要是为了调整输出的大小。

如果每次进行卷积运算都会缩小空间，那么在某个时刻输出大小就有可能变为1，导致无法再应用卷积运算。为了避免出现这样的情况，就要使用填充。在刚才的例子中，将填充的幅度设为1，那么相对于输入大小(4, 4)，输出大小也保持为原来的(4, 4)。因此，卷积运算就可以在保持空间大小不变的情况下将数据传给下一层。

步幅

应用滤波器的位置间隔称为步幅（stride）

3维数据的卷积运算

图像是3维数据，有高、长、通道方向

通道方向上有多个特征图时，会按通道进行输入数据和滤波器的卷积运算，并将结果相加，从而得到输出。

需要注意的是，在3 维数据的卷积运算中，输入数据和滤波器的通道数要设为相同的值

滤波器大小可以设定为任意值（不过，每个通道的滤波器大小要全部相同）。这个例子中滤波器大小为(3, 3)，但也可以设定为(2, 2)、(1, 1)、(5, 5) 等任意值。再强调一下，通道数只能设定为和输入数据的通道数相同的值（本例中为3）。

结合方块思考

在这个例子中，数据输出是1 张特征图。所谓1 张特征图，换句话说，就是通道数为1 的特征图。

作为4 维数据，滤波器的权重数据要按(output_channel, input_channel, height, width) 的顺序书写

不同形状的方块相加时，可以基于NumPy的广播功能轻松实现

批处理

神经网络的处理中进行了将输入数据打包的批处理。

需要将在各层间传递的数据保存为4 维数据。具体地讲，就是按(batch_num, channel, height, width)的顺序保存数据

这里需要注意的是，网络间传递的是4 维数据，对这N个数据进行了卷积运算。也就是说，批处理将N次的处理汇总成了1 次进行。

池化层

池化是缩小高、长方向上的空间的运算

一般来说，池化的窗口大小会和步幅设定成相同的值

[!WARNING]

除了Max 池化之外，还有Average 池化等。相对于Max 池化是从目标区域中取出最大值，Average 池化则是计算目标区域的平均值。在图像识别领域，主要使用Max 池化。因此，本书中说到“池化层”时，指的是Max 池化。

池化层的特征

没有要学习的参数
通道数不发生变化
对微小的位置变化具有鲁棒性（健壮）

卷积层和池化层的实现

4维数组

比如数据的形状是(10, 1, 28, 28)，则它对应10 个高为28、长为28、通道为1 的数据

CNN中处理的是4维数据，因此卷积运算的实现看上去会很复杂，但是通过使用下面要介绍的im2col这个技巧，问题就会变得很简单

基于im2col的展开

im2col是一个函数，将输入数据展开以适合滤波器（权重）

对于输入数据，将应用滤波器的区域（3 维方块）横向展开为1 列。im2col会在所有应用滤波器的地方进行这个展开处理。

在滤波器的应用区域重叠的情况下，使用im2col展开后，展开后的元素个数会多于原方块的元素个数。因此，使用im2col的实现存在比普通的实现消耗更多内存的缺点。但是，汇总成一个大的矩阵进行计算，对计算机的计算颇有益处

卷积层的实现

class Convolution:
    def __init__(self, W, b, stride=1, pad=0):
        self.W = W
        self.b = b
        self.stride = stride
        self.pad = pad
        
    def forward(self, x):
        FN, C, FH, FW = self.W.shape
        N, C, H, W = x.shape
        out_h = int(1 + (H + 2*self.pad - FH) / self.stride)
        out_w = int(1 + (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)
        
        return out
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

池化层的实现

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
    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)
        # 展开(1)
        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h*self.pool_w)
        # 最大值(2)
        out = np.max(col, axis=1)
        # 转换(3)
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)
        return out
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

池化层的实现按下面3 个阶段进行:

展开输入数据。
求各行的最大值。
转换为合适的输出大小。

CNN的实现

参数

input_dim―输入数据的维度：（通道，高，长）
conv_param―卷积层的超参数（字典）。字典的关键字如下：
- filter_num―滤波器的数量
- filter_size―滤波器的大小
- stride―步幅
- pad―填充
hidden_size―隐藏层（全连接）的神经元数量
output_size―输出层（全连接）的神经元数量
weitght_int_std―初始化时权重的标准差

class SimpleConvNet:
    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):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)
    
    def gradient(self, x, t):
        # forward
        self.loss(x, t)
        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)
        
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)
        # 设定
        grads = {}
        grads['W1'] = self.layers['Conv1'].dW
        grads['b1'] = self.layers['Conv1'].db
        grads['W2'] = self.layers['Affine1'].dW
        grads['b2'] = self.layers['Affine1'].db
        grads['W3'] = self.layers['Affine2'].dW
        grads['b3'] = self.layers['Affine2'].db
        return grads
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69