梯度下降是机器学习中常用的优化算法之一,通过反复迭代来最小化损失函数,从而找到最优的模型参数。Tensorflow中提供了多种梯度下降优化算法,针对不同的模型和数据,我们需选择不同的算法。
随机梯度下降算法是最基本的梯度下降变体,具体实现过程中,在每次迭代中随机抽取一个样本进行计算,从而减小计算量。随机梯度下降对数据集的要求较低,但对数据噪声敏感,收敛速度较慢。
Tensorflow中实现随机梯度下降的代码:
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)
Momentum算法是对SGD的一种改进,可以使梯度下降更快地达到收敛,减少震荡现象。Momentum算法在更新梯度时,除了考虑当前的梯度以外,还引入了一个指数加权平均,将过往的梯度也考虑进来,以使优化方向更加平缓。
Tensorflow中实现Momentum的代码:
optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9).minimize(cost)
Adagrad算法针对不同维度的特征,分别调节学习率,使得参数的更新更加精细化,从而加速收敛过程。Adagrad算法采用一般来说是不超过0.01的初始学习率,并运行一定的步数进行微调。
Tensorflow中实现Adagrad的代码:
optimizer = tf.train.AdagradOptimizer(learning_rate=learning_rate).minimize(cost)
Adadelta是除了Adam以外的两个常用优化算法之一,它是一种在学习过程中自适应调节学习率的方法。Adadelta算法的主要思想是,根据参数的历史梯度信息来修改学习率,以适应问题的梯度变化特点。
Tensorflow中实现Adadelta的代码:
optimizer = tf.train.AdadeltaOptimizer(learning_rate=learning_rate).minimize(cost)
import tensorflow as tf
import numpy as np
x_data = np.random.rand(100).astype(np.float32)
y_data = 0.2 * x_data + 0.3
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b
learning_rate = 0.5
cost = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.MomentumOptimizer(learning_rate, momentum=0.9).minimize(cost)
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
for step in range(201):
sess.run(optimizer)
if step % 20 == 0:
print(step, sess.run(W), sess.run(b))
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
x = tf.placeholder(tf.float32, [None, 784])
y = tf.placeholder(tf.float32, [None, 10])
W1 = tf.Variable(tf.truncated_normal([784, 256], stddev=0.1))
b1 = tf.Variable(tf.zeros([256]))
L1 = tf.nn.relu(tf.matmul(x, W1) + b1)
W2 = tf.Variable(tf.truncated_normal([256, 10], stddev=0.1))
b2 = tf.Variable(tf.zeros([10]))
y_predict = tf.nn.softmax(tf.matmul(L1, W2) + b2)
learning_rate = 0.1
batch_size = 100
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(y_predict), reduction_indices=1))
optimizer = tf.train.AdagradOptimizer(learning_rate).minimize(cost)
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
for epoch in range(50):
total_batch = int(mnist.train.num_examples/batch_size)
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
if epoch % 5 == 0:
print("Epoch:", (epoch+1), "cost=", sess.run(cost, feed_dict={x: mnist.test.images, y: mnist.test.labels}))
correct_prediction = tf.equal(tf.argmax(y_predict, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))
在上述两个例子中,我们使用了Tensorflow中的Momentum和Adagrad优化算法来优化不同的模型,分别是线性回归和多层感知器。
本文链接:http://task.lmcjl.com/news/14387.html