03-TensorFlow 神经网络优化过程

1.预备知识

1.tf.where()
条件语句真返回A，条件语句假返回B
tf.where(条件语句，真返回A，假返回B)

import tensorflow as tf


if __name__ == '__main__':
    a=tf.constant([1,2,3,1,1])
    b=tf.constant([0,1,3,4,5])
    c=tf.where(tf.greater(a,b), a, b) # 若a>b，返回a对应位置的元素，否则返回b对应位置的元素
    print("c:",c)

2.np.random.RandomState.rand()
返回一个[0,1)之间的随机数
np.random.RandomState.rand(维度) #维度为空，返回标量

import numpy as np

if __name__ == '__main__':
    rdm = np.random.RandomState(seed=1)  # seed=常数每次生成随机数相同
    a = rdm.rand()  # 返回一个随机标量
    b = rdm.rand(2, 3)  # 返回维度为2行3列随机数矩阵
    print("a:", a)
    print("b:", b)

3.np.vstack()
将两个数组按垂直方向叠加
np.vstack(数组1，数组2)

import numpy as np

if __name__ == '__main__':
    a = np.array([1, 2, 3])
    b = np.array([4, 5, 6])
    c = np.vstack((a, b))#把两个1行3列的张量合并成一个两行3列的张量
    print("c:\n", c)

4.np.mgrid[ ]、x.ravel( )、np.c_[ ]

np.mgrid[ 第1维，第2维 ，第3维 ， …]
第n维的书写形式为：
a : b : c
c表示步长，为实数表示间隔；该为长度为[a,b),左开右闭

np.mgrid[ 起始值 : 结束值 : 步长 ，起始值 : 结束值 : 步长 , … ]

import numpy as np

if __name__ == '__main__':
    x, y = np.mgrid[1:3:1, 2:4:0.5] #生成个2D矩阵，有x坐标和y坐标
    grid = np.c_[x.ravel(), y.ravel()]
    print("x:", x)
    print("y:", y)
    print('grid:\n', grid)

2.神经网络复杂度

1.空间复杂度

空间复杂度（访存量），严格来讲包括两部分：总参数量 + 各层输出特征图。
参数量：模型所有带参数的层的权重参数总量；
特征图：模型在实时运行过程中每层所计算出的输出特征图大小。

2.时间复杂度

即模型的运算次数，可用浮点运算次数（FPLOPs, FLoating-point OPerations）或者乘加运算次数衡量.

3.学习率

1.指数衰减

import tensorflow as tf

w = tf.Variable(tf.constant(5, dtype=tf.float32))

epoch = 40
LR_BASE = 0.2  # 最初学习率
LR_DECAY = 0.99  # 学习率衰减率
LR_STEP = 1  # 喂入多少轮BATCH_SIZE后，更新一次学习率

for epoch in range(epoch):  # for epoch 定义顶层循环，表示对数据集循环epoch次，此例数据集数据仅有1个w,初始化时候constant赋值为5，循环100次迭代。
    lr = LR_BASE * LR_DECAY ** (epoch / LR_STEP)
    with tf.GradientTape() as tape:  # with结构到grads框起了梯度的计算过程。
        loss = tf.square(w + 1)
    grads = tape.gradient(loss, w)  # .gradient函数告知谁对谁求导

    w.assign_sub(lr * grads)  # .assign_sub 对变量做自减 即：w -= lr*grads 即 w = w - lr*grads
    print("After %s epoch,w is %f,loss is %f,lr is %f" % (epoch, w.numpy(), loss, lr))

其中， learning_rate是初始学习率，decay_rate 是衰减率， gloab_step表示从0到当前的训练次数， decay_step用来控制衰减速度
指数衰减学习率是先使用较大的学习率来快速得到一个较优的解，然后随着迭代的继续,逐步减小学习率，使得模型在训练后期 更加稳定。指数型学习率衰减法是最常用的衰减方法，在大量模型中都广泛使用。

2.分段常数衰减

分段常数衰减可以让调试人员针对不同任务设置不同的学习率，进行精细调参，在任意步长后下降任意数值的learning rate，要求调试人员对模型和数据集有深刻认识.

4.激活函数

激活函数是用来加入非线性因素的，因为线性模型的表达能力不够。引入非线性激活函数，可使深层神经网络的表达能力更加强大。

a.优秀的激活函数
• 非线性： 激活函数非线性时，多层神经网络可逼近所有函数
• 可微性： 优化器大多用梯度下降更新参数
• 单调性： 当激活函数是单调的，能保证单层网络的损失函数是凸函数
• 近似恒等性： f(x)≈x当参数初始化为随机小值时，神经网络更稳定

b.激活函数输出值的范围：
• 激活函数输出为有限值时，基于梯度的优化方法更稳定
• 激活函数输出为无限值时，建议调小学习率

1.sigmoid



优点：

1. 输出映射在(0,1)之间，单调连续，输出范围有限，优化稳定，可用作输出层；
2. 求导容易。

缺点：

1. 易造成梯度消失；
2. 输出非0均值，收敛慢；
3. 幂运算复杂，训练时间长。

sigmoid函数可应用在训练过程中。然而，当处理分类问题作出输出时，sigmoid却无能为力。简单地说，sigmoid函数只能处理两个类，不适用于多分类问题。而softmax可以有效解决这个问题，并且softmax函数大都运用在神经网路中的最后一层网络中，使得值得区间在（0,1）之间，而不是二分类的。

2.tanh

优点：

1. 比sigmoid函数收敛速度更快。
2. 相比sigmoid函数，其输出以0为中心。

缺点：

1. 易造成梯度消失；
2. 幂运算复杂，训练时间长。

3.ReLU



优点：
4. 解决了梯度消失问题(在正区间)；
5. 只需判断输入是否大于0，计算速度快；
6. 收敛速度远快于sigmoid和tanh，因为sigmoid和tanh涉及很多expensive的操作；
7. 提供了神经网络的稀疏表达能力。

缺点：

1. 输出非0均值，收敛慢；
2. Dead ReLU问题：某些神经元可能永远不会被激活，导致相应的参数永远不能被更新。

4. Leaky ReLU



理论上来讲，Leaky ReLU有ReLU的所有优点，外加不会有Dead ReLU问题，但是在实际操作当中，并没有完全证明Leaky ReLU总是好于ReLU。

5.softmax

对神经网络全连接层输出进行变换，使其服从概率分布，即每个值都位于[0,1]区间且和为1。

6.建议
对于初学者的建议：

1. 首选ReLU激活函数；
2. 学习率设置较小值；
3. 输入特征标准化，即让输入特征满足以0为均值，1为标准差的正态分布；
4. 初始化问题：初始参数中心化，即让随机生成的参数满足以0为均值，√（2/当前层输入特征个数）为标准差的正态分布。

5.损失函数

1.损失函数用来评价模型的预测值和真实值不一样的程度，深度学习训练模型的时候就是通过计算损失函数，更新模型参数，从而减小优化误差，直到损失函数值下降到目标值 或者 达到了训练次数。
2.不同的模型用的损失函数一般也不一样。损失函数设置的越好，通常模型的性能越好。
3.loss函数可以自定义

import tensorflow as tf
import numpy as np

SEED = 23455

rdm = np.random.RandomState(seed=SEED)  # 生成[0,1)之间的随机数
x = rdm.rand(32, 2)
y_ = [[x1 + x2 + (rdm.rand() / 10.0 - 0.05)] for (x1, x2) in x]  # 生成噪声[0,1)/10=[0,0.1); [0,0.1)-0.05=[-0.05,0.05)
x = tf.cast(x, dtype=tf.float32)

w1 = tf.Variable(tf.random.normal([2, 1], stddev=1, seed=1))

epoch = 15000
lr = 0.002

for epoch in range(epoch):
    with tf.GradientTape() as tape:
        y = tf.matmul(x, w1)
        loss_mse = tf.reduce_mean(tf.square(y_ - y))

    grads = tape.gradient(loss_mse, w1)
    w1.assign_sub(lr * grads)

    if epoch % 500 == 0:
        print("After %d training steps,w1 is " % (epoch))
        print(w1.numpy(), "\n")
print("Final w1 is: ", w1.numpy())

6.欠拟合与过拟合

1.欠拟合的解决方法：

• 增加输入特征项
• 增加网络参数
• 减少正则化参数

2.过拟合的解决方法：

• 数据清洗
• 增大训练集
• 采用正则化
• 增大正则化参数

7.优化器

优化算法可以分成一阶优化和二阶优化算法，其中一阶优化就是指的梯度算法及其变种，而二阶优化一般是用二阶导数（Hessian 矩阵）来计算，如牛顿法，由于需要计算Hessian阵和其逆矩阵，计算量较大，因此没有流行开来。这里主要总结一阶优化的各种梯度下降方法。

深度学习优化算法经历了SGD -> SGDM -> NAG ->AdaGrad -> AdaDelta -> Adam -> Nadam这样的发展历程

定义：待优化参数啊 ，损失函数 ，初始学习率 ，每次迭代一个batch，t表示当前batch迭代的总次数。

# 利用鸢尾花数据集，实现前向传播、反向传播，可视化loss曲线

# 导入所需模块
import tensorflow as tf
from sklearn import datasets
from matplotlib import pyplot as plt
import numpy as np
import time  ##1##

# 导入数据，分别为输入特征和标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target

# 随机打乱数据（因为原始数据是顺序的，顺序不打乱会影响准确率）
# seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样（为方便教学，以保每位同学结果一致）
np.random.seed(116)  # 使用相同的seed，保证输入特征和标签一一对应
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

# 将打乱后的数据集分割为训练集和测试集，训练集为前120行，测试集为后30行
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]

# 转换x的数据类型，否则后面矩阵相乘时会因数据类型不一致报错
x_train = tf.cast(x_train, tf.float32)
x_test = tf.cast(x_test, tf.float32)

# from_tensor_slices函数使输入特征和标签值一一对应。（把数据集分批次，每个批次batch组数据）
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

# 生成神经网络的参数，4个输入特征故，输入层为4个输入节点；因为3分类，故输出层为3个神经元
# 用tf.Variable()标记参数可训练
# 使用seed使每次生成的随机数相同（方便教学，使大家结果都一致，在现实使用时不写seed）
w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))

lr = 0.1  # 学习率为0.1
train_loss_results = []  # 将每轮的loss记录在此列表中，为后续画loss曲线提供数据
test_acc = []  # 将每轮的acc记录在此列表中，为后续画acc曲线提供数据
epoch = 500  # 循环500轮
loss_all = 0  # 每轮分4个step，loss_all记录四个step生成的4个loss的和

# 训练部分
now_time = time.time()  ##2##
for epoch in range(epoch):  # 数据集级别的循环，每个epoch循环一次数据集
    for step, (x_train, y_train) in enumerate(train_db):  # batch级别的循环 ，每个step循环一个batch
        with tf.GradientTape() as tape:  # with结构记录梯度信息
            y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
            y = tf.nn.softmax(y)  # 使输出y符合概率分布（此操作后与独热码同量级，可相减求loss）
            y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式，方便计算loss和accuracy
            loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
            loss_all += loss.numpy()  # 将每个step计算出的loss累加，为后续求loss平均值提供数据，这样计算的loss更准确
        # 计算loss对各个参数的梯度
        grads = tape.gradient(loss, [w1, b1])

        # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
        w1.assign_sub(lr * grads[0])  # 参数w1自更新
        b1.assign_sub(lr * grads[1])  # 参数b自更新

    # 每个epoch，打印loss信息
    print("Epoch {}, loss: {}".format(epoch, loss_all / 4))
    train_loss_results.append(loss_all / 4)  # 将4个step的loss求平均记录在此变量中
    loss_all = 0  # loss_all归零，为记录下一个epoch的loss做准备

    # 测试部分
    # total_correct为预测对的样本个数, total_number为测试的总样本数，将这两个变量都初始化为0
    total_correct, total_number = 0, 0
    for x_test, y_test in test_db:
        # 使用更新后的参数进行预测
        y = tf.matmul(x_test, w1) + b1
        y = tf.nn.softmax(y)
        pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引，即预测的分类
        # 将pred转换为y_test的数据类型
        pred = tf.cast(pred, dtype=y_test.dtype)
        # 若分类正确，则correct=1，否则为0，将bool型的结果转换为int型
        correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
        # 将每个batch的correct数加起来
        correct = tf.reduce_sum(correct)
        # 将所有batch中的correct数加起来
        total_correct += int(correct)
        # total_number为测试的总样本数，也就是x_test的行数，shape[0]返回变量的行数
        total_number += x_test.shape[0]
    # 总的准确率等于total_correct/total_number
    acc = total_correct / total_number
    test_acc.append(acc)
    print("Test_acc:", acc)
    print("--------------------------")
total_time = time.time() - now_time  ##3##
print("total_time", total_time)  ##4##

# 绘制 loss 曲线
plt.title('Loss Function Curve')  # 图片标题
plt.xlabel('Epoch')  # x轴变量名称
plt.ylabel('Loss')  # y轴变量名称
plt.plot(train_loss_results, label="$Loss$")  # 逐点画出trian_loss_results值并连线，连线图标是Loss
plt.legend()  # 画出曲线图标
plt.show()  # 画出图像

# 绘制 Accuracy 曲线
plt.title('Acc Curve')  # 图片标题
plt.xlabel('Epoch')  # x轴变量名称
plt.ylabel('Acc')  # y轴变量名称
plt.plot(test_acc, label="$Accuracy$")  # 逐点画出test_acc值并连线，连线图标是Accuracy
plt.legend()
plt.show()

# 本文件较 class1\p45_iris.py 仅添加四处时间记录  用 ##n## 标识
# 请将loss曲线、ACC曲线、total_time记录到 class2\优化器对比.docx  对比各优化器收敛情况