卷积神经网络CNN-基础

最新推荐文章于 2022-01-18 23:01:02 发布

大树先生的博客

最新推荐文章于 2022-01-18 23:01:02 发布

阅读量1.4k

点赞数

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

本文链接：https://blog.csdn.net/Koala_Tree/article/details/77573836

版权

Deep Learning 专栏收录该内容

8 篇文章 3 订阅

订阅专栏

卷积神经网络CNN-基础

1. 链式反向梯度传导

链式法则的计算

y = f (x) ， z = g (y) \partial z \partial x = \partial z \partial y \cdot \partial y \partial x

$y=f(x)，z=g(y)\\\dfrac{\partial z}{\partial x}=\dfrac{\partial z}{\partial y}\cdot\dfrac{\partial y}{\partial x}$

简单函数的例子

f (x, y, z) = (x + y) \cdot z

$f(x,y,z)=(x+y)\cdot z$
记：

q=x+y，f=q⋅z $q=x+y，f=q\cdot z$ 。
则有：

\partial f \partial z = q ， \partial f \partial q = z \partial q \partial x = 1 ， \partial q \partial y = 1

$\dfrac{\partial f}{\partial z}=q，\dfrac{\partial f}{\partial q}=z\\ \dfrac{\partial q}{\partial x}=1，\dfrac{\partial q}{\partial y}=1$

函数

f $f$ 对自己的导数为1，上面的数字代表各层传递的值。
这里写图片描述

从后向前反向传播，得到反向梯度传导的导数值。

layer融合的过程中，如果layer是相加的，则直接传递导数；如果是相乘，则相互交换导数。

复杂函数的例子

f (x, y, w) = 1 exp { - [ ( x 1 + x 2 ) w + max ( y 1 , y 2 ) ] }

$f(x,y,w)=\dfrac{1} {\exp\left\{ {-[(x_{1}+x_{2})w+\max(y_{1},y_{2})]}\right\}}$

对每层的导数（

Δy，Δx $\Delta y，\Delta x$ ）结果进行存储，用于下一层的导数计算。

2. 卷积层

卷积层的定义

卷积层由多个卷积核组合形成，每个卷积核同输入数据进行卷积运算，形成新的特征图。

每一个卷积核，仅产生一层特征图。有多少个卷积核，下一层便产生特征图的“厚度“即为对应的个数。

卷积核

同输入数据进行计算的二维（一维，三维）算子；
其大小有用户定义，其深度根据输入的数据深度大小确定；
卷积核的“矩阵”值，便为卷积神经网络的参数，及网络需要学习的参数；
卷积核初值随机生成，通过反向传播进行更新。
-

卷积层关键参数

卷积核的大小：
- 一般卷积核会选择奇数，满足对称，偶数也可以；
- 一般会选择卷积核小一些，层数多一些的结构来建立卷积神经网络模型。
- $1\times 1\times n大小的卷积核可以用做特殊的降维处理。$ **
- 卷积核的“厚度”与前一层输入数据的“厚度”保持一致；
- 一般卷积核会覆盖全部输入，特殊情况下覆盖局部区域。
步长
步长（stride）表示对输入特征图的扫描间隔对输出特征图的影响。
步长大的情况相当于在卷积的过程中做了池化。
边界扩充（pad）
在卷积计算过程中，为了允许边界上的数据也能作为中心参与卷积运算，将边界假装延伸。
- 扩充的目的是为了确保卷积后特征图尺度一致；
- 卷积核的宽度为 $2i+1$ ，则添加pad的宽度为 $i$ 。
卷积神经网络的“宽度”
一般常见的参数为64、128、256。主要是为了GPU并行计算，使得训练过程更加高效。

卷积网络

卷积网络的参数计算
- Num： $n\times3\times3\times m$ ， $n$ 个 $3\times3\times m$ 大小的卷积核。
- 与传统的神经网络相比，其参数的数量会减少，但是其计算量会增加。
正向传播（Forward Propagation）
反向传播（Back Propagation）

3. 功能层

卷积神经网络需要的一些额外功能：
* 非线性激励：卷积是线性运算，增加非线性描述的能力；
* 降维：特征图稀疏，减少数据运算量，保持精度；
* 归一化：特征的scale保持一致；
* 区域分割：不同区域进行独立学习；
* 区域融合：对分开的区域进行合并，方便信息融合；
* 增维：增加图片生成或探测任务中空间信息。

非线性激励层

在输入的特征图和卷积核卷积的过程中，每一次卷积计算都会生成特征图的一个值，卷积计算为线性运算，需要将所得结果输入非线性激励函数中，得到一个非线性值，增加非线性描述的能力。
一般会使用ReLU函数，相当于选取 $XW$ 和 $0$ 两者之间的最大值。

池化层

数据降维，方便计算和存储；
池化过程中，每张特征图单独降维。

归一化层

在计算的过程中，中间层部分激励不平等，则对数据进行归一化。某种程度上可以减少梯度衰减。

批量归一化Batch Normalization(BN)
- 可以加速训练过程，提高精度。

近邻归一化Local Response Normalization

x i = x i ( k + ( α \sum j x 2 j ) ) β

$x_{i}=\dfrac{x_{i}}{(k+(\alpha\sum_{j}x_{j}^{2}))^{\beta}}$
与BN的区别：

BN依据mini batch的数据，近邻归一化仅需要自身；
BN训练中有学习参数。

切分层

在某些应用中，希望独立对某些区域单独学习。
其好处是，学习多套参数，其具有更强的特征描述能力。

融合层

对独立进行特征学习的分支进行融合，构建高效且精简的特征组合。
例如：GoogleLeNet 的基本模块用多种分辨率对目标特征进行学习，之后进行多分辨率特征的融合。

级连 - concatenation
不同输入网络特征简单叠加。
合并 - 运算融合形状一致的特征层，通过（+，-，X， max，conv）运算，形成形状相同的输出。
ResNet的融合：

4. 卷积神经网络MNIST

下面还是利用mnist数据集，利用卷积神经网络进行手写字体的识别。

代码

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

import tensorflow as tf

# Parameters
learning_rate = 0.001
training_epochs = 30
batch_size = 100
display_step = 1

# Network Parameters
n_input = 784 # MNIST data input (img shape: 28*28)
n_classes = 10 # MNIST total classes (0-9 digits)

# tf Graph input
x = tf.placeholder("float", [None, n_input])
y = tf.placeholder("float", [None, n_classes])

#pre-define the  
def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')


# Create model
def multilayer_perceptron(x, weights, biases):
    #now, we want to change this to a CNN network

    #first reshape the data to 4-D
    x_image = tf.reshape(x, [-1,28,28,1])

    #then apply cnn layers

    h_conv1 = tf.nn.relu(conv2d(x_image, weights['conv1']) + biases['conv_b1'])
    h_pool1 = max_pool_2x2(h_conv1)

    h_conv2 = tf.nn.relu(conv2d(h_pool1, weights['conv2']) + biases['conv_b2'])
    h_pool2 = max_pool_2x2(h_conv2)

    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, weights['fc1']) + biases['fc1_b'])


    # Output layer with linear activation
    out_layer = tf.matmul(h_fc1, weights['out']) + biases['out_b']
    return out_layer

# Store layers weight & biases
weights = {
    'conv1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
    'conv2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
    'fc1' : tf.Variable(tf.random_normal([7*7*64,256])),
    'out': tf.Variable(tf.random_normal([256,n_classes]))
}
biases = {
    'conv_b1': tf.Variable(tf.random_normal([32])),
    'conv_b2': tf.Variable(tf.random_normal([64])),
    'fc1_b': tf.Variable(tf.random_normal([256])),
    'out_b': tf.Variable(tf.random_normal([n_classes]))
}

# Construct model
pred = multilayer_perceptron(x, weights, biases)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

# Initializing the variables
init = tf.global_variables_initializer()

# Launch the graph
with tf.Session() as sess:
    sess.run(init)

    # Training cycle
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(mnist.train.num_examples/batch_size)
        # Loop over all batches
        for i in range(total_batch):
            batch_x, batch_y = mnist.train.next_batch(batch_size)
            # Run optimization op (backprop) and cost op (to get loss value)
            _, c = sess.run([optimizer, cost], feed_dict={x: batch_x,
                                                          y: batch_y})
            # Compute average loss
            avg_cost += c / total_batch
        # Display logs per epoch step
        if epoch % display_step == 0:
            print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
    print("Optimization Finished!")

    # Test model
    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
    # Calculate accuracy
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

关键代码解释

1.：tf.nn.conv2d

tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)

除去name参数用以指定该操作的name，与方法有关的一共五个参数：

第一个参数input：指需要做卷积的输入图像，它要求是一个Tensor，具有[batch, in_height, in_width, in_channels]这样的shape，具体含义是[训练时一个batch的图片数量, 图片高度, 图片宽度, 图像通道数]，注意这是一个4维的Tensor，要求类型为float32和float64其中之一；
第二个参数filter：相当于CNN中的卷积核，它要求是一个Tensor，具有[filter_height, filter_width, in_channels, out_channels]这样的shape，具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]，要求类型与参数input相同，有一个地方需要注意，第三维in_channels，就是参数input的第四维；
第三个参数strides：卷积时在图像每一维的步长，这是一个一维的向量，长度4；对于图片，因为只有两维，通常strides取[1，stride，stride，1]；
第四个参数padding：string类型的量，只能是”SAME”,”VALID”其中之一，这个值决定了不同的卷积方式。’SAME’时，表示卷积核可以停留在图像边缘，即图片的大小不会因为卷积运算而变小；’VALID’时，表示卷积核不能停留在图像边缘，即会因为卷积运算图片的大小会缩小；
第五个参数：use_cudnn_on_gpu :bool类型，是否使用cudnn加速，默认为true。
结果返回一个Tensor，这个输出，就是我们常说的feature map.

2.：tf.nn.max_pool

tf.nn.max_pool(value, ksize, strides, padding, name=None)

第一个参数value：需要池化的输入，一般池化层接在卷积层后面，所以输入通常是feature map，依然是[batch, height, width, channels]这样的shape；
第二个参数ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，因为我们不想在batch和channels上做池化，所以这两个维度设为了1；
第三个参数strides：和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]；
第四个参数padding：和卷积类似，可以取’VALID’ 或者’SAME’。
返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]这种形式。

3.：tf.reshape