目录
5. 实现“Character-Level Language Models”源代码
1. 使用Numpy实现SRN
代码：
import numpy as np
inputs = np.array([[1., 1.],
[1., 1.],
[2., 2.]]) # 初始化输入序列
print('inputs is ', inputs)
state_t = np.zeros(2, ) # 初始化存储器
print('state_t is ', state_t)
w1, w2, w3, w4, w5, w6, w7, w8 = 1., 1., 1., 1., 1., 1., 1., 1.
U1, U2, U3, U4 = 1., 1., 1., 1.
for input_t in inputs:
print('inputs is ', input_t)
print('state_t is ', state_t)
in_h1 = np.dot([w1, w3], input_t) + np.dot([U2, U4], state_t)
in_h2 = np.dot([w2, w4], input_t) + np.dot([U1, U3], state_t)
state_t = in_h1, in_h2
output_y1 = np.dot([w5, w7], [in_h1, in_h2])
output_y2 = np.dot([w6, w8], [in_h1, in_h2])
print('output_y is ', output_y1, output_y2)
print('---------------------') 运行结果：
手算结果：
和PPT结果以及程序运算结果一致。
2. 在1的基础上，增加激活函数tanh
代码：
import numpy as np
inputs = np.array([[1., 1.],
[1., 1.],
[2., 2.]]) # 初始化输入序列
print('inputs is ', inputs)
state_t = np.zeros(2, ) # 初始化存储器
print('state_t is ', state_t)
w1, w2, w3, w4, w5, w6, w7, w8 = 1., 1., 1., 1., 1., 1., 1., 1.
U1, U2, U3, U4 = 1., 1., 1., 1.
print('--------------------------------------')
for input_t in inputs:
print('inputs is ', input_t)
print('state_t is ', state_t)
in_h1 = np.tanh(np.dot([w1, w3], input_t) + np.dot([U2, U4], state_t))
in_h2 = np.tanh(np.dot([w2, w4], input_t) + np.dot([U1, U3], state_t))
state_t = in_h1, in_h2
output_y1 = np.dot([w5, w7], [in_h1, in_h2])
output_y2 = np.dot([w6, w8], [in_h1, in_h2])
print('output_y is ', output_y1, output_y2)
print('---------------------------------------------')运行结果：
3. 分别使用nn.RNNCell、nn.RNN实现SRN
学习一下nn.RNNCell()和nn.RNN()：
这两种方式的区别在于nn.RNNCell()只能接受序列中单步的输入，且必须传入隐藏状态，而nn.RNN()可以接受一个序列的输入，默认会传入全 0 的隐藏状态，也可以自己申明隐藏状态传入。一般情况下我们都是用nn.RNN()而不是nn.RNNCell(),因为 nn.RNN() 能够避免我们手动写循环,非常方便。
下面是nn.RNNCell()和nn.RNN()的官方文档介绍：
nn.RNN()：
RNN的输入格式不同于CNN，CNN模型的输入尺寸是batch_size放前面，也就是
[batch_size, input_size_1, input_size_2]，而RNN是放中间，也就是
[input_size_1, batch_size, input_size_2]
nn.RNNCell()：
可以看到nn.RNN()是读取了0时刻的隐层信息h0，剩下的过程自动循环完成;而nn.RNNCell()需要自己写循环处理。
接下来代码实现对比二者区别：
nn.RNNCell实现：
import torch
batch_size = 1
seq_len = 3 # 序列长度
input_size = 2 # 输入序列维度
hidden_size = 2 # 隐藏层维度
output_size = 2 # 输出层维度
# RNNCell
cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size)
# 初始化参数 https://zhuanlan.zhihu.com/p/342012463
for name, param in cell.named_parameters():
if name.startswith("weight"):
torch.nn.init.ones_(param)
else:
torch.nn.init.zeros_(param)
# 线性层
liner = torch.nn.Linear(hidden_size, output_size)
liner.weight.data = torch.Tensor([[1, 1], [1, 1]])
liner.bias.data = torch.Tensor([0.0])
seq = torch.Tensor([[[1, 1]],
[[1, 1]],
[[2, 2]]])
hidden = torch.zeros(batch_size, hidden_size)
output = torch.zeros(batch_size, output_size)
for idx, input in enumerate(seq):
print('=' * 20, idx, '=' * 20)
print('Input :', input)
print('hidden :', hidden)
hidden = cell(input, hidden)
output = liner(hidden)
print('output :', output)运行结果：
nn.RNN实现:
import torch
batch_size = 1
seq_len = 3
input_size = 2
hidden_size = 2
num_layers = 1
output_size = 2
cell = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers)
for name, param in cell.named_parameters(): # 初始化参数
if name.startswith("weight"):
torch.nn.init.ones_(param)
else:
torch.nn.init.zeros_(param)
# 线性层
liner = torch.nn.Linear(hidden_size, output_size)
liner.weight.data = torch.Tensor([[1, 1], [1, 1]])
liner.bias.data = torch.Tensor([0.0])
inputs = torch.Tensor([[[1, 1]],
[[1, 1]],
[[2, 2]]])
hidden = torch.zeros(num_layers, batch_size, hidden_size)
out, hidden = cell(inputs, hidden)
print('Input :', inputs[0])
print('hidden:', 0, 0)
print('Output:', liner(out[0]))
print('--------------------------------------')
print('Input :', inputs[1])
print('hidden:', out[0])
print('Output:', liner(out[1]))
print('--------------------------------------')
print('Input :', inputs[2])
print('hidden:', out[1])
print('Output:', liner(out[2]))运行结果：
4. 分析“二进制加法” 源代码
二进制加法思想为逢二进一，对应到代码上“二进制加法”主要做的事就是告诉RNN前一阶段的运算结果(进位)和当前阶段(加法)，让RNN网络自己去学习加法和进位操作，具体操作就是将两个二进制传入，从最后一位开始，一层一层地通过sigmoid函数，得到最终的预测值。然后将预测值与准确值之间的差值设为layer_2层的loss值。得出loss值后，就可以得到对应层的权重参数，进而从最高位像前进行反向传播(从代码上来看，就是很普通的反向传播)。
动态演示：
前向传播：
反向传播(黑色是预测值，errors是亮黄色，派生物(导数)是芥末色):
讲的不是那么清楚，官网有更加详细的演示解释和代码注释：
Anyone Can Learn To Code an LSTM-RNN in Python (Part 1: RNN) - i am trask
5. 实现“Character-Level Language Models”源代码
因为这次反向传播和之间实验做得反向传播相差不大，所以直接调用backward()：
import torch
# 使用RNN 有嵌入层和线性层
num_class = 4 # 4个类别
input_size = 4 # 输入维度是4
hidden_size = 8 # 隐层是8个维度
embedding_size = 10 # 嵌入到10维空间
batch_size = 1
num_layers = 2 # 两层的RNN
seq_len = 5 # 序列长度是5
# 准备数据
idx2char = ['e','h','l','o'] # 字典
x_data = [[1,0,2,2,3]] # hello 维度（batch,seqlen）
y_data = [3,1,2,3,2] # ohlol 维度 (batch*seqlen)
inputs = torch.LongTensor(x_data)
labels = torch.LongTensor(y_data)
# 构造模型
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
self.emb = torch.nn.Embedding(input_size,embedding_size)
self.rnn = torch.nn.RNN(input_size=embedding_size,hidden_size=hidden_size,num_layers=num_layers,batch_first=True)
self.fc = torch.nn.Linear(hidden_size,num_class)
def forward(self,x):
hidden = torch.zeros(num_layers,x.size(0),hidden_size)
x = self.emb(x) # (batch,seqlen,embeddingsize)
x,_ = self.rnn(x,hidden)
x = self.fc(x)
return x.view(-1,num_class) # 转变维2维矩阵，seq*batchsize*numclass -》((seq*batchsize),numclass)
model = Model()
# 损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(),lr=0.05) # lr = 0.01学习的太慢
# 训练
for epoch in range(15):
optimizer.zero_grad()
outputs = model(inputs) # inputs是（seq,Batchsize,Inputsize） outputs是(seq,Batchsize,Hiddensize)
loss = criterion(outputs,labels) # labels是（seq，batchsize，1）
loss.backward()
optimizer.step()
_,idx = outputs.max(dim=1)
idx = idx.data.numpy()
print("Predicted:",''.join([idx2char[x] for x in idx]),end='')
print(",Epoch {}/15 loss={:.3f}".format(epoch+1,loss.item()))
运行结果：
翻译：开头便提到了普通网络和卷积神经网络的局限性，即接受固定大小的向量作为输入（例如图像）并产生固定大小的向量作为输出（例如不同类别的概率） ）。不仅如此：这些模型使用固定数量的计算步骤（例如模型中的层数）执行此映射。而循环网络允许我们对向量序列进行操作：输入中的序列、输出中的序列，或者在最一般的情况下两者兼而有之，如下所示：
每个矩形都是一个向量，箭头代表函数（例如矩阵乘法）。输入向量为红色，输出向量为蓝色，绿色向量保持 RNN 的状态（稍后会详细介绍）。从左到右：（1）没有RNN的Vanilla模式处理，从固定大小的输入到固定大小的输出（例如图像分类）。(2)序列输出（例如图像字幕获取图像并输出一个单词的句子）。(3)序列输入（例如，给定句子被分类为表达积极或消极情绪的情绪分析）。(4)序列输入和序列输出（例如机器翻译：RNN 读取英文句子，然后输出法文句子）。(5)同步序列输入和输出（例如，我们希望标记视频的每一帧的视频分类）。请注意，在每种情况下，对长度序列都没有预先指定的约束，因为循环变换（绿色）是固定的，可以应用任意多次。（抄自谷歌翻译）
总的来说，RNN 将输入向量与其状态向量与一个固定的（但学习的）函数相结合，以产生一个新的状态向量，如果训练普通神经网络是对函数的优化，那么训练循环网络就是对程序的优化。
但是RNN在没有序列的情况下仍能进行顺序处理，如下：
即即使数据不是序列形式，您仍然可以制定和训练强大的模型来学习按顺序处理它。
然后就是介绍char-RNN的内容：
例如，我们看到，在第一个时间步，当 RNN 看到字符“h”时，它为下一个字母“h”分配置信度 1.0，将 2.2 分配给字母“e”，-3.0 分配给“l”，以及 4.1也”。由于在我们的训练数据（字符串“hello”）中，下一个正确字符是“e”，我们希望增加它的置信度（绿色）并降低所有其他字母的置信度（红色）。同样，在我们希望网络赋予更大置信度的 4 个时间步长中的每一个时间步长上，我们都有一个期望的目标角色。由于 RNN 完全由可微分运算组成，我们可以运行反向传播算法（这只是微积分中链式法则的递归应用）来确定我们应该向哪个方向调整每个权重以增加正确目标的分数（绿色粗体数字）。然后我们可以执行一个参数更新，在这个梯度方向上微调每个权重。如果我们在参数更新后向 RNN 提供相同的输入，我们会发现正确字符的分数（例如第一个时间步中的“e”）会略高（例如 2.3 而不是 2.2），并且错误字符的分数会略低。然后我们一遍又一遍地重复这个过程，直到网络收敛并且它的预测最终与训练数据一致，因为正确的字符总是被预测到下一个。
更技术性的解释是，我们同时对每个输出向量使用标准 Softmax 分类器（通常也称为交叉熵损失）。RNN 使用小批量随机梯度下降进行训练，我喜欢使用RMSProp或 Adam（每参数自适应学习率方法）来稳定更新。
另请注意，第一次输入字符“l”时，目标是“l”，但第二次输入的目标是“o”。因此，RNN 不能单独依赖输入，必须使用其循环连接来跟踪上下文以完成此任务。
在测试时，我们将一个字符输入 RNN 并获得接下来可能出现的字符的分布。我们从这个分布中采样，并直接反馈给它以获得下一个字母。重复此过程，您正在对文本进行采样！现在让我们在不同的数据集上训练一个 RNN，看看会发生什么。
为了进一步澄清，出于教育目的，作者还给出了Python/numpy 中编写了一个最小的字符级 RNN 语言模型。它只有大约 100 行长，如果你更擅长阅读代码而不是文本，希望它能提供一个简洁、具体和有用的总结。我们现在将深入研究使用更高效的 Lua/Torch 代码库生成的示例结果。
最后，作者给了几个RNN的应用，不再赘述。
参考链接：
The Unreasonable Effectiveness of Recurrent Neural Networks
6. 分析“序列到序列”源代码
将Seq2Seq模型分为三部分：Encoder、Decoder、Seq2Seq。
Encoder：
这一部分有五个参数，分别为
- input_dim输入encoder的one-hot向量维度，这个和输入词汇大小一致
- emb_dim嵌入层的维度，这一层将one-hot向量转为密度向量
- hid_dim隐藏层和cell状态维度
- n_layersRNN的层数
- dropout是要使用的丢失量。这是一个防止过度拟合的正则化参数
返回值：输出（每个时间步的顶层隐藏状态），隐藏（每个层的最终隐藏状态，堆叠在彼此之上）和单元格（每个层的最终单元状态
，叠加在彼此之上）。
由于只需要最终隐藏和单元格状态（以制作我们的上下文向量），因此只返回隐藏和单元格。
Decoder:
Decoder只执行一个解码步骤。第一层将从前一个时间步，接收隐藏和单元状态，并通过将当前的token 喂给LSTM，进一步产生一个新的隐藏和单元状态。后续层将使用下面层中的隐藏状态，以及来自其图层的先前隐藏和单元状态，。这提供了与编码器中的方程非常相似的方程。
另外，Decoder的初始隐藏和单元状态是我们的上下文向量，它们是来自同一层的Encoder的最终隐藏和单元状态
接下来将隐藏状态传递给Linear层，预测目标序列下一个标记应该是什么。
Decoder的参数和Encoder类似，其中output_dim是将要输入到Decoder的one-hot向量。
在forward方法中，获取到了输入token、上一层的隐藏状态和单元状态。解压之后加入句子长度维度。接下来与Encoder类似，传入嵌入层并使用dropout，然后将这批嵌入式令牌传递到具有先前隐藏和单元状态的RNN。这产生了一个输出（来自RNN顶层的隐藏状态），一个新的隐藏状态（每个层一个，堆叠在彼此之上）和一个新的单元状态（每层也有一个，堆叠在彼此的顶部） ）。然后我们通过线性层传递输出（在除去句子长度维度之后）以接收我们的预测。然后我们返回预测，新的隐藏状态和新的单元状态。
Seq2Seq:
- 接收输入/源句子
- 使用Encoder生成上下文向量
- 使用Decoder生成预测输出/目标句子
参数说明：
- device ：把张量放到GPU上。新版的Pytorch使用to方法可以容易地将对象移动到不同的设备（代替以前的cpu()或cuda()方法）
- outputs：存储Decoder所有输出的张量
- teacher_forcing_ratio：该参数的作用是，当使用teacher force时，decoder网络的下一个input是目标语言的下一个字符，当不使用时，网络的下一个input是其预测出的那个字符。
在该网络中，编码器和解码器的层数（n_layers）和隐藏层维度（hid_dim）是相等。但是，在其他的Seq2seq模型中不一定总是需要相同的层数或相同的隐藏维度大小。例如，编码器有2层，解码器只有1层，这就需要进行相应的处理，如对编码器输出的两个上下文向量求平均值，或者只使用最后一层的上下文向量作为解码器的输入等。
分析的不太到位，可以去看官网源码以及相应的解释或者佬的解释：
NLP From Scratch: Translation with a Sequence to Sequence Network and Attention — PyTorch Tutorials 1.13.0+cu117 documentation
Pytorch学习记录-torchtext和Pytorch的实例（ 使用神经网络训练Seq2Seq代码） - 交流_QQ_2240410488 - 博客园Pytorch实现Seq2Seq模型：以机器翻译为例_Flutter Yang的博客-CSDN博客_中src trgPytorch学习记录-torchtext和Pytorch的实例（ 使用神经网络训练Seq2Seq代码） - 交流_QQ_2240410488 - 博客园
7. “编码器-解码器”的简单实现
跑了一下源码，还挺好玩：
import torch
import numpy as np
import torch.nn as nn
import torch.utils.data as Data
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
letter = [c for c in 'SE?abcdefghijklmnopqrstuvwxyz']
letter2idx = {n: i for i, n in enumerate(letter)}
seq_data = [['man', 'women'], ['black', 'white'], ['king', 'queen'], ['girl', 'boy'], ['up', 'down'], ['high', 'low']]
# Seq2Seq Parameter
n_step = max([max(len(i), len(j)) for i, j in seq_data]) # max_len(=5)
n_hidden = 128
n_class = len(letter2idx) # classfication problem
batch_size = 3
def make_data(seq_data):
enc_input_all, dec_input_all, dec_output_all = [], [], []
for seq in seq_data:
for i in range(2):
seq[i] = seq[i] + '?' * (n_step - len(seq[i])) # 'man??', 'women'
enc_input = [letter2idx[n] for n in (seq[0] + 'E')] # ['m', 'a', 'n', '?', '?', 'E']
dec_input = [letter2idx[n] for n in ('S' + seq[1])] # ['S', 'w', 'o', 'm', 'e', 'n']
dec_output = [letter2idx[n] for n in (seq[1] + 'E')] # ['w', 'o', 'm', 'e', 'n', 'E']
enc_input_all.append(np.eye(n_class)[enc_input])
dec_input_all.append(np.eye(n_class)[dec_input])
dec_output_all.append(dec_output) # not one-hot
# make tensor
return torch.Tensor(enc_input_all), torch.Tensor(dec_input_all), torch.LongTensor(dec_output_all)
enc_input_all, dec_input_all, dec_output_all = make_data(seq_data)
class TranslateDataSet(Data.Dataset):
def __init__(self, enc_input_all, dec_input_all, dec_output_all):
self.enc_input_all = enc_input_all
self.dec_input_all = dec_input_all
self.dec_output_all = dec_output_all
def __len__(self): # return dataset size
return len(self.enc_input_all)
def __getitem__(self, idx):
return self.enc_input_all[idx], self.dec_input_all[idx], self.dec_output_all[idx]
loader = Data.DataLoader(TranslateDataSet(enc_input_all, dec_input_all, dec_output_all), batch_size, True)
# Model
class Seq2Seq(nn.Module):
def __init__(self):
super(Seq2Seq, self).__init__()
self.encoder = nn.RNN(input_size=n_class, hidden_size=n_hidden, dropout=0.5) # encoder
self.decoder = nn.RNN(input_size=n_class, hidden_size=n_hidden, dropout=0.5) # decoder
self.fc = nn.Linear(n_hidden, n_class)
def forward(self, enc_input, enc_hidden, dec_input):
enc_input = enc_input.transpose(0, 1) # enc_input: [n_step+1, batch_size, n_class]
dec_input = dec_input.transpose(0, 1) # dec_input: [n_step+1, batch_size, n_class]
# h_t : [num_layers(=1) * num_directions(=1), batch_size, n_hidden]
_, h_t = self.encoder(enc_input, enc_hidden)
# outputs : [n_step+1, batch_size, num_directions(=1) * n_hidden(=128)]
outputs, _ = self.decoder(dec_input, h_t)
model = self.fc(outputs) # model : [n_step+1, batch_size, n_class]
return model
model = Seq2Seq().to(device)
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
for epoch in range(5000):
for enc_input_batch, dec_input_batch, dec_output_batch in loader:
# make hidden shape [num_layers * num_directions, batch_size, n_hidden]
h_0 = torch.zeros(1, batch_size, n_hidden).to(device)
(enc_input_batch, dec_intput_batch, dec_output_batch) = (
enc_input_batch.to(device), dec_input_batch.to(device), dec_output_batch.to(device))
# enc_input_batch : [batch_size, n_step+1, n_class]
# dec_intput_batch : [batch_size, n_step+1, n_class]
# dec_output_batch : [batch_size, n_step+1], not one-hot
pred = model(enc_input_batch, h_0, dec_intput_batch)
# pred : [n_step+1, batch_size, n_class]
pred = pred.transpose(0, 1) # [batch_size, n_step+1(=6), n_class]
loss = 0
for i in range(len(dec_output_batch)):
# pred[i] : [n_step+1, n_class]
# dec_output_batch[i] : [n_step+1]
loss += criterion(pred[i], dec_output_batch[i])
if (epoch + 1) % 1000 == 0:
print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Test
def translate(word):
enc_input, dec_input, _ = make_data([[word, '?' * n_step]])
enc_input, dec_input = enc_input.to(device), dec_input.to(device)
# make hidden shape [num_layers * num_directions, batch_size, n_hidden]
hidden = torch.zeros(1, 1, n_hidden).to(device)
output = model(enc_input, hidden, dec_input)
# output : [n_step+1, batch_size, n_class]
predict = output.data.max(2, keepdim=True)[1] # select n_class dimension
decoded = [letter[i] for i in predict]
translated = ''.join(decoded[:decoded.index('E')])
return translated.replace('?', '')
print('test')
print('man ->', translate('man'))
print('mans ->', translate('mans'))
print('king ->', translate('king'))
print('black ->', translate('black'))
print('up ->', translate('up'))
print('old ->', translate('old'))
print('high ->', translate('high'))
运行结果：
参考链接：
总结
这次主要复习了RNN、seq2seq模型，在李宏毅和吴恩达老师的课上听过一些，吴恩达老师也提过这次翻译的论文，只不过当时做的作业是恐龙小作业。学习了char-RNN模型以及对比了nn.RNN（）和nn.RNNCell（）的不同，并做了复现，花了好多时间在阅读论文和代码上面，但是还是不能完全掌握，需要课上进一步探索。感觉结果还挺有意思，与端到端学习不同，大致知道怎么来的。
参考链接
NNDL 作业8：RNN - 简单循环网络_HBU_David的博客-CSDN博客
扫一扫
1618
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
