深度学习原理与框架-Tensorflow卷积神经网络-卷积神经网络mnist分类 1.tf.nn.conv2d(卷积操作) 2.tf.nn.max_pool(最大池化操作) 3.tf.nn.dropout(执行dropout操作) 4.tf.nn.softmax_cross_entropy_with_logits(交叉熵损失) 5.tf.truncated_normal(两个标准差内的正态分布)

1. tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')  # 对数据进行卷积操作

参数说明：x表示输入数据，w表示卷积核， strides表示步长，分别表示为样本数，长，宽，通道数，padding表示补零操作

2. tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')  # 对数据进行池化操作

参数说明：x表示输入数据，ksize表示卷积的大小，分别表示卷积核的个数，长，框，通道数，padding表示补零操作

3. tf.nn.dropout(x, keep_prob) # 对全连接层做dropout操作

参数说明：x表示输入数据，keep_prob表示保留的比例，可以设置为0.5，

4. tf.nn.softmax_cross_entropy_with_logits(logits=scores, labels=y) # 用于构造交叉熵损失函数

参数说明：logits表示预测得分值，labels表示实际的标签值，表示是用One-hot编码的

5. tf.truncated_normal([28, 28, 1, 5], sttdv=0.1) # 生成数据和均值不大于标准差两倍的正态分布

参数说明：[28， 28， 1， 5]表示生成的为u的， sttdv表示标准差的大小

6.tf.nn.relu(x) # 进行激活操作

参数说明：x表示输入值

卷积神经网络：对于数据的输入，在tensorflow中，必须是[num_sample, width, height, C] num_sample表示样本的个数，width和height表示样本的宽和高，C表示样本的通道数，如果是黑白图，那么这里设置为1

对于卷积核的设置维度为[5, 5, 1, 64]  5和5表示的是样本的长和宽， 1表示卷积核的通道数，64表示卷积核的个数

代码：下面对mnist数据集使用卷积神经进行分类，两个卷积层，两个全连接层，卷积核使用的是5*5的，全连接层的隐藏层的个数为50

第一步：输入的读入

第二步：使用tf.nn.conv2d构造卷积函数，使用tf.nn.max_pool构造池化函数

第三步：设置超参数，即batch大小，迭代次数，分类的类别数，全连接隐藏层的个数

第四步：使用tf.placeholder设置输入的x和y， x = tf.placeholder(tf.float32, [None, 28, 28, 1])

第五步：设置卷积层的参数，为5*5*1*64的卷积，b为64的维度，使用conv2d进行卷积，使用tf.nn.relu 进行激活操作，使用max_pool进行池化操作

第六步：设置第二层卷积层的参数，为5*5*64*64，b为64的维度，进行卷积，激活，池化操作

第七步：设置全连接的参数，同时用tf.reshape([-1, 7*7*64]) 对上一层池化的结果进行维度的重构，用于进行全连接操作，使用tf.matmul进行点乘，并进行激活

第八步：构造keep_prob的输入参数，使用tf.nn.dropout构造对全连接层进行dropout操作，防止过拟合

第九步：设置最后一层全连接的参数，使用tf.matmul和激活函数

第十步：使用tf.nn.sotfmax构造损失softmax损失函数

第十一步：使用tf.train.Adaoptimzer()构造自适应的梯度优化器，对损失值进行优化

第十二步：使用tf.equal和tf.reduce_mean计算准确度

第十三步：进行循环，使用mnist.train.next_batch读取data和labels数据，并对data数据进行维度的重构，维度为[None, 28, 28, 1]进行卷积操作

第十四步：执行梯度优化，来更新参数

第十五步：如果迭代次数为100次，打印准确率和损失值

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data

# 第一步：数据集的读入
mnist = input_data.read_data_sets('/data', one_hot=True)
tf.reset_default_graph()
sess = tf.InteractiveSession()
# 第二步：构建卷积函数，使用tf.nn.conv2d(), 构造池化的函数, 使用tf.nn.max_pool()
def conv2d(x, W):
    return tf.nn.conv2d(input=x, filter=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')

# 第三步：设定超参数，batchsize的大小，分类的类别数，第一个全连接的数目
batchSize = 50
num_classes = 10
num_hidden = 50
trainIteration = 10000

# 第四步：使用tf.placeholder() 构造输入数据，实现数据的占位， X是一个num_data, 28, 28, 1，28和28表示维度， 1表示通道数
X = tf.placeholder('float', shape=[None, 28, 28, 1])
y_ = tf.placeholder('float', shape=[None, num_classes])

# 第五步：构造卷积层的参数，进行第一层卷积并使用relu激活函数，然后进行一次池化，压缩图片的维度
W_conv1 = tf.Variable(tf.truncated_normal([5, 5, 1, 32], stddev=0.1))
# 使用tf.constant(0.1, shape=[32])构造偏置项b
b_conv1 = tf.Variable(tf.constant(0.1, shape=[32]))
conv_h1 = tf.nn.relu(conv2d(X, W_conv1) + b_conv1)
pool_h1 = max_pool_2x2(conv_h1)

# 第六步：构造第二层卷积的参数，进行卷积，tf.nn.relu激活， 然后使用池化压缩梯度
W_conv2 = tf.Variable(tf.truncated_normal([5, 5, 32, 64], stddev=0.1))
b_conv2 = tf.Variable(tf.constant(0.1, shape=[64]))
conv_h2 = tf.nn.relu(conv2d(pool_h1, W_conv2) + b_conv2)
pool_h2 = max_pool_2x2(conv_h2)

# 第七步：构造第一层全连接的参数，需要将池化后的数据，进行一次拉长，即把维度变为N, 7*7&64,为了进行全连接操作
W_affine1 = tf.Variable(tf.truncated_normal([7*7*64, 1024], stddev=0.1))
b_affine1 = tf.Variable(tf.constant(0.1, shape=[1024]))
affine_x = tf.reshape(pool_h2, [-1, 7*7*64])
affine_1 = tf.nn.relu(tf.matmul(affine_x, W_affine1)+b_affine1)

# 第八步：构造输入数据keep_prob,使用tf.nn.dropout进行全连接的dropout操作
keep_prob = tf.placeholder('float')
affine_1_drop = tf.nn.dropout(affine_1, keep_prob)
# 第九步：构造初始化参数，使用tf.matmul构造全连接第二层
W_affine2 = tf.Variable(tf.truncated_normal([1024, num_classes], stddev=0.1))
b_affine2 = tf.Variable(tf.constant(0.1, shape=[num_classes]))
scores = tf.matmul(affine_1_drop, W_affine2) + b_affine2

# 第十步：使用softmax构造损失值函数
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=scores))
# 第十一步：使用自适应梯度下降生成损失值的优化器
opt = tf.train.AdamOptimizer().minimize(loss)
# 第十二步：使用tf.equal判断最大值的索引位置是否相同，使用tf.reduce_mean 判断计算准确率
correct = tf.equal(tf.argmax(scores, 1), tf.argmax(y_, 1))
accr = tf.reduce_mean(tf.cast(correct, 'float'))

init = tf.global_variables_initializer()
sess.run(init)

for i in range(trainIteration):
    # 第十三步：获得batch的数据，对输入的data数据进行维度的变换
    batch = mnist.train.next_batch(batchSize)
    trainInput = batch[0].reshape([batchSize, 28, 28, 1])
    trainLabel = batch[1]
    # 第十四步：执行梯度优化的操作，用来更新参数
    sess.run(opt, feed_dict={X:trainInput, y_: trainLabel, keep_prob:0.8})
    # 第十五步：每迭代一百次，就打印一个batchSize的准确率
    if i % 100 == 0:
        print('accr :%g'%(sess.run(accr, feed_dict={X: trainInput, y_: trainLabel, keep_prob:1.0})))