Tensorflow学习之MNIST数字集识别

Tensorflow学习日记之MNIST数字集识别

Tensorflow学习之MNIST数字集识别

（底部附上我的全部代码）

前一阵突然被Tensorflow吸引了，正如Google发布人工智能系统TensorFlow文档中所说：
你正在阅读的项目可能会比 Android 系统更加深远地影响着世界！
没赶上Android开发的快车，当然不会放过Tensorflow这艘大轮船。
言归正传，不管学什么，都是有步骤地。

1. 肯定是 What is it? 解决方法各种百度google。

2. 看一遍Tensorflow文档，毕竟是官方的东西，看一遍没坏处。

3. 在经历第二步之后会发现在数学算法方面有所缺失，理应补一下这个缺口，推荐回顾一下线性代数和概率论。

4. 搭环境 这个之前的博客讲过。

5. MNIST 数据集测试就是机器学习和深度学习当中的＂Hello World＂工程。跑一下
   Tensorflow之MNIST 数据集测试
   （底部附上我的全部代码）
   首先了解一下什么是MNIST
   MNIST是一个入门级的计算机视觉数据集，它包含各种手写数字图片：
   完成这个测试就好比编程入门有Hello World

参考《Tensorflow官方文档》
首先从官方网站下载数据集
数据集下载网址

下载下来的数据集被分成两部分：60000行的训练数据集（ mnist.train ）和10000行的测试数据集（ mnist.test ）。
这样的切分很重要，在机器学习模型设计时必须有一个单独的测试数据集不用于训练而是用来评估这个模
型的性能，从而更加容易把设计的模型推广到其他数据集上（泛化）。
数据集里面每一张图片包含28像素X28像素，每张照片对应一个标签。

在MNIST训练数据集中， mnist.train.images 是一个形状为 [60000, 784] 的张量，第一个维度数字用来
索引图片，第二个维度数字用来索引每张图片中的像素点。在此张量里的每一个元素，都表示某张图片里的某个
像素的强度值，值介于0和1之间。

代码部分-------------------------------------------------------------
（这个代码是使用了Tensorflow最简单的一个模型，识别率91%左右，文章末尾附上另一个代码，使用了多层卷积网络，识别率97%左右）

#  import cv2
#  Tensorflow已经包含了mnist案例的数据
# 利用Tensorflow 对 MNIST 进行读取和格式转换
from tensorflow.examples.tutorials.mnist import input_data

#将下载的MNIST数据放在MNIST_data文件下
# input_data.read_data_sets()函数可以自动检测指定目录下是否存在MNIST数据，如果存在，就不会下载了
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)


# 笔记：Tensorflow依赖于一个高效的C++后端来进行计算。与后端的这个连接叫做session。一般而言，使用TensorFlow程序的流程是先创建一个图，然后在session中启动它。
# 导入Tensorflow
import tensorflow as tf

# 运行TensorFlow的InteractiveSession
sess = tf.InteractiveSession


# # 通过opencv打印一张照片和对应标签测试一下
# print(mnist.train.images.shape, mnist.train.labels.shape)
# image = mnist.train.images[4,:]
# #将图像数据还原成28*28的分辨率
# image = image.reshape(28,28)
# #打印对应的标签
# print(mnist.train.labels[4])
# cv2.imshow('uu', image)
# cv2.waitKey(0)
# 创建一个占位符，通过操作符号变量来描述这些可交互的操作单元
# None　代表图片数量未知,784=28*28


# 构建Softmax 回归模型
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])
# x = tf.placeholder("float", [None, 784])

# 通过Variable的方式加入权重值和偏置量，Variable代表一个可修改的张量
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))


# sess.run(tf.global_variables_initializer())

# 实现我们的模型
y = tf.nn.softmax(tf.matmul(x, W)+b)

#为训练过程指定最小化误差用的损失函数
cross_entropy = -tf.reduce_sum(y_*tf.log(y))

# -----------------------------------------------------
# 构建CNN模型，对图片运算来说，CNN模型算比较优秀的模型
# 训练模型
# 用最速下降法让交叉熵下降，步长为0.01
# 作用：往计算图上添加一个新操作，其中包括计算梯度，计算每个参数的步长变化，并且计算出新的参数值
# 往计算图上添加一个新操作，其中包括计算梯度，计算每个参数的步长变化，并且计算出新的参数值
# 每一步迭代，我们都会加载50个训练样本，然后执行一次train_step
# 并通过feed_dict将x 和 y_张量占位符用训练训练数据替代。
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# 变量需要通过seesion初始化后，才能在session中使用。
# init = tf.initialize_all_variables()

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

for i in range(1000):
    batch = mnist.train.next_batch(50)
    sess.run(train_step, feed_dict={x: batch[0], y_: batch[1]})
    # train_step.run(feed_dict={x: batch[0], y_: batch[1]})

#------------------------------------------------------

# 评估模型
# 用 tf.equal 来检测我们的预测是否真实标签匹配(索引位置一样表示匹配)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
# 返回一个布尔数组

# 将布尔值转换为浮点数来代表对、错，然后取平均值。
# 例如：[True, False, True, True]变为[1,0,1,1]，计算出平均值为0.75
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

# 计算出在测试数据上的准确率
# ------------------------------------------------------
print("测试数据集正确率:")
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

这是一个分界线-------------------------------------------------------------
下面是多层卷积网络版的

# coding:utf-8

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf

mnist = input_data.read_data_sets("MNIST_data",one_hot=True)


input = tf.placeholder(tf.float32,[None,784])
input_image = tf.reshape(input,[-1,28,28,1])

y = tf.placeholder(tf.float32,[None,10])

# input 代表输入，filter 代表卷积核
def conv2d(input,filter):
    return tf.nn.conv2d(input,filter,strides=[1,1,1,1],padding='SAME')
# 池化层
def max_pool(input):
    return tf.nn.max_pool(input,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

# 初始化卷积核或者是权重数组的值
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev=0.1)
    return tf.Variable(initial)

# 初始化bias的值
def bias_variable(shape):
    return tf.Variable(tf.zeros(shape))

#[filter_height, filter_width, in_channels, out_channels]
#定义了卷积核
filter = [3,3,1,32]

filter_conv1 = weight_variable(filter)
b_conv1 = bias_variable([32])
# 创建卷积层，进行卷积操作，并通过Relu**，然后池化
h_conv1 = tf.nn.relu(conv2d(input_image,filter_conv1)+b_conv1)
h_pool1 = max_pool(h_conv1)

h_flat = tf.reshape(h_pool1,[-1,14*14*32])

W_fc1 = weight_variable([14*14*32,768])
b_fc1 = bias_variable([768])
h_fc1 = tf.matmul(h_flat,W_fc1) + b_fc1

W_fc2 = weight_variable([768,10])
b_fc2 = bias_variable([10])

y_hat = tf.matmul(h_fc1,W_fc2) + b_fc2



cross_entropy = tf.reduce_mean(
    tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=y_hat ))

train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
#train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y_hat,1),tf.argmax(y,1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    for i in range(10000):

        batch_x,batch_y = mnist.train.next_batch(50)

        if i % 100 == 0:
            train_accuracy = accuracy.eval(feed_dict={input:batch_x,y:batch_y})
            print("step %d,train accuracy %g " %(i,train_accuracy))

        train_step.run(feed_dict={input:batch_x,y:batch_y})

        # sess.run(train_step,feed_dict={x:batch_x,y:batch_y})

    print("test accuracy %g " % accuracy.eval(feed_dict={input:mnist.test.images,y:mnist.test.labels}))

运行结果：