第6章 单个神经元

部分知识点笔记：
正向传播、反向传播（BP算法）
激活函数：
Sigmoid函数、Tanh函数、ReLU函数、Swish函数

Softmax算法——处理分类问题（伴随的分类标签都为one_hot编码）
损失函数：
描述模型预测值与真实值的差距大小（常用的算法：均值平方差和交叉熵），交叉熵 预测输入样本属于某一类的概率。交叉熵也是值越小，代表预测结果越准。
损失函数的选取：如果输入的是实数、无界的值，损失函数使用平方差；如果输入标签是位矢量（分类标志），使用交叉熵会更合适。
常见的交叉熵函数有：
Sigmoid交叉熵；softmax交叉熵；Sparse交叉熵；加权Sigmoid交叉熵。

梯度下降，用负梯度方向为搜索方向，沿着梯度下降方向求解极小值。
常用的梯度下降方法：
批量梯度下降，随机梯度下降，小批量梯度下降。

通常在程序中使用tf.train.***Optimizer()来进行训练。
设置学习率的大小，在精度和速度之间找到一个平衡：学习率较大，训练速度会提升，精度不够；学习率较小，精度提升，耗费时间增加。
学习率衰减：当训练刚开始时使用大的学习率加快速度，训练到一定程度后使用小的学习率来提高精度。
Learning_rate= tf.train.exponential_decay(starter_learning_rate,global_step,100000,0.96)
这种方式定义的学习率就是退化学习率，他的意思是当前迭代到global_step步，学习率每一步都按照每10万步缩小到0.96%的速度衰退。

6.1 softmax应用
假设有一个标签labels和一个网络输出值logits
（1）两次softmax实验
（2）两次交叉熵
（3）自建公式，将做两次softmax的值放到公式中得到正确的值
代码：

import tensorflow as tf

#     交叉熵实验
labels = [[0,0,1],[0,1,0]]
logits = [[2,0.5,6],[0.1,0,3]]
logits_scaled = tf.nn.softmax(logits)
logits_scaled2 = tf.nn.softmax(logits_scaled)  # 进行第二次softmax操作

result1 = tf.nn.softmax_cross_entropy_with_logits(labels=labels,logits = logits)
result2 = tf.nn.softmax_cross_entropy_with_logits(labels=labels,logits = logits_scaled)
result3 = -tf.reduce_sum(labels*tf.log(logits_scaled),1)

with tf.Session() as sess:
    print("scaled=",sess.run(logits_scaled))
    print("scaled2=",sess.run(logits_scaled2))
                        # 经过第二次的softmax后，分布概率会有变化
    print("rell=",sess.run(result1),"\n") #正确的打开方式
    print("rel2 = ",sess.run(result2),"\n")
    # 如果将softmax变换完的值放进去会，就相当于第二次softmax的loss。所以会出错
    print("rel3=",sess.run(result3))

#     ont_hot实验
# 标签总概率为1
labels = [[0.4,0.1,0.5],[0.3,0.6,0.1]]
result4 = tf.nn.softmax_cross_entropy_with_logits(labels=labels,logits = logits)
with tf.Session() as sess:
    print("rel4 =",sess.run(result4),"\n")
# 交叉熵的应用
# sparse标签
labels = [2,1] # 表明labels中总共分为3个类：
                # 0、1、2.[2,1]等价于onehot编码中的001和010
result5 = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels,logits=logits)
with tf.Session() as sess:
    print("rel5=",sess.run(result5),"\n")

# 计算loss值
loss = tf.reduce_sum(result1)
with tf.Session() as sess:
    print("loss=",sess.run(loss))

labels = [[0,0,1],[0,1,0]]
loss2 = -tf.reduce_sum(labels * tf.log(logits_scaled))
with tf.Session() as sess:
    print("loss2=",sess.run(loss2))   # 计算出的loss1和loss2的值相同

结果：

scaled= [[0.01791432 0.00399722 0.97808844]
 [0.04980332 0.04506391 0.90513283]]
scaled2= [[0.21747023 0.21446465 0.56806517]
 [0.2300214  0.22893383 0.5410447 ]]
rell= [0.02215516 3.0996735 ] 

rel2 =  [0.56551915 1.4743223 ] 

rel3= [0.02215518 3.0996735 ]
rel4 = [2.1721554 2.7696736] 

rel5= [0.02215516 3.0996735 ] 

loss= 3.1218286
loss2= 3.1218288

6.3 退化学习率

Learning_rate= tf.train.exponential_decay(starter_learning_rate,global_step,100000,0.96)

这种方式定义的学习率就是退化学习率，他的意思是当前迭代到global_step步，学习率每一步都按照每10万步缩小到0.96%的速度衰退。

程序：

import tensorflow as tf
global_step = tf.Variable(0,trainable=False)
initial_learning_rate = 0.1
learning_rate = tf.train.exponential_decay(initial_learning_rate,
                                           global_step=global_step,
                                           decay_steps=10,decay_rate=0.9)
opt = tf.train.GradientDescentOptimizer(learning_rate)
add_global = global_step.assign_add(1)  # 定义一个op，令global_step+1完成计步
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    print(sess.run(learning_rate))
    for i in range(20):
        g,rate = sess.run([add_global,learning_rate])
                                            # 循环20步，将每步的学习率打印出来
        print(g,rate)

结果：

0.1
1 0.1
2 0.09895193
3 0.09688862
4 0.095873155
5 0.094868325
6 0.094868325
7 0.09387404
8 0.092890166
9 0.09191661
10 0.089999996
11 0.08905673
12 0.08812335
13 0.087199755
14 0.08628584
15 0.08628584
16 0.0853815
17 0.08360115
18 0.08272495
19 0.08272495
20 0.08185793