深度学习--------------------黑白期影象网络(LSTM)

黑白期影象网络

忘记门：将值朝0减少
输入门：决定要不要忽略掉输入数据
输出门：决定要不要使用隐状态。

---

候选影象单元

---

影象单元

影象单元会把上一个时候的影象单元作为状态放进来，所以LSTM和RNN跟GRU不一样的地方是它的状态里面有两个独立的。
如果：                                                   F                               t                                            F_t                     Ft​即是0的话，就是盼望不要记住                                                   C                                           t                                  −                                  1                                                       C_{t-1}                     Ct−1​。
如果：                                                   I                               t                                            I_t                     It​是1的话，就是盼望只管的去用它，如果                                                   I                               t                                            I_t                     It​即是0的话，就是把如今的影象单元丢掉。

---

隐状态

---

黑白期影象网络代码从零实现

1. import torch
2. from torch import nn
3. from d2l import torch as d2l
5. # 设置批量大小为32，时间步数为35
6. batch_size, num_steps = 32, 35
7. # 使用d2l库中的load_data_time_machine函数加载时间机器数据集，
8. # 并设置批量大小为32，时间步数为35，将加载的数据集赋值给train_iter和vocab变量
9. train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

复制代码

---

初始化模型参数

1. def get_lstm_params(vocab_size, num_hiddens, device):
2.     # 将词汇表大小赋值给num_inputs和num_outputs
3.     num_inputs = num_outputs = vocab_size
4.    
5.     # 定义一个辅助函数normal，用于生成具有特定形状的正态分布随机数，并将其初始化为较小的值
6.     def normal(shape):
7.         return torch.randn(size=shape, device=device) * 0.01
8.    
9.     # 定义一个辅助函数three，用于生成三个参数：输入到隐藏状态的权重矩阵、隐藏状态到隐藏状态的权重矩阵和隐藏状态的偏置项
10.     def three():
11.         return (normal(
12.             (num_inputs, num_hiddens)), normal((num_hiddens, num_hiddens)),
13.                 torch.zeros(num_hiddens, device=device))
14.    
15.     # 调用three函数获取输入到隐藏状态的权重矩阵W_xi、隐藏状态到隐藏状态的权重矩阵W_hi和隐藏状态的偏置项b_i
16.     W_xi, W_hi, b_i = three()
17.     # 调用three函数获取输入到隐藏状态的权重矩阵W_xf、隐藏状态到隐藏状态的权重矩阵W_hf和隐藏状态的偏置项b_f
18.     W_xf, W_hf, b_f = three()
19.     # 调用three函数获取输入到隐藏状态的权重矩阵W_xo、隐藏状态到隐藏状态的权重矩阵W_ho和隐藏状态的偏置项b_o
20.     W_xo, W_ho, b_o = three()
21.     # 调用three函数获取输入到隐藏状态的权重矩阵W_xc、隐藏状态到隐藏状态的权重矩阵W_hc和隐藏状态的偏置项b_c
22.     W_xc, W_hc, b_c = three()
23.     # 生成隐藏状态到输出的权重矩阵W_hq
24.     W_hq = normal((num_hiddens, num_outputs))
25.     # 生成输出的偏置项b_q
26.     b_q  = torch.zeros(num_outputs, device=device)
27.     # 将所有参数组合成列表params
28.     params = [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]   
29.    
30.     # 变量所有参数
31.     for param in params:
32.         # 将所有参数的requires_grad属性设置为True，表示需要计算梯度
33.         param.requires_grad_(True)
34.         
35.     # 返回所有参数
36.     return params

复制代码

---

初始化

1. def init_lstm_state(batch_size, num_hiddens, device):
2.     # 返回一个元组，包含两个张量：一个全零张量表示初始的隐藏状态(即：H要有个初始化)，和一个全零张量表示初始的记忆细胞状态(即：C要有个初始化)。
3.     return (torch.zeros((batch_size, num_hiddens), device=device),
4.             torch.zeros((batch_size, num_hiddens), device=device))

复制代码

---

实际模型

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.     # 解包状态元组state，分别赋值给隐藏状态H和记忆细胞状态C
4.     (H, C) = state
5.     # 创建一个空列表用于存储每个时间步的输出
6.     outputs = []
7.     # 对于输入序列中的每个时间步
8.     for X in inputs:
9.         # 输入门的计算：使用输入、隐藏状态和偏置项，通过线性变换和sigmoid函数计算输入门
10.         I = torch.sigmoid((X @ W_xi) + (H @ W_hi) + b_i)
11.         # 遗忘门的计算：使用输入、隐藏状态和偏置项，通过线性变换和sigmoid函数计算遗忘门
12.         F = torch.sigmoid((X @ W_xf) + (H @ W_hf) + b_f)
13.         # 输出门的计算：使用输入、隐藏状态和偏置项，通过线性变换和sigmoid函数计算输出门
14.         O = torch.sigmoid((X @ W_xo) + (H @ W_ho) + b_o)
15.         # 新的记忆细胞候选值的计算：使用输入、隐藏状态和偏置项，通过线性变换和tanh函数计算新的记忆细胞候选值
16.         C_tilda = torch.tanh((X @ W_xc) + (H @ W_hc) + b_c)
17.         # 更新记忆细胞状态：将旧的记忆细胞状态与遗忘门和输入门的乘积相加，再与新的记忆细胞候选值的乘积相加，得到新的记忆细胞状态
18.         C = F * C + I * C_tilda
19.         # 更新隐藏状态：将输出门和经过tanh函数处理的记忆细胞状态的乘积作为新的隐藏状态
20.         H = O * torch.tanh(C)
21.         # 输出的计算：使用新的隐藏状态和偏置项，通过线性变换得到输出
22.         Y = (H @ W_hq) + b_q
23.         # 将当前时间步的输出添加到列表中
24.         outputs.append(Y)
25.     # 将所有时间步的输出在维度0上拼接起来，作为最终的输出结果；
26.     # 返回最终的输出结果和更新后的隐藏状态和记忆细胞状态的元组
27.     return torch.cat(outputs, dim=0), (H, C)

复制代码

---

训练

1. vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
2. num_epochs, lr = 500, 1
3. # 使用d2l库中的RNNModelScratch类创建一个基于LSTM的模型对象，
4. model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_lstm_params, init_lstm_state, lstm)
5. d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

复制代码

---

简洁实现

1. import torch
2. from torch import nn
3. from d2l import torch as d2l
5. batch_size, num_steps = 32, 35
6. train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
7. vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu()
8. num_epochs, lr = 500, 1
9. num_inputs = vocab_size
10. # 使用nn.LSTM创建一个LSTM层，输入特征数量为num_inputs，隐藏单元数量为num_hiddens
11. lstm_layer = nn.LSTM(num_inputs, num_hiddens)
12. # 使用d2l库中的RNNModel类创建一个基于LSTM的模型对象，传入LSTM层和词汇表大小
13. model = d2l.RNNModel(lstm_layer, len(vocab))
14. mode = model.to(device)
15. d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)
16. d2l.plt.show()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。