卷积神经网络-手写识别(CNN

日常头文件

import tensorflow as tf
import matplotlib.pyplot as plt
import tensorflow.examples.tutorials.mnist.input_data as input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

mnist是函数读取出来的数据集并整合成的一个大的结构。具体包括了
mnist.train.images
mnist.train.labels
ne_hot为one_hot编码，即独热码，作用是将状态值编码成状态向量，
例如，数字状态共有0~9这10种，对于数字7，将它进行one_hot编码后为[0 0 0 0 0 0 0 1 0 0]，这样使得状态对于计算机来说更加明确，
对于矩阵操作也更加高效。
验证准确率的函数：
tf.equal判断两个函数是否相同
tf.case为转换数据类型，因为类型不同时无法计算

def compute_accuracy(v_xs,v_ys):
    global prediction
    y_pre = sess.run(prediction,feed_dict={xs:v_xs,keep_prob : 1.0})
    correct_prediction = tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1))
    #tf.argmax(input, axis=None, name=None, dimension=None)
    #tf.equal判断两个值是否相同
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    #将x的数据格式转化成dtype
    #这里是把correct_prediction转换为float32
    result = sess.run(accuracy,feed_dict={xs:v_xs,ys:v_ys,keep_prob:1.0})
    return result

把W的建立和偏置的建立包成函数，这里偏置的大小需要与卷积结果的高度相同

def weight_variable(shape):#输入shape，返回一个随机大小的W
    initial = tf.truncated_normal(shape,stddev=0.1)#产生随机数大小为shape，stddev为标准差
    return tf.Variable(initial)

def bias_variable(shape):#创建一个偏置
    #tf.constant(-1.0, shape=[2, 3]) => [[-1. -1. -1.] [-1. -1. -1.]
    #值为啊a,大小为b
    initial = tf.constant(0.1,shape=shape)
    return tf.Variable(initial)

卷积函数，x为输入的images信息，W为四位随机变量W，进行卷积
strike的[1,x,y,1]表示卷积的x与y的步数，只改变高度，不改变大小

def conv2d(x,W):#卷积层，涂层,x为输入的东西(图片的全部信息,W为权值，进行卷积
    #strike [1,x_movement,y_movement,1]
    #2种padding,valid,抽取全部在图片里面
    #sahe抽取全部,包括在外面
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')#strides每一次抽取抽多少，步长
    #2维度,第一个与最后一个都要是1
    #第一个参数input：指需要做卷积的输入图像,第二个参数相当于卷积核
    #第三个为参数input的4维度，第四个为卷积方式，只有"SAME","VALID"
#当其为‘SAME’时，表示卷积核可以停留在图像边缘，而"VALID"只能在里面
#结果返回一个Tensor，这个输出，就是我们常说的feature map，shape仍然是[batch, height, width, channels]这种形式。

池化层，只改长宽，不改高度

def max_pool_2x2(x):#池化层，
    # 跨度过大，使其变小，从一个大的变成大的那部分，保留更多的图片信息
    # strike [1,x_movement,y_movement,1]
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')#长和宽是不变的，用same的方式
    #value：池化的输入，一般池化层接在卷积层的后面，所以输出通常为feature map。feature map依旧是
    # [batch, in_height, in_width, in_channels]这样的参数。
    # ksize：池化窗口的大小，参数为四维向量，通常取[1, height, width, 1]，
    # 因为我们不想在batc h和channels上做池化，所以这两个维度设为了1.1
    # 一个四维向量的步长

ys = tf.placeholder(tf.float32,[None,10])
keep_prob = tf.placeholder(tf.float32)
把数据转换成 适合 nn 输入的数据格式 ，-1代表先不考虑输入的图片例子多少个维度
x_image = tf.reshape(xs,[-1,28,28,1]) #-1是导入数据有多少，导入到卷积函数中
最后一个1表示颜色个数
print(x_image.shape)
这个一般用做预测
W_conv1 = weight_variable([5,5,1,32])
patch=5*5(拿出来小方块的大小，传入为insize 1 厚度，然后变成高度为32
这里要求输出的高度与卷积后的高度一致
b_conv1 = bias_variable([32])
conv2的第一个参数具有[batch, in_height, in_width, in_channels]这样的shape，
 具体含义是[训练时一个batch的图片数量, 图片高度, 图片宽度, 图像通道数]

conv2d的第二个参数具有[filter_height, filter_width, in_channels, out_channels]这样的shape，
 具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]
那么就是5*5的方式拿出来
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)#长和宽不变，28*28*32,高度变成32，这里有个是偏置
非线性处理
h_pool1 = max_pool_2x2(h_conv1) #14*14*32,池化层，高度不变，按照步长均/2
输出值

W_conv2 = weight_variable([5,5, 32,64]) #2的话，传入变成了32，传出变成64
patch=5*5(拿出来小方块的大小，然后变成高度为32
 insize 1 是单位的厚度，out size 32为卷积核个数
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)#14*14*64,非线性处理
h_pool2 = max_pool_2x2(h_conv2) #7*7*64 高度不变

func1 layer
W_fc1 = weight_variable([7*7*64,1024])#图片大小与高度
b_fc1 = bias_variable([1024])#高度
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64]) #把pooling的结果变平，-1表示原有维度，[n_samples,7,7,64]->>[n_samples,7*7*64]
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)#卷积以后的结果计算
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)#dropout减少过拟合，仅仅这一行
然后跟矩阵相乘
func2 layer
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2) #这里为预测值
这里xs为占位符，等调用的时候在输入


(张量)意味着N维数组
28*28当作行处理
表中的每一行代表一张图片，label代表这张图片的数字，其他列是每个像素点的值，不是0就是1，每张图有 28 * 28 = 784 个像素点。
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),
                                            reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)

saver.save(sess, "model_data/model.ckpt")
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict = {xs : batch_xs, ys : batch_ys, keep_prob : 0.5})
    if i % 100 == 0:
        print(compute_accuracy(mnist.test.images[:500], mnist.test.labels[:500]))

就可以跑出结果了