Tensorflow详解（六）——优化网络的方法

tensorflow提供的优化器

1.train.Optimizer()  #基本优化器

2.train.GradientDescentOptimizer()  #梯度下降优化器

3.train.AdagradOptimizer()  #Adagrad自适应学习率优化器

    3.1train.AdagradDAOptimizer()  #Adagrad自适应学习率优化器的升级版，加入了几项正则化的内容

4.train.RMSPropOptimizer()  #RMSProp自适应学习率优化器

5.train.AdamOptimizer()  #Adam自适应学习率优化器

6.train.AdadeltaOptimizer()  #Adadelta算法优化器

7.train.ProximalGradientDescentOptimizer()  

8.train.ProximalAdagradOptimizer()  

9.train.FtrlOptimizer()  #ftrl算法优化器

学习率的独立设置

1.指数衰减的学习率

tf.train.exponential_decay(learning_rate,global_step,decay_steps,decay_rate,staircase,name)

ARG:

   learning_rate:初始学习率

   global_step：当前训练的轮数

   decay_steps：衰减速度

   decay_rate：衰减系数

   staircase：指定衰减方式 =False 连续衰减、=True  迭代decay_steps轮后更新学习率

2.反时限学习率衰减

tf.train.inverse_time_decay(learning_rate,global_step,decay_steps,decay_rate,staircase,name)

3.自然指数学习率衰减

tf.train.natural_exp_decay(learning_rate,global_step,decay_steps,decay_rate,staircase,name)

4.分片常数学习率衰减

tf.train.piecewise_constant(x,boundaries,values,name)

5.多项式学习率衰减

tf.train.polynomial_decay(learning_rate,global_step,decay_steps,end_learning_rate,power,cycle,name)

过拟合的解决

1.正则化

定义：在损失函数中加入被称为正则化项（Regularizer）的惩罚

未加入正则化时，优化损失函数J(w); 

加入正则化时，优化损失函数J(w)+k*R(w)——

                   —— R(w)就是加入的正则化项——通过对权重参数求解犯数的方式对模型的复杂程度进行刻画（一般而言，

                    权重w决定了 模型的复杂程度），

                    ——k是提前挑选的值，控制我们偏好小犯数权重的程度（越大的k偏好犯数越小的权重）

计算R(w)常用两种方法：

   1.1 L1正则化

Tensorflow提供了计算L2正则化的函数——tf.contrib.layers.l2_regularizer(正则化项权重)——它返回一个函数，这个函数

 可以计算一个给定参数的L2正则化的值

      公式：

   1.2  L2正则化

Tensorflow也提供了计算L1正则化的函数——tf.contrib.layers.l1_regularizer(正则化项权重)——它返回一个函数，这个函数

         可以计算一个给定参数的L1正则化的值

   公式：

   1.3  同时使用 L1正则化，L2正则化

 

编程小技巧——为应对当神经网络的参数增加之后需要统计总损失loss的情况；当神经网络的参数增多之后，这样定义总损失的方式可读性差且容易出错，尤其是当定义网络结构的部分和计算总损失的部分不在同一个函数中。为解决这个问题，可以使用集合（collection）——集合可以在一个计算图（Graph）中维护一组个体（比如张量）

import tensorflow as tf
weights = tf.constant([[1.0,2.0],[-3.0,-4.0]])
print(weights)
#regularizer_l2是l2_regularizer()函数返回的函数
regularizer_l2 = tf.contrib.layers.l2_regularizer(.5)

#regularizer_l1是l1_regularizer()函数返回的函数
regularizer_l1 = tf.contrib.layers.l1_regularizer(.5)
with tf.Session() as sess:
    print(sess.run(regularizer_l2(weights)))
    #输出7.5
    print(sess.run(regularizer_l1(weights)))
    #输出5.0

#自定义的损失函数。pow()函数用于计算幂函数，原型为pow(x,y,name=None)
#返回结果为x的y次幂，这里返回结果为(y_-y)^2用于衡量计算值与实际值的差距
error_loss = tf.reduce_sum(tf.pow(y_ - y, 2)) / sample_size
tf.add_to_collection("losses", error_loss)      #加入集合的操作

#在权重参数上实现L2正则化
regularizer = tf.contrib.layers.l2_regularizer(0.01)
regularization = regularizer(weight1)+regularizer(weight2)+regularizer(weight3)
tf.add_to_collection("losses",regularization)     #加入集合的操作


#get_collection()函数获取指定集合中的所有个体，这里是获取所有损失值
#并在add_n()函数中进行加和运算
loss = tf.add_n(tf.get_collection("losses"))

 

2.Bagging方法（模型平均）——一种集成方法

 需要构造多个不同的训练数据集

3.Dropout方法——在训练时，将神经网络一层的单元（不包含输入层的单元）数据随机丢弃一部分

   tf.nn.dropout(x,keep_prob,noise_shape,seed,name)

 arg:  x               ：需要进行dropout处理的数据

         keep_prob：是float类型的参数，x中每个元素被保留下来的概率：被保留的元素会被乘以1/keep_prob,没有被保留下

                                来 的元素会被乘以0；

  

import tensorflow as tf

#定义x作为需要进行dropout处理的数据
x = tf.Variable(tf.ones([10, 10]))

#定义dro作为dropout处理时代keep_prob参数
dro = tf.placeholder(tf.float32)

#定义一个dropout操作
#函数原型dropout(x,keep_prob,noise_shape,seed,name)
y = tf.nn.dropout(x, dro)

init = tf.initialize_all_variables()
with tf.Session() as sess:
    sess.run(init)
    print (sess.run(y, feed_dict = {dro: 0.5}))

'''print输出的结果
    [[2. 0. 2. 0. 0. 0. 2. 2. 0. 2.]
     [0. 0. 2. 0. 0. 2. 0. 2. 0. 2.]
     [0. 0. 0. 2. 2. 2. 2. 2. 2. 0.]
     [2. 0. 0. 2. 2. 2. 2. 2. 0. 0.]
     [2. 2. 2. 0. 2. 0. 2. 2. 2. 2.]
     [0. 2. 0. 0. 2. 0. 2. 0. 0. 2.]
     [0. 2. 2. 2. 2. 2. 0. 0. 2. 2.]
     [2. 0. 0. 2. 2. 0. 2. 0. 2. 2.]
     [2. 0. 2. 2. 2. 0. 0. 2. 2. 0.]
     [0. 2. 0. 0. 0. 2. 0. 2. 2. 0.]]