python人工智能tensorflowtf优化器Optimizer算法汇总

目录

• 前言
• tensorflow常见的Optimizer
• 1 梯度下降法
• 2 Adagrad下降法
• 3 动量优化法
• 4 RMSProp算法
• 5 Adam算法
• 例子
• 1 梯度下降法
• 2 Adagrad下降法
• 3 动量优化法
• 4 RMSProp算法
• 5 Adam算法
• 总结

前言

优化器的选择关乎参数更新的方法，合理的方法可以帮助机器学习更好的寻找到全局最佳值。
那我们快点开始学习吧

tensorflow常见的Optimizer

1 梯度下降法

tf.train.GradientDescentOptimizer(learning_rate, use_locking=False, name='GradientDescent')

常用参数为学习率learning_rate。

使用梯度下降算法的Optimizer，容易陷入局部最优解。

2 Adagrad下降法

tf.train.AdagradOptimizer(learning_rate, initial_accumulator_value=0.1, use_locking=False,name='Adagrad')

常用的参数为学习率learning_rate。

使用Adagrad算法的Optimizer，独立地适应所有模型参数的学习率，缩放每个参数反比于其所有梯度历史平均值总和的平方根。具有代价函数最大梯度的参数相应地有个快速下降的学习率，而具有小梯度的参数在学习率上有相对较小的下降。

Adagrad 的主要优势在于不需要人为的调节学习率，它可以自动调节；缺点在于，随着迭代次数增多，学习率会越来越小，最终会趋近于0。

3 动量优化法

tf.train.MomentumOptimizer.__init__(learning_rate, momentum, use_locking=False, name='Momentum', use_nesterov=False)

常用的参数 learning_rate，momentum，use_nesterov使用Momentum算法的Optimizer使用动量(Momentum)的随机梯度下降法(SGD)，主要思想是引入一个积攒历史梯度信息动量来加速SGD。

动量优化法的优点是收敛快，不容易陷入局部最优解，但是缺点是有时候会冲过头了，使得结果不够精确。

如果使得use_nesterov=True，则该优化器实现牛顿加速梯度（NAG, Nesterov accelerated gradient）算法，该算法是Momentum动量算法的变种。

4 RMSProp算法

tf.train.RMSPropOptimizer(learning_rate, decay=0.9, momentum=0.0, epsilon=1e-10, use_locking=False, name='RMSProp')

常用的参数由learning_rate
RMSProp算法修改了AdaGrad的梯度积累为指数加权的移动平均，使得其在非凸设定下效果更好。
RMSProp算法在经验上已经被证明是一种有效且实用的深度神经网络优化算法。目前它是深度学习从业者经常采用的优化方法之一。

5 Adam算法

tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name='Adam')

常用的参数由learning_rate

Adam中动量直接并入了梯度一阶矩（指数加权）的估计。相比于缺少修正因子导致二阶矩估计可能在训练初期具有很高偏置的RMSProp，Adam包括偏置修正，修正从原点初始化的一阶矩（动量项）和（非中心的）二阶矩估计。

Adam通常被认为对超参数的选择相当鲁棒，尽管学习率有时需要从建议的默认修改。
在实际运用中Adam效果非常优秀。

例子

本文以Mnist手写体识别为例子，将各个Optimizer在实际分类中进行运用，本例中，使用的神经网络是一个二层神经网络，每一层神经元均为150个，所用激励函数均为tf.nn.tanh()。

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

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

def add_layer(inputs,in_size,out_size,n_layer,activation_function = None):

    layer_name = 'layer%s'%n_layer
    with tf.name_scope(layer_name):
        with tf.name_scope("Weights"):
            Weights = tf.Variable(tf.random_normal([in_size,out_size]),name = "Weights")
            tf.summary.histogram(layer_name+"/weights",Weights)
        with tf.name_scope("biases"):
            biases = tf.Variable(tf.zeros([1,out_size]) + 0.1,name = "biases")
            tf.summary.histogram(layer_name+"/biases",biases)
        with tf.name_scope("Wx_plus_b"):
            Wx_plus_b = tf.matmul(inputs,Weights) + biases
            tf.summary.histogram(layer_name+"/Wx_plus_b",Wx_plus_b)
        if activation_function == None :
            outputs = Wx_plus_b
        else:
            outputs = activation_function(Wx_plus_b)
        tf.summary.histogram(layer_name+"/outputs",outputs)
        return outputs

def compute_accuracy(x_data,y_data):
    global prediction
    y_pre = sess.run(prediction,feed_dict={xs:x_data})
    correct_prediction = tf.equal(tf.arg_max(y_data,1),tf.arg_max(y_pre,1))     #判断是否相等
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))   #赋予float32数据类型，求平均。
    result = sess.run(accuracy,feed_dict = {xs:batch_xs,ys:batch_ys})   #执行
    return result

xs = tf.placeholder(tf.float32,[None,784])
ys = tf.placeholder(tf.float32,[None,10])

layer1 = add_layer(xs,784,150,"layer1",activation_function = tf.nn.tanh)
prediction = add_layer(layer1,150,10,"layer2")

with tf.name_scope("loss"):
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=ys,logits = prediction),name = 'loss')
    #label是标签，logits是预测值，交叉熵。
    tf.summary.scalar("loss",loss)

train = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
init = tf.initialize_all_variables()

merged = tf.summary.merge_all()

with tf.Session() as sess:
    sess.run(init)
    write = tf.summary.FileWriter("logs/",sess.graph)
    for i in range(5001):
        batch_xs,batch_ys = mnist.train.next_batch(100)
        sess.run(train,feed_dict = {xs:batch_xs,ys:batch_ys})
        if i % 1000 == 0:
            print("训练%d次的识别率为：%f。"%((i+1),compute_accuracy(mnist.test.images,mnist.test.labels)))

            result = sess.run(merged,feed_dict={xs:batch_xs,ys:batch_ys})
            write.add_summary(result,i)

在该部分中，我主要只修改训练的Optimizer。

train = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

1 梯度下降法

在该例子中，训练器为：

train = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

得到结果：

训练1次的识别率为：0.119100。
训练1001次的识别率为：0.864600。
训练2001次的识别率为：0.889300。
训练3001次的识别率为：0.897400。
训练4001次的识别率为：0.905600。
训练5001次的识别率为：0.910200。

2 Adagrad下降法

在该例子中，训练器为：

train = tf.train.AdagradOptimizer(0.1).minimize(loss)

得到结果

训练1次的识别率为：0.136100。
训练1001次的识别率为：0.871600。
训练2001次的识别率为：0.894400。
训练3001次的识别率为：0.900500。
训练4001次的识别率为：0.909100。
训练5001次的识别率为：0.911600。

3 动量优化法

在该例子中，训练器为：

train = tf.train.MomentumOptimizer(learning_rate=0.05, momentum=0.9).minimize(loss)

得到结果

训练1次的识别率为：0.121300。
训练1001次的识别率为：0.894800。
训练2001次的识别率为：0.909400。
训练3001次的识别率为：0.916900。
训练4001次的识别率为：0.920700。
训练5001次的识别率为：0.927600。

4 RMSProp算法

在该例子中，训练器为：;

train = tf.train.RMSPropOptimizer(0.01).minimize(loss)

得到结果

训练1次的识别率为：0.071500。
训练1001次的识别率为：0.929500。
训练2001次的识别率为：0.944000。
训练3001次的识别率为：0.954100。
训练4001次的识别率为：0.953900。
训练5001次的识别率为：0.958000。

5 Adam算法

在该例子中，训练器为：

train = tf.train.AdamOptimizer(0.004).minimize(loss)

得到结果

训练1次的识别率为：0.103100。
训练1001次的识别率为：0.900700。
训练2001次的识别率为：0.928100。
训练3001次的识别率为：0.938900。
训练4001次的识别率为：0.945600。
训练5001次的识别率为：0.952100。

总结

在本例中，RMSProp算法和Adam算法在短时间内就得到了很好的训练效果，识别率都在95%以上，相比之下梯度下降法、Adagrad下降法和动量优化法表现较为逊色，但不能说明在任何情况下都是RMSProp算法和Adam算法比其它算法更加优秀，在实际应用中，选择哪种优化器应结合具体问题具体分析。

同时，也优化器的选择也取决于使用者对优化器的掌握情况，其中调节参数就是非常重要的一环，更多关于tensorflowtf优化器Optimizer的资料请关注我们其它相关文章！