Tensorflow基础概念与编程（第五讲）

末蓝、 2022-03-09 05:50 336阅读 0赞

# 图像识别与卷积神经网络 #

## 图像识别问题简介及经典数据集 ##

对于图像处理的问题来说，卷积神经网络可以得到更低的错误率，而且通过卷积神经网络达到的错误率已经非常接近人工标注的错误率了；MNIST是一个相对简单的数据集，CIFAR数据集就是一个影响力很大的图像分类数据集，CIFAR-10有来自10个不同种类的60000张图片，大小为32\*32，灰度图

无论MNIST数据集还是CIFAR数据集，相比真实环境下的图像识别的问题，有两个最大的问题：

*  现实生活中的图片分辨率要远高于32\*32
 *  现实生活中的物品的种类很多，无论是10类还是100类都不能完全覆盖所有的种类

### 小知识点： ###

*  Top-N：top-N正确率指的是图像识别算法中给出前N个答案中有一个是正确的概率，在图像分类问题上，很多学术论文都将前N个答案的正确率进行比较
 *  之前介绍的损失函数和参数的优化过程也都适用于卷积神经网络
 *  卷积神经网络和全连接神经网络的唯一区别就在于神经网络中相邻两层的连接方式
 *  RGB色彩模式下，一个完整的图像是由红色、绿色和蓝色3个通道组成的，因为每个通道在每个像素点都有亮度值，所以整个图像就是一个三维矩阵
 *  卷积神经网络中的卷积层和池化层相当于做了特征选择的工作
 *  全连接层用来完成分类任务
 *  卷积神经网络中每一个卷积层所使用的卷积核中得参数都是一样的，这是卷积核一个非常重要的特征，这样可以减少参数个数

## 卷积神经网络常用结构 ##

### 卷积层 ###

import tnesorflow as tf
    # 通过tf.get_variable()的方式创建过滤器的权重变量和偏置项变量
    # 卷积层的参数只和过滤器的尺寸、深度以及当前层节点的深度有关，所以在定义的时候定义了一个四维矩阵，前面的两个维度代表了过滤器的尺寸
    # 第三个维度代表当前层的深度，第四个维度代表过滤器的深度
    filter_weights = tf.get_variable('filter_weights', [5,5,3,16], initializer=tf.truncated_normal_initializer(stddev=0.1))
    biases = tf.get_variable('biases', [16], initializer=tf.constant_initializer(0.1))
    
    # tf.nn.conv2d提供了一个非常方便的函数来实现卷积层前向传播的算法
    # 这个函数的第一个输入是当前层的节点矩阵，注意这个矩阵是一个节点矩阵，第一位对应一个输入batch，后面三个维度对应一个节点矩阵
    # 比如[0,:,:,:]表示第一张图片
    # 第二个参数提供了卷积层的权重，第三个参数为不同纬度上的步长；虽然第三个参数提供的是一个长度为4的数组，但是第一维和最后一维一定是1
    # 这是因为卷积层的步长只对矩阵的长和宽有效
    # 最后一个参数是填充，tensorflow提供SAME和VALID两种选择，其中SAME表示添加全0填充，VALIDA表示不添加
    conv = tf.nn.conv2d(input, filter_weights, [1,1,1,1], padding='SAME')
    
    # tf.nn.bias_add提供了一个方便的函数给每一个节点加上偏置项，注意这里不能直接使用加法，因为矩阵上不同位置上的节点都需要加上同样的偏置项
    bias = tf.nn.bias_add(conv, biases)
    # 将计算结果通过RELU激活函数完成去线性化
    actived_conv = tf.nn.relu(bias)

### 池化层 ###

# tf.nn.max_pool实现了最大池化层的前向传播过程，它的参数和tf.nn.conv2d函数类似
    # ksize提供了过滤器的尺寸，strides提供了步长信息
    # 第二个参数虽然给出了一个长度为4的一维数组，但是这个数组的第一个和最后一个数必须是1，第三个参数也是，第一个和最后一个数必须是1
    pool = tf.nn.max_pool(actived_conv, ksize=[1,3,3,1], strides=[1,2,2,1]， padding='SAME')

## 经典卷积神经网络 ##

### LeNet-5模型 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70][]

下面给出一个tensorflow的程序来实现一个类似LeNet-5模型的卷积神经网络来解决MNIST数字识别问题；通过tensorflow来实现对卷积神经网络和之前提到过的训练全连接神经网络是一样的，损失函数的计算、反向传播的计算和之前都是一样的；唯一的区别在于因为卷积神经网络的输入层为一个三维的矩阵，所以需要调整一下输入数据的格式：

**代码实现卷积神经网络处理MNIST手写数据集：**

import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    import numpy as np
    import os
    
    mnist = input_data.read_data_sets('/path/', one_hot=True)
    print(mnist.train.num_examples)
    print(mnist.validation.num_examples)
    print(mnist.test.num_examples)
    
    # 设置常用参数
    IMAGE_SIZE = 28
    NUM_CHANNELS = 1  # 原始图像的深度
    TRAINING_EPOCH = 1000
    BATCH_SIZE = 100
    INPUT = 784
    OUTPUT_NODE = 10
    CONV1_DEEP = 32
    CONV2_DEEP = 64
    FC1_NODE = 7*7*64
    FC2_NODE = 1024
    REGULAR_LAMBDA = 0.0001
    LEARNING_RATE = 0.1
    LEARNING_DECAY = 0.99
    MODEL_SAVE_PATH = '/path/model/'
    MODEL_NAME = 'mnist_LeNet5.ckpt'
    
    
    # 获得权重参数
    def get_weights_regularizer(shape, regularizer):
        weights = tf.get_variable('weights', shape, initializer=tf.truncated_normal_initializer(stddev=0.1))
        tf.add_to_collection('losses', regularizer(weights))
        return weights
    
    # 获得偏置项参数
    def get_biases(shape):
        biases = tf.get_variable('biases', shape, initializer=tf.constant_initializer(0.0))
        return biases
    
    # 获得卷积结果
    def conv2d(input, filter_weights, biases):
        conv = tf.nn.conv2d(input, filter_weights, [1, 1, 1, 1], padding='SAME')
        bias = tf.nn.bias_add(conv, biases)
        actived_conv = tf.nn.relu(bias)
        return actived_conv
    
    # 池化层结果
    def pool(actived_conv):
        return tf.nn.max_pool(actived_conv, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
    
    # 图片格式转换函数
    # 将输入格式是784的一维数据转换为正常的图片格式
    # def reshape_input(input):
        # input_shape = input.shape
        # return np.reshape(input, (input_shape[0], IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS))
    
    
    # 构建LeNet-5模型的答题结构
    def LeNet5(input, regularizer, keep_prob):
        # 输入28*28*1，得到28*28*32
        with tf.variable_scope('layer11'):
            filter_weights = get_weights_regularizer([5, 5, 1, 32], regularizer)
            biases = get_biases([CONV1_DEEP])
            actived_conv1 = conv2d(input, filter_weights, biases)
            # 池化后为14*14*32
            pool1 = pool(actived_conv1)
        
        # 输入为14*14*32
        with tf.variable_scope('layer22'):
            filter_weights = get_weights_regularizer([5,5,32,64], regularizer)
            biases = get_biases([CONV2_DEEP])
            actived_conv2 = conv2d(pool1, filter_weights, biases)
            # 池化后为14*14*64
            pool2 = pool(actived_conv2)
            # k
            # pool_shape = pool2.get_shape().as_list()
            # 计算矩阵拉伸成向量之后的长度，，这个长度就是矩阵的长宽及深度的乘机
            # nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]
            # reshaped = tf.reshape(pool2, [pool_shape[0], nodes])
            reshaped = tf.reshape(pool2, [-1, 7*7*64])
            
        # 输入为1024，进入全连接层
        with tf.variable_scope('fc1'):
            weights = get_weights_regularizer([FC1_NODE, FC2_NODE], regularizer)
            biases = get_biases([FC2_NODE])
            fc1 = tf.nn.relu(tf.matmul(reshaped, weights) + biases)
            fc1 = tf.nn.dropout(fc1, keep_prob)
            
        with tf.variable_scope('fc2'):
            weights = get_weights_regularizer([FC2_NODE, OUTPUT_NODE], regularizer)
            biases = get_biases([OUTPUT_NODE])
            output = tf.matmul(fc1, weights) + biases
        return output 
    
    
    # 进行训练
    def train(mnist):
        x = tf.placeholder(tf.float32, [None, INPUT], name='x-input')
        y = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name='y-input')
        keep_prob = tf.placeholder(tf.float32)
        # np.reshape函数的第二个参数是元组
        x_ = tf.reshape(x, (-1, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS))
        regularizer = tf.contrib.layers.l2_regularizer(REGULAR_LAMBDA)
        pred = LeNet5(x_, regularizer, keep_prob)
        loss = tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y)
        reduce_loss = tf.reduce_mean(loss)
        loss = reduce_loss + tf.add_n(tf.get_collection('losses'))
        global_step = tf.Variable(0.0, trainable=False)
        learning_rate = tf.train.exponential_decay(LEARNING_RATE, global_step, mnist.train.num_examples / BATCH_SIZE, LEARNING_DECAY)
        optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
        init = tf.global_variables_initializer()
        # 定义精度
        correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        saver = tf.train.Saver()
        
        with tf.Session() as sess:
            sess.run(init)
            for i in range(TRAINING_EPOCH):
                xs, ys = mnist.train.next_batch(BATCH_SIZE)
                train_feed = {x:xs, y:ys, keep_prob:1.0}
                validation_feed = {x:mnist.validation.images, y:mnist.validation.labels,keep_prob:1.0}
                sess.run(optimizer, feed_dict=train_feed)
                if i % 100 == 0:
                    print('After %s, train_accuracy=%g'%(i, sess.run(accuracy, feed_dict=train_feed)))
                    # print('After %s, validation_accuracy=%g'%(i, sess.run(accuracy, feed_dict=validation_feed)))
                    # saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)
                
            # 测试精度
            # test_feed = {x:mnist.test.images, y:mnist.test.labels}
            # print('test accuracy:', sess.run(accyracy, feed_dict=test_feed))
            
            
    def main(argv=None):
        train(mnist)
        
        
    if __name__ == '__main__':
        tf.app.run()

### 卷积神经网络的构建方法 ###

一般来说卷积神经网络的构建都是以下结构：

输入层---->（卷积层+---->池化层？）---->全连接层

*  也就是说一般情况下是有一层或者多层的卷积层，然后跟着一个或者不跟池化层，以此往复，最后加上一个全连接层就可以构建一个卷积神经网络了
 *  池化层虽然可以起到减少参数防止过拟合的问题，但是在部分论文中也发现可以直接通过调整卷积层步长来完成，所以有些卷积神经网络没有池化层
 *  一般全连接层有一到两层
 *  在过滤器的深度上，大部分卷积神经网络都采用逐层递增的方式
 *  卷积层的步长一般是1，但是有些模型也会选择使用2，或者3作为步长
 *  池化层的配置一般简单，用的最多的就是最大池化层，池化层的过滤器边长一般为2或者3，步长也一般为2或者3

### 小补充 ###

对于自己构造的卷积神经网络，有时候会出现最后的模型在测试数据集上的效果增长的并不明显，如果排除数据量不够的情况下，一般我们可以调低学习率、使用交叉熵（分类），还有就是最好使用梯度下降算法

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70]: /images/20220309/e2d2425a5087422f82b5cede1efb189a.png