tensorflow入门MNIST多版本实现

最新推荐文章于 2022-08-24 00:25:07 发布

Lane Phoebe

最新推荐文章于 2022-08-24 00:25:07 发布

阅读量416

点赞数

分类专栏：机器学习实战 python 文章标签： tensorflow入门MNIST多版本实现

本文链接：https://blog.csdn.net/qq_25628891/article/details/94013898

版权

python 同时被 2 个专栏收录

16 篇文章 1 订阅

订阅专栏

机器学习实战

15 篇文章 1 订阅

订阅专栏

前言

本文实现方法具体步骤可在tensflow中文查看，我把实现代码贴了出来，再做了一些修改。在修改过程中，我发现损失函数的写法不同，带来的精度相差很大，具体我会在下面给大家展示。

Git下载地址

运行代码之前，先对mnist数据集稍微说明一下

MNIST是机器学习领域的一个经典问题，指的是让机器查看一系列大小为28x28像素的手写数字灰度图像，并判断这些图像代表0-9中的哪一个数字。

因为我每次在跑别人的程序的时候，老是会出现数据集null，未找到…等等这些错误。所以接下来我简单说明下这个数据集的引用。

注：在自己的程序中引入input_data.py，MNIST数据会自动下载和安装。

第一步： 从git上下载input_data.py，然后在自己的程序中引入，引入代码如下图。接下来在运行程序的时候，会自动下载数据集到本地MNIST_data/目录下，这个目录可以根据自己需求修改。

import input_data
mnist = input_data.read_data_sets(“MNIST_data/”, one_hot=True)

在这里插入图片描述
第二步： 数据集下好了之后，就是对这个数据集运用，下面我贴出一张表格。这里说明下，mnist在上面你读取数据时可以任意命名的，我这里统一用mnist，有很多人也写作data_sets。

数据集	作用
mnist.train	55000个图像和标签（labels），作为主要训练集。
mnist.validation	5000个图像和标签，用于迭代验证训练准确度。
mnist.test	10000个图像和标签，用于最终测试训练准确度（trained accuracy）。

根据自己的需要可以读取数据集中的数据，比如要读取训练集的图片就直接使用mnist.train.images，读取训练集的标签mnist.train.labels。这些在input_data.py中已经封装好了。接下来就是不同的版本比对了。

mnist识别多版本实现

版本1和版本2的交叉熵的写法略微不同，精度相差将近3%

版本1loss(交叉熵)的写法

# y = Wx+b
y = tf.matmul(x, W) + b
# 定义一个损失函数评估模型 交叉熵
# cross_entropy = H_y'(y) = sum(y'log(y))
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=y_))

# Accuracy: 0.8698

版本2交叉熵的写法

# y = Wx+b
y = tf.nn.softmax(tf.matmul(x,W) + b)
# 定义一个损失函数评估模型 交叉熵
# loss = H_y'(y) = -sum(y'log(y))
cross_entropy = -tf.reduce_sum(y_*tf.log(y))

# Accuracy: 0.9097

版本3使用 ‘with’ 代码块，自动完成会话关闭操作

with tf.Session() as sess:
    # Train
    sess.run(tf.global_variables_initializer())
    for _ in range(NUM_STEPS):
        batch_xs, batch_ys = mnist.train.next_batch(MINIBATCH_SIZE)
        sess.run(train_step, feed_dict={x:batch_xs, y_:batch_ys})

    # Test
    ans = sess.run(accuracy, feed_dict={x:mnist.test.images, y_:mnist.test.labels})
# Accuracy: 91.8%

版本4构建两层卷积网络，使用ADAM梯度下降

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

# step 0, training accuracy 0.1
# step 500, training accuracy 0.9
# step 1000, training accuracy 0.98
# step 1500, training accuracy 1.0
# test accuracy 0.9773

版本5 为了让模型简单易读，定义一些辅助函数在auxiliary.py，在版本5中引入，只迭代了1000次，所以精度没4高，想要更高精度，调整STEPS这个参数就ok了

import auxiliary as aux

# step 0, training_accuracy 0.18000000715255737
# step 500, training_accuracy 0.9200000166893005
# test accuracy: 0.9643999934196472

版本3

import tensorflow as tf
import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# 实现模型
# 
# 创建可操作的变量，x不是一个特定的值，而是一个占位符
x = tf.placeholder("float", [None, 784])
y_ = tf.placeholder("float", [None,10])
# 创建一个权重W和偏置b，全为0的张量初始化
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
# y = Wx+b
y = tf.nn.softmax(tf.matmul(x,W) + b)

# 定义一个损失函数评估模型 交叉熵
# loss = H_y'(y) = -sum(y'log(y))
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
# 使用GDO以0.01的学习率最小化交叉熵
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# 在一个Session里面启动我们的模型，并且初始化变量
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

# 开始训练模型，这里我们让模型循环训练1000次！
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

# 评估模型
#
# equal()会给我们一组布尔值[True, False, True, True]
# cast把布尔值转换成浮点数
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print("Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

sess.close()

版本4

import tensorflow as tf
import input_data

# ===================================== #
#                                       #
#          构建一个多层卷积网络            #
#                                       #
# ===================================== #

# 定义初始值
DATA_DIR = 'MNIST_data/'
NUM_STEPS = 2000
MINIBATCH_SIZE = 50
RATE = 0.01

# 加载MNIST数据
mnist = input_data.read_data_sets(DATA_DIR, one_hot=True)

# 运行TensorFlow的InteractiveSession
# 更加灵活地构建代码
sess = tf.InteractiveSession()

# 为输入图像和目标输出类别创建节点
x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])

# 权重初始化
#
# 这个模型中的权重在初始化时应该加入少量的噪声来打破对称性以及避免0梯度
# truncated_normal是截断正态，steddev是标准差，取值范围在0.2倍steddev之内   
def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)


# 卷积和池化
#
# 卷积层步长stride为1，SAME模版，保证输入输出大小不变
# 池层2*2 max pooling
# strides代表在shape每一维的步长
def conv2d(x,W):
    return tf.nn.conv2d(x, 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')

# 为了用卷积层，把x变成一个4D向量，其2，3维代表图片的宽、高，最后一维代表图片的颜色通道数
# input tensor of shape [batch, in height, in width, in channels]
# batch:图片的数量  height:图片的高度   weight:图片的宽度   channal:图片的通道数(彩图:3)
x_image = tf.reshape(x, [-1,28,28,1])

# 第一层卷积
# kernel tensor of shape [filter height, filter width, in channels, out channels]
# 前两个维度是patch的大小，接着是输入的通道数目，最后是输出的通道数目
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

# 把x_image和全值向量进行卷积，加上偏置项
# 然后应用ReLU激活函数，最后进行max pooling
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

# 第二层卷积
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

# 全连接层
# 经过两次卷积，图片尺寸缩小到7*7，连接一个1024的全连接层，用于处理整个图片
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

# 为了减少过拟合，在输出层之前加入dropout
# 用一个placeholder来代表一个神经元的输出在dropout中保持不变的概率
# 在训练过程中启用dropout，在测试过程中关闭dropout
keep_prob = tf.placeholder('float')
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

# 输出层
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

# 训练和评估模型
# 
# 使用ADAM优化器做梯度下降
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

# 评估模型
correct_production = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_production, 'float'))

# Train
sess.run(tf.global_variables_initializer())
for i in range(NUM_STEPS):
    batch = mnist.train.next_batch(MINIBATCH_SIZE)
    if i%100 == 0:
        train_accuracy = accuracy.eval(feed_dict={
            x: batch[0], y_: batch[1], keep_prob: 1.0})
        print("step {:d}, training accuracy {:.4}".format(i, train_accuracy))
        
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
# Test
test_accuracy = accuracy.eval(feed_dict={
    x:mnist.test.images, y_:mnist.test.labels,keep_prob:1.0})

print("test accuracy %g"%test_accuracy)

版本5

import auxiliary as aux
import input_data
import tensorflow as tf
import numpy as np

# ===================================== #
#                                       #
#          使用自定义辅助函数实例           #
#                                       #
# ===================================== #

# 定义初始值 
# 
DATA_DIR = 'MNIST_data/'
STEPS = 1000
BATCH_SIZE = 50

# 编写模型
#
# 为输入图像和目标输出类别创建节点
with tf.name_scope('build_mod') as scope:
    x = tf.placeholder(tf.float32, shape=[None, 784])
    y_ = tf.placeholder(tf.float32, shape=[None, 10])

    # 构建卷积层
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    conv1 = aux.conv_layer(x_image, shape=[5, 5, 1, 32])
    conv1_pool = aux.max_pool_2x2(conv1)

    conv2 = aux.conv_layer(conv1_pool, [5, 5, 32, 64])
    conv2_pool = aux.max_pool_2x2(conv2)

    conv2_flat = tf.reshape(conv2_pool, [-1, 7*7*64])
    full1 = tf.nn.relu(aux.full_layer(conv2_flat, 1024))

    keep_prob = tf.placeholder(tf.float32)
    full1_drop = tf.nn.dropout(full1, keep_prob=keep_prob)

    y_conv = aux.full_layer(full1_drop, 10)

    # 训练模型计算图，使用梯度下降
    # cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_))
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

    # 评估模型计算图
    correct_production = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_production, tf.float32))

# 训练模型
#
# 使用mnist数据集
with tf.name_scope('train_mod') as scope:
    # 引用数据集
    mnist = input_data.read_data_sets(DATA_DIR, one_hot=True)

    # 在session里面启动模型
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        for i in range(STEPS):
            batch = mnist.train.next_batch(BATCH_SIZE)

            if i%100 ==0:
                train_accuracy = sess.run(accuracy, feed_dict={
                                                        x: batch[0], 
                                                        y_: batch[1], 
                                                        keep_prob: 1.0})
                print('step {}, training_accuracy {}'.format(i, train_accuracy))
            
            sess.run(train_step, feed_dict={
                                    x: batch[0], 
                                    y_: batch[1], 
                                    keep_prob: 0.5})
        # Test
        # test_accuracy = sess.run(accuracy, feed_dict={
        #                                         x: mnist.test.images, 
        #                                         y_: mnist.test.labels, 
        #                                         keep_prob:1.0})
        
        X = mnist.test.images.reshape(10, 1000, 784)
        Y = mnist.test.labels.reshape(10, 1000, 10)
        test_accuracy = np.mean([sess.run(accuracy,
                                feed_dict={x: X[i], y_: Y[i], keep_prob:1.0})
                                for i in range(10)])
        print("test accuracy: {}".format(test_accuracy))