精华内容
下载资源
问答
  • BPTT

    2017-12-23 23:22:00
    RNN 的 BP —— Back Propagation Through Time. 参考:零基础入门深度学习(5) - 循环神经网络。知乎。 1 def backward(self, sensitivity_array, 2 activator): ... 4 实现BPTT...

    RNN 的 BP —— Back Propagation Through Time.

    参考:零基础入门深度学习(5) - 循环神经网络知乎

     

     1   def backward(self, sensitivity_array, 
     2                  activator):
     3         '''
     4         实现BPTT算法
     5         '''
     6         self.calc_delta(sensitivity_array, activator)
     7         self.calc_gradient()
     8     def calc_delta(self, sensitivity_array, activator):
     9         self.delta_list = []  # 用来保存各个时刻的误差项
    10         for i in range(self.times):
    11             self.delta_list.append(np.zeros(
    12                 (self.state_width, 1)))
    13         self.delta_list.append(sensitivity_array)
    14         # 迭代计算每个时刻的误差项
    15         for k in range(self.times - 1, 0, -1):
    16             self.calc_delta_k(k, activator)
    17     def calc_delta_k(self, k, activator):
    18         '''
    19         根据k+1时刻的delta计算k时刻的delta
    20         '''
    21         state = self.state_list[k+1].copy()
    22         element_wise_op(self.state_list[k+1],
    23                     activator.backward)
    24         self.delta_list[k] = np.dot(
    25             np.dot(self.delta_list[k+1].T, self.W),
    26             np.diag(state[:,0])).T
    27     def calc_gradient(self):
    28         self.gradient_list = [] # 保存各个时刻的权重梯度
    29         for t in range(self.times + 1):
    30             self.gradient_list.append(np.zeros(
    31                 (self.state_width, self.state_width)))
    32         for t in range(self.times, 0, -1):
    33             self.calc_gradient_t(t)
    34         # 实际的梯度是各个时刻梯度之和
    35         self.gradient = reduce(
    36             lambda a, b: a + b, self.gradient_list,
    37             self.gradient_list[0]) # [0]被初始化为0且没有被修改过
    38     def calc_gradient_t(self, t):
    39         '''
    40         计算每个时刻t权重的梯度
    41         '''
    42         gradient = np.dot(self.delta_list[t],
    43             self.state_list[t-1].T)
    44         self.gradient_list[t] = gradient

     

     1 class RNN2(RNN1):
     2     # 定义 Sigmoid 激活函数
     3     def activate(self, x):
     4         return 1 / (1 + np.exp(-x))
     5 
     6     # 定义 Softmax 变换函数
     7     def transform(self, x):
     8         safe_exp = np.exp(x - np.max(x))
     9         return safe_exp / np.sum(safe_exp)
    10 
    11     def bptt(self, x, y):
    12         x, y, n = np.asarray(x), np.asarray(y), len(y)
    13         # 获得各个输出,同时计算好各个 State
    14         o = self.run(x)
    15         # 照着公式敲即可 ( σ'ω')σ
    16         dis = o - y
    17         dv = dis.T.dot(self._states[:-1])
    18         du = np.zeros_like(self._u)
    19         dw = np.zeros_like(self._w)
    20         for t in range(n-1, -1, -1):
    21             st = self._states[t]
    22             ds = self._v.T.dot(dis[t]) * st * (1 - st)
    23             # 这里额外设定了最多往回看 10 步
    24             for bptt_step in range(t, max(-1, t-10), -1):
    25                 du += np.outer(ds, x[bptt_step])
    26                 dw += np.outer(ds, self._states[bptt_step-1])
    27                 st = self._states[bptt_step-1]
    28                 ds = self._w.T.dot(ds) * st * (1 - st)
    29         return du, dv, dw
    30 
    31     def loss(self, x, y):
    32         o = self.run(x)
    33         return np.sum(
    34             -y * np.log(np.maximum(o, 1e-12)) -
    35             (1 - y) * np.log(np.maximum(1 - o, 1e-12))
    36         )

     

    转载于:https://www.cnblogs.com/niuxichuan/p/8094800.html

    展开全文
  • 最基础的深度学习BPTT算法,用纯python代码实现,便于理解RNN底层网络结构,提高认识。
  • RNN BPTT算法详细推导

    2020-07-03 23:12:56
    BPTT算法推导 BPTT全称:back-propagation through time。这里以RNN为基础,进行BPTT的推导。 BPTT的推导比BP算法更难,同时所涉及的数学知识更多,主要用到了向量矩阵求导、向量矩阵微分、向量矩阵的链式求导法则,...

    BPTT算法推导

    BPTT全称:back-propagation through time。这里以RNN为基础,进行BPTT的推导。

    BPTT的推导比BP算法更难,同时所涉及的数学知识更多,主要用到了向量矩阵求导、向量矩阵微分、向量矩阵的链式求导法则,想要完全理解掌握BPTT的推导,这些是基础工具。

    向量矩阵求导主要参考刘建平的相关博客:https://www.cnblogs.com/pinard/p/10750718.html

    RNN的BPTT推导主要参考刘建平的相关博客:https://www.cnblogs.com/pinard/p/6509630.html

    上图是RNN的经典图示。

    RNN的BPTT推导:

    在刘的博客中,损失函数为交叉熵损失函数,输出的激活函数为softmax函数,隐藏层的激活函数为tanh函数;

    但是按照这种配置,无法推导出后续的表达式;经过思考,我认为应该是以下的配置:

    损失函数为交叉熵损失函数(二元交叉熵损失函数),输出的激活函数应该为sigmoid函数,隐藏层的激活函数为tanh函数。(二分类问题)

    对于RNN,由于在序列的每个位置都有损失函数,因此最终的损失 L L L为:
    L = ∑ t = 1 τ L ( t ) = − ∑ t = 1 τ y t log ⁡ y ^ t + ( 1 − y t ) log ⁡ ( 1 − y ^ t ) L = \sum_{t=1}^{\tau}L^{(t)}=-\sum_{t=1}^{\tau}y^t\log\hat{y}^{t}+(1-y^t)\log(1-\hat{y}^t) L=t=1τL(t)=t=1τytlogy^t+(1yt)log(1y^t)

    ∂ L ∂ c = ∑ t = 1 τ ∂ L t ∂ c = ∑ t = 1 τ ( y ^ t − y t ) \frac{\partial L}{\partial c} = \sum_{t=1}^{\tau}\frac{\partial L^t}{\partial c} = \sum_{t=1}^{\tau}(\hat{y}^t-y^t) cL=t=1τcLt=t=1τ(y^tyt)

    按照刘的说法,如果是softmax的激活函数,那么这里的 c c c应该是向量,但是在他的文章中, c c c的符号是标量符号。主要是如果按照softmax来进行推导,得不到后续的公式,这里暂且先按照sigmoid函数来。
    ∂ L t ∂ c = ∂ L t ∂ y ^ t ⋅ ∂ y ^ t ∂ o t ⋅ ∂ o t ∂ c ∂ L t ∂ y ^ t = − ∂ ∂ y ^ t ( y t log ⁡ y ^ t + ( 1 − y t ) log ⁡ ( 1 − y ^ t ) ) = − y t y ^ t + 1 − y t 1 − y ^ t ∂ y ^ t ∂ o t = ∂ ∂ o t ( s i g m o i d ( o t ) ) = s i g m o i d ( o t ) ( 1 − s i g m o i d ( o t ) ) = y ^ t ( 1 − y ^ t ) ∂ o t ∂ c = ∂ ∂ c ( V h t + c ) = 1 \frac{\partial L^t}{\partial c} = \frac{\partial L^t}{\partial \hat{y}^t}\cdot \frac{\partial \hat{y}^t}{\partial o^t}\cdot\frac{\partial o^t}{\partial c}\\\frac{\partial L^t}{\partial \hat{y}^t} =-\frac{\partial }{\partial \hat{y}^t}(y^t\log\hat{y}^{t}+(1-y^t)\log(1-\hat{y}^t))\\=-\frac{y^t}{\hat{y}^t}+\frac{1-y^t}{1-\hat{y}^t}\\\frac{\partial \hat{y}^t}{\partial o^t}=\frac{\partial}{\partial o^t}(sigmoid(o^t))\\=sigmoid(o^t)(1-sigmoid(o^t))\\=\hat{y}^t(1-\hat{y}^t)\\\frac{\partial o^t}{\partial c} = \frac{\partial}{\partial c}(Vh^t+c)\\=1 cLt=y^tLtoty^tcoty^tLt=y^t(ytlogy^t+(1yt)log(1y^t))=y^tyt+1y^t1ytoty^t=ot(sigmoid(ot))=sigmoid(ot)(1sigmoid(ot))=y^t(1y^t)cot=c(Vht+c)=1
    检查一下第一个表达式,由于每个变量都是标量,所以可以按照标量的链式求导法则来求导。把每个表达式的值代入,发现的确如此。由上面的推导,还可以得到:
    ∂ L t ∂ o t = ∂ L t ∂ c (1) \frac{\partial L^t}{\partial o^t} = \frac{\partial L^t}{\partial c}\tag{1} otLt=cLt(1)

    ∂ L ∂ V = ∑ t = 1 τ ∂ L t ∂ V = ∑ t = 1 τ ( y ^ t − y t ) ( h t ) T (2) \frac{\partial L}{\partial V} = \sum_{t=1}^\tau \frac{\partial L^t}{\partial V} = \sum_{t=1}^\tau(\hat{y}^t-y^t)(h^t)^T\tag{2} VL=t=1τVLt=t=1τ(y^tyt)(ht)T(2)

    其中, L ∈ R , V ∈ R 1 × m , h t ∈ R m L\in \bold{R}, V\in\bold{R}^{1\times m}, h^t\in \bold{R}^m LR,VR1×m,htRm,注意到,这里涉及到标量对向量的求导,采用分母布局,注意检查等号两边的维度是否相同,参与运算的变量保证能够进行矩阵相乘,必要的时候需要调整位置以便能完成相应的矩阵乘法。公式2的推导很简单,因为 ∂ L t ∂ V = ∂ L t ∂ o t ⋅ ∂ o t ∂ V \frac{\partial L^t}{\partial V} = \frac{\partial L^t}{\partial o^t}\cdot\frac{\partial o^t}{\partial V} VLt=otLtVot

    接下来就是 W , U , b W,U,b W,U,b的梯度计算了,这三者的梯度计算是相对复杂的。从RNN的结构可以知道,反向传播时,在某个时刻t的梯度损失由当前位置的输出对应的梯度损失和 t + 1 t+1 t+1时刻的梯度损失两部分共同决定,而 t + 1 t+1 t+1时刻的梯度损失有相同的结构,可以看出是循环嵌套的。因此 W W W在某一位置t的梯度损失需要一步步计算。我们定义序列索引 t t t的隐藏状态的梯度为:
    δ t = ∂ L ∂ h t (3) \delta^t = \frac{\partial L}{\partial h^t}\tag{3} δt=htL(3)
    注意到公式3也是标量对向量的导数

    这样我们可以像DNN一样从 δ t + 1 \delta^{t+1} δt+1递推 δ t \delta^t δt
    δ t = ∂ L ∂ o t ⋅ ∂ o t ∂ h t + ( ∂ h t + 1 ∂ h t ) T ⋅ ∂ L ∂ h t + 1 = V T ∑ t = 1 τ ( y ^ t − y t ) + W T d i a g ( 1 − ( h t + 1 ) 2 ) δ t + 1 (4) \delta^t = \frac{\partial L}{\partial o^t}\cdot\frac{\partial o^t}{\partial h^t}+(\frac{\partial h^{t+1}}{\partial h^t})^T\cdot\frac{\partial L}{\partial h^{t+1}}\\=V^T\sum_{t=1}^{\tau}(\hat{y}^t-y^t)+W^Tdiag(1-(h^{t+1})^2)\delta^{t+1}\tag{4} δt=otLhtot+(htht+1)Tht+1L=VTt=1τ(y^tyt)+WTdiag(1(ht+1)2)δt+1(4)
    公式4和刘的表达式不一样,个人认为我的应该是对的,刘的公式按照向量的求导法则,表达式中的维度不一致。第一步参考刘的矩阵微分系列博客。第二步中的第二部分,第一次看的时候没有明白,也花了挺多时间推导,这里记录一下。
    h t + 1 = t a n h ( W h t + U x t + 1 + b ) h^{t+1} = tanh(Wh^t+Ux^{t+1}+b) ht+1=tanh(Wht+Uxt+1+b)
    其中, W ∈ R m × m , x t ∈ R n , U ∈ R m × n W\in \bold{R}^{m\times m}, x^t\in \bold{R}^n,U\in\bold{R}^{m\times n} WRm×m,xtRn,URm×n t a n h ′ ( x ) = 1 − ( t a n h ( x ) ) 2 tanh^{'}(x)=1-(tanh(x))^2 tanh(x)=1(tanh(x))2

    ∂ h t + 1 ∂ h t \frac{\partial h^{t+1}}{\partial h^t} htht+1,这是向量对向量的求导,按照分子布局求导结果的维度是 m × m m\times m m×m。这里我们按照定义来求:
    ∂ h i t + 1 ∂ h t \frac{\partial h_i^{t+1}}{\partial h^t} hthit+1
    此时变成了标量对向量的求导,按照分母布局,结果维度应该和 h t h^t ht相同,此时
    h i t + 1 = t a n h ( W i , : h t ) h_i^{t+1} = tanh(W_{i,:}h^t) hit+1=tanh(Wi,:ht)
    省略了与 h h h无关的项。那么:
    ∂ h i t + 1 ∂ h t = ( 1 − ( h i t + 1 ) 2 ) ∂ ∂ h t ( W i , : h t ) = ( 1 − ( h i t + 1 ) 2 ) W i , : T \frac{\partial h_i^{t+1}}{\partial h^t} = (1-(h_i^{t+1})^2)\frac{\partial }{\partial h^t}(W_{i,:}h^t)\\=(1-(h_i^{t+1})^2)W_{i,:}^T hthit+1=(1(hit+1)2)ht(Wi,:ht)=(1(hit+1)2)Wi,:T
    此时结果的维度是 m × 1 m\times 1 m×1,由于是按照分子布局, i i i对应最后矩阵的第 i i i行,所以这里应该在转置一下,变成:
    ( 1 − ( h i t + 1 ) 2 ) W i , : (1-(h_i^{t+1})^2)W_{i,:} (1(hit+1)2)Wi,:

    所以:
    ∂ h t + 1 ∂ h t = d i a g ( 1 − ( h t + 1 ) 2 ) W \frac{\partial h^{t+1}}{\partial h^t}=diag(1-(h^{t+1})^2)W htht+1=diag(1(ht+1)2)W

    其中, d i a g ( 1 − ( h t + 1 ) 2 ) diag(1-(h^{t+1})^2) diag(1(ht+1)2) indicates the diagonal matrix containing the elements 1 − ( h i t + 1 ) 2 1-(h_i^{t+1})^2 1(hit+1)2(来自花书英文版385页)。

    将其代入公式4,就明白为什么是那样的表达式了。

    这里在记录一下另一个点,
    t a n h ( W h t ) tanh(Wh^t) tanh(Wht)
    这是一个向量,有:
    ∂ ∂ W h t ( t a n h ( W h t ) ) = d i a g ( 1 − ( t a n h ( W h t ) ) 2 ) \frac{\partial }{\partial Wh^t}(tanh(Wh^t))=diag(1-(tanh(Wh^t))^2) Wht(tanh(Wht))=diag(1(tanh(Wht))2)
    其实这就是向量对向量的求导,按照分子布局求导结果为 m × m m\times m m×m的矩阵,刚好对角矩阵是一个 m × m m\times m m×m的矩阵,这间接说明了等式的正确性。

    在刘的https://www.cnblogs.com/pinard/p/10825264.html第三节的最后部分,给出了四个非常重要的表达式,这里记录下接下来会用到的一个表达式:
    z = f ( y ) , y = X a + b − > ∂ z ∂ X = ∂ z ∂ y a T (5) z = f(y), y = Xa+b \quad-> \frac{\partial z}{\partial X}=\frac{\partial z}{\partial y}a^T\tag{5} z=f(y),y=Xa+b>Xz=yzaT(5)
    其中, z z z为标量, y , a , b y,a,b y,a,b为向量, X X X为矩阵。不过发现好像用不到。。。

    有了 δ t \delta^t δt的表达式后,我们求 W , U , b W,U,b W,U,b就方便很多了,有
    ∂ L ∂ W = ∑ t = 1 τ d i a g ( 1 − ( h t ) 2 ) δ t ( h t − 1 ) T ∂ L ∂ W = ∂ h τ ∂ W ∂ L ∂ h τ + . . . + ∂ h 1 ∂ W ∂ L ∂ h 1 = ∑ t = 1 τ ∂ h t ∂ W ∂ L ∂ h t (6) \frac{\partial L}{\partial W} = \sum_{t=1}^{\tau}diag(1-(h^t)^2)\delta^t(h^{t-1})^T\\\frac{\partial L}{\partial W} = \frac{\partial h^\tau}{\partial W}\frac{\partial L}{\partial h^\tau}+...+\frac{\partial h^1}{\partial W}\frac{\partial L}{\partial h^1}\\=\sum_{t=1}^\tau\frac{\partial h^t}{\partial W}\frac{\partial L}{\partial h^t}\\\tag{6} WL=t=1τdiag(1(ht)2)δt(ht1)TWL=WhτhτL+...+Wh1h1L=t=1τWhthtL(6)
    老实说,这一步我不确定是否正确,因为这涉及到了向量对矩阵的导数,这玩意儿我还不会。不过这一步解释了为什么公式6里面有个累加符号。后续推导就更不会了,会的大佬请不吝赐教。不过感觉上好像是这么回事。只要这一步搞懂了,对 U , b U,b U,b的求导是类似的,可以参考刘的博客,这里就不写了。(太菜了,关键步骤不会)

    从表达式4可以看出RNN梯度消失和梯度爆炸的根本原因(展开后就能知道为什么了)。
    后续补充LSTM的BPTT。(毕竟面试的时候会要求公式层面的对LSTM防止梯度消失和梯度爆炸的理解)

    展开全文
  • RNN-bptt简单推导

    千次阅读 2018-01-22 17:00:30
    摘要: 在前面的文章里面,RNN训练与BP算法,我们提到了RNN的训练算法。但是回头看的时候在时间的维度上没有做处理,所以整个推导...这里首先解释一下所谓的bpttbptt的思路其实很简单,就是把整个RNN按时间的维度展

    摘要:


    在前面的文章里面,RNN训练与BP算法,我们提到了RNN的训练算法。但是回头看的时候在时间的维度上没有做处理,所以整个推导可能存在一点问题。

    那么,在这篇文章里面,我们将介绍bptt(Back Propagation Through Time)算法如在训练RNN。

    关于bptt


    这里首先解释一下所谓的bptt,bptt的思路其实很简单,就是把整个RNN按时间的维度展开成一个“多层的神经网络”。具体来说比如下图:
    这里写图片描述

    既然RNN已经按时间的维度展开成一个看起来像多层的神经网络,这个时候用普通的bp算法就可以同样的计算,只不过这里比较复杂的是权重共享。比如上图中每一根线就是一个权重,而我们可以看到在RNN由于权重是共享的,所以三条红线的权重是一样的,这在运用链式法则的时候稍微比较复杂。

    正文:


    首先,和以往一样,我们先做一些定义。
    hti=f(netthi)

    netthi=m(vimxtm)+s(uisht1s)

    nettyk=mwkmhtm
    最后一层经过softmax的转化
    otk=enettykkenettyk
    在这里我们使用交叉熵作为Loss Function
    Et=kztklnotk

    我们的任务同样也是求 Ewkm Evim Euim
    注意,这里的 E 没有时间的下标。因为在RNN里,这些梯度分别为各个时刻的梯度之和。
    即:
    Ewkm=stept=0Etwkm
    Evim=stept=0Etvim
    Euim=stept=0Etuim

    所以下面我们推导的是 Etwkm Etvim Etuim

    我们先推导 Etwkm
    Etwkm=kEtotkotknettyknettykwkm=(otkztk)htm 。(这一部分的推导在前面的文章已经讨论过了)。
    在这里,记误差信号:
    δ(output,t)k=Etnettyk=kEtotkotknettyk=(otkztk) (后面会用到)

    对于 Etvim Etuim 其实是差不多的,所以这里详细介绍其中一个。这两个导数也是RNN里面最复杂的。

    推导: Etvim

    Etvim=tt=0Etnetthinetthivim
    对于这个式子第一次看可能有点懵逼,这里稍微解释一下:
    从式: hti=f(m(vimxtm)+s(uisht1s)) 中我们可以看到, vim 影响的是所有时刻的 netthi,t=0,1,2,....step 。所以当 Et vim 求偏导的时候,由于链式法则需要考虑到所有时刻的 netthi

    下面分成两部分来求 Etnetthi netthivim.
    第一部分: Etnetthi
    这里我们记 δ(t,t)i=Etnetthi (误差信号,和前面文章一样)。



    (由于带着符号去求这两个导数会让人看起来非常懵逼,所以下面指定具体的值,后面抽象给出通式)
    假设共3个时刻,即t=0,1,2。
    对于 t=2 t=2 时:
    E2 表示第2个时刻(也是最后一个时刻)的误差)
    net2hi 表示第2个时刻隐藏层第i个神经元的净输入)
    具体来说: E2net2hi=E2h2ih2inet2hi

    对于 E2h2i=kE2net2yknet2ykh2i
    由于 δ(output,t)k=Etnettyk
    所以,我们有:
    E2h2i=kE2net2yknet2ykh2i=kδ(output,2)knet2ykh2i=kδ(output,2)kwki
    综上:
    δ(2,2)i=E2net2hi=E2h2ih2inet2hi=(kδ(output,2)kwki)f(net2hi)

    对于 t=1 t=2 时:
    E2 表示第2个时刻的误差)
    net1hi 表示第1个时刻隐藏层第i个神经元的净输入)
    具体来说: E2net1hi=E2h1ih1inet1hi
    那么 E2h1i=kE2net1yknet1ykh1i+jE2net2hjnet2hjh1i 。请对比这个式子和上面 t=2 t=2 时的区别,区别在于多了一项 jE2net2hjnet2hjh1i 。这个原因我们已经在RNN与bp算法中讨论过,这里简单的说就是由于 t=1 时刻有 t=2 时刻反向传播回来的误差,所以要考虑上这一项,但是对于 t=2 已经是最后一个时刻了,没有反向传播回来的误差。

    对于第一项 kE2net1yknet1ykh1i 其实是0。下面简单分析下原因:
    上式进一步可以化为: k(kE2o1ko1knet1yk)net1ykh1i E2 与第1个时刻输出 o1k 无关。所以为0。

    对于第二项 jE2net2hjnet2hjh1i ,我们带入 δ(t,t)i=Etnetthi 有:
    jE2net2hjnet2hjh1i=jδ(2,2)jnet2hjh1i
    同时明显有 net2hjh1i=uji
    即: E2h1i=jδ(2,2)juji

    综上:
    δ(1,2)i=E2net1hi=E2h1ih1inet1hi=(jδ(2,2)jnet2hjh1i)f(net1hi)=(jδ(2,2)juji)f(net1hi)

    对于 t=0 t=2 时:
    E2 表示第2个时刻的误差)
    net0hi 表示第0个时刻隐藏层第i个神经元的净输入)。
    和上面的思路一样,我们容易得到:
    δ(0,2)i=E2net0hi=(jδ(1,2)juji)f(net0hi)

    至此,我们求完了 Etnetthi 。下面我们来总结一下其通式:

    Etnetthi=δ(t,t)i={(kδ(output,t)kwki)f(netthi),(jδ(t+1,t)juji)f(netthi),t=ttt


    另外,对于 δ(output,t)k 有以下表达式:
    δ(output,t)k=Etnettyk=kEtotkotknettyk=(otkztk)



    最后只要求出 netthivim ,其值具体为 netthivim=xtm


    最后,对于 Etuim 其实和上面的差不多,主要是后面的部分不一样,具体来说:
    Etuim=tt=0Etnetthinetthiuim ,可以看到就只有等式右边的第二项不一样,关键部分是一样的。 netthiuim=ht1m

    细节-1


    上面提到,当只有3个时刻时,t=0,1,2。
    对于误差 E2 (最后一个时刻的误差),没有再下一个时刻反向传回的误差。
    那么对于 E1 (第1个时刻的误差)存在下一个时刻反向传回的误差,但是在 E1h1i 中的第二项 jE1net2hjnet2hjh1i 仍然为0。是因为 E1net2hj=0 ,因为 E1 的误差和下一个时刻隐藏层的输出没有任何关系。

    总结


    看起来bptt和我们之前讨论的bp本质上是一样的,只是在一些细节的处理上由于权重共享的原因有所不同,但是基本上还是一样的。

    下面这篇文章是有一个简单的rnn代码,大家可以参考一下
    参考文章1
    代码的bptt中每一步的迭代公式其实就是上面的公式。希望对大家有帮助~

    展开全文
  • BPTT算法推导

    2021-03-01 20:24:52
  • RNN BPTT算法推导

    千次阅读 2019-03-26 22:29:58
    BPTT(沿时反向传播算法)基本原理与BP算法一样,包含三个步骤: 前向计算每个神经元的输出值 反向计算每个神经元的误差项δjδ_jδj​,它是误差函数E对神经元j的加权输入netjnet_jnetj​的偏导数 计算每个权重的梯度...
  • RNN详解及BPTT详解

    万次阅读 2018-10-13 21:04:19
    BPTT(back-propagation through time)算法是常用的训练RNN的方法,其实本质还是BP算法,只不过RNN处理时间序列数据,所以要基于时间反向传播,故叫随时间反向传播。BPTT的中心思想和BP算法相同,沿着需要优化的...
  • 循环神经网络——RNN的训练算法:BPTT基本步骤前向计算误差项的计算权重梯度的计算RNN的梯度爆炸和消失问题 基本步骤 BPTT算法是针对循环层的训练算法,它的基本原理和BP算法是一样的,也包含同样的三个步骤: 1.前...
  • BPTT-RNN训练算法

    2020-06-14 16:09:58
    BPTT:与BP类似,加上时序演化。 输出的激活函数:双曲正切,通过softmax,损失交叉熵。 举一个例子:求E3对V的梯度 y是输出值,z是输入激活函数的值,z=V*S3.最后求和可得E对V的梯度!!(梯度下降) E对W梯度 W是...
  • 为了解决这个问题,引入了BPTT,我们下面就详细的讲讲他是如何更新的,想要搞明白BPTT,上面的图很关键,好下面我先使用口语化和大家解释他是如何更新所有时间序列的权值的: 这里我们先从输出得到误差信号,反向...
  • 不用工具箱实现的elman神经网络,基于BPTT算法实现
  • BPTT深度理解

    千次阅读 2018-04-27 21:07:36
    2.1 Back-Propagation Through Time (BPTT)算法 上图左边的网络结构 表示的反向传播的过程。其中绿色的表示的是时间上的反向传播的过程,红色的是同一个时刻空间上的传播的过程(其实也就是普通前馈神经网络的误差...
  • 本文介绍BPTT的原理和实现,是读“Recurrent Neural Networks Tutorial, Part 3 – Backpropagation Through Time and Vanishing Gradients”的读书笔记,代码也来自于这篇文章,加了部分注释。
  • RNN训练算法BPTT介绍

    千次阅读 2018-11-02 11:12:30
    本篇文章第一部分翻译自:... 最近看到RNN,先是困惑于怎样实现隐藏层的互联,搞明白之后又不太明白如何使用BPTT进...
  • BPTT : Back-Propagation Through Time ∂L∂U=∑t∂Lt∂U\frac{\partial L}{\partial U} = \sum_t\frac{\partial L_t}{\partial U}∂U∂L​=∑t​∂U∂Lt​​ 例如t=4 时, ∂L4∂U=∂L4∂y4∂y4∂h4∂h4∂U\frac...
  • # print "Backpropagation step t=%d bptt step=%d " % (t, bptt_step) # Add to gradients at each previous step dLdW + = np.outer(delta_t, s[bptt_step - 1 ])  dLdU[:,x[bptt_step]] + = delta_t...
  • RNN网络的学习算法-BPTT笔记 本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 ...
  • 在博客里看见的一个非常有用的推导过程,自己记录一下之后复习用: 下面贴一下笔记:
  • 这里需要知道的是由于vanishing/exploding gradient problem导致普通RNN采用BPTT很难学习到long-term dependencies。 例如下面的这句话: The cat, which already ate ..., was full. The cats, which already ...
  • 【参考资料】 【1】《python深度学习:基于PyTorch》 1. BPTT 2. BPTT
  • BPTT 算法 由于循环神经网络是一种基于时序数据的网络模型,因此传统的 BP 算法并不适用于该模型的优化,循环神经网络中最常用的优化算法为 BPTT(Backpropagation Through Time) 算法。 首先我们有: 接着我们可以...
  • 【深度学习】BPTT

    千次阅读 2019-03-30 20:29:09
    参考: 零基础入门深度学习(6) - 长短时记忆网络(LSTM) LSTM的推导与实现(这个写的有点复杂)
  • DNN中的BP和RNN中的BPTT推导

    千次阅读 2018-07-12 11:59:23
    1.5、BP和BPTT 参考博客:http://www.cnblogs.com/pinard/p/6509630.html 1、反向传播算法(Backpropagation) 反向传播算法要解决的问题 深层神经网络(Deep Neural Network,DNN)由输入层、多个隐藏层和输出...
  • 本篇内容就是详细介绍RNN的反向传播算法,即BPTT。 首先让我们来用动图来表示RNN的损失是如何产生的,以及如何进行反向传播,如下图所示。 上面两幅图片,已经很详细的展示了损失是如何产生的, 以及...
  • 反向传播(BPTT)与循环神经网络(RNN)文本预测

    千次阅读 多人点赞 2017-05-10 22:14:24
    反向传播(BPTT)与RNN文本预测实战 本文介绍简单Recurrent Neural Networks(RNN)的基本训练算法BACKPROPAGATION THROUGH TIME (BPTT),并用 python2.7 实现RNN的文本预测。
  • RNN训练方法介绍-BPTT

    万次阅读 2017-12-04 15:32:32
    url:... Training RNN——BPTT ...由于RNN和时间序列有关,因此我们不能通过Backpropagation来调参,我们使用的是Backpropagation through time(BPTT) 回顾Backpropagation  
  • 首先明确一下,本文需要对RNN有一定的了解,而且本文只针对标准的网络结构,旨在彻底搞清楚反向传播和BPTT。 反向传播形象描述 什么是反向传播?传播的是什么?传播的是误差,根据误差进行调整。 举个例子:你...
  • BPTT paper This report provides detailed description and necessary derivations for the BackPropagation Through Time (BPTT) algorithm. BPTT is often used to learn recurrent neural networks (RNN). ...
  • 作者:徐志强 ... 来源:知乎 ...在前一篇教程中,我们从头开始实现了RNN,但并没有深入到BPTT如何计算梯度的细节中去。在本部分,我们将对BPTT做一个简短的介绍,并解释它和传统的反向传播有什么不同。然后

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,600
精华内容 1,440
关键字:

bptt