TensorFlow实战（三）

优化器（Optimizer）

标准梯度下降法：计算所有样本汇总误差，然后根据总误差来更新权值（数据量太大时，更新权值可能比较慢）

随机梯度下降法：抽取一个样本来计算误差，然后随机更新权值（可能会引入噪声，权值更新的方向可能不是好的方向）

批量梯度下降法：从总样本中选取一个批次，然后计算这个batch的总误差，根据这个总误差来更新权值

采用不同的优化器对手写数字分类器进行训练。

GradientDecenOptimizer：

代码：

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

# 载入数据集
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

# 每个批次的大小，一次性放入神经网络的数据数量，以矩阵的形式放入
# 批次优化
batch_size = 100
# batch_size = 100
# 计算一共有多少个批次 //是整除的意思
n_batch = mnist.train.num_examples // batch_size

# 定义两个placehlder,None指的是可以是任意的值，根据传入的批次进行确定
x = tf.placeholder(tf.float32, [None, 784])
y = tf.placeholder(tf.float32, [None, 10])

# 增加隐藏层---优化
# 创建一个简单的神经网络
# W = tf.Variable(tf.zeros([784, 10]))
# b = tf.Variable(tf.zeros([10]))
# prediction = tf.nn.softmax(tf.matmul(x, W) + b)

W1 = tf.Variable(tf.truncated_normal([784, 300], stddev=0.1))
b1 = tf.Variable(tf.zeros([300]))
l_1 = tf.nn.sigmoid(tf.matmul(x, W1) + b1)

W2 = tf.Variable(tf.zeros([300, 10]))
b2 = tf.Variable(tf.zeros([10]))
# 输出层使用softmax函数做分类
prediction = tf.nn.softmax(tf.matmul(l_1, W2) + b2)
# 二次代价函数-----优化使用交叉熵
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
# loss = tf.reduce_mean(tf.square(y-prediction))
# 梯度下降法-->可以修改学习率，可以更改为其他的优化方法
train = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

# 初始化变量
init = tf.global_variables_initializer()

# equal比较两个参数是否是一样的，相同返回True，不同返回False argmax求最大的值在那个位置（比如求预测的概率最大的数字在什么位置）
# 结果存放在一个布尔型列表中
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(prediction, 1))

# 求准确率 cast:转换类型，布尔型转换为浮点型
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

with tf.Session() as sess:
    sess.run(init)
    # 迭代21个周期--->可以增加训练的轮数
    # for epoch in range(21):
    for epoch in range(21):
        # 每个周期一共训练的批次
        for batch in range(n_batch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train, feed_dict={x: batch_xs, y: batch_ys})
        acc = sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels})
        print('第', str(epoch + 1), '轮准确率：', acc)

结果：

第 1 轮准确率： 0.5768
第 2 轮准确率： 0.7447
第 3 轮准确率： 0.8112
第 4 轮准确率： 0.8302
第 5 轮准确率： 0.8371
第 6 轮准确率： 0.8413
第 7 轮准确率： 0.8433
第 8 轮准确率： 0.846
第 9 轮准确率： 0.8482
第 10 轮准确率： 0.8484
第 11 轮准确率： 0.8508
第 12 轮准确率： 0.8508
第 13 轮准确率： 0.8511
第 14 轮准确率： 0.8536
第 15 轮准确率： 0.8526
第 16 轮准确率： 0.8547

AdamOptimizer:

代码：

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

# 载入数据集
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

# 每个批次的大小，一次性放入神经网络的数据数量，以矩阵的形式放入
# 批次优化
batch_size = 100
# batch_size = 100
# 计算一共有多少个批次 //是整除的意思
n_batch = mnist.train.num_examples // batch_size

# 定义两个placehlder,None指的是可以是任意的值，根据传入的批次进行确定
x = tf.placeholder(tf.float32, [None, 784])
y = tf.placeholder(tf.float32, [None, 10])

# 增加隐藏层---优化
# 创建一个简单的神经网络
# W = tf.Variable(tf.zeros([784, 10]))
# b = tf.Variable(tf.zeros([10]))
# prediction = tf.nn.softmax(tf.matmul(x, W) + b)

W1 = tf.Variable(tf.truncated_normal([784, 300], stddev=0.1))
b1 = tf.Variable(tf.zeros([300]))
l_1 = tf.nn.sigmoid(tf.matmul(x, W1) + b1)

W2 = tf.Variable(tf.zeros([300, 10]))
b2 = tf.Variable(tf.zeros([10]))
# 输出层使用softmax函数做分类
prediction = tf.nn.softmax(tf.matmul(l_1, W2) + b2)
# 二次代价函数-----优化使用交叉熵
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
# loss = tf.reduce_mean(tf.square(y-prediction))
# 梯度下降法-->可以修改学习率，可以更改为其他的优化方法
# train = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
# AdamOptimizer一般使用比较低的学习率（使用1e-6~1e-4等），但是收敛的速度比GradientDecentOptimizer快
train = tf.train.AdamOptimizer(1e-2).minimize(loss)

# 初始化变量
init = tf.global_variables_initializer()

# equal比较两个参数是否是一样的，相同返回True，不同返回False argmax求最大的值在那个位置（比如求预测的概率最大的数字在什么位置）
# 结果存放在一个布尔型列表中
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(prediction, 1))

# 求准确率 cast:转换类型，布尔型转换为浮点型
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

with tf.Session() as sess:
    sess.run(init)
    # 迭代21个周期--->可以增加训练的轮数
    # for epoch in range(21):
    for epoch in range(21):
        # 每个周期一共训练的批次
        for batch in range(n_batch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train, feed_dict={x: batch_xs, y: batch_ys})
        acc = sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels})
        print('第', str(epoch + 1), '轮准确率：', acc)

结果：

第 1 轮准确率： 0.8642
第 2 轮准确率： 0.949
第 3 轮准确率： 0.9593
第 4 轮准确率： 0.9669
第 5 轮准确率： 0.9648
第 6 轮准确率： 0.9696
第 7 轮准确率： 0.9705
第 8 轮准确率： 0.9688
第 9 轮准确率： 0.9682
第 10 轮准确率： 0.9709
第 11 轮准确率： 0.9681
第 12 轮准确率： 0.9724
第 13 轮准确率： 0.9732
第 14 轮准确率： 0.9684

TensorFlow实战（三）

猜你喜欢