GRU

RNN存在的问题：梯度较容易出现衰减或爆炸（BPTT）

⻔控循环神经⽹络：捕捉时间序列中时间步距离较⼤的依赖关系

RNN:

Ht=ϕ(XtWxh+Ht−1Whh+bh)
H_{t} = ϕ(X_{t}W_{xh} + H_{t-1}W_{hh} + b_{h})
Ht​=ϕ(Xt​Wxh​+Ht−1​Whh​+bh​)

GRU:

Rt=σ(XtWxr+Ht−1Whr+br)Zt=σ(XtWxz+Ht−1Whz+bz)H~t=tanh(XtWxh+(Rt⊙Ht−1)Whh+bh)Ht=Zt⊙Ht−1+(1−Zt)⊙H~t
R_{t} = σ(X_tW_{xr} + H_{t−1}W_{hr} + b_r)\\
Z_{t} = σ(X_tW_{xz} + H_{t−1}W_{hz} + b_z)\\
\widetilde{H}_t = tanh(X_tW_{xh} + (R_t ⊙H_{t−1})W_{hh} + b_h)\\
H_t = Z_t⊙H_{t−1} + (1−Z_t)⊙\widetilde{H}_t
Rt​=σ(Xt​Wxr​+Ht−1​Whr​+br​)Zt​=σ(Xt​Wxz​+Ht−1​Whz​+bz​)Ht​=tanh(Xt​Wxh​+(Rt​⊙Ht−1​)Whh​+bh​)Ht​=Zt​⊙Ht−1​+(1−Zt​)⊙Ht​

• 重置⻔有助于捕捉时间序列⾥短期的依赖关系；

• 更新⻔有助于捕捉时间序列⾥⻓期的依赖关系。

载入数据集

  1. import os
  2. os.listdir('/home/kesci/input')
  1. ['d2lzh1981', 'houseprices2807', 'jaychou_lyrics4703', 'd2l_jay9460']
  1. import numpy as np
  2. import torch
  3. from torch import nn, optim
  4. import torch.nn.functional as F
  1. import sys
  2. sys.path.append("../input/")
  3. import d2l_jay9460 as d2l
  4. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  6. (corpus_indices, char_to_idx, idx_to_char, vocab_size) = d2l.load_data_jay_lyrics()

初始化参数

  1. num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
  2. print('will use', device)
  4. def get_params():
  5.     def _one(shape):
  6.         ts = torch.tensor(np.random.normal(0, 0.01, size=shape), device=device, dtype=torch.float32) #正态分布
  7.         return torch.nn.Parameter(ts, requires_grad=True)
  8.     def _three():
  9.         return (_one((num_inputs, num_hiddens)),
  10.                 _one((num_hiddens, num_hiddens)),
  11.                 torch.nn.Parameter(torch.zeros(num_hiddens, device=device, dtype=torch.float32), requires_grad=True))
  13.     W_xz, W_hz, b_z = _three()  # 更新门参数
  14.     W_xr, W_hr, b_r = _three()  # 重置门参数
  15.     W_xh, W_hh, b_h = _three()  # 候选隐藏状态参数
  17.     # 输出层参数
  18.     W_hq = _one((num_hiddens, num_outputs))
  19.     b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device, dtype=torch.float32), requires_grad=True)
  20.     return nn.ParameterList([W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q])
  22. def init_gru_state(batch_size, num_hiddens, device):   #隐藏状态初始化
  23.     return (torch.zeros((batch_size, num_hiddens), device=device), )
  1. will use cpu

GRU模型

  1. def gru(inputs, state, params):
  2.     W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params
  3.     H, = state
  4.     outputs = []
  5.     for X in inputs:
  6.         Z = torch.sigmoid(torch.matmul(X, W_xz) + torch.matmul(H, W_hz) + b_z)
  7.         R = torch.sigmoid(torch.matmul(X, W_xr) + torch.matmul(H, W_hr) + b_r)
  8.         H_tilda = torch.tanh(torch.matmul(X, W_xh) + R * torch.matmul(H, W_hh) + b_h)
  9.         H = Z * H + (1 - Z) * H_tilda
  10.         Y = torch.matmul(H, W_hq) + b_q
  11.         outputs.append(Y)
  12.     return outputs, (H,)

训练模型

  1. num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
  2. pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']
  1. d2l.train_and_predict_rnn(gru, get_params, init_gru_state, num_hiddens,
  2.                           vocab_size, device, corpus_indices, idx_to_char,
  3.                           char_to_idx, False, num_epochs, num_steps, lr,
  4.                           clipping_theta, batch_size, pred_period, pred_len,
  5.                           prefixes)
  1. epoch 40, perplexity 149.271885, time 1.17 sec
  2.  - 分开 我想我不不 我想你的让我 你想我的让我 你想我不想 我想你我想想想想想你想你的可爱人  坏我的让我
  3.  - 不分开 我想你我不想 你不我 我想你的爱爱 我想你的让我 我想你我想想想想想想你的可爱人  坏我的让我 我
  4. epoch 160, perplexity 1.427383, time 1.16 sec
  5.  - 分开 我已带口 你已已是不起 让你知没面对我 甩散球我满腔的怒火 我想揍你已经很久 别想躲 说你眼睛看着
  6.  - 不分开 整过 是你开的玩笑 想通 却又再考倒我 说散 你想很久了吧? 败给你的黑色幽默 说散 你想很久了吧

简洁实现

  1. num_hiddens=256
  2. num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
  3. pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']
  5. lr = 1e-2 # 注意调整学习率
  6. gru_layer = nn.GRU(input_size=vocab_size, hidden_size=num_hiddens)
  7. model = d2l.RNNModel(gru_layer, vocab_size).to(device)
  8. d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
  9.                                 corpus_indices, idx_to_char, char_to_idx,
  10.                                 num_epochs, num_steps, lr, clipping_theta,
  11.                                 batch_size, pred_period, pred_len, prefixes)
  1. epoch 40, perplexity 1.016101, time 0.89 sec
  2.  - 分开始想像 爸和妈当年的模样 说著一口吴侬软语的姑娘缓缓走过外滩 消失的 旧时光 一九四三 回头看 的片
  3.  - 不分开暴风圈来不及逃 我不能再想 我不能再想 我不 我不 我不能 爱情走的太快就像龙卷风 不能承受我已无处
  4. epoch 80, perplexity 1.010881, time 0.96 sec
  5.  - 分开都会值得去做 我想大声宣布 对你依依不舍 连隔壁邻居都猜到我现在的感受 河边的风 在吹着头发飘动 牵
  6.  - 不分开暴风圈来不及逃 我不能再想 我不能再想 我不 我不 我不能 爱情走的太快就像龙卷风 不能承受我已无处
  7. epoch 120, perplexity 1.011403, time 0.95 sec
  8.  - 分开的我爱你看棒球 想这样没担忧 唱着歌 一直走 我想就这样牵着你的手不放开 爱可不可以简简单单没有伤害
  9.  - 不分开暴风圈来不及逃 我不能再想 我不能再想 我不 我不 我不能 爱情走的太快就像龙卷风 不能承受我已无处
  10. epoch 160, perplexity 1.058085, time 0.88 sec
  11.  - 分开始打呼 管到当初爱你的时空 停格内容不忠 所有回忆对着我进攻   简单爱情来的太快就像龙卷风 离不开
  12.  - 不分开始打呼 管家是一只是我怕眼泪撑不住 不懂 你给我抬起头 有话去对医药箱说 别怪我 别怪我 说你怎么面

LSTM

** 长短期记忆long short-term memory **:

遗忘门:控制上一时间步的记忆细胞

输入门:控制当前时间步的输入

输出门:控制从记忆细胞到隐藏状态

记忆细胞：⼀种特殊的隐藏状态的信息的流动

It=σ(XtWxi+Ht−1Whi+bi)Ft=σ(XtWxf+Ht−1Whf+bf)Ot=σ(XtWxo+Ht−1Who+bo)C~t=tanh(XtWxc+Ht−1Whc+bc)Ct=Ft⊙Ct−1+It⊙C~tHt=Ot⊙tanh(Ct)
I_t = σ(X_tW_{xi} + H_{t−1}W_{hi} + b_i) \\
F_t = σ(X_tW_{xf} + H_{t−1}W_{hf} + b_f)\\
O_t = σ(X_tW_{xo} + H_{t−1}W_{ho} + b_o)\\
\widetilde{C}_t = tanh(X_tW_{xc} + H_{t−1}W_{hc} + b_c)\\
C_t = F_t ⊙C_{t−1} + I_t ⊙\widetilde{C}_t\\
H_t = O_t⊙tanh(C_t)
It​=σ(Xt​Wxi​+Ht−1​Whi​+bi​)Ft​=σ(Xt​Wxf​+Ht−1​Whf​+bf​)Ot​=σ(Xt​Wxo​+Ht−1​Who​+bo​)Ct​=tanh(Xt​Wxc​+Ht−1​Whc​+bc​)Ct​=Ft​⊙Ct−1​+It​⊙Ct​Ht​=Ot​⊙tanh(Ct​)

初始化参数

  1. num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
  2. print('will use', device)
  4. def get_params():
  5.     def _one(shape):
  6.         ts = torch.tensor(np.random.normal(0, 0.01, size=shape), device=device, dtype=torch.float32)
  7.         return torch.nn.Parameter(ts, requires_grad=True)
  8.     def _three():
  9.         return (_one((num_inputs, num_hiddens)),
  10.                 _one((num_hiddens, num_hiddens)),
  11.                 torch.nn.Parameter(torch.zeros(num_hiddens, device=device, dtype=torch.float32), requires_grad=True))
  13.     W_xi, W_hi, b_i = _three()  # 输入门参数
  14.     W_xf, W_hf, b_f = _three()  # 遗忘门参数
  15.     W_xo, W_ho, b_o = _three()  # 输出门参数
  16.     W_xc, W_hc, b_c = _three()  # 候选记忆细胞参数
  18.     # 输出层参数
  19.     W_hq = _one((num_hiddens, num_outputs))
  20.     b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device, dtype=torch.float32), requires_grad=True)
  21.     return nn.ParameterList([W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q])
  23. def init_lstm_state(batch_size, num_hiddens, device):
  24.     return (torch.zeros((batch_size, num_hiddens), device=device),
  25.             torch.zeros((batch_size, num_hiddens), device=device))
  1. will use cpu

LSTM模型

  1. def lstm(inputs, state, params):
  2.     [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q] = params
  3.     (H, C) = state
  4.     outputs = []
  5.     for X in inputs:
  6.         I = torch.sigmoid(torch.matmul(X, W_xi) + torch.matmul(H, W_hi) + b_i)
  7.         F = torch.sigmoid(torch.matmul(X, W_xf) + torch.matmul(H, W_hf) + b_f)
  8.         O = torch.sigmoid(torch.matmul(X, W_xo) + torch.matmul(H, W_ho) + b_o)
  9.         C_tilda = torch.tanh(torch.matmul(X, W_xc) + torch.matmul(H, W_hc) + b_c)
  10.         C = F * C + I * C_tilda
  11.         H = O * C.tanh()
  12.         Y = torch.matmul(H, W_hq) + b_q
  13.         outputs.append(Y)
  14.     return outputs, (H, C)

训练模型

  1. num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
  2. pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']
  4. d2l.train_and_predict_rnn(lstm, get_params, init_lstm_state, num_hiddens,
  5.                           vocab_size, device, corpus_indices, idx_to_char,
  6.                           char_to_idx, False, num_epochs, num_steps, lr,
  7.                           clipping_theta, batch_size, pred_period, pred_len,
  8.                           prefixes)
  1. epoch 40, perplexity 211.457328, time 1.51 sec
  2.  - 分开 我不的我 我不的我 我不不 我不的我 我不不 我不的我 我不不 我不的我 我不不 我不的我 我不不
  3.  - 不分开 我不不 我不的我 我不不 我不的我 我不不 我不的我 我不不 我不的我 我不不 我不的我 我不不
  4. epoch 80, perplexity 68.458662, time 1.50 sec
  5.  - 分开 我想你这你 我不要这你 我不要这你 我不要这你 我不要这你 我不要这你 我不要这你 我不要这你 我
  6.  - 不分开 我想你你的你 我想要你 我不要 我不要 我不要 我不要 我不要 我不要 我不要 我不要 我不要 我
  7. epoch 120, perplexity 15.034657, time 1.49 sec
  8.  - 分开 我想你你的你笑 不知不觉 你你了一我不我 别发抖 快给我抬起起着你 别发抖 快给我抬起头 有你去对
  9.  - 不分开 我想你你 我不要再想我 不知不觉 你你了离不我 不知不觉 你跟了离不我 不知不觉 我该了这节活 后
  10. epoch 160, perplexity 3.897414, time 1.49 sec
  11.  - 分开 我想带你里嵩山 学少林跟了了刚 我想就你了嵩着 我想去这生嵩 不天到双截棍 哼哼哈兮 快使用双截棍
  12.  - 不分开 我 我你你的微笑 像通  又又我 我想就这样牵着你的手不放  穿过来回单单 我 想和你样堡堡 我想

简洁实现

  1. num_hiddens=256
  2. num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
  3. pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']
  5. lr = 1e-2 # 注意调整学习率
  6. lstm_layer = nn.LSTM(input_size=vocab_size, hidden_size=num_hiddens)
  7. model = d2l.RNNModel(lstm_layer, vocab_size)
  8. d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
  9.                                 corpus_indices, idx_to_char, char_to_idx,
  10.                                 num_epochs, num_steps, lr, clipping_theta,
  11.                                 batch_size, pred_period, pred_len, prefixes)
  1. epoch 40, perplexity 1.019881, time 1.04 sec
  2.  - 分开始打呼 管家是一只会说法语举止优雅的猪 吸血前会念约翰福音做为弥补 拥有一双蓝色眼睛的凯萨琳公主 专
  3.  - 不分开的玩笑 想通 却又再考倒我 说散 你想很久了吧? 败给你的黑色幽默 不想太多 我想一定是我听错弄错搞
  4. epoch 80, perplexity 1.013078, time 1.01 sec
  5.  - 分开的话像语言暴力 我已无能为力再提起 决定中断熟悉 然后在这里 不限日期 然后将过去 慢慢温习 让我爱
  6.  - 不分开的玩笑 想通 却又再考倒我 说散 你想很久了吧? 败给你的黑色幽默 说散 你想很久了吧? 我的认真败
  7. epoch 120, perplexity 1.010264, time 1.01 sec
  8.  - 分开 我们儿子她人在江南等我 泪不休 语沉默 一壶好酒 再来一碗热粥 配上几斤的牛肉 我说店小二 三两银
  9.  - 不分开 我有你看棒球 想这样没担忧 唱着歌 一直走 我想就这样牵着你的手不放开 爱可不可以简简单单没有伤害
  10. epoch 160, perplexity 1.008950, time 1.02 sec
  11.  - 分开 我才  原来我只想要你 陪我去吃汉堡  说穿了其实我的愿望就怎么小 就怎么每天祈祷我的心跳你知道
  12.  - 不分开 我才你看 我想要再这样打我妈妈 我说的话 你甘会听 不要再这样打我妈妈 难道你手不会痛吗 其实我回

深度循环神经网络

Ht(1)=ϕ(XtWxh(1)+Ht−1(1)Whh(1)+bh(1))Ht(ℓ)=ϕ(Ht(ℓ−1)Wxh(ℓ)+Ht−1(ℓ)Whh(ℓ)+bh(ℓ))Ot=Ht(L)Whq+bq
\boldsymbol{H}_t^{(1)} = \phi(\boldsymbol{X}_t \boldsymbol{W}_{xh}^{(1)} + \boldsymbol{H}_{t-1}^{(1)} \boldsymbol{W}_{hh}^{(1)} + \boldsymbol{b}_h^{(1)})\\
\boldsymbol{H}_t^{(\ell)} = \phi(\boldsymbol{H}_t^{(\ell-1)} \boldsymbol{W}_{xh}^{(\ell)} + \boldsymbol{H}_{t-1}^{(\ell)} \boldsymbol{W}_{hh}^{(\ell)} + \boldsymbol{b}_h^{(\ell)})\\
\boldsymbol{O}_t = \boldsymbol{H}_t^{(L)} \boldsymbol{W}_{hq} + \boldsymbol{b}_q
Ht(1)​=ϕ(Xt​Wxh(1)​+Ht−1(1)​Whh(1)​+bh(1)​)Ht(ℓ)​=ϕ(Ht(ℓ−1)​Wxh(ℓ)​+Ht−1(ℓ)​Whh(ℓ)​+bh(ℓ)​)Ot​=Ht(L)​Whq​+bq​

  3. num_hiddens=256
  4. num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e2, 1e-2
  5. pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']
  7. lr = 1e-2 # 注意调整学习率
  9. gru_layer = nn.LSTM(input_size=vocab_size, hidden_size=num_hiddens,num_layers=2)
  10. model = d2l.RNNModel(gru_layer, vocab_size).to(device)
  11. d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
  12.                                 corpus_indices, idx_to_char, char_to_idx,
  13.                                 num_epochs, num_steps, lr, clipping_theta,
  14.                                 batch_size, pred_period, pred_len, prefixes)
  1. epoch 40, perplexity 12.840496, time 1.52 sec
  2.  - 分开我 想你的话我在想再你的让我女疼 我想你 我有要有 想你你 想你的让我女沉 我想你你 想你的让我女沉
  3.  - 不分开的经爱女人 坏坏的让我疯狂的可爱女人 坏坏的让我疯狂的可爱女人 坏坏的让我疯狂的可爱女人 坏坏的让我
  4. epoch 80, perplexity 1.247634, time 1.52 sec
  5.  - 分开有一条热昏头的响尾蛇 无力的躺在干枯的河 在等待雨季来临变沼泽 灰狼啃食著水鹿的骨头 秃鹰盘旋死盯着
  6.  - 不分开的会手 穿梭放受 一朵一朵因你而香 试图让夕阳飞翔 带领你我环绕大自然 迎著风 开始共渡每一天 手牵
  7. epoch 120, perplexity 1.021974, time 1.56 sec
  8.  - 分开我妈妈 我有多重要 我后悔没让你知道 安静的听你撒娇 看你睡著一直到老 就是开不了口让她知道 就是那
  9.  - 不分开的会堡  想要将我不投 又不会掩护我 选你这种队友 瞎透了我 说你说 分数怎么停留 一直在停留 谁让
  10. epoch 160, perplexity 1.016324, time 1.59 sec
  11.  - 分开在没有一个人身留  旧时光 一九四三 在回忆 的路上 时间变好慢 老街坊 小弄堂 是属于那年代白墙黑
  12.  - 不分开的我有 有样的要再这样打我妈妈 难道你手不会痛吗 不要再这样打我妈妈 难道你手不会痛吗 不要再这样打
  1. gru_layer = nn.LSTM(input_size=vocab_size, hidden_size=num_hiddens,num_layers=6)
  2. model = d2l.RNNModel(gru_layer, vocab_size).to(device)
  3. d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
  4.                                 corpus_indices, idx_to_char, char_to_idx,
  5.                                 num_epochs, num_steps, lr, clipping_theta,
  6.                                 batch_size, pred_period, pred_len, prefixes)
  1. epoch 40, perplexity 276.815235, time 8.50 sec
  2.  - 分开
  3.  - 不分开
  4. epoch 80, perplexity 276.278550, time 8.51 sec
  5.  - 分开
  6.  - 不分开
  7. epoch 120, perplexity 276.146710, time 8.53 sec
  8.  - 分开
  9.  - 不分开
  10. epoch 160, perplexity 275.739864, time 9.04 sec
  11.  - 分开
  12.  - 不分开

双向循环神经网络

H→t=ϕ(XtWxh(f)+H→t−1Whh(f)+bh(f))H←t=ϕ(XtWxh(b)+H←t+1Whh(b)+bh(b))
\begin{aligned} \overrightarrow{\boldsymbol{H}}_t &= \phi(\boldsymbol{X}_t \boldsymbol{W}_{xh}^{(f)} + \overrightarrow{\boldsymbol{H}}_{t-1} \boldsymbol{W}_{hh}^{(f)} + \boldsymbol{b}_h^{(f)})\\
\overleftarrow{\boldsymbol{H}}_t &= \phi(\boldsymbol{X}_t \boldsymbol{W}_{xh}^{(b)} + \overleftarrow{\boldsymbol{H}}_{t+1} \boldsymbol{W}_{hh}^{(b)} + \boldsymbol{b}_h^{(b)}) \end{aligned} Ht​Ht​​=ϕ(Xt​Wxh(f)​+Ht−1​Whh(f)​+bh(f)​)=ϕ(Xt​Wxh(b)​+Ht+1​Whh(b)​+bh(b)​)​

Ht=(H→t,H←t)
\boldsymbol{H}_t=(\overrightarrow{\boldsymbol{H}}_{t}, \overleftarrow{\boldsymbol{H}}_t)
Ht​=(Ht​,Ht​)

Ot=HtWhq+bq
\boldsymbol{O}_t = \boldsymbol{H}_t \boldsymbol{W}_{hq} + \boldsymbol{b}_q
Ot​=Ht​Whq​+bq​

  1. num_hiddens=128
  2. num_epochs, num_steps, batch_size, lr, clipping_theta = 160, 35, 32, 1e-2, 1e-2
  3. pred_period, pred_len, prefixes = 40, 50, ['分开', '不分开']
  5. lr = 1e-2 # 注意调整学习率
  7. gru_layer = nn.GRU(input_size=vocab_size, hidden_size=num_hiddens,bidirectional=True)
  8. model = d2l.RNNModel(gru_layer, vocab_size).to(device)
  9. d2l.train_and_predict_rnn_pytorch(model, num_hiddens, vocab_size, device,
  10.                                 corpus_indices, idx_to_char, char_to_idx,
  11.                                 num_epochs, num_steps, lr, clipping_theta,
  12.                                 batch_size, pred_period, pred_len, prefixes)
  1. epoch 40, perplexity 1.001741, time 0.91 sec
  2.  - 分开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开
  3.  - 不分开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开
  4. epoch 80, perplexity 1.000520, time 0.91 sec
  5.  - 分开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开
  6.  - 不分开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开
  7. epoch 120, perplexity 1.000255, time 0.99 sec
  8.  - 分开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开
  9.  - 不分开球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我
  10. epoch 160, perplexity 1.000151, time 0.92 sec
  11.  - 分开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开始开
  12.  - 不分开球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我球我

L9循环神经网络进阶 ModernRNN的更多相关文章

  1. [ DLPytorch ] 循环神经网络进阶&拟合问题&梯度消失与爆炸

    循环神经网络进阶 BPTT 反向传播过程中,训练模型通常需要模型参数的梯度. \[ \frac{\partial L}{\partial \boldsymbol{W}_{qh}} = \sum_{t= ...

  2. 循环神经网络-RNN进阶

    这部分许多内容要类比CNN来进行理解和解释,所以需要对CNN比较熟悉. RNN的特点 1. 权值共享 CNN权值共享,RNN也有权值共享,在入门篇可以看到RNN结构图中,权重使用的是同样的字母 为什么 ...

  3. Recurrent Neural Network系列1--RNN（循环神经网络）概述

    作者:zhbzz2007 出处:http://www.cnblogs.com/zhbzz2007 欢迎转载,也请保留这段声明.谢谢! 本文翻译自 RECURRENT NEURAL NETWORKS T ...

  4. Java 第8章 循环结构进阶

    循环结构进阶 什么是二重循环? 二重循环的执行顺序是什么?

  5. Recurrent Neural Network(循环神经网络)

    Reference:   Alex Graves的[Supervised Sequence Labelling with RecurrentNeural Networks] Alex是RNN最著名变种 ...

  6. 循环神经网络(RNN, Recurrent Neural Networks)介绍（转载）

    循环神经网络(RNN, Recurrent Neural Networks)介绍    这篇文章很多内容是参考:http://www.wildml.com/2015/09/recurrent-neur ...

  7. CNN(卷积神经网络)、RNN(循环神经网络)、DNN(深度神经网络)的内部网络结构有什么区别？

    https://www.zhihu.com/question/34681168 CNN(卷积神经网络).RNN(循环神经网络).DNN(深度神经网络)的内部网络结构有什么区别?修改 CNN(卷积神经网 ...

  8. 循环神经网络(RNN)模型与前向反向传播算法

    在前面我们讲到了DNN,以及DNN的特例CNN的模型和前向反向传播算法,这些算法都是前向反馈的,模型的输出和模型本身没有关联关系.今天我们就讨论另一类输出和模型间有反馈的神经网络:循环神经网络(Rec ...

  9. 循环神经网络RNN公式推导走读

    0语言模型-N-Gram 语言模型就是给定句子前面部分,预测后面缺失部分 eg．我昨天上学迟到了,老师批评了____. N-Gram模型: ,对一句话切词 我 昨天 上学 迟到 了 ,老师 批评 了 ...

随机推荐

  1. Redis 主从复制技术原理

    基于前面介绍的 Redis 内容,Redis 只能作为一个单机内存数据库,一旦服务器宕机即不能提供服务,即便能通过持久化策略重启恢复数据,往往也做不到百分之百还原.再一个就是,单机的 Redis 需要 ...

  2. Hive常用的10个系统函数及作用

    聚合函数 函数处理的数据粒度为多条记录. sum()—求和 count()—求数据量 avg()—求平均直 distinct—求不同值数 min—求最小值 max—求最人值 分析函数 Analytic ...

  3. 2020年PHP 面试问题(二）

    一.什么是 CGI?什么是 FastCGI?php-fpm,FastCGI,Nginx 之间是什么关系? CGI,通用网关接口,用于WEB服务器和应用程序间的交互,定义输入输出规范,用户的请求通过WE ...

  4. 【转】.strip().split('t')和.strip().split()

    https://blog.csdn.net/qq_35290785/article/details/94780620 .strip().split('t')line =' nihao, zhenhao ...

  5. Attention-based Extraction of Structured Information from Street View Imagery：基于注意力的街景图像提取结构化信息

    基于注意力的街景图像提取结构化信息 一种用于真实图像文本提取问题的TensorFlow模型. 该文件夹包含在FSNS数据集数据集上训练新的注意OCR模型所需的代码,以在法国转录街道名称. 您还可以使用 ...

  6. PHP7内核（三）：源码目录结构

    上篇文章我们已经介绍了源码分析工具的安装.配置以及调试方法,本文我们来讲述一下PHP源码的目录结构. 一.目录概览 以php-7.0.12为例,看过源码的同学们应该发现源码目录多达十多个,下面是每个目 ...

  7. 【SQL SERVER】锁机制

    锁定是 SQL Server 数据库引擎用来同步多个用户同时对同一个数据块的访问的一种机制. 基本概念 利用SQL Server Profiler观察锁 死锁产生的原因及避免 总结 基本概念 数据库引 ...

  8. 性能计数器在.NET Core中的新玩法

    传统的.NET Framework提供的System.Diagnostics.PerformanceCounter类型可以帮助我们收集Windows操作系统下物理机或者进程的性能指标,基于Perfor ...

  9. coding++：Spring Boot 全局事务解释及使用（二）

    什么是全局事务: Spring Boot(Spring) 事务是通过 aop(aop相关术语:通知(Advice).连接点(Joinpoint).切入点(Pointcut).切面(Aspect).目标 ...

  10. Java程序员必读的9本书

    本文列出的9本书在Java程序员界都是被认为很棒的书.当一个程序员开始初学Java时,他的第一个问题应该是如何选择一本书来作为指导学习Java.这个问题也就表明,相对于其他的教程和博客,Java书籍还 ...