TensorFlow中的优化算法_proximaladagradoptimizer-CSDN博客

最基础的方法就是GD了，将整个数据集放入模型中，不断的迭代得到模型的参数，当然这样的方法计算资源占用的比较大，那么有没有什么好的解决方法呢？就是把整个数据集分成小批(mini-batch)，然后再进行上述操作这就是SGD了，这种方法虽然不能反应整体的数据情况，不过能够很大程度上加快了模型的训练速度，并且也不会丢失太多的准确率
参数的迭代公式
w:=w−α∗dww:=w−α∗dw

Momentum

传统的GD可能会让学习过程十分的曲折，这里我们引入了惯性这一分量，在朝着最优点移动的过程中由于惯性走的弯路会变少
m=β∗m−α∗dwm=β∗m−α∗dw
w:=w−mw:=w−m

AdaGrad

这个方法主要是在学习率上面动手脚，每个参数的更新都会有不同的学习率
s=s+dw2s=s+dw2
w:=w−α∗dw/s√w:=w−α∗dw/s

RMSProp

AdaGrad收敛速度快，但不一定是全局最优，为了解决这一点，加入了Momentum部分
s=β∗s+(1−β)dw2s=β∗s+(1−β)dw2
w:=w−α∗dw/s√w:=w−α∗dw/s

Adam

adam是目前比较好的方法，它融合了Momentum和RMSProp方法

# https://www.cnblogs.com/wxshi/p/8645634.html
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np


def reset_graph(seed=42):
    tf.reset_default_graph()
    tf.set_random_seed(seed)
    np.random.seed(seed)


reset_graph()
plt.figure(1, figsize=(10, 8))
x = np.linspace(-1, 1, 100)[:, np.newaxis]  # <==>x=x.reshape(100,1)
noise = np.random.normal(0, 0.1, size=x.shape)
y = np.power(x, 2) + x + noise  # y=x^2 + x+噪音
plt.scatter(x, y)
plt.show()
learning_rate = 0.01
batch_size = 10  # mini-batch的大小


class Network(object):
    def __init__(self, func, **kwarg):
        self.x = tf.placeholder(tf.float32, [None, 1])
        self.y = tf.placeholder(tf.float32, [None, 1])
        hidden = tf.layers.dense(self.x, 20, tf.nn.relu)
        output = tf.layers.dense(hidden, 1)
        self.loss = tf.losses.mean_squared_error(self.y, output)
        self.train = func(learning_rate, **kwarg).minimize(self.loss)


SGD = Network(tf.train.GradientDescentOptimizer)
Momentum = Network(tf.train.MomentumOptimizer, momentum=0.5)
AdaGrad = Network(tf.train.AdagradOptimizer)
RMSprop = Network(tf.train.RMSPropOptimizer)
Adam = Network(tf.train.AdamOptimizer)
networks = [SGD, Momentum, AdaGrad, RMSprop, Adam]
record_loss = [[], [], [], [], []]  # 踩的坑不能使用[[]]*5
plt.figure(2, figsize=(10, 8))
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for stp in range(200):
        index = np.random.randint(0, x.shape[0], batch_size)  # 模拟batch
        batch_x = x[index]
        batch_y = y[index]
        for net, loss in zip(networks, record_loss):
            _, l = sess.run([net.train, net.loss], feed_dict={net.x: batch_x, net.y: batch_y})
            loss.append(l)  # 保存每一batch的loss
labels = ['SGD', 'Momentum', 'AdaGrad', 'RMSprop', 'Adam']
for i, loss in enumerate(record_loss):
    plt.plot(loss, label=labels[i])
plt.legend(loc="best")
plt.xlabel("steps")
plt.ylabel("loss")
plt.show()