梯度 订阅
梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。 展开全文
梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。
信息
外文名
gradient
适用范围
数理科学
相关概念
方向导数
中文名
梯度
学    科
微积分学
性    质
向量
梯度定义
设二元函数 在平面区域D上具有一阶连续偏导数,则对于每一个点P(x,y)都可定出一个向量 ,该函数就称为函数 在点P(x,y)的梯度,记作gradf(x,y)或 ,即有:gradf(x,y)= = 其中 称为(二维的)向量微分算子或Nabla算子, 。设 是方向l上的单位向量,则 由于当方向l与梯度方向一致时,有 所以当l与梯度方向一致时,方向导数 有最大值,且最大值为梯度的模,即 因此说,函数在一点沿梯度方向的变化率最大,最大值为该梯度的模。 [1] 
收起全文
精华内容
下载资源
问答
  • 文章目录RNN 梯度消失&梯度爆炸1. 深层网络角度解释梯度消失和梯度爆炸2. 激活函数角度解释梯度消失和梯度爆炸3. RNN中的梯度消失和CNN的梯度消失有区别4. 梯度消失、爆炸的解决方案4.1 梯度爆炸的解决方案4.2 ...

    RNN 梯度消失&梯度爆炸

    参考:https://zhuanlan.zhihu.com/p/33006526?from_voters_page=true

    梯度消失和梯度爆炸本质是同一种情况。梯度消失经常出现的原因:一是使用深层网络;二是采用不合适的损失函数,如Sigmoid。梯度爆炸一般出现的场景:一是深层网络;二是权值初始化太大。

    1. 深层网络角度解释梯度消失和梯度爆炸

    深层网络由许多非线性层堆叠而来,每一层网络激活后的输出为 f i ( x ) f_{i}(x) fi(x),其中 i i i为第 i i i层, x x x是第 i i i层的输入,即第 i − 1 i-1 i1层的输出, f f f是激活函数,整个深层网络可视为一个复合的非线性多元函数:
    f i + 1 = f ( f i ∗ w i + b ) F ( x ) = f n ( . . . f 3 ( f 2 ( f 1 ( x ) ∗ w 1 + b ) ∗ w 2 + b ) . . . ) f_{i+1} = f(f_{i}*w_{i}+b) \\ F(x)=f_n(...f_3(f_2(f_1(x)*w_{1}+b)*w_{2}+b)...) fi+1=f(fiwi+b)F(x)=fn(...f3(f2(f1(x)w1+b)w2+b)...)
    目的是多元函数 F ( x ) F(x) F(x)完成输入到输出的映射,假设不同的输入,输出的最优解是g(x),则优化深层网络就是为了找到合适的权值,满足 L o s s = L ( g ( x ) , F ( x ) ) Loss=L(g(x),F(x)) Loss=L(g(x),F(x))取得极小值。

    BP 算法基于梯度下降策略,以负梯度方向对参数进行调整,参数更新:
    w ← w + Δ w Δ w = − α ∂ L o s s ∂ w Δ w 1 = ∂ L o s s ∂ w 2 = ∂ L o s s ∂ f n ∂ f n ∂ f n − 1 ∂ f n − 1 ∂ f n − 2 . . . ∂ f 3 ∂ f 2 ∂ f 2 ∂ w 2 ∂ f 2 ∂ w 2 = f 1 w\leftarrow w+\Delta{w} \\ \Delta{w} = -\alpha\frac{\partial{Loss}}{\partial{w}} \\ \Delta{w_1} = \frac{\partial Loss}{\partial w_2} = \frac{\partial Loss}{\partial f_n}\frac{\partial f_n}{\partial f_{n-1}}\frac{\partial f_{n-1}}{\partial f_{n-2}}... \frac{\partial f_{3}}{\partial f_{2}} \frac{\partial f_{2}}{\partial w_{2}} \\ \frac{\partial f_{2}}{\partial w_{2}}=f_1 ww+ΔwΔw=αwLossΔw1=w2Loss=fnLossfn1fnfn2fn1...f2f3w2f2w2f2=f1
    ∂ f n ∂ f n − 1 \frac{\partial f_n}{\partial f_{n-1}} fn1fn即对激活函数求导,如果此部分大于1,随着层数增加,梯度更新将以指数形式增加,即发生梯度爆炸;如果此部分小于1,随着层数增加,梯度更新将以指数形式衰减,即发生梯度消失。

    梯度消失、爆炸,其根本原因在于反向传播训练法则,链式求导次数太多。

    2. 激活函数角度解释梯度消失和梯度爆炸

    计算权值更新信息,需要计算前层偏导信息,因此激活函数选择不合适,比如Sigmoid,梯度消失会更明显。
    S i g m o i d ( x ) = 1 1 + e − x S i g m o i d ′ ( x ) = e − x ( 1 + e − x ) 2 = S i g m o i d ( x ) ( 1 − S i g m o i d ( x ) ) Sigmoid(x) = \frac{1}{1+e^{-x}}\\ Sigmoid'(x) = \frac{e^{-x}}{(1+e^{-x})^2} =Sigmoid(x)(1-Sigmoid(x)) Sigmoid(x)=1+ex1Sigmoid(x)=(1+ex)2ex=Sigmoid(x)(1Sigmoid(x))
    如果使用sigmoid作为损失函数,其梯度是不可能超过0.25的,这样经过链式求导之后,很容易发生梯度消失。

    在这里插入图片描述

    tanh作为损失函数,它的导数图如下,可以看出,tanh比sigmoid要好一些,但是它的导数仍然是小于1的。
    t a n h ( x ) = s i n h ( x ) c o s h ( x ) = e x − e − x e x + e − x t a n h ′ ( x ) = 1 − ( e x − e − x ) 2 ( e x + e − x ) 2 = 1 − t a n h 2 ( x ) tanh(x) = \frac{sinh(x)}{cosh(x)}=\frac{e^{x}-e^{-x}}{e^{x}+e^{-x}}\\ tanh'(x) = 1-\frac{(e^{x}-e^{-x})^2}{(e^{x}+e^{-x})^2} = 1-tanh^2(x) tanh(x)=cosh(x)sinh(x)=ex+exexextanh(x)=1(ex+ex)2(exex)2=1tanh2(x)
    在这里插入图片描述

    由于sigmoid和tanh存在上述的缺点,因此relu激活函数成为了大多数神经网络的默认选择。relu函数的导数在正数部分是恒等于1,因此在深层网络中就不存在梯度消失/爆炸的问题,每层网络都可以得到相同的更新速度。另外计算方便,计算速度快,加速网络的训练。

    但是relu也存在缺点:即在 x x x小于0时,导数为0,导致一些神经元无法激活。输出不是以0为中心的。因此引申出下面的leaky relu函数,但是实际上leaky relu使用的并不多。
    R E L U ( x ) = m a x ( 0 , x ) L e a k y R E L U ( x ) = m a x ( 0.01 x , x ) RELU(x)=max(0,x)\\ Leaky RELU(x) =max(0.01x,x) RELU(x)=max(0,x)LeakyRELU(x)=max(0.01x,x)
    在这里插入图片描述

    在这里插入图片描述

    3. RNN中的梯度消失和CNN的梯度消失有区别

    RNN中的梯度消失/爆炸和MLP/CNN中的梯度消失/爆炸含义不同:MLP/CNN中不同的层有不同的参数,各是各的梯度;而 RNN 中同样的权重在各个时间步共享,最终的梯度 g 等于各个时间步的梯度 g t g_t gt 的和。

    • RNN中的总的梯度不会消失。即便梯度越传越弱,那也只是远距离的梯度消失,由于近距离的梯度不会消失,所有梯度之和并不会消失。RNN 所谓梯度消失的真正含义是,梯度被近距离梯度主导,导致模型难以学到远距离的依赖关系。

      在这里插入图片描述

      RNN前向传导过程:
      t = 1 s 1 = g ( U x 1 + W s 0 ) o 1 = f ( V g ( U x 1 + W s 0 ) ) t = 2 s 2 = g ( U x 2 + W s 1 ) o 2 = f ( V g ( U x 2 + W s 1 ) ) = f ( V g ( U x 2 + W g ( U x 1 + W s 0 ) ) ) t = 3 s 3 = g ( U x 3 + W s 2 ) o 3 = f ( V g ( U x 3 + W s 2 ) ) = f ( V g ( U x 3 + W g ( U x 2 + W ( U x 1 + W s 0 ) ) ) ) . . . t = m . . . L o s s = L ( o m , y ) ∂ L ∂ U = ∂ L ∂ o m ∂ o m ∂ s m ∂ s m ∂ U + ∂ L ∂ o m ∂ o m ∂ s m ∂ s m ∂ s m − 1 ∂ s m − 1 ∂ U + . . . + ∂ L ∂ o m ∂ o m ∂ s m ∂ s m ∂ s m − 1 . . . ∂ s 2 ∂ s 1 ∂ s 1 ∂ U = ∑ t = 1 m ∂ L ∂ o m ∂ o m ∂ s m ( ∏ j = t + 1 m ∂ s j ∂ s j − 1 ) ∂ s t ∂ U \begin{aligned} t &= 1 \\ s_1 &= g(Ux_1 + Ws_{0})\\ o_1 &= f(Vg(Ux_1 + Ws_{0}))\\ t &= 2 \\ s_2 &= g(Ux_2 + Ws_{1})\\ o_2 &= f(Vg(Ux_2 + Ws_{1})) =f(Vg(Ux_2 + Wg(Ux_1 + Ws_{0})))\\ t &= 3 \\ s_3 &= g(Ux_3 + Ws_{2})\\ o_3 &= f(Vg(Ux_3 + Ws_{2})) = f(Vg(Ux_3 + Wg(Ux_2 + W(Ux_1 + Ws_{0}))))\\ ...\\ t &= m \\ ...\\ Loss &= L(o_m,y)\\ \frac{\partial L}{\partial U} &= \frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\frac{\partial s_m}{\partial U} + \frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\frac{\partial s_m}{\partial s_{m-1}}\frac{\partial s_{m-1}}{\partial U}+...+ \frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\frac{\partial s_m}{\partial s_{m-1}}...\frac{\partial s_{2}}{\partial s_{1}}\frac{\partial s_{1}}{\partial U}\\ &= \sum_{t=1}^{m}\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\left(\prod_{j=t+1}^{m}\frac{\partial s_{j}}{\partial s_{j-1}}\right)\frac{\partial s_t}{\partial U} \end{aligned} ts1o1ts2o2ts3o3...t...LossUL=1=g(Ux1+Ws0)=f(Vg(Ux1+Ws0))=2=g(Ux2+Ws1)=f(Vg(Ux2+Ws1))=f(Vg(Ux2+Wg(Ux1+Ws0)))=3=g(Ux3+Ws2)=f(Vg(Ux3+Ws2))=f(Vg(Ux3+Wg(Ux2+W(Ux1+Ws0))))=m=L(om,y)=omLsmomUsm+omLsmomsm1smUsm1+...+omLsmomsm1sm...s1s2Us1=t=1momLsmom(j=t+1msj1sj)Ust

      当激活函数为tanh, s t = t a n h ( U x t + W s t − 1 ) s_t = tanh(Ux_t + Ws_{t-1}) st=tanh(Uxt+Wst1)

      权值梯度:
      L o s s = ∑ t = 1 m ∂ L ∂ o m ∂ o m ∂ s m ( ∏ j = t + 1 m ∂ s j ∂ s j − 1 ) ∂ s t ∂ U = ∑ t = 1 m ∂ L ∂ o m ∂ o m ∂ s m ( ∏ j = t + 1 m t a n h ′ W ) ∂ s t ∂ U \begin{aligned} Loss &= \sum_{t=1}^{m}\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\left(\prod_{j=t+1}^{m}\frac{\partial s_{j}}{\partial s_{j-1}}\right)\frac{\partial s_t}{\partial U}\\ &= \sum_{t=1}^{m}\frac{\partial L}{\partial o_m}\frac{\partial o_m}{\partial s_m}\left(\prod_{j=t+1}^{m}tanh'W \right)\frac{\partial s_t}{\partial U} \end{aligned} Loss=t=1momLsmom(j=t+1msj1sj)Ust=t=1momLsmom(j=t+1mtanhW)Ust

    • MLP/CNN 的梯度消失:主要是随着网络加深,浅层网络的梯度越来越小,导致参数无法更新迭代。

    4. 梯度消失、爆炸的解决方案

    在深度神经网络中,往往是梯度消失出现的更多一些。

    4.1 梯度爆炸的解决方案

    1. 梯度裁剪:主要思想是设置一个梯度剪切阈值,然后更新梯度的时候,如果梯度超过这个阈值,那么就将其强制限制在这个范围之内。这可以防止梯度爆炸。

    2. 权值正则化(weithts regularization):正则化是通过对网络权重做正则限制过拟合,如下正则项在损失函数中的形式:
      L o s s = ( y − W T x ) 2 + α ∣ ∣ W ∣ ∣ 2 Loss = (y-W^Tx)^2+\alpha||W||^2 Loss=(yWTx)2+αW2
      常见的是L1正则和L2正则,在各个深度框架中都有相应的API可以使用正则化。

      其中, α \alpha α是指正则项系数,因此,如果发生梯度爆炸,权值的范数就会变的非常大,通过正则化项,可以部分限制梯度爆炸的发生。

    4.2 梯度消失的解决方案

    4.2.1 选择relu、leakrelu、elu等激活函数

    • relu函数的导数在正数部分是恒等于1的,因此在深层网络中不会导致梯度消失和爆炸的问题。relu优点:解决了梯度消失、爆炸的问题,计算速度快,加速网络训练。relu缺点:导数的负数部分恒为0,会导致一些神经元无法激活(可通过设置小学习率部分解决),输出不是以0为中心的。

    • leakrelu就是为了解决relu的0区间带来的影响。数学表达: l e a k r e l u = m a x ( x ∗ k , x ) leakrelu=max(x*k,x) leakrelu=max(xk,x)

      其中k是leak系数,一般选择0.1或者0.2,或者通过学习而来。leakrelu解决了0区间带来的影响,而且包含了relu的所有优点。

    在这里插入图片描述

    • elu也是为了解决relu的0区间带来的影响,其数学表达为:

      e l u ( x ) = { x , if  x > 0 α ( e x − 1 ) , otherwise elu(x) = \begin{cases} x, & \text{if }x>0\\ \alpha(e^x-1), & \text{otherwise} \end{cases} elu(x)={x,α(ex1),if x>0otherwise
      但是elu相对于leakrelu来说,计算要更耗时间一些。

    4.2.2 使用Batchnorm(batch normalization,简称BN):

    目前已经被广泛的应用到了各大网络中,具有加速网络收敛速度,提升训练稳定性的效果,Batchnorm本质上是解决反向传播过程中的梯度问题。通过规范化操作将输出信号x规范化到均值为0,方差为1保证网络的稳定性。 具体来说就是反向传播中,经过每一层的梯度会乘以该层的权重,举个简单例子: 正向传播中 f 3 = f 2 ( w T x + b ) f_3=f_2(w^Tx+b) f3=f2(wTx+b) ,那么反向传播中, ∂ f 2 ∂ x = ∂ f 2 ∂ f 1 w \frac{\partial f_2}{\partial x}=\frac{\partial f_2}{\partial f_1}w xf2=f1f2w, 反向传播式子中有 w w w 的存在,所以 w w w 的大小影响了梯度的消失和爆炸,batchnorm就是通过对每一层的输出做scale和shift的方法,通过一定的规范化手段,把每层神经网络任意神经元这个输入值的分布强行拉回到接近均值为0方差为1的标准正太分布,即严重偏离的分布强制拉回比较标准的分布,这样使得激活输入值落在非线性函数对输入比较敏感的区域,这样输入的小变化就会导致损失函数较大的变化,使得让梯度变大,避免梯度消失问题产生,而且梯度变大意味着学习收敛速度快,能大大加快训练速度。

    4.2.3 残差结构:

    残差单元里的shortcut(捷径)部分可以保证在反向传播中梯度不会消失。

    ∂ L o s s ∂ x l = ∂ L o s s ∂ x L ∂ x L ∂ x l = ∂ L o s s ∂ x L ( 1 + ∂ ∂ x L ∑ i = l L − 1 F ( x i , W i ) ) \frac{\partial Loss}{\partial x_l}=\frac{\partial Loss}{\partial x_L}\frac{\partial x_L}{\partial x_l}=\frac{\partial Loss}{\partial x_L}\left(1+\frac{\partial }{\partial x_L}\sum_{i=l}^{L-1}F(x_i,W_i)\right) xlLoss=xLLossxlxL=xLLoss(1+xLi=lL1F(xi,Wi))
    式子的第一个因子 ∂ L o s s ∂ x L \frac{\partial Loss}{\partial x_L} xLLoss表示的损失函数到达 L 层的梯度,小括号中的1表明短路机制可以无损地传播梯度,而另外一项残差梯度则需要经过带有weights的层,梯度不是直接传递过来的。残差梯度不会那么巧全为-1,而且就算其比较小,有1的存在也不会导致梯度消失。所以残差学习会更容易。

    在这里插入图片描述

    4.2.4 LSTM:

    使用LSTM(long-short term memory networks,长短期记忆网络),就不那么容易发生梯度消失,主要原因在于LSTM内部复杂的“门”(gates),如下图,LSTM通过它内部的“门”可以在更新的时候“记住”前几次训练的“残留记忆”,因此,经常用于生成文本中。

    在这里插入图片描述

    5. 参考

    RNN

    • https://zybuluo.com/hanbingtao/note/541458
    • https://colab.research.google.com/drive/1Zfvt9Vfs3PrJwSDF8jMvomz7CzU36RXk

    LSTM

    • http://colah.github.io/posts/2015-08-Understanding-LSTMs/
    • https://www.youtube.com/watch?v=9zhrxE5PQgY&feature=youtu.be
    • https://towardsdatascience.com/illustrated-guide-to-lstms-and-gru-s-a-stepby-step-explanation-44e9eb85bf21
    • https://medium.com/datadriveninvestor/how-do-lstm-networks-solve-theproblem-of-vanishing-gradients-a6784971a577
    展开全文
  • TensorFlow2 手把手教你避开梯度消失和梯度爆炸

    千次阅读 多人点赞 2021-06-11 10:25:34
    TensorFlow2 手把手教你避开梯度消失和梯度爆炸.

    梯度消失 & 梯度爆炸

    在这里插入图片描述
    输出结果:

    vanish: 0.025517964452291125
    explode: 37.78343433288728
    

    梯度消失

    梯度消失问题 (Vanishing gradient problem). 如果导数小于 1, 随着网络层数的增加梯度跟新会朝着指数衰减的方向前进, 这就是梯度消失.

    在这里插入图片描述
    当导数小于 1 的时候, 层数越多, 梯度就越小, 即梯度消失.

    梯度爆炸

    梯度爆炸问题 (Exploding gradient problem). 如果导数大于 1, 随着网络层数的增加梯度跟新会朝着指数增加的方向前进, 这就是梯度爆炸.
    在这里插入图片描述
    当导数大于 1 的时候, 层数越多, 梯度就越大, 即梯度爆炸.

    张量限幅

    通过张量限幅, 我们可以有效解决梯度爆炸问题.

    在这里插入图片描述

    tf.clip_by_value

    我们可以通过tf.clip_by_value函数来实现张量限幅.

    格式:

    tf.clip_by_value(
        t, clip_value_min, clip_value_max, name=None
    )
    

    参数:

    • t: 传入的张量
    • clip_value_min: 下限
    • clip_value_max: 上限
    • name: 数据名称

    例子:

    # clip_by_value
    a = tf.range(10)
    print(a)
    
    b = tf.maximum(a, 2)
    print(b)
    
    c = tf.minimum(a, 8)
    print(c)
    
    d = tf.clip_by_value(a, 2, 8)
    print(d)
    

    输出结果:

    tf.Tensor([0 1 2 3 4 5 6 7 8 9], shape=(10,), dtype=int32)
    tf.Tensor([2 2 2 3 4 5 6 7 8 9], shape=(10,), dtype=int32)
    tf.Tensor([0 1 2 3 4 5 6 7 8 8], shape=(10,), dtype=int32)
    tf.Tensor([2 2 2 3 4 5 6 7 8 8], shape=(10,), dtype=int32)
    

    tf.clip_by_norm

    tf.clip_by_norm可以对梯度进行裁剪, 防止梯度爆炸.

    格式:

    tf.clip_by_norm(
        t, clip_norm, axes=None, name=None
    )
    

    参数:

    • t: 传入的张量
    • clip_norm: 定义最大限幅
    • axes: 计算尺寸
    • name: 数据名称

    例子:

    # clip_by_normal
    a = tf.random.normal([2, 2], mean=10)
    print(a)
    print(tf.norm(a))  # 范数
    
    b = tf.clip_by_norm(a, 15)
    print(b)
    print(tf.norm(b))  # 范数
    

    输出结果:

    tf.Tensor(
    [[ 9.33037  10.703022]
     [ 9.788097  9.713704]], shape=(2, 2), dtype=float32)
    tf.Tensor(19.793266, shape=(), dtype=float32)
    tf.Tensor(
    [[7.070867  8.111109 ]
     [7.417748  7.3613706]], shape=(2, 2), dtype=float32)
    tf.Tensor(15.0, shape=(), dtype=float32)
    

    mnist 展示梯度爆炸

    为了实现梯度爆炸, 我们把学习率设为 0.1.

    完整代码

    # 读取训练集的特征值和目标值
    (x, y), _ = tf.keras.datasets.mnist.load_data()
    
    # 转换为0~1的形式
    x = tf.convert_to_tensor(x, dtype=tf.float32) / 255
    
    # 转换成one_hot编码
    y = tf.one_hot(y, depth=10)
    
    # 批次分割
    train_db = tf.data.Dataset.from_tensor_slices((x, y)).batch(256).repeat(30)
    
    
    def main():
        # 生成w1形状为[784, 512]的截断正态分布, 中心为0, 标差为0.1
        w1 = tf.Variable(tf.random.truncated_normal([784, 512], stddev=0.1))
    
        # 生成b1形状为[512]初始化为0
        b1 = tf.Variable(tf.zeros([512]))
    
        # 生成w2形状为[512, 256]的截断正态分布, 中心为0, 标差为0.1
        w2 = tf.Variable(tf.random.truncated_normal([512, 256], stddev=0.1))
    
        # 生成b2形状为[256]初始化为0
        b2 = tf.Variable(tf.zeros([256]))
    
        # 生成w3形状为[256, 10]的截断正态分布, 中心为0, 标差为0.1
        w3 = tf.Variable(tf.random.truncated_normal([256, 10], stddev=0.1))
    
        # 生成b3形状为[10]初始化为0
        b3 = tf.Variable(tf.zeros([10]))
    
        # 优化器
        optimizer = tf.keras.optimizers.SGD(learning_rate=0.1)  # 梯度下降
    
        for step, (x, y) in enumerate(train_db):
    
            # 把x平铺 [256, 28, 28] => [256, 784]
            x = tf.reshape(x, [-1, 784])
    
            with tf.GradientTape() as tape:
    
                # 第一个隐层
                h1 = x @ w1 + b1
                h1 = tf.nn.relu(h1)  # 激活
    
                # 第二个隐层
                h2 = h1 @ w2 + b2
                h2 = tf.nn.relu(h2)  # 激活
    
                # 输出层
                out = h2 @ w3 + b3
    
                # 计算损失函数
                loss = tf.square(y - out)
                loss = tf.reduce_mean(loss)
    
                # 计算梯度
                grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])
    
                # 调试输出剪切前的范数
                print("================before===============")
                for g in grads:
                    print(tf.norm(g))
    
                grads, _ = tf.clip_by_global_norm(grads, 15)
    
                # 调试输出剪切后的范数
                print("================after===============")
                for g in grads:
                    print(tf.norm(g))
    
                optimizer.apply_gradients(zip(grads, [w1, b1, w2, b2, w3, b3]))  # 跟新权重
    
    
    if __name__ == '__main__':
        main()
    

    输出结果

    ================before===============
    tf.Tensor(5.5961547, shape=(), dtype=float32)
    tf.Tensor(0.87258744, shape=(), dtype=float32)
    tf.Tensor(7.397964, shape=(), dtype=float32)
    tf.Tensor(0.69156337, shape=(), dtype=float32)
    tf.Tensor(9.840232, shape=(), dtype=float32)
    tf.Tensor(0.8157242, shape=(), dtype=float32)
    ================after===============
    tf.Tensor(5.5961547, shape=(), dtype=float32)
    tf.Tensor(0.87258744, shape=(), dtype=float32)
    tf.Tensor(7.397964, shape=(), dtype=float32)
    tf.Tensor(0.69156337, shape=(), dtype=float32)
    tf.Tensor(9.840232, shape=(), dtype=float32)
    tf.Tensor(0.8157242, shape=(), dtype=float32)
    ================before===============
    tf.Tensor(18.01539, shape=(), dtype=float32)
    tf.Tensor(2.9375393, shape=(), dtype=float32)
    tf.Tensor(21.330334, shape=(), dtype=float32)
    tf.Tensor(2.1504176, shape=(), dtype=float32)
    tf.Tensor(21.820374, shape=(), dtype=float32)
    tf.Tensor(2.0918982, shape=(), dtype=float32)
    ================after===============
    tf.Tensor(7.5730414, shape=(), dtype=float32)
    tf.Tensor(1.2348388, shape=(), dtype=float32)
    tf.Tensor(8.966527, shape=(), dtype=float32)
    tf.Tensor(0.90396047, shape=(), dtype=float32)
    tf.Tensor(9.172523, shape=(), dtype=float32)
    tf.Tensor(0.8793609, shape=(), dtype=float32)
    ================before===============
    tf.Tensor(0.5821787, shape=(), dtype=float32)
    tf.Tensor(0.0859229, shape=(), dtype=float32)
    tf.Tensor(0.7110027, shape=(), dtype=float32)
    tf.Tensor(0.082481824, shape=(), dtype=float32)
    tf.Tensor(0.51846975, shape=(), dtype=float32)
    tf.Tensor(0.1655324, shape=(), dtype=float32)
    ================after===============
    tf.Tensor(0.5821787, shape=(), dtype=float32)
    tf.Tensor(0.0859229, shape=(), dtype=float32)
    tf.Tensor(0.7110027, shape=(), dtype=float32)
    tf.Tensor(0.082481824, shape=(), dtype=float32)
    tf.Tensor(0.51846975, shape=(), dtype=float32)
    tf.Tensor(0.1655324, shape=(), dtype=float32)
    
    ... ...
    
    展开全文
  • 梯度算法之梯度上升和梯度下降方向导数当讨论函数沿任意方向的变化率时,也就引出了方向导数的定义,即:某一点在某一趋近方向上的导数值。导数和偏导数的定义中,均是沿坐标轴正方向讨论函数的变化率。那么当讨论...

    梯度算法之梯度上升和梯度下降

    方向导数

    当讨论函数沿任意方向的变化率时,也就引出了方向导数的定义,即:某一点在某一趋近方向上的导数值。

    f0b2264b221bdfa0ae72d67a3a88fda5.png

    导数和偏导数的定义中,均是沿坐标轴正方向讨论函数的变化率。那么当讨论函数沿任意方向的变化率时,也就引出了方向导数的定义,即:某一点在某一趋近方向上的导数值。

    通俗的解释是: 我们不仅要知道函数在坐标轴正方向上的变化率(即偏导数),而且还要设法求得函数在其他特定方向上的变化率。而方向导数就是函数在其他特定方向上的变化率。

    梯度

    e499ba83c9febaecf6561deecf1ff99b.png

    100d756b3b9d8d65cdcb1460a9fed79c.png

    函数在某一点的梯度是这样一个向量,它的方向与取得最大方向导数的方向一致,而它的模为方向导数的最大值。

    注意点:

    1)梯度是一个向量

    2)梯度的方向是最大方向导数的方向

    3)梯度的值是最大方向导数的值

    梯度下降与梯度上升

    在机器学习算法中,在最小化损失函数时,可以通过梯度下降思想来求得最小化的损失函数和对应的参数值,反过来,如果要求最大化的损失函数,可以通过梯度上升思想来求取。

    梯度下降

    关于梯度下降的几个概念

    82b1902053d5bfe1fc3846a9088f8191.png

    梯度下降的代数方法描述

    3cd948afc1bcb6bf52823ae9aa445a7c.png

    8365ead2f084e15d08f901159a7555df.png

    梯度下降的矩阵方式描述

    b90c6c796a7b7d78c18fd5f91c4efdfa.png

    970e09de00e406b6f07868d8502206b0.png

    梯度上升

    梯度上升和梯度下降的分析方式是一致的,只不过把 θθ 的更新中 减号变为加号。

    梯度下降的算法优化

    算法的步长选择。在前面的算法描述中,我提到取步长为1,但是实际上取值取决于数据样本,可以多取一些值,从大到小,分别运行算法,看看迭代效果,如果损失函数在变小,说明取值有效,否则要增大步长。前面说了。步长太大,会导致迭代过快,甚至有可能错过最优解。步长太小,迭代速度太慢,很长时间算法都不能结束。所以算法的步长需要多次运行后才能得到一个较为优的值。

    算法参数的初始值选择。 初始值不同,获得的最小值也有可能不同,因此梯度下降求得的只是局部最小值;当然如果损失函数是凸函数则一定是最优解。由于有局部最优解的风险,需要多次用不同初始值运行算法,关键损失函数的最小值,选择损失函数最小化的初值。

    归一化。由于样本不同特征的取值范围不一样,可能导致迭代很慢,为了减少特征取值的影响,可以对特征数据归一化,也就是对于每个特征x,求出它的均值 x¯和标准差std(x),然后转化为:

    d039e2e4ac3ca6284dcefadf9bf1f8d8.png

    这样特征的新期望为0,新方差为1,迭代次数可以大大加快。

    梯度算法之批量梯度下降,随机梯度下降和小批量梯度下降

    在机器学习领域,体梯度下降算法分为三种

    批量梯度下降算法(BGD,Batch gradient descent algorithm)

    随机梯度下降算法(SGD,Stochastic gradient descent algorithm)

    小批量梯度下降算法(MBGD,Mini-batch gradient descent algorithm)

    批量梯度下降算法

    BGD是最原始的梯度下降算法,每一次迭代使用全部的样本,即权重的迭代公式中(公式中用θ代替θi),

    64a053e5e2ebf4999795f7cfe12cca6c.png

    这里的m代表所有的样本,表示从第一个样本遍历到最后一个样本。

    特点:

    能达到全局最优解,易于并行实现

    当样本数目很多时,训练过程缓慢

    随机梯度下降算法

    SGD的思想是更新每一个参数时都使用一个样本来进行更新,即公式(1)中m为1。每次更新参数都只使用一个样本,进行多次更新。这样在样本量很大的情况下,可能只用到其中的一部分样本就能得到最优解了。

    但是,SGD伴随的一个问题是噪音较BGD要多,使得SGD并不是每次迭代都向着整体最优化方向。

    特点:

    训练速度快

    准确度下降,并不是最优解,不易于并行实现

    小批量梯度下降算法

    MBGD的算法思想就是在更新每一参数时都使用一部分样本来进行更新,也就是公式(1)中的m的值大于1小于所有样本的数量。

    相对于随机梯度下降,Mini-batch梯度下降降低了收敛波动性,即降低了参数更新的方差,使得更新更加稳定。相对于批量梯度下降,其提高了每次学习的速度。并且其不用担心内存瓶颈从而可以利用矩阵运算进行高效计算。一般而言每次更新随机选择[50,256]个样本进行学习,但是也要根据具体问题而选择,实践中可以进行多次试验,选择一个更新速度与更次次数都较适合的样本数。mini-batch梯度下降可以保证收敛性,常用于神经网络中。

    补充

    在样本量较小的情况下,可以使用批量梯度下降算法,样本量较大的情况或者线上,可以使用随机梯度下降算法或者小批量梯度下降算法。

    在机器学习中的无约束优化算法,除了梯度下降以外,还有前面提到的最小二乘法,此外还有牛顿法和拟牛顿法。

    梯度下降法和最小二乘法相比,梯度下降法需要选择步长,而最小二乘法不需要。梯度下降法是迭代求解,最小二乘法是计算解析解。如果样本量不算很大,且存在解析解,最小二乘法比起梯度下降法要有优势,计算速度很快。但是如果样本量很大,用最小二乘法由于需要求一个超级大的逆矩阵,这时就很难或者很慢才能求解解析解了,使用迭代的梯度下降法比较有优势。

    梯度下降法和牛顿法/拟牛顿法相比,两者都是迭代求解,不过梯度下降法是梯度求解,而牛顿法/拟牛顿法是用二阶的海森矩阵的逆矩阵或伪逆矩阵求解。相对而言,使用牛顿法/拟牛顿法收敛更快。但是每次迭代的时间比梯度下降法长。

    参考资料:

    展开全文
  • 梯度下降——R语言

    2021-08-01 15:20:02
    Gradient Descent一、梯度下降1. 一元梯度下降1> 绘制方程的图像2> 梯度下降3> 修改 θ\thetaθ2. 多元梯度下降二、梯度下降&线性回归1. 批量梯度下降法(BGD)1> R语言编写2> R自带的线性回归2. ...

    一、梯度下降

    ​ 梯度的本意是一个向量(矢量),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)。
    g r a d f ( x 1 , x 2 , ⋅ ⋅ ⋅ , x n ) = ∇ f ( x 1 , x 2 , ⋅ ⋅ ⋅ , x n ) = { ∂ f ∂ x 1 , ∂ f ∂ x 2 , ⋅ ⋅ ⋅ , ∂ f ∂ x n } gradf(x_1,x_2,···,x_n) = \nabla f(x_1,x_2,···,x_n) = \{ \frac{\partial f}{\partial x_1},\frac{\partial f}{\partial x_2},···,\frac{\partial f}{\partial x_n}\} gradf(x1,x2,,xn)=f(x1,x2,,xn)={x1f,x2f,xnf}
    ​ 思想:寻找最小值

    1. 一元梯度下降

    y = ( x − 2.5 ) 2 − 1 d y d x = 2 ∗ ( x − 2.5 ) y = (x-2.5)^2 - 1 \\ \frac{dy}{dx} = 2*(x-2.5) y=(x2.5)21dxdy=2(x2.5)

    1> 绘制方程的图像

    plot_x <- seq(-1, 6, 0.05)
    plot_y <- (plot_x-2.5) ^ 2 - 1
    
    par(lwd = 3)
    plot(plot_x, plot_y, lty = 1, type = 'l', col = 'blue')
    

    请添加图片描述

    2> 梯度下降

    请添加图片描述

    ​ 取得极值的必要条件: f ′ = 0 f' = 0 f=0
    ∀ η > 0 , ∃ δ > 0 → w h e n   0 < ∣ △ x ∣ < δ , ∣ f ( x + △ x ) − f ( x ) ∣ < η θ n e w = θ o l d − η ∗ f ′ ( θ ) \forall \eta>0, \exist \delta>0 \\ \rightarrow \\when\ 0<|\triangle x|<\delta, |f(x+\triangle x)-f(x)|<\eta\\ \theta_{new} = \theta_{old} - \eta *f'(\theta) η>0,δ>0when 0<x<δ,f(x+x)f(x)<ηθnew=θoldηf(θ)

    dY <- function(theta){
      return(2*(theta - 2.5))
    }
    
    Y <- function(theta){
      return((theta - 2.5)^2 - 1)
    }
    
    
    eta <- 0.1
    epsilon <- 1e-8
    theta <- 0.0
    theta_history <-  vector()
    i = 1
    while(TRUE){
      theta_history[i] = theta
      gradient = dJ(theta)
      last_theta = theta
      theta = theta - eta * gradient
      i <- i+1
      
      if (abs(J(theta) - J(last_theta)) < epsilon){
        break
      }
    }
    
    '''
    + theta
      [1] 2.499891
    + J(theta)
      [1] -1
    '''
    
    plot(plot_x, J(plot_x), lty = 1, type = 'l', col = 'blue', lwd = 3)
    lines(theta_history, J(theta_history), type = 'o', col = 'red', pch = 16, lty = 1, lwd = 2)
    

    请添加图片描述

    3> 修改 θ \theta θ

    gradient_descent <- function(eta = 0.1, epsilon = 1e-8, theta = 0.0){
    theta_history <-  vector()
    i = 1
    while(TRUE){
      theta_history[i] = theta
      gradient = dJ(theta)
      last_theta = theta
      theta = theta - eta * gradient
      i <- i+1
      
      if (abs(J(theta) - J(last_theta)) < epsilon){
        break
      }
    }
    
    plot(plot_x, J(plot_x), lty = 1, type = 'l', col = 'blue', lwd = 3)
    lines(theta_history, J(theta_history), type = 'o', col = 'red', pch = 16, lty = 1, lwd = 2)
    }
    
    gradient_descent(eta = 0.01)
    

    请添加图片描述

    gradient_descent(eta = 0.8)
    

    请添加图片描述

    gradient_descent(eta = 1.1)
    
    
    '''
    Error in if (abs(J(theta) - J(last_theta)) < epsilon) { : 
      missing value where TRUE/FALSE needed
    '''
    
    
    eta <- 1.1
    epsilon <- 1e-8
    theta <- 0.0
    theta_history <-  vector()
    i = 1
    while(TRUE){
      theta_history[i] = theta
      gradient = dJ(theta)
      last_theta = theta
      theta = theta - eta * gradient
      i <- i+1
      
      if (i > 100){
        break
      }
    }
    
    plot(plot_x, J(plot_x), lty = 1, type = 'l', col = 'blue', lwd = 3, xlim = c(-8,15), ylim = c(0,100))
    lines(theta_history, J(theta_history), type = 'o', col = 'red', pch = 16, lty = 1, lwd = 2)
    

    请添加图片描述

    2. 多元梯度下降

    请添加图片描述

    ​ 取得极值的必要条件: ∇ f = 0 \nabla f = 0 f=0
    ∀ η > 0 , ∃ δ > 0 → w h e n   0 < ∣ △ x ∣ < δ , ∣ f ( x + △ x ) − f ( x ) ∣ < η θ n e w = θ o l d − η ∗ ∇ \forall \eta>0, \exist \delta>0 \\ \rightarrow \\when\ 0<|\triangle x|<\delta, |f(x+\triangle x)-f(x)|<\eta\\ \theta_{new} = \theta_{old} - \eta *\nabla η>0,δ>0when 0<x<δ,f(x+x)f(x)<ηθnew=θoldη

    二、梯度下降&线性回归

    1. 批量梯度下降法(BGD)

    ​ 多元线性回归的最小化问题:

    J = a r g m i n ( ∑ 1 n ( y − y ^ ) 2 ) = a r g m i n ( Y − X β ^ ) ′ ( Y − X β ^ ) ∂ J ∂ β ^ = 2 X ′ ( X β ^ − Y ) J = argmin(\sum_{1}^n(y - \hat{y})^2)=argmin(Y-X\hat \beta)'(Y-X\hat \beta) \\ \frac{\partial J}{\partial \hat \beta} = 2X'(X\hat\beta-Y) J=argmin(1n(yy^)2)=argmin(YXβ^)(YXβ^)β^J=2X(Xβ^Y)
    ​ Modify:
    J = a r g m i n 1 2 n ( ∑ 1 n ( y − y ^ ) 2 ) = a r g m i n 1 2 n ( Y − X β ^ ) ′ ( Y − X β ^ ) ∂ J ∂ β ^ = 1 n X ′ ( X β ^ − Y ) J = argmin\frac{1}{2n}(\sum_{1}^n(y - \hat{y})^2)=argmin\frac{1}{2n}(Y-X\hat \beta)'(Y-X\hat \beta) \\ \frac{\partial J}{\partial \hat \beta} = \frac{1}{n}X'(X\hat\beta-Y) J=argmin2n1(1n(yy^)2)=argmin2n1(YXβ^)(YXβ^)β^J=n1X(Xβ^Y)

    1> R语言编写

    首先先建立一个样本,样本如图所示。

    J <- function(beta, X_b, y){
      return(sum((y-X_b%*%beta)^2)/(2*dim(X_b)[1]))
    }
    
    dJ <- function(beta, X_b, y){
      return(2*t(X_b)%*%(X_b%*%beta - y)/(2*dim(X_b)[1]))
    }
    
    gradient_descent <- function(X_b, y, initial_beta, eta, n_iters = 1e4, epsilon = 1e-4){
      beta = initial_beta
      i_iter = 0
      
      while (i_iter < n_iters){
      gradient = dJ(beta, X_b, y)
      last_beta = beta
      beta = beta - eta * gradient
      
      if (abs(J(beta, X_b, y) - J(last_beta, X_b, y)) < epsilon){
        break
      }
      i_iter = 1 + i_iter
    }
      return(beta)
    }
    

    请添加图片描述

    n <- 200
    x_1 <- runif(n, 0, 2)
    y = x_1 * 3. + 4. + runif(n)
    plot(x_1,y)
    
    x_0 <- rep(1, n)
    
    x <- cbind(x_0, x_1)
    
    initial_theta <- c(0,0)
    eta = 0.1
    theta = gradient_descent(x, y,initial_theta ,eta)
    theta
    
    '''
    > theta
            [,1]
    x_0 4.407078
    x_1 3.062182
    '''
    

    2> R自带的线性回归

    fit <- lm(y~x_1)
    summary(fit)
    
    '''
    Coefficients:
                Estimate Std. Error t value Pr(>|t|)
    (Intercept)  4.57461    0.04038  113.28   <2e-16
    x_1          2.91995    0.03498   83.48   <2e-16
    '''
    

    2. 随机梯度下降(SGD)

    观察一下gradient
    ∇ J = ∂ J ∂ β ^ = 1 n X ′ ( X β ^ − Y ) = 1 n [ ∑ i = 1 n ( Y i − X i β ) ∑ i = 1 n ( Y i − X i β ) ( X i 1 ) ⋅ ⋅ ⋅ ⋅ ⋅ ∑ i = 1 n ( Y i − X i β ) ( X i ( k − 1 ) ) ] \nabla J = \frac{\partial J}{\partial \hat \beta} = \frac{1}{n}X'(X\hat\beta-Y) = \frac{1}{n} \begin{bmatrix} \sum_{i = 1}^n (Y_i - X_i\beta) \\ \sum_{i = 1}^n (Y_i - X_i\beta)(X_{i1}) \\ ····· \\ \sum_{i = 1}^n (Y _i- X_i\beta)(X_{i(k-1)}) \end{bmatrix} J=β^J=n1X(Xβ^Y)=n1i=1n(YiXiβ)i=1n(YiXiβ)(Xi1)i=1n(YiXiβ)(Xi(k1))
    ∇ J \nabla J J 中的每一个分量都要经过n次的矩阵运算然后求和,这时候梯度的计算量就变的十分巨大,所以SGD的思想随即被提出。

    1> SGD的思路

    M o d i f i e d   ∇ J : Modified\ \nabla J: Modified J:
    1 n [ ∑ i = 1 n ( Y i − X i β ) ∑ i = 1 n ( Y i − X i β ) ( X i 1 ) ⋅ ⋅ ⋅ ⋅ ⋅ ∑ i = 1 n ( Y i − X i β ) ( X i ( k − 1 ) ) ] ≈ [ ( X i β − Y i ) ( X i β − Y i ) X i 1 ⋅ ⋅ ⋅ ⋅ ⋅ ( X i β − Y i ) X i ( k − 1 ) ] = X i ′ ( X i β − Y i ) \frac{1}{n} \begin{bmatrix} \sum_{i = 1}^n (Y_i - X_i\beta) \\ \sum_{i = 1}^n (Y_i - X_i\beta)(X_{i1}) \\ ····· \\ \sum_{i = 1}^n (Y _i- X_i\beta)(X_{i(k-1)}) \end{bmatrix}\approx \begin{bmatrix} (X_i \beta - Y_i)\\ (X_i \beta - Y_i)X_{i1}\\ ·····\\(X_i \beta - Y_i)X_{i(k-1)} \end{bmatrix}= X_i'(X_i\beta - Y_i) n1i=1n(YiXiβ)i=1n(YiXiβ)(Xi1)i=1n(YiXiβ)(Xi(k1))(XiβYi)(XiβYi)Xi1(XiβYi)Xi(k1)=Xi(XiβYi)
    ​ 经验表面SGD可以趋向于Loss Function的最小值。(证明查看本节3)

    ​ 很显然,SGD所得到的 m o d i f i e d   ∇ f modified\ \nabla f modified f 是不等于真实的 ∇ f \nabla f f 的,如果每一次都按照相同的步长进行梯度下降的话,结果很难达到 ∇ f = 0 \nabla f = 0 f=0 的位置。于是我们思考如何将每一次的梯度变化趋向于真正的梯度,于是提出学习率的概念,随着计算次数的增加,每一步的权重逐渐减小,这样就可以让梯度的最后收敛在真正的极值。

    请添加图片描述

    学习率:
    η = 1 i _ i t e r s   M o d i f y : η = a i _ i t e r s + b = η = t 0 i _ i t e r s + t 1 θ n e w = θ o l d − η ∗ ∇ \eta = \frac{1}{i\_iters}\\ \ \\ Modify:\\ \eta = \frac{a}{i\_iters + b} = \eta = \frac{t_0}{i\_iters + t_1}\\ \theta_{new} = \theta_{old} - \eta *\nabla η=i_iters1 Modify:η=i_iters+ba=η=i_iters+t1t0θnew=θoldη

    2> SGD in R

    sgd<- function(X_b, y, initial_theta, n_iters = 5, t0 = 5, t1 = 50){
      learning_rate <-  function(t){
        return(t0/(t + t1))
      }
      theta = initial_theta
      m = dim(x)[1]
      for(cur_iter in 1:n_iters){
        rand_i = ceiling(runif(1, 0, m))
        X = t(X_b[rand_i,])
        gradient = dJ(theta, X, y[rand_i])
        theta = theta - learning_rate(cur_iter) * gradient
      }  
      return(theta)
    }
    
    theta = sgd(x, y, initial_theta, n_iters = dim(x)[1])
    theta
    
    '''
    > theta
            [,1]
    x_0 4.443793
    x_1 3.027330
    '''
    theta <- 0.0
    theta = sgd(x, y, initial_theta, n_iters = floor(dim(x)[1]))
    theta
    
    '''
    > theta
            [,1]
    x_0 3.933352
    x_1 3.406223
    '''
    

    ​ 跑了两次SGD后,发现两个 θ \theta θ 的取值差异较大,这就是是SGD的另一大特点,最后的收敛结果会在真实值附近。

    3> SGD 的收敛

    ​ 观察Loss Function的 ∇ J \nabla J J M o d i f i e d   ∇ J Modified\ \nabla J Modified J ,
    1 n [ ∑ i = 1 n ( Y i − X i β ) ∑ i = 1 n ( Y i − X i β ) ( X i 1 ) ⋅ ⋅ ⋅ ⋅ ⋅ ∑ i = 1 n ( Y i − X i β ) ( X i ( k − 1 ) ) ] ≈ [ ( X i β − Y i ) ( X i β − Y i ) X i 1 ⋅ ⋅ ⋅ ⋅ ⋅ ( X i β − Y i ) X i ( k − 1 ) ] = X i ′ ( X i β − Y i ) \frac{1}{n} \begin{bmatrix} \sum_{i = 1}^n (Y_i - X_i\beta) \\ \sum_{i = 1}^n (Y_i - X_i\beta)(X_{i1}) \\ ····· \\ \sum_{i = 1}^n (Y _i- X_i\beta)(X_{i(k-1)}) \end{bmatrix}\approx \begin{bmatrix} (X_i \beta - Y_i)\\ (X_i \beta - Y_i)X_{i1}\\ ·····\\(X_i \beta - Y_i)X_{i(k-1)} \end{bmatrix}= X_i'(X_i\beta - Y_i) n1i=1n(YiXiβ)i=1n(YiXiβ)(Xi1)i=1n(YiXiβ)(Xi(k1))(XiβYi)(XiβYi)Xi1(XiβYi)Xi(k1)=Xi(XiβYi)

    1 n \frac{1}{n} n1 代入矩阵,得到

    ∇ J ≈ M o d i f i e d   ∇ J   [ 1 n ∑ i = 1 n ( Y i − X i β ) 1 n ∑ i = 1 n ( Y i − X i β ) ( X i 1 ) ⋅ ⋅ ⋅ ⋅ ⋅ 1 n ∑ i = 1 n ( Y i − X i β ) ( X i ( k − 1 ) ) ] ≈ [ ( X i β − Y i ) ( X i β − Y i ) X i 1 ⋅ ⋅ ⋅ ⋅ ⋅ ( X i β − Y i ) X i ( k − 1 ) ] = X i ′ ( X i β − Y i ) \nabla J \approx Modified\ \nabla J\\ \ \\ \begin{bmatrix} \frac{1}{n}\sum_{i = 1}^n (Y_i - X_i\beta) \\ \frac{1}{n}\sum_{i = 1}^n (Y_i - X_i\beta)(X_{i1}) \\ ····· \\ \frac{1}{n}\sum_{i = 1}^n (Y _i- X_i\beta)(X_{i(k-1)}) \end{bmatrix}\approx \begin{bmatrix} (X_i \beta - Y_i)\\ (X_i \beta - Y_i)X_{i1}\\ ·····\\(X_i \beta - Y_i)X_{i(k-1)} \end{bmatrix}= X_i'(X_i\beta - Y_i) JModified J n1i=1n(YiXiβ)n1i=1n(YiXiβ)(Xi1)n1i=1n(YiXiβ)(Xi(k1))(XiβYi)(XiβYi)Xi1(XiβYi)Xi(k1)=Xi(XiβYi)

    我们观察到 ∇ J \nabla J J 实际上就是 E ( ∇ J ) E (\nabla J) EJ ,而 M o d i f i e d   ∇ J Modified\ \nabla J Modified J 是一个样本量为1对样本对 ∇ J \nabla J J 的点估计, X i ′ ( X i β − Y i ) X_i'(X_i\beta - Y_i) Xi(XiβYi) 是来自于总体 X ′ ( X β − Y ) X'(X\beta - Y) X(XβY) 的一个样本,我们可以得到:
    E   X i ′ ( X i β − Y i ) = E X ′ ( X β − Y ) E\ X_i'(X_i\beta - Y_i) = E X'(X\beta - Y) E Xi(XiβYi)=EX(XβY)
    这样便可以理解为什么SGD的方法总是会收敛到真实值的附近。同时,这也造成了一个问题,就是样本量为1的样本的估计显而易见是不准确的,这也体现在SGD所得到的结果总是差异过大,根据朴素的统计学思想我们第一想到的就是增加样本,于是梯度下降就得到了第三种方法,批量随机梯度下降(Mini-Batch Gradient Descent)。

    ​ 更为具体的数学证明请参考Léon Bottou, Frank E. Curtis, Jorge Nocedal的文章Optimization Methods for Large-Scale Machine Learning第四章。

    3. Mini-Batch Gradient Descent

    ​ 批量随机梯度下降(Mini-Batch Gradient Descent),在随机梯度下降的基础上提高了准确性。

    ∇ J ≈ M o d i f i e d   ∇ J   1 n [ ∑ i = 1 n ( Y i − X i β ) ∑ i = 1 n ( Y i − X i β ) ( X i 1 ) ⋅ ⋅ ⋅ ⋅ ⋅ ∑ i = 1 n ( Y i − X i β ) ( X i ( k − 1 ) ) ] ≈ 1 m [ ∑ i = 1 m ( Y i − X i β ) ∑ i = 1 m ( Y i − X i β ) ( X i 1 ) ⋅ ⋅ ⋅ ⋅ ⋅ ∑ i = 1 m ( Y i − X i β ) ( X i ( k − 1 ) ) ] = 1 m X m ′ ( X m β − Y i ) ( m < n ) \nabla J \approx Modified\ \nabla J\\ \ \\ \frac{1}{n}\begin{bmatrix} \sum_{i = 1}^n (Y_i - X_i\beta) \\ \sum_{i = 1}^n (Y_i - X_i\beta)(X_{i1}) \\ ····· \\ \sum_{i = 1}^n (Y _i- X_i\beta)(X_{i(k-1)}) \end{bmatrix}\approx \frac{1}{m} \begin{bmatrix} \sum_{i = 1}^m (Y_i - X_i\beta) \\ \sum_{i = 1}^m (Y_i - X_i\beta)(X_{i1}) \\ ····· \\ \sum_{i = 1}^m (Y _i- X_i\beta)(X_{i(k-1)}) \end{bmatrix}= \frac{1}{m}X_m'(X_m\beta - Y_i) \quad (m< n) JModified J n1i=1n(YiXiβ)i=1n(YiXiβ)(Xi1)i=1n(YiXiβ)(Xi(k1))m1i=1m(YiXiβ)i=1m(YiXiβ)(Xi1)i=1m(YiXiβ)(Xi(k1))=m1Xm(XmβYi)(m<n)

    **思考题:R语言编写批量随机梯度下降(Mini-Batch Gradient Descent) **

    三、梯度下降法的一些问题

    1. 计算时间

    ​ 计算时间我们在上面的讨论过了,可以用SGD和M-BGD方法解决计算的一部分问题。

    2. 局部最小值问题

    请添加图片描述

    ​ SGD恰好能解决一部分的局部最小值的问题,其余方法可以参考SEBASTIAN RUDER的An overview of gradient descent optimization algorithms这篇文章。

    网址:https://ruder.io/optimizing-gradient-descent/index.html#momentum

    参考文献

    [1] SEBASTIAN RUDER, An overview of gradient descent optimization algorithms[J], OPTIMIZATION, 2017

    [2] 阿斯顿·张 李沐等,《动手学深度学习》,北京:人民邮电出版社,2019

    [3] 李航,《统计学习方法(第2版)》, 北京:清华大学出版社,2019

    [4] 日本数学会.数学百科词典:科学出版社,1984

    [5] Léon Bottou, Frank E. Curtis, Jorge Nocedal, Optimization Methods for Large-Scale Machine Learning, 2018

    展开全文
  • 梯度消失 与梯度为0有关。表现为只在后层学习,浅层不学习,浅层梯度基本无,权重改变量小,收敛慢,训练速度慢。 原因: 采用了不适合的激活函数,导致链式法则累乘时被0影响。 模型在训练的过程中,会不断调整...
  • 梯度下降算法

    2021-09-10 17:41:35
    (一)梯度下降的原理: 梯度下降是一个一阶优化算法,又称为最速下降法。梯度下降法是最小化目标函数(假设为J(θ))的一种方法,其中θ为模型的参数,梯度下降法利用目标函数的梯度∇θJ(θ)的反方向来更新参数...
  • 梯度下降方法(三种不同地梯度下降方法简介)标签:#优化##机器学习##梯度下降##深度学习#时间:2018/10/17 14:20:47作者:小木梯度下降是一种迭代优化的方法,它的目标是求解一个函数的最小值。我们以一个简单的例子...
  • 梯度下降法

    千次阅读 2021-09-22 15:40:45
    梯度下降法 参考文献:【梯度下降(Gradient Descent)小结】,【深入浅出–梯度下降法及其实现】 在求解机器学习算法的模型参数,即无约束优化问题时,梯度下降(Gradient Descent)是最常用的方法之一。 1. 梯度的...
  • 梯度下降计实例计算(二维) 文章目录内容简介示例说明绘制曲线进一步讨论参考资料 内容简介 梯度下降是在机器学习中重要的计算内容。本文就一个具体的示例,展示如何在梯度下降中。 示例说明 设损失函数 y=loss(x)=(x...
  • 1.51.RNN训练难题–梯度弥散与梯度爆炸 1.51.1.梯度弥散与梯度爆炸 1.51.2.详解机器学习中的梯度消失、爆炸原因及其解决方法 1.51.2.1.前言 1.51.2.2.第一部分:为什么要使用梯度更新规则 1.51.2.3.第二部分:梯度...
  • 伪代码:批量梯度下降法(Batch Gradient Descent):Repeat until convergence{}随机梯度下降法(Stochastic Batch Gradient Descent):Loop{for i = 1 to m,,{}}小批量梯度下降(Mini Batch Gradient Descent):Repeat{...
  • 随机梯度下降详解

    2021-02-24 12:20:38
    在求解机器学习算法的模型参数,即无约束优化问题时,梯度下降(Gradient Descent)是最常采用的方法之一,另一种常用的方法是最小二乘法。这里就对梯度下降法做一个完整的总结。 1. 梯度  在微积分里面,对多元...
  • 本发明涉及磁共振成像技术领域,尤其涉及一种用于磁共振成像的梯度线圈组件。背景技术:磁共振成像需要具有高强度和高均匀性的磁场,此磁场通常由超导或电阻性线圈的电磁体提供。目前,虽然对磁体系统的设计投入了大量...
  • 梯度下降和随机梯度下降 虽然梯度下降在深度学习中很少被直接使用,但理解梯度的意义以及沿着梯度反方向更新自变量可能降低目标函数值的原因是学习后续优化算法的基础。 一维梯度下降 先以简单的一维梯度下降为例。...
  • 梯度下降(8)

    2021-10-27 13:51:40
    1.2.2 1.2、梯度下降   梯度下降法(Gradient Descent)是一个算法,但不是像多元线性回归那样是一个具体做回归任务的算法,而是一个非常通用的优化算法来帮助一些机器学习算法(都是无约束最优化问题)求解出最优...
  • 数值计算之 梯度向量,雅可比矩阵,海森矩阵前言梯度向量梯度矩阵雅可比矩阵海森矩阵总结 前言 非线性最小二乘中的函数求导内容,主要涉及梯度向量、雅可比矩阵和海森矩阵。因此提前做一个辨析。实际上之前在矩阵...
  • 基于梯度的优化方法

    2021-09-20 21:13:37
    基于梯度的优化方法 大多数深度学习算法都涉及某种形式的优化。优化指的是改变 x 以最小化或最大化某个函数 f(x) 的任务。我们通常以最小化 f(x) 指代大多数最优化问题。最大化可经由最小化算法最小化*-f(x)* 来实现...
  • 机器学习-梯度下降

    2021-08-20 18:48:25
    梯度下降 一、梯度下降的定义 梯度(gradient)是一个向量(矢量,有方向),表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大.损失函数沿梯度...
  • 2.3 代价函数的直观理解I 让我们通过一些例子来获取一些直观的感受,看看代价函数到底是在干什么。 2.4 代价函数的直观理解II ...代价函数的样子类似于等高线图,则可以看出在三维空间...梯度下降是一个用来求函数最
  • 人脑皮层组织的大尺度梯度皮层位置的重要性皮质组织的感觉运动脑区-跨模态脑区梯度分布皮层微结构宏观尺度的连接基因表达功能处理层次结构理解结构梯度与功能专门化的关系大脑皮层的内在坐标系统未解决的问题总结 ...
  • 一、梯度下降(Gradient Descent) 二、随机梯度下降(Gradient Descent) 三、Mini-batch梯度下降(Mini-batch Gradient Descent)
  • 【翻译自 : Gradient Descent With ... 梯度下降是一种优化算法,遵循目标函数的负梯度以定位函数的最小值。 梯度下降的一个限制是,如果目标函数返回嘈杂的梯度,则它可能会卡在平坦的区域中或反弹。动量是...
  • 本文通过数据试验分析梯度消失和梯度爆炸的原因并分析各种常用解决方案的效果。 梯度消失/爆炸是困扰深度神经网络的大问题,ResNet和BatchNormalization的原理在网上已有不少文章介绍,但是从文章的跟帖评论中可以...
  • 1. 梯度是什么? 梯度 : 一个向量,导数+变化最快的方向 机器学习: 收集数据x, 构建模型f,通过f(x, w) = Ypredict 判断模型质量的方法,计算loss loss=(Ypredict−Ytrue)2(回归损失)loss=Ytrue⋅log(Ypredict)...
  • python实现梯度下降法

    千次阅读 2021-04-05 21:31:13
    文章目录一、什么是梯度下降法二、如何理解梯度下降法2.1 概念2.2 举例说明 一、什么是梯度下降法 梯度下降是迭代法的一种,可以用于求解最小二乘问题(线性和非线性都可以)。在求解机器学习算法的模型参数,即无约束...
  • 本次试验对比了最小二乘、定步长梯度下降和回溯法的梯度下降法对添加高斯加性噪声的信号的降噪情况,通过添加正则项达到降噪的目的。最小二乘法的结果受惩罚系数的影响较大;定步长梯度下降的降噪结果严重偏离真实...
  • 函数实现 对于一个函数f(x0,x1)=x0的平方+x1的平方 偏导数可以这样实现: ...梯度可以这样实现: def _numerical_gradient_no_batch(f, x): h = 1e-4 # 0.0001 grad = np.zeros_like(x) for idx in range(x.size):
  • 共轭梯度法的简单直观理解 共轭梯度法可以看作是梯度下降法(又称最速下降法)的一个改进。 梯度下降法x移动的方向正是函数f的负梯度方向,这代表了局部上f减小最快的方向。 但是局部上减小最快的方向并不代表全局上...
  • 积分梯度是一种神经网络可解释性方法 此方法首先在论文《Gradients of Counterfactuals》中提出,后来 《Axiomatic Attribution for Deep Networks》再次介绍了它,这已经是2016~2017年间的工作了 此方法已得到较多...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 302,358
精华内容 120,943
关键字:

梯度