Deep learning Part Five RNN--24.4.29

接着上期,CBOW模型无法解决文章内容过长的单词预测的,那该如何解决呢?

除此之外,根据图中5-5的左图所示,在CBOW模型的中间层求单词向量的和,这时就会出现另一个问题的,那就是上下文的单词的顺序将会被打乱的;举个例子:(you, say)和(say, you)会被视为相同内容处理的,这又该如何解决呢?

 方案一:拼接法,就如5-5图右侧的那样,在中间层“拼接”上下文的单词向量的。

但是,这时候新的问题又出现了的,采用拼接法固然可以解决上一个问题的,但是,这时候就会发生一系列连锁反应的,出现新的问题的:权重参数等比例增加,处理的数据量爆炸式增加!

这时候有该如何解决呢?嘿嘿!

主角终于还是在最后登场的啦,有请RNN大哥善良登场的

RNN有一个特性:

是不是感觉用RNN解决这个问题,专业且对口,哈哈。

总结:专业的领域就应该派出合适的人解决它的,不禁让老夫想到“万物相生相克!”大道就在脚下,冲啊!热血少年

小故事驿站:

5.2 RNN

RNN(Recurrent Neural Network)中的 Recurrent 源自拉丁语,意思是“反复发生。

RNN核心:RNN 的特征就在于拥有这样一个环路(或回路)。这个环路可以使数据不断循环。通过数据的循环,RNN 一边记住过去的数据,一边更新到最新的数据。

5.2.2 展开循环

从图中可以看出:RNN类似于曾经的前馈神经网络结构是相同的

二者区别:前馈神经网络的数据是一个方向传播的,而RNN是向两个方向传播的嘛,为啥?分叉呗,他的输出数据被复制了一份返回输入了的。

还有多个RNN都是同一个层,怎么理解呢?就是他是个循环的,所以就相当于在同一个层的,这一点也是与之前的神经网络不一样的。

为什么说RNN具有状态呢?因为:RNN不是输出时复制了一份吗?我个人的理解就是他在每一个计算的结束留下了一个表明时间的影子的,以此来处理时序问题。

5.2.3 Backpropagation Through Time

这个东西是干什么的?

用来计算“按时间顺序展开的神经网络的误差反向传播法”,所以引入Backpropagation Through Time的,(中文:基于时间的反向传播法),方便起见,就把他简称为BPTT吧。

用来常规的误差反向传播法,看似就可以让RNN学习了的,但是,又有新问题了的,随着RNN学习长时序的问题时,随着数据的不断增多,BPTT消耗的计算机资源也会不断增加的,当增加到一定程度时,反向传播的梯度也会变得极其不稳定的,就等同盖的高楼是豆腐渣工程,很可能一夜回到解放前,崩溃掉。

然后呢,引入了新的伙伴:Truncated BPTT

他是干啥子的?帮忙解决上述问题的;

他的核心:就是将一条长长的网络连接分成小段的,分开处理,间接减小他的处理太长时序数据的工作量,避免累垮掉Backpropagation Trough Time的(也就是处理时序问题的反向传播法的)。

登场:

5.2.4 Truncated BPTT

抽象剪刀图片:

这时我们剪断了反向传播的连接的,以使它可以以10个RNN层为单位进行反向传播的。但是要注意的是:他斩断的只是反向传播的,不影响正向传播的正常进行的。

然后呢,困难又来了的,正向传播前后数据之间不是都有关系的嘛,这就可以间接的想到我们最初的问题中的数据的顺序问题的,这意味着数据必须是按照顺序输入的

困难已至,我们该怎么办的?躲不掉,那就干掉他!

干掉他的方法如下:

总结:核心就是保留上一个斩断部分的隐藏层h的(说人话就是曾经被我们复制的两份输出的嘞)

原理类似于数据结构的链表的指针域的,(指针域中会存储着上一个数据的位置的,可以认为是间接排序)。

好处:不会乱序的,解决掉了斩断乱序的困难的。

接着嘞,困难又来了,mini-batch学习,需要考虑批数据的,这咋办,接着干掉他。

这时,又请来了“偏移”来干掉他。

抽象理解:就是假如数据有一千份,可以把他从中间斩断,变成两批数据去完成mini-batch的

原理解释:

核心:斩断后的两组数据同样按照一组数据处理的操作进行的,只不过将一组变为了两组的额,类似之前让你计算一个1+1,现在拓展一下,计算两个1+1的。

5.3 RNN的实现

CORE(核心):引入两个大箱子:hs,xs;hs装RNN每次输出的数据h,xs装RNN每次输入的数据x的。

5.3.1 RNN的实现

class RNN:
    def __init__(self, Wx, Wh, b):
        self.params = [Wx, Wh, b]
        self.grads = [np.zeros_like(Wx), np.zeros_like(Wh), np.zeros_like(b)]
        self.cache = None

    def forward(self, x, h_prev):
        Wx, Wh, b = self.params
        t = np.dot(h_prev, Wh) + np.dot(x, Wx) + b
        h_next = np.tanh(t)

        self.cache = (x, h_prev, h_next)
        return h_next
# params:用来保存列表类型的成员变量的。
# grads:保存各个参数对应的形状初始化梯度的
# cache:保存反向传播时用到的中间层数据

RNN的backward:

def backward(self, dh_next):
    Wx, Wh, b = self.params
    x, h_prev, h_next = self.cache

    dt = dh_next * (1 - h_next ** 2)
    db = np.sum(dt, axis=0)
    dWh = np.dot(h_prev.T, dt)
    dh_prev = np.dot(dt, Wh.T)
    dWx = np.dot(x.T, dt)
    dx = np.dot(dt, Wx.T)

    self.grads[0][...] = dWx
    self.grads[1][...] = dWh
    self.grads[2][...] = db

    return dx, dh_prev

Time RNN:

def backward(self, dh_next):
    Wx, Wh, b = self.params
    x, h_prev, h_next = self.cache

    dt = dh_next * (1 - h_next ** 2)
    db = np.sum(dt, axis=0)
    dWh = np.dot(h_prev.T, dt)
    dh_prev = np.dot(dt, Wh.T)
    dWx = np.dot(x.T, dt)
    dx = np.dot(dt, Wx.T)

    self.grads[0][...] = dWx
    self.grads[1][...] = dWh
    self.grads[2][...] = db

    return dx, dh_prev

RNN forward:
 

def forward(self, xs):
    Wx, Wh, b = self.params
    N, T, D = xs.shape
    D, H = Wx.shape

    self.layers = []
    hs = np.empty((N, T, H), dtype='f')

    if not self.stateful or self.h is None:
        self.h = np.zeros((N, H), dtype='f')

    for t in range(T):
        layer = RNN(*self.params)
        self.h = layer.forward(xs[:, t, :], self.h)
        hs[:, t, :] = self.h
        self.layers.append(layer)

    return hs

第t个RNN的反向传播的实现:

def backward(self, dhs):
    Wx, Wh, b = self.params
    N, T, H = dhs.shape
    D, H = Wx.shape    

    dxs = np.empty((N, T, D), dtype='f')
    dh = 0
    grads = [0, 0, 0]
    for t in reversed(range(T)):
        layer = self.layers[t]
        dx, dh = layer.backward(dhs[:, t, :] + dh) # 求和后的梯度
        dxs[:, t, :] = dx

        for i, grad in enumerate(layer.grads):
            grads[i] += grad

    for i, grad in enumerate(grads):
        self.grads[i][...] = grad
    self.dh = dh

    return dxs

5.5.2 语言模型的评价

  • 19
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. ARIMA 2. SARIMA 3. VAR 4. Auto-ARIMA 5. Auto-SARIMA 6. LSTM 7. GRU 8. RNN 9. CNN 10. MLP 11. DNN 12. MLP-LSTM 13. MLP-GRU 14. MLP-RNN 15. MLP-CNN 16. LSTM-ARIMA 17. LSTM-MLP 18. LSTM-CNN 19. GRU-ARIMA 20. GRU-MLP 21. GRU-CNN 22. RNN-ARIMA 23. RNN-MLP 24. RNN-CNN 25. CNN-ARIMA 26. CNN-MLP 27. CNN-LSTM 28. CNN-GRU 29. ARIMA-SVM 30. SARIMA-SVM 31. VAR-SVM 32. Auto-ARIMA-SVM 33. Auto-SARIMA-SVM 34. LSTM-SVM 35. GRU-SVM 36. RNN-SVM 37. CNN-SVM 38. MLP-SVM 39. LSTM-ARIMA-SVM 40. LSTM-MLP-SVM 41. LSTM-CNN-SVM 42. GRU-ARIMA-SVM 43. GRU-MLP-SVM 44. GRU-CNN-SVM 45. RNN-ARIMA-SVM 46. RNN-MLP-SVM 47. RNN-CNN-SVM 48. CNN-ARIMA-SVM 49. CNN-MLP-SVM 50. CNN-LSTM-SVM 51. CNN-GRU-SVM 52. ARIMA-RF 53. SARIMA-RF 54. VAR-RF 55. Auto-ARIMA-RF 56. Auto-SARIMA-RF 57. LSTM-RF 58. GRU-RF 59. RNN-RF 60. CNN-RF 61. MLP-RF 62. LSTM-ARIMA-RF 63. LSTM-MLP-RF 64. LSTM-CNN-RF 65. GRU-ARIMA-RF 66. GRU-MLP-RF 67. GRU-CNN-RF 68. RNN-ARIMA-RF 69. RNN-MLP-RF 70. RNN-CNN-RF 71. CNN-ARIMA-RF 72. CNN-MLP-RF 73. CNN-LSTM-RF 74. CNN-GRU-RF 75. ARIMA-XGBoost 76. SARIMA-XGBoost 77. VAR-XGBoost 78. Auto-ARIMA-XGBoost 79. Auto-SARIMA-XGBoost 80. LSTM-XGBoost 81. GRU-XGBoost 82. RNN-XGBoost 83. CNN-XGBoost 84. MLP-XGBoost 85. LSTM-ARIMA-XGBoost 86. LSTM-MLP-XGBoost 87. LSTM-CNN-XGBoost 88. GRU-ARIMA-XGBoost 89. GRU-MLP-XGBoost 90. GRU-CNN-XGBoost 91. RNN-ARIMA-XGBoost 92. RNN-MLP-XGBoost 93. RNN-CNN-XGBoost 94. CNN-ARIMA-XGBoost 95. CNN-MLP-XGBoost 96. CNN-LSTM-XGBoost 97. CNN-GRU-XGBoost 98. ARIMA-ANN 99. SARIMA-ANN 100. VAR-ANN 上面这些缩写模型的全称及相关用途功能详细解释
07-15

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值