深度学习基础（CNN详解以及训练过程1）

时间 2019-11-20

标签深度学习基础 cnn 详解以及训练过程繁體版

原文原文链接

深度学习是一个框架，包含多个重要算法: python

Convolutional Neural Networks(CNN)卷积神经网络
AutoEncoder自动编码器
Sparse Coding稀疏编码
Restricted Boltzmann Machine(RBM)限制波尔兹曼机
Deep Belief Networks(DBN)深信度网络
Recurrent neural Network(RNN)多层反馈循环神经网络神经网络

对于不一样问题(图像，语音，文本)，须要选用不一样网络模型好比CNN RESNET等才能达到更好效果。git

今天来说最基础的CNN网络。算法

能够不能够模仿人类大脑的这个特色，构造多层的神经网络，较低层的识别初级的图像特征，若干底层特征组成更上一层特征，最终经过多个层级的组合，最终在顶层作出分类呢？答案是确定的，这也是许多深度学习算法（包括CNN）的灵感来源。数组

CNN网络介绍

卷积神经网络是一种多层神经网络，擅长处理图像特别是大图像的相关机器学习问题。网络

卷积网络经过一系列方法，成功将数据量庞大的图像识别问题不断降维，最终使其可以被训练。CNN最先由Yann LeCun提出并应用在手写字体识别上（MINST）。LeCun提出的网络称为LeNet，其网络结构以下：app

这是一个最典型的卷积网络，由卷积层、池化层、全链接层组成。其中卷积层与池化层配合，组成多个卷积组，逐层提取特征，最终经过若干个全链接层完成分类。框架

卷积层完成的操做，能够认为是受局部感觉野概念的启发，而池化层，主要是为了下降数据维度。dom

综合起来讲，CNN经过卷积来模拟特征区分，而且经过卷积的权值共享及池化，来下降网络参数的数量级，最后经过传统神经网络完成分类等任务。机器学习

下降参数量级

为何要下降参数量级？从下面的例子就能够很容易理解了。分布式

若是咱们使用传统神经网络方式，对一张图片进行分类，那么，咱们把图片的每一个像素都链接到隐藏层节点上，那么对于一张1000x1000像素的图片，若是咱们有1M隐藏层单元，那么一共有10^12个参数，这显然是不能接受的。（以下图所示）

可是咱们在CNN里，能够大大减小参数个数，咱们基于如下两个假设：

1）最底层特征都是局部性的，也就是说，咱们用10x10这样大小的过滤器就能表示边缘等底层特征

2）图像上不一样小片断，以及不一样图像上的小片断的特征是相似的，也就是说，咱们能用一样的一组分类器来描述各类各样不一样的图像

基于以上两个，假设，咱们就能把第一层网络结构简化以下：

咱们用100个10x10的小过滤器，就可以描述整幅图片上的底层特征。

卷积（Convolution）

卷积运算的定义以下图所示：

如图所示，咱们有一个5x5的图像，咱们用一个3x3的卷积核：

1　　0　　1

0　　1　　0

1　　0　　1

来对图像进行卷积操做（能够理解为有一个滑动窗口，把卷积核与对应的图像像素作乘积而后求和），获得了3x3的卷积结果。

这个过程咱们能够理解为咱们使用一个过滤器（卷积核）来过滤图像的各个小区域，从而获得这些小区域的特征值。

在实际训练过程当中，卷积核的值是在学习过程当中学到的。

在具体应用中，每每有多个卷积核，能够认为，每一个卷积核表明了一种图像模式，若是某个图像块与此卷积核卷积出的值大，则认为此图像块十分接近于此卷积核。若是咱们设计了6个卷积核，能够理解：咱们认为这个图像上有6种底层纹理模式，也就是咱们用6中基础模式就能描绘出一副图像。如下就是24种不一样的卷积核的示例：

池化（Pooling）

池化听起来很高深，其实简单的说就是下采样。池化的过程以下图所示：

上图中，咱们能够看到，原始图片是20x20的，咱们对其进行下采样，采样窗口为10x10，最终将其下采样成为一个2x2大小的特征图。

之因此这么作的缘由，是由于即便作完了卷积，图像仍然很大（由于卷积核比较小），因此为了下降数据维度，就进行下采样。

之因此能这么作，是由于即便减小了许多数据，特征的统计属性仍可以描述图像，并且因为下降了数据维度，有效地避免了过拟合。

在实际应用中，池化根据下采样的方法，分为最大值下采样（Max-Pooling）与平均值下采样（Mean-Pooling）。

全链接层（fully connected layers，FC）

在整个卷积神经网络中起到“分类器”的做用。若是说卷积层、池化层和激活函数层等操做是将原始数据映射到隐层特征空间的话，全链接层则起到将学到的“分布式特征表示”映射到样本标记空间的做用。在实际使用中，全链接层可由卷积操做实现：对前层是全链接的全链接层能够转化为卷积核为1x1的卷积；而前层是卷积层的全链接层能够转化为卷积核为hxw的全局卷积，h和w分别为前层卷积结果的高和宽。

全链接层的实现

LeNet介绍

下面再回到LeNet网络结构：

这回咱们就比较好理解了，原始图像进来之后，先进入一个卷积层C1，由6个5x5的卷积核组成，卷积出28x28的图像，而后下采样到14x14（S2）。

接下来，再进一个卷积层C3，由16个5x5的卷积核组成，以后再下采样到5x5（S4）。

注意，这里S2与C3的链接方式并非全链接，而是部分链接，以下图所示：

其中行表明S2层的某个节点，列表明C3层的某个节点。

咱们能够看出，C3-0跟S2-0,1,2链接，C3-1跟S2-1,2,3链接，后面依次类推，仔细观察能够发现，其实就是排列组合：

0 0 0 1 1 1

0 0 1 1 1 0

0 1 1 1 0 0

...

1 1 1 1 1 1

咱们能够领悟做者的意图，即用不一样特征的底层组合，能够获得进一步的高级特征，例如：/ + \ = ^ （比较抽象O(∩_∩)O~），再好比好多个斜线段连成一个圆等等。

最后，经过全链接层C五、F6获得10个输出，对应10个数字的几率。

最后说一点我的的想法哈，我认为第一个卷积层选6个卷积核是有缘由的，大概也许多是由于0~9其实能用如下6个边缘来表明：

是否是有点道理呢，哈哈

而后C3层的数量选择上面也说了，是从选3个开始的排列组合，因此也是能够理解的。

其实这些都是针对特定问题的trick，如今更加通用的网络的结构都会复杂得多，至于这些网络的参数如何选择，那就须要咱们好好学习了。

-----------------------------------------------------------------------------------------------------------------------

训练过程

卷积网络在本质上是一种输入到输出的映射，它可以学习大量的输入与输出之间的映射关系，而不须要任何输入和输出之间的精确的数学表达式，只要用已知的模式对卷积网络加以训练，网络就具备输入输出对之间的映射能力。卷积网络执行的是有监督训练，因此其样本集是由形如：（输入向量，理想输出向量）的向量对构成的。全部这些向量对，都应该是来源于网络即将模拟的系统的实际“运行”结果。它们能够是从实际运行系统中采集来的。在开始训练前，全部的权都应该用一些不一样的小随机数进行初始化。“小随机数”用来保证网络不会因权值过大而进入饱和状态，从而致使训练失败；“不一样”用来保证网络能够正常地学习。实际上，若是用相同的数去初始化权矩阵，则网络无能力学习。

卷积神经网络的训练过程与传统神经网络相似，也是参照了反向传播算法。

第一阶段，向前传播阶段：

a）从样本集中取一个样本(X,Y_p)，将X输入网络；

b）计算相应的实际输出O_p。

在此阶段，信息从输入层通过逐级的变换，传送到输出层。这个过程也是网络在完成训练后正常运行时执行的过程。在此过程当中，网络执行的是计算（实际上就是输入与每层的权值矩阵相点乘，获得最后的输出结果）：

O_p=F_n（…（F₂（F₁（X_pW^（1））W^（2））…）W^（n））

第二阶段，向后传播阶段

a）算实际输出O_p与相应的理想输出Y_p的差；

b）按极小化偏差的方法反向传播调整权矩阵。

以上内容摘自其余博客，因为我也没有仔细了解这一块，建议直接参考原博客。

手写数字分类的例子，基于tensorflow

引自：使用TensorFlow编写识别数字的CNN训练程序详解

CNN的结构

从网上借用一张图片来表示一下，是一个有2层hidden layer的CNN。

程序中设置的一些参数是：
卷积层1：kernel_size [5, 5], stride=1， 4个卷积窗口
卷积层2：kernel_size [5, 5], stride=1， 6个卷积窗口
池化层： pool_size [2, 2], stride = 2
全链接层1: 1024个特征

MNIST数据的获取

以往咱们获取MINIST的方式是:

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

如今能够：

from tensorflow.contrib import learn
mnist = learn.datasets.load_dataset('mnist')

经过mnist.train, mnist.test, mnist.validation来得到3个数据集，每一个数据集里面的方法有(已train为例)：

train.images 图片数据，二维数组 (55000, 784) dtype=float32
train.labels 图片的分类，一维数组，每一个数值表示图片对应的数字
array([7, 3, 4, …, 5, 6, 8], dtype=uint8)
train.num_examples 图片数量 55000
train.next_batch 下一批数据
n = train.next_batch n[0] 是images n[1]是labels

第一次load MNIST数据的时候，会自动从网上下载，放到当前目录的MNIST-data目录下

第一种加载方式，有一个one-hot参数，此时每一个样本的label，返回的是一个长度10的vector，其中只有一个位置是1，其余都是0。第二种方式，没有这个参数，若是须要的话，得直接调用datasets.mnist.read_data_sets

定义卷积层

在tf.contrib.layers里面有convolution2d，conv2d等方法，其实都是convolution方法的别名

convolution(inputs, num_outputs, kernel_size, stride=1, padding='SAME', data_format=None, rate=1, activation_fn=nn.relu, normalizer_fn=None, normalizer_params=None, weights_initializer=initializers.xavier_initializer(), weights_regularizer=None, biases_initializer=init_ops.zeros_initializer, biases_regularizer=None, reuse=None, variables_collections=None, outputs_collections=None, trainable=True, scope=None)

这个函数很强大，1到3维的卷积都支持。(我暂时只用过2维)

inputs: 输入变量，是一个N+2维的Tensor
- 类型要求是一个Tensor，而咱们通常训练的数据都是常量(好比mnist，load之后获得是python的数据类型，不是tf的)，因此须要把用tf的方法作一下转换，好比tf.reshape
- 为何是N+2维呢，好比图像，除了宽度和高度，实际上还有样本数量和通道数量(如RGB3通道)，因此多了2维。
- inputs的格式，由date_format这个参数来以为，好比2维，有NHWC和NCHW两种。N是样本数量，H高度，W宽度，C通道数。
num_outputs: 卷积filter的数量，或者说提取的特征数量，好比5,10
kernel_size: 卷积核的大小，是N个参数的list，好比二维图像，能够时候[10,10]，若是参数值相同，用一个整数来表示也能够；
stride: 卷积步长，一样是N个参数的序列，或者都相等的话，用一个整数来表示，默认是1.
padding: 字符串格式，默认SAME，可选’VALID’。（想问：这两个效果上有多大差别？）
data_format: 字符串，指定inputs的格式
- 一维数据：”NWC” (default) and “NCW”
- 二维数据：”NHWC” (default) and “NCHW”
- 三维数据：”NDHWC”
- 也就是，不指定的话，通道数都是最后一个参数。
rate: a sequence of N positive integers specifying the dilation rate to use for a’trous convolution. Can be a single integer to specify the same value for all spatial dimensions. (暂时没看到其做用)
activation_fn: 激活函数，默认relu
normalizer_fn: normalization function to use instead of biases.（没用过，不知道起做用）
normalizer_params： normalization function parameters.
weights_initializer：这不用说了，有默认值，估计用默认的就能够了。
weights_regularizer: Optional regularizer for the weights.(没明白为何须要这个)
biases_initializer: 有默认值，通常也就不用指定。
biases_regularizer: …
reuse: whether or not the layer and its variables should be reused. To be able to reuse the layer scope must be given. 应该都须要reuse吧，因此这个参数默认为True更好，如今是None。
variables_collections：怎么用暂时不太明白，但应该不用指定也能够；
outputs_collections：同上；
trainable： If True also add variables to the graph collection GraphKeys.TRAINABLE_VARIABLES，默认是True。（这个是否是说在fit的时候须要设为True，evaluate和predict的时候为false？）
scope：也便是variable_scope，若是用多个卷积层的话，须要设置这个参数，以便把每一次的weight和bias区别出来。

咱们在对MNIST作卷积的时候，只要指定inputs, num_outputs, kernel_size, scope这几个参数就能够了，好比:

conv1 = tf.contrib.layers.conv2d(inputs, 4, [5, 5], 'conv_layer1')
#stride默认1，weights和biases也都是默认的

定义池化层

能够用 tf.contrib.layers.max_pool2d或者tf.contrib.layers.avg_pool2d

max_pool2d(inputs, kernel_size, stride=2, padding=’VALID’, data_format=DATA_FORMAT_NHWC, outputs_collections=None, scope=None)

inputs: 就是卷积的输出了；
kernel_size: 是否是叫pool_size更贴切。[kernel_height, kernel_width]或者是一个整数；
stride： [stride_height, stride_width]，不过文档上说目前这两个值必须同样
padding：这里默认是VALID，和卷积默认不同，为何要这样呢？
data_format: 注意和卷积用的同样哦；
outputs_collections: …
scope: pooling的时候没有参数，须要scope吗？

pool1 = tf.contrib.layers.max_pool2d(conv1, [2, 2], padding='SAME')

定义全链接层

tf.contrib.layers下有可用的全链接方法：

fully_connected(inputs, num_outputs, activation_fn=nn.relu, normalizer_fn=None, normalizer_params=None, weights_initializer=initializers.xavier_initializer(), weights_regularizer=None, biases_initializer=init_ops.zeros_initializer, biases_regularizer=None, reuse=None, variables_collections=None, outputs_collections=None, trainable=True, scope=None)

看这个函数，参数和卷积不少地方是同样的, 咱们能够这样用：

fc = tf.contrib.layers.fully_connected(inputs, 1024, scope='fc_layer')

惟一须要注意的是这里的inputs参数，通常是二维的形式[batch_size, depth]，而前面卷积的结果，通常是[batch_size, height, width, channels]的形式，因此须要作一个flatten操做后再传给fully_connected。

通常在fc以后还会作dropout，能够用以下方法：

dropout(inputs, keep_prob=0.5, noise_shape=None, is_training=True, outputs_collections=None, scope=None)

参数的意义很明显，其中is_training须要注意一下，在训练的时候传True，其余状况下传False。

dropout是指在深度学习网络的训练过程当中，对于神经网络单元，按照必定的几率将其暂时从网络中丢弃。注意是暂时，对于随机梯度降低来讲，因为是随机丢弃，故而每个mini-batch都在训练不一样的网络。

dropout是CNN中防止过拟合提升效果的一个大杀器。

定义logits

全链接以后，通常就是用softmax作分类，而后定义loss，就能够训练了。可是看官方的例子，softmax前还加了一步，计算叫logits的东西，代码里面的说明是：

We don’t apply softmax here because 
tf.nn.softmax_cross_entropy_with_logits accepts the unscaled logits 
and performs the softmax internally for efficiency.

为何要这样暂时不太明白，可是依样画葫芦，定义logtis自己很简单，作一个线性变换，把FC的结果映射到分类的数量上：

def inference(x, num_class):
  with tf.variable_scope('softmax'):
    dtype = x.dtype.base_dtype
    # Set up the requested initialization.
    init_mean = 0.0
    init_stddev = 0.0
    weights = tf.get_variable('weights',
                                [x.get_shape()[1], num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)
    biases = tf.get_variable('bias', [num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)

    logits = tf.nn.xw_plus_b(x, weights, biases)
    return logits

定义loss

在tf.contrib.losses下有一些预约义的loss函数，好比直接用

softmax_cross_entropy(logits, onehot_labels, weights=_WEIGHT_SENTINEL, label_smoothing=0, scope=None)

注意这里的label是onehot格式的, 咱们从mnist获取的label要转换成这个格式。

定义train_op

能够用tf.contrib.layers.optimize_loss，经过传递不一样的参数，就能够调用不一样的优化方法。

optimize_loss(loss,
              global_step,
              learning_rate,
              optimizer,
              gradient_noise_scale=None,
              gradient_multipliers=None,
              clip_gradients=None,
              learning_rate_decay_fn=None,
              update_ops=None,
              variables=None,
              name=None,
              summaries=None,
              colocate_gradients_with_ops=False):

预约义的optimizer有：

OPTIMIZER_CLS_NAMES = {
    "Adagrad": train.AdagradOptimizer,
    "Adam": train.AdamOptimizer,
    "Ftrl": train.FtrlOptimizer,
    "Momentum": train.MomentumOptimizer,
    "RMSProp": train.RMSPropOptimizer,
    "SGD": train.GradientDescentOptimizer,
}
或者这么写
train_op = tf.contrib.layers.optimize_loss(
            loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad', learning_rate=0.1)

model和Estimator

结合上面的内容，就能够定义出model，从而用Estimator完成训练，预测等功能，完整的程序以下：

import numpy as np

import sklearn.metrics as metrics
import tensorflow as tf
from PIL import Image
from tensorflow.contrib import learn
from tensorflow.contrib.learn import SKCompat
from tensorflow.contrib.learn.python.learn.estimators import model_fn as model_fn_lib
from tensorflow.python.ops import init_ops

IMAGE_SIZE = 28
LOG_DIR = './ops_logs'

mnist = learn.datasets.load_dataset('mnist')

def inference(x, num_class):
  with tf.variable_scope('softmax'):
    dtype = x.dtype.base_dtype
    init_mean = 0.0
    init_stddev = 0.0
    weight = tf.get_variable('weights',
                                [x.get_shape()[1], num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)
    biases = tf.get_variable('bias', [num_class], initializer=init_ops.random_normal_initializer(init_mean, init_stddev, dtype=dtype), dtype=dtype)

    logits = tf.nn.xw_plus_b(x, weight, biases)
    return logits

def model(features, labels, mode):
    if mode != model_fn_lib.ModeKeys.INFER:
        labels = tf.one_hot(labels, 10, 1, 0)
    else:
        labels = None

    inputs = tf.reshape(features, (-1, IMAGE_SIZE, IMAGE_SIZE, 1))

    #conv1
    conv1 = tf.contrib.layers.conv2d(inputs, 4, [5, 5], scope='conv_layer1', activation_fn=tf.nn.tanh);
    pool1 = tf.contrib.layers.max_pool2d(conv1, [2, 2], padding='SAME')
    #conv2
    conv2 = tf.contrib.layers.conv2d(pool1, 6, [5, 5], scope='conv_layer2', activation_fn=tf.nn.tanh);
    pool2 = tf.contrib.layers.max_pool2d(conv2, [2, 2], padding='SAME')
    pool2_shape = pool2.get_shape()
    pool2_in_flat = tf.reshape(pool2, [pool2_shape[0].value or -1, np.prod(pool2_shape[1:]).value])
    #fc
    fc1 = tf.contrib.layers.fully_connected(pool2_in_flat, 1024, scope='fc_layer1', activation_fn=tf.nn.tanh)
    #dropout
    is_training = False
    if mode == model_fn_lib.ModeKeys.TRAIN:
        is_training = True

    dropout = tf.contrib.layers.dropout(fc1, keep_prob=0.5, is_training=is_training, scope='dropout')

    logits = inference(dropout, 10)
    prediction = tf.nn.softmax(logits)
    if mode != model_fn_lib.ModeKeys.INFER:
        loss = tf.contrib.losses.softmax_cross_entropy(logits, labels)
        train_op = tf.contrib.layers.optimize_loss(
            loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad',
            learning_rate=0.1)
    else:
        train_op = None
        loss = None

    return {'class': tf.argmax(prediction, 1), 'prob': prediction}, loss, train_op


classifier = SKCompat(learn.Estimator(model_fn=model, model_dir=LOG_DIR))

classifier.fit(mnist.train.images, mnist.train.labels, steps=1000, batch_size=300)

predictions = classifier.predict(mnist.test.images)
score = metrics.accuracy_score(mnist.test.labels, predictions['class'])
print('Accuracy: {0:f}'.format(score))