MOOC北大tensorflow笔记二

我会带着你远行 2021-09-25 13:16 386阅读 0赞

**一. 神经网络(NN)的复杂度**

NN复杂度：多个NN层数和NN参数的个数表示。

1.空间复杂度

层数=隐藏层层数+一个输出层

总参数=总w+总b

2.时间复杂度

乘加运算次数

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70][]

** 二.指数衰减学习率**

在神经网络的参数更新过程中，学习率不能太大也不能太小，太大可能会导致参数在最优值两侧来回移动，太小会大大降低优化速度，为了解决学习率的问题，TensorFlow 提供了一种灵活的学习率设置方法，即指数衰减法。

可以用较大的学习率，快速得到较优解，然后逐步减小学习率，使模型在训练后期稳定。

指数衰减学习率=初始学习率\*学习率衰减率\*\*（当前轮数/多少论=轮衰减一次）

import tensorflow as tf
    import matplotlib.pyplot as plt
    epoch=1000#定义迭代轮数
    LR_BASE=0.2#当前学习率
    LR_DECAY=0.99#学习率衰减率
    LR_STEP=1#一轮更新一次学习率
    w=tf.Variable(tf.constant(5,dtype=tf.float32))
    
    lr_epoch=[]
    for epoch in range(epoch):
    
        lr=LR_BASE * LR_DECAY ** (epoch/LR_STEP)
        lr_epoch.append(lr)
        with tf.GradientTape() as tape:
            loss=tf.square(w+1)
        grads=tape.gradient(loss,w)
    
        w.assign_sub(lr*grads)
        print("After %s epoch w is %f,loss is %f,lr is %f" %(epoch,w,loss,lr))
    #将学习率用二维图像表示
    plt.figure(num=1)
    
    plt.plot(range(epoch+1),lr_epoch)
    plt.xlabel('lr')
    plt.ylabel('epoch')
    plt.show()

运行结果：随着迭代次数，学习率在指数衰减

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 2][]

** 三.激活函数**

**优秀的激活函数：**  
**非线性**:激活函数非线性时，多层神经网络可逼近所有函数  
**可微性**:优化器大多用梯度下降更新参数  
**单调性**:当激活函数是单调的，能保证单层网络的损失函数是凸函数  
**近似恒等性**：F(X)~x当参数初始化为随机小值时，神经网络更稳定  
**激活函数输出值的范围：**  
激活函数输出为有限值时，基于梯度的优化方法更稳定  
激活函数输出为无限值时，建议调小学习率

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 3][]

1.sigmoid函数的导数的输出使是0到0.25之间的小数，链式求导需要层导数连续相乘，会出现多个0到0.25之间的连续相乘，结果将趋于0产生梯度消失，使得参数无法继续更新。

2.输出的非零均值，sigmoid激活函数后的数据都是正数，回事收敛变慢

3.存在幂运算计算复杂度大，训练时间长。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 5][]

**对于初学者的建议: **  
首选relu激活函数;   
R学习率设置较小值；  
输入特征标准化，即让输入特征满足以0为均值，  
1为标准差的正态分布;   
初始参数中心化，即让随机生成的参数满足以0 为均值，sqrt\{(2/当前输入的特征值)\} 为标准差的正态分布。

**四.损失函数**

损失函数就是与测试y与已知答案y\_的差距

NN优化目标有三种使loss最小----1.mse(平均均方误差)，2.自定义损失函数，3.ce（(Cross Entropy) (交叉熵)）

**1.mse(平均均方误差)**

![20210812000557809.png][]

tensorflow表示：

loss=tf.reduce_mean(tf.square(y_-y))

举个例子：

预测酸奶日销量y, x1、 x2是影响日销量的因素。建模前，应预先采集的数据有:每日x1、 x2和销量y\_ (即已知答案， 最佳情况:产量=销量)拟造数据集X,Y\_ : y\_ =x1 + x2  
噪声: -0.05~ +0.05拟合 可以预测销量的函数。

其实就是通过梯度下降，使w1的两个数与制造数据集的公式y=x1+x2+-0.05一致，也就是使两个数接近于1.

代码：

numpy.random.RandomState(seed=?)是一个伪随机数生成器, 此命令将会产生一个随机状态种子,在该状态下生成的随机序列（正态分布）一定会有相同的模式。伪随机数是用确定性的算法计算出来的似来自[0,1]均匀分布的随机数序列，作用同np.random.seed(n)

import tensorflow as tf
    import numpy as np
    
    #设置随机种子
    seed=23455
    #numpy.random.RandomState(seed=?)是一个伪随机数生成器, 此命令将会产生一个随机状态种子,在该状态下生成的随机序列（正态分布）一定会有相同的模式。
    #伪随机数是用确定性的算法计算出来的似来自[0,1]均匀分布的随机数序列
    #起作用同np.random.seed(n)
    rdm = np.random.RandomState(seed=seed)
    x=rdm.rand(32,2)#生成x1,x2
    #rdm.rand() 生成0-1之间的随机数
    #取出x中的两列数，输入前面再加上噪声+-0.05
    y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in x]
    
    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 type:
            y=tf.matmul(x,w1)
            loss=tf.reduce_mean(tf.square(y_-y))
    
        grads=type.gradient(loss,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())

最终结果接近于1，说明拟合成功。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 6][]

** 2.自定义损失函数**

如上述的商品销量中，预测多了，损失的是成本，少了损失的是利润。用mse的loss无法实现利益的最大化，所以可以自定义loss

![20210812002820256.png][]

如酸奶销量，成本COST为1元，利润PROFIT为99元，如何实现利益的最大化呢

代码如下：

tf.greater(y,y\_)比较大小  
 tf.where(condition,a,b)相当于三目运算，如果condition成立输出a,否则输出b

import tensorflow as tf
    import numpy as np
    
    #设置随机种子
    seed=23455
    
    rdm = np.random.RandomState(seed=seed)
    x=rdm.rand(32,2)#生成x1,x2
    #rdm.rand() 生成0-1之间的随机数
    #取出x中的两列数，输入前面再加上噪声+-0.05
    y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in x]
    
    x=tf.cast(x,dtype=tf.float32)
    #生成两行一列的生态分布随机数
    w1=tf.Variable(tf.random.normal([2,1],stddev=1,seed=1))
    
    Cost=1
    Profit=99
    epoch=15000
    lr=0.002
    for epoch in range(epoch):
        with tf.GradientTape() as type:
            y=tf.matmul(x,w1)
            #tf.greater(y,y_)比较大小
            #tf.where(condition,a,b)相当于三目运算，如果condition成立输出a,否则输出b
            loss=tf.reduce_sum(tf.where(tf.greater(y,y_),(y-y_)*Cost,(y_-y)*Profit))
    
        grads=type.gradient(loss,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())

结果是如果cost小，profit大，那么w1的值就会比1大，因为利润大，尽可能多预测。

![2021081200430940.png][]

3.交叉熵

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 8][]

**Softmax于交叉熵结合**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 9][]

**五.正则化缓解过拟合**

详见[L2正则化缓解过拟合实例][L2]

**六.优化器**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 10][]

1.SGD

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 11][]

代码表示：

# w1 = w1 - lr * w1_grad
     w1.assign_sub(lr * grads[0])

2.SGDM

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 12][]

m_w,m_b=0,0
    beta=0.9
    
      grads = tape.gradient(loss, [w1, b1])
            m_w=beta*m_w+(1-beta)*grads[0]
            m_b=beta*m_b+(1-beta)*grads[1]
    
    
            # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
            w1.assign_sub(lr * m_w)  # 参数w1自更新
            b1.assign_sub(lr * m_b)  # 参数b自更新

3.Adagrad

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 13][]

代码：

v_w,v_b=0,0
     grads = tape.gradient(loss, [w1, b1])
            v_w+=tf.square(grads[0])
            v_b+=tf.square(grads[1])
    
            # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
            w1.assign_sub(lr * grads[0]/tf.sqrt(v_w))  # 参数w1自更新
            b1.assign_sub(lr * grads[1]/tf.sqrt(v_b))  # 参数b自更新

4.RMSProp

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 14][]

v_w,v_b=0,0
    beta=0.9       
     grads = tape.gradient(loss, [w1, b1])
            v_w=beta*v_w+(1-beta)*tf.square(grads[0])
            v_b=beta*v_b+(1-beta)*tf.square(grads[1])
    
    
            # 实现梯度更新 w1 = w1 - lr * w1_grad    b = b - lr * b_grad
            w1.assign_sub(lr * grads[0] / tf.sqrt(v_w))  # 参数w1自更新
            b1.assign_sub(lr * grads[1] / tf.sqrt(v_b))  # 参数b自更新

5.Adam

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 15][]

code:

m_w,m_b=0,0
    v_w,v_b=0,0
    beta1,beta2=0.9,0.999
    delta_w,delta_b=0,0
    global_step=0#存放总batch数
    
    
    # 训练部分
    for epoch in range(epoch):  #数据集级别的循环，每个epoch循环一次数据集
        for step, (x_train, y_train) in enumerate(train_db):  #batch级别的循环 ，每个step循环一个batch
            global_step+=1
            ................
            ................
    
     
      grads = tape.gradient(loss, [w1, b1])
            m_w = beta1 * m_w + (1 - beta1) * grads[0]
            m_b = beta1*m_b + (1 - beta1)*grads[1]
            v_w = beta2 * v_w + (1 - beta2) * tf.square(grads[0])
            v_b = beta2 * v_b + (1 - beta2) * tf.square(grads[1])
        
            m_w_correction = m_w / (1 - tf.pow(beta1, int(global_step)))
            m_b_correction = m_b / (1 - tf.pow(beta1, int(global_step)))
            v_w_correction = v_w / (1 - tf.pow(beta2, int(global_step)))
            v_b_correction = v_b / (1 - tf.pow(beta2, int(global_step)))
            w1.assign_sub(lr * m_w_correction / tf.sqrt(v_w_correction))
            b1.assign_sub(lr * m_b_correction / tf.sqrt(v_b_correction))

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70]: /images/20210923/da7c14a8929f45199bf4110e2fcf8630.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 1]: /images/20210923/b75fcd978a7846d0a14f42bc2af26a9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 2]: /images/20210923/3e89ad5300a44416a12f14ed30aaa65d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 3]: /images/20210923/80c237a353c34887b799b94549e1825f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 4]: /images/20210923/e4634b126da9459d8447bc70e0c0d63b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 5]: /images/20210923/9a0ad759ff44481a84322b03e9d5e446.png
[20210812000557809.png]: /images/20210923/b8414a1bf24f4e598c54f8899c38d737.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 6]: /images/20210923/a2bc687b90874a4f85d650f3a1c6314e.png
[20210812002820256.png]: /images/20210923/3a360af5a4544e30a8620d5f7ac19455.png
[2021081200430940.png]: /images/20210923/76e79b04687248c2957717eab52639fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 7]: /images/20210923/537957b98cde4a28b2f32b8e91ca306c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 8]: /images/20210923/3278f28ea3f14a1c968170d3ef39bee8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 9]: /images/20210923/58589f877611470e8ce1bad32a44cd2c.png
[L2]: https://blog.csdn.net/qq_41950447/article/details/119721223
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 10]: /images/20210923/620936bc23f745b4bc2eb4fbda74da1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 11]: /images/20210923/5da23bcb94d844ac91a42ccbf47550d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 12]: /images/20210923/da720c15fb184bf48dd6d4182bd8104c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 13]: /images/20210923/4a138ea213a549548c28dc26a692754f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 14]: /images/20210923/2ed9b02a300b41d383df0ad3a88a0061.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTUwNDQ3_size_16_color_FFFFFF_t_70 15]: /images/20210923/567d6e00bc7147d2847e5687289bf1a5.png