TensorFlow学习总结（三）优化神经网络

一、深度学习与深层神经网络

        深度学习有两个非常重要的特性——多层和非线性

1.非线性变换

a = tf.nn.relu(tf.matmul(x,w1)+biases1)

  非线性与线性的区别：每个节点的输出在加权和的基础上还做了非线性变化f(x).

2.多层变换

加入隐藏层，组合特征提取功能，解决不易提取特征向量的问题（比如图片识别、语音识别）。

二、神经网络优化——损失函数

1.经典损失函数

(1)分类问题：将不同样本分到事先定义好的类别中。

          神经网络解决多分类问题最常用的方法是设置n个输出节点，即神经网络得到一个n维数组作为结果，每一维对应一个类别。 

①判断分类效果——输出向量和期望向量接近程度——交叉熵(cross_entropy)——刻画两个概率分布之间的距离

                                                       p代表正确答案   q代表预测值，即通过概率q来表达p的困难程度，H越小与接近

②将输出结果变为概率分布——Softmax回归 

③用tensorflow来实现交叉熵

cross_entropy = -tf.reduce_mean(
    y_ *tf.log(tf.clip_by_value(y, 1e-10, 1.0)))
      # y_代表正确结果（p），y代表预测结果（q）
'''
1.tf.clip_by_value(y, 1e-10, 1.0)  
把一个张量中的数值y限制在一个范围[1e-10,1.0]之内，避免一些运算错误（如log0）
2.tf.log()
取对数
3.乘法*
实现元素之间相乘，不是矩阵乘法
4.tf.reduce_mean()
通过上3步得到的输出结果n×m的矩阵，n为batch的样例数量，m为分类的类别数量
把所有数加起来取平均
'''

   (2)回归问题：解决具体数值的预测

          解决回归问题的神经网络一般只有1个输出节点，此节点为预测值。

①判断预测效果——均方误差

②用tensorflow实现均方误差

mse = tf.reduce_mean(tf.square(y_, - y))
'''
y_正确答案，y预测值
tf.square 平方差
tf.reduece_mean  把所有数加起来取平均
其他同上
'''

 2.自定义损失函数

(1)引入自定义损失函数

         自定义损失函数更接近实际问题的需求。以预测商品销售为例：预测少了，每个商品损失利润a；预测多了，每个商品损失成本b。

                                                                   yi为一个batch中第i个数据的正确答案，yi'为预测值 

(2)用tensorflow实现上述自定义损失函数

loss = tf.reduce_sum(tf.select(tf.greater(y, y_), 
                        (y - y_)*loss_more, (y_ - y)*loss_less))
'''
1.tf.greater(y, y_)
比较y和y_的大小，如果前一个大于后一个为True，否则为False
2.tf.select
ture时执行前一项  (y - y_)*loss_more；
false时执行后一项 (y_ - y)*loss_less)
'''

note：condition是一阶的，而x和y拥有更高阶时

import tensorflow as tf
 
if __name__ == "__main__":
    #定义一个张量a
    a = tf.constant([[1.,2.,3.],[1,2,3]])
    #定义一个张量b
    b = tf.constant([[4.,5.,6.],[7,8,9]])
    #创建一个session并设置为默认session
    sess = tf.InteractiveSession()
    print(tf.where([True,False],a,b).eval())
    '''
    [[ 1.  2.  3.]
     [ 7.  8.  9.]]
    '''
    print(tf.where([[True, False,True],[True, False,True]], a, b).eval())
    '''
    [[ 1.  5.  3.]
     [ 1.  8.  3.]]
    '''

3.用tensorflow实现神经网络优化——损失函数

import tensorflow as tf
from numpy.random import RandomState
'''
----------------步骤1-------------------------------------------------------------------------
'''
#定义神经网络结构
batch_size = 8
x = tf.placeholder(tf.float32, shape=(None, 2), name='x-input')
y_ = tf.placeholder(tf.float32, shape=(None, 1), name='y-input')

#前向传播网络预测
w1 = tf.Variable(tf.random_normal([2,1], stddev=1,seed=1)) #w1为输入到隐藏层的权重，2*1的矩阵
y = tf.matmul(x, w1)#y为预测的输出值

'''
--------------步骤2------------------------------------------------------------------------
'''
#损失函数及反向传播网络优化
loss_less = 10
loss_more = 1
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_) * loss_more, (y_ - y) * loss_less))#损失函数，所有训练样本的损失总和
train_step = tf.train.AdamOptimizer(0.01).minimize(loss)#反向传播算法，优化权重参数

'''
-------------步骤3---------------------------------------------------------------------------
'''
#随机生成模拟数据集
rdm = RandomState(1) #rdm为伪随机数发生器，种子为1，只要种子相同，该发生器每次生成的随机数都是一样的
dataset_size = 128
X = rdm.rand(dataset_size, 2)
Y = [[x1+x2+rdm.rand()/10.0-0.05] for (x1, x2) in X]

#生成会话，训练神经网络
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEP = 5000
    for i in range(5000):
        start = (i * batch_size) % dataset_size
        end = min(start+batch_size, dataset_size)
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
    print(sess.run(w1))
'''
[[1.0218611]
 [1.0385854]]
'''

三、神经网络优化——梯度下降优化参数（迭代更新）

1.梯度下降

(1)思想

          

(2)原理 

假设学习率0.3，初始值5

2.反向传播算法

(1)思想

  在所有参数上使用梯度下降算法，使神经网络模型在训练数据集上损失尽可能小。

(2)原理

神经网络优化过程分为两个阶段：

1°通过前向传播算法计算得到预测值（y），并将预测值和真实值对比得到两者的差距(loss)

2°通过反向传播算法计算损失函数对每一个参数的梯度，再根据梯度和学习率使用梯度下降算法更新每一个参数（train_step）。

'''步骤1'''
#前向传播网络预测
w1 = tf.Variable(tf.random_normal([2,1], stddev=1,seed=1)) #w1为输入到隐藏层的权重，2*1的矩阵
y = tf.matmul(x, w1)#y为预测的输出值
#损失函数
loss_less = 10
loss_more = 1
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_) * loss_more, (y_ - y) * loss_less))#损失函数，所有训练样本的损失总和

'''步骤2'''
#反向传播网络优化
train_step = tf.train.AdamOptimizer(0.01).minimize(loss)#反向传播算法，优化权重参数

(3)缺点

 ①不一定全局最优

②计算时间过长

解决办法：折中——每次计算一小部分训练数据的损失函数

#每次选取batch_size个样本进行训练
        start = (i * batch_size) % dataset_size
        end = min(start+batch_size, dataset_size)