深度学习入门（五）：卷积神经网络

最新推荐文章于 2024-01-31 08:00:00 发布

evil心安

最新推荐文章于 2024-01-31 08:00:00 发布

阅读量623

点赞数

分类专栏：深度学习文章标签：卷积深度学习神经网络 python 卷积神经网络

本文链接：https://blog.csdn.net/weixin_46013817/article/details/111927709

版权

深度学习专栏收录该内容

10 篇文章 2 订阅

订阅专栏

卷积神经网络

本章的主题是卷积神经网。CNN被用于图像识别、语言识别等各种场合。

整体结构

之前介绍的神经网络中，相邻层的所有神经元之间都有连接。这称为全连接。CNN中新增了Convolution层和Pooling层。CNN层的连接顺序是“Convolution-ReLU-(Pooling)”（Pooling层有时会被省略）。这可以理解为之前的“affine-ReLU”连接被替换成了“Convolution-ReLU-(Pooling)”连接。

卷积层

CNN中出现了一些特有的术语。比如填充，步幅等。此外，各层中传递的数据都是有形状的数据。

全连接层存在的问题

全连接层存在什么问题呢？那就是数据的形状被”忽视“了。比如，输入数据是图像时，图像通常时高，长、通道方向上的3维形状。但是，向全连接层输入时，需要将3维数据拉平维1维数据。
图像是3维形状，这个形状中应该含有重要的空间信息。比如，空间上邻近的像素为相似的值，RGB的各个通道之间分别有密切的关联性、相距较远的像素之间没有什么关联等，3维形状中可能隐藏有值得提取的本质模式。
而卷积层可以保持形状不变。当输入数据是图像时，卷积层会以3维数据的形式接受输入数据，并同样以 3维数据的形式输出至下一层。因此，在CNN中，可以（有可能）正确理解图像等具有形状的数据。
另外，CNN中，有时将卷积层的输入输出数据称为特征图。其中，卷积层的输入数据称为输入特征图，输出数据称为输出特征图。

卷积运算

卷积层进行的处理就是卷积运算。
对于输入数据，卷积运算以一定间隔滑动滤波器的窗口并应用。将各个位置上滤波器的元素和输入的对应元素相乘，然后再求和（有时将这个计算称为乘积累加运算）。将这个过程在所有位置都进行一遍，就可以得到卷积运算的输出。
CNN中，滤波器的参数就对应之间的权重。在这里插入图片描述

包含偏置的卷积运算的处理流
在这里插入图片描述

填充

在卷积层的处理之前，有时要向输入数据的周围填入固定的数据（比如0等），这称为填充，是卷积运算中经常会用到的处理。在下图中对大小为（4，4）的输入数据应用了幅度为1的填充。”幅度为1的填充“是指用幅度为1像素的0填充周围。
在这里插入图片描述
通过填充，大小为（4，4）的输入数据变成了（6，6）的形状。然后，应用大小为（3，3）的滤波器，生成了大小为（4，4）的输出数据。
使用填充主要是为了调整输出的大小。比如，对大小为（4，4）的输入数据应用（3，3）的滤波器时，输出大小变为（2，2），相当于输出大小比输入大小缩小了2个元素。在反复进行多次卷积运算的深度网络中会成为问题。为什么呢？因为如果每次进行卷积运算都会缩小空间，那么在某个时刻输出大小就有可能变为1，导致无法再应用卷积运算。

步幅

应用滤波器的位置间隔称为步幅。
在这里插入图片描述
如果将步幅设为2，应用滤波器的窗口间隔变为2个元素。
综上，增大步幅后，输出大小会变小。而增大填充后，输出大小会变大。如何计算输出大小。
假设输入大小为（H,W）,滤波器大小为（FH,FW），输出大小为（OH,OW）,填充为P，步幅为S。此时，输出大小 $OH=\frac{H+2P-FH}{S}+1$ $OW=\frac{W+2P-FW}{S}+1$
上述公式只适用于可以除尽的情况。

3维数据的卷积运算

在这里插入图片描述
通道方向上有多个特征图时，会按通道进行输入数据和滤波器的卷积运算，并将结果相加，从而得到输出。
在3维数据的卷积运算中，输入数据和滤波器的通道数要设为相同的值。滤波器的大小可以设定为任意值（不过，每个通道的滤波器大小要全部相同）。在这里插入图片描述
在这个例子中，数据输出是1张特征图。所谓1张特征图，就是通道数为1的特征图。那么，如果要在通道方向上也拥有多个卷积运算的输出，该怎么做？为此，就需要多个滤波器。
如果追加偏置的加法运算处理，结果如下：
在这里插入图片描述
不同形状的方块相加时，可以基于NumPy的广播功能轻松实现。

批处理

神经网络的处理中进行了将输入数据打包的批处理。通过批处理，能够实现处理的高效化和学习时对mini-batch的对应。
我们希望卷积运算也同样对应批处理。为此，需要将在各层间传递的数据保存为4维数据。（batch_num,channel,height,width）的顺序保存数据。
也就是说，批处理将N次的处理汇总成了1次进行。
在这里插入图片描述

池化层

池化是缩小高，长方向上的空间的运算。
在这里插入图片描述

这个例子是按步幅进行2×2的Max池化时的处理顺序。“Max池化”是获取最大值的运算。“2×2”表示目标区域的大小。从2×2区域中取出最大的元素。此外，这个例子将步幅设为了2，所以2×2的窗口的移动间隔为2个元素，另外，一般来说，池化窗口的大小会和步幅设定成相同的值。
除了Max池化之外，还有Average池化等。相对于Max池化是从目标区域中取出最大值，Average池化则是计算目标区域的平均值。

池化层的特征

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

卷积层和池化层的实现

基于im2col的展开

im2col是一个函数，将输入数据展开以适合滤波器（权重）对三维的输入数据应用im2col后，数据转换为2维矩阵。
im2col会把输入数据展开以适合滤波器。对于输入数据，将应用滤波器的区域（3维方块）横向展开为1列。im2col会在所有应用滤波器的地方进行这个展开处理。
使用im2col的实现存在比普通的实现比普通的实现消耗更多内存的缺点，由于滤波器的应用区域几乎都是重叠的。但是，汇总成一个大的矩阵进行计算，对计算机的实现颇有益处，比如，在矩阵计算的库（线性代数库）等中，矩阵计算的实现已被高度最优化。可以高效地进行大矩阵的乘法运算。
在这里插入图片描述
使用im2col展开输入数据后，之后就只需将卷积层的滤波器纵向展开为1列，并计算2个矩阵的乘积即可。然后将2维输出数据转换维合适的形状。

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

    Parameters
    ----------
    input_data : 由(数据量, 通道, 高, 长)的4维数组构成的输入数据
    filter_h : 滤波器的高
    filter_w : 滤波器的长
    stride : 步幅
    pad : 填充

    Returns
    -------
    col : 2维数组
    """
    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

卷积层的实现

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

transpose会更改多维数组的轴的顺序。

池化层的实现

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)

        # 展开
        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h * self.pool_w)
        
        # 最大值
        out = np.max(col, axis=1)
        
        # 转换
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)
        
        return out

CNN的实现

网络的构成是“Convolution - ReLU - Pooling - Affine - ReLU - Affine - Softmax”,我们将它命名为SimpleConvNet的类

参数

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

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

具有代表性的CNN

LeNet

LeNet有连续的卷积层和池化层，最后经全连接层输出结果。
和“现在的CNN”相比，LeNet有几个不同点。

LeNet中使用sigmoid函数，而现在的CNN中主要使用ReLU函数。
原始的LeNet中使用子采样缩小中间数据的大小，而现在的CNN中Max池化是主流。

AlexNet

AlexNet与LeNet的不同：

激活函数使用ReLU
使用进行局部正规化的LRN层。
使用Dropout

说明

此为本人学习《深度学习入门》的学习笔记，详情请阅读原书.

evil心安

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
深度学习入门（五）：卷积神经网络

卷积神经网络本章的主题是卷积神经网。CNN被用于图像识别、语言识别等各种场合。整体结构之前介绍的神经网络中，相邻层的所有神经元之间都有连接。这称为全连接。CNN中新增了Convolution层和Pooling层。CNN层的连接顺序是“Convolution-ReLU-(Pooling)”（Pooling层有时会被省略）。这可以理解为之前的“affine-ReLU”连接被替换成了“Convolution-ReLU-(Pooling)”连接。卷积层CNN中出现了一些特有的术语。比如填充，步幅等。此外，
复制链接

扫一扫