简单循环神经网络（SRN）
1. 实现SRN
（1）使用Numpy
代码：
import numpy as np
inputs=np.array([[1.,1.],
[1.,1.],
[2.,2.]])#初始化输入序列
print('inputs is:',inputs)
states_t=np.zeros(2,)#初始化存储器
print('states_t is:',states_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 t,input_t in enumerate(inputs):
print('第',t+1,'时刻：')
print('inputs is:',input_t)
print('state_t is:',states_t)
in_h1=np.dot([w1,w3],input_t)+np.dot([U2,U4],states_t)
in_h2=np.dot([w2,w4],input_t)+np.dot([U1,U3],states_t)
states_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('--------------------------------------')
运行结果：
（2）在1的基础上，增加激活函数tanh
代码：
import numpy as np
inputs=np.array([[1.,1.],
[1.,1.],
[2.,2.]])#初始化输入序列
print('inputs is:',inputs)
states_t=np.zeros(2,)#初始化存储器
print('states_t is:',states_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 t,input_t in enumerate(inputs):
print('第',t+1,'时刻：')
print('inputs is:',input_t)
print('state_t is:',states_t)
in_h1=np.tanh(np.dot([w1,w3],input_t)+np.dot([U2,U4],states_t))
in_h2=np.tanh(np.dot([w2,w4],input_t)+np.dot([U1,U3],states_t))
states_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实现
代码：
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)
#线性层
linear=torch.nn.Linear(hidden_size,output_size)
linear.weight.data=torch.Tensor([[1,1],[1,1]])
linear.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('--------------------------------------')
print('第',idx,'时刻：')
print('Input :',input)
print('hidden :',hidden)
hidden=cell(input,hidden)
output=linear(hidden)
print('Output:',output)
运行结果：
（4）使用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)
#线性层
linear=torch.nn.Linear(hidden_size,output_size)
linear.weight.data=torch.Tensor([[1,1],[1,1]])
linear.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:', linear(out[0]))
print('--------------------------------------')
print('Input :', inputs[1])
print('hidden:', out[0])
print('Output:', linear(out[1]))
print('--------------------------------------')
print('Input :', inputs[2])
print('hidden:', out[1])
print('Output:', linear(out[2]))
运行结果：
2. 实现“序列到序列”
观看视频，学习RNN原理，并实现视频P12中的教学案例
循环神经网络（基础篇）_哔哩哔哩_bilibili
代码：
import torch
input_size=4
hidden_size=4
batch_size=1
idx2char=['e','h','l','o']
x_data=[1,0,2,2,3]
y_data=[3,1,2,3,2]
one_hot_lookup=[[1,0,0,0],
[0,1,0,0],
[0,0,1,0],
[0,0,0,1]]
x_one_hot=[one_hot_lookup[x] for x in x_data]
inputs=torch.Tensor(x_one_hot).view(-1,batch_size,input_size)
labels=torch.LongTensor(y_data).view(-1,1)
class Model(torch.nn.Module):
def __init__(self,input_size,hidden_size,batch_size):
super(Model,self).__init__()
self.batch_size=batch_size
self.input_size=input_size
self.hidden_size=hidden_size
self.rnncell=torch.nn.RNNCell(input_size=self.input_size,hidden_size=self.hidden_size)
def forward(self,input,hidden):
hidden=self.rnncell(input,hidden)
return hidden
def init_hidden(self):
return torch.zeros(self.batch_size,self.hidden_size)
net=Model(input_size,hidden_size,batch_size)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.1)
for epoch in range(15):
loss=0
optimizer.zero_grad()
hidden=net.init_hidden()
print('Predicted string: ', end='')
for input,label in zip(inputs,labels):
hidden=net(input,hidden)
loss+=criterion(hidden,label)
_,idx=hidden.max(dim=1)
print(idx2char[idx.item()], end='')
loss.backward()
optimizer.step()
print(', Epoch [%d/15] loss=%.4f' % (epoch + 1, loss.item()))
运行结果：
3. “编码器-解码器”的简单实现
代码：
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')
# S: Symbol that shows starting of decoding input
# E: Symbol that shows starting of decoding output
# ?: Symbol that will fill in blank sequence if current batch data size is short than n_step
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: [6, n_step+1 (because of 'E'), n_class]
dec_input_all: [6, n_step+1 (because of 'S'), n_class]
dec_output_all: [6, n_step+1 (because of 'E')]
'''
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(=input_batch): [batch_size, n_step+1, n_class]
# dec_inpu(=output_batch): [batch_size, n_step+1, n_class]
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'))
运行结果：
4. 简单总结nn.RNNCell、nn.RNN
nn.RNNCell
注意传入的参数的格式。
实例化nn.RNNCell时，传入输入神经元和隐层神经元个数。
调用时，传入的是t时刻输入神经元的值和t-1时刻隐层神经元的值。
在我看来，RNNCell实质上是一个线性层，这个线性层的输入是t时刻前一层神经元和本层t-1时刻的神经元。如下图，对于t时刻的隐层神经元（t时刻蓝色的），它其实就是t时刻前一层神经元（t时刻红色的）和t-1时刻本层神经元（t-1时刻蓝色的）的一个线性组合。
其实就是对我们之前熟悉的全连接层做了一个改进，在t时刻，影响本层神经元的不仅仅只是前一层神经元的值，还有本层神经元上一时刻的值（相当于记住我之前是什么了，有了记忆）。
nn.RNN
注意传入的参数的格式。
实例化nn.RNNCell时，input_size=传入输入神经元个数、hidden_size=隐层神经元个数、num_layers=循环层的个数（也就是有几个隐层）。
调用时，input是要输入的整个序列、hidden是初始时刻每个循环层（隐层）神经元的值。输出的out是对于每一个输入经过多个隐层之后，最后一个隐层的输出的值，输出的hidden是最后每个隐层神经元的值。
注意：batch_first，默认是 False，即输入数据的格式为(seq_len, batch, input_size)。
当batch_first=True时，输入序列的格式应该为( batch,seq_len, input_size)。这一点在实验中会遇到。
当num_layers=1时:
当num_layers=3时:
注意：相同颜色的RNNCell是同一个隐层神经元。
对比nn.RNNCell、nn.RNN：
1. 从输入角度来看：nn.RNNCell输入参数是当前时刻的输入神经元值与前一时刻隐层的值，如果有多个时刻的输入，需要使用for循环遍历每一的输入值，同时要更新隐层的值。nn.RNN是一下把所有时刻的输入和每个隐层的初始值全部都输进去了。
2. 从输出角度来看： nn.RNNCell输出的是当前时刻的隐层输出。nn.RNN输出的是所有时刻最后一个隐层的输出值和最后时刻所有隐层的输出值。
5. 谈一谈对“序列”、“序列到序列”的理解
序列：按字面意思就是有顺序的一组数据。
序列到序列：就如字面意思，输入一个序列，输出另一个序列。这种结构最重要的地方在于输入序列和输出序列的长度是可变的。Seq2Seq 属于 Encoder-Decoder 的大范畴。输入的是一个序列，输出的也是一个序列。有同步的也有异步的。
encoder-decoder听起来有点高大上，其实本质上也就是两个RNN构成的一个模型。
第一个RNN：它的输入是原始序列、hidden_0，我么要的输出是经过RNN后最终每个隐层的值。
第二个RNN：他的输入是加了个结束标志的要预测的最终序列、和经过第一个RNN后最终每个隐层的值（上一个RNN的输出），输出是最终预测的序列。
注意下面这几个问题：
6. 总结本周理论课和作业，写心得体会
这次理论课和作业学到的内容还是不少的！！！
在这次理论课中，了解了循环神经网络，这是一种具有短期记忆能力的网络。
为什么要提出这种网络呢？因为前馈神经网络有缺陷：
1）连接在层与层之间，每层节点间无连接。
2）输入和输出的维数固定，不能任意改变。
3）无法处理时序数据。
我们是如何让循环神经网络有记忆呢？
给网络增加了一个延时器，本质上就是我们创建的一个额外的张量，用于保存隐藏层上一时刻的值，这样我们才能记住之前的信息，否则，在下一时刻我们输入下一个数据时，隐藏层的值经过全连接就会发生改变，如果不用一个额外的变量记住之前的值的话，那么之前的信息就记不住了。
有了记忆呢，如何记住之前的信息呢？
其实就是对我们之前熟悉的全连接层做了一个改进，在t时刻，影响本层神经元的不仅仅只是前一层神经元的值，还有本层神经元上一时刻的值（相当于记住我之前是什么了，有了记忆）。“影响是通过全连接的权重”，权重越大影响越大，反向传播会更新权重。
如代码和图：
in_h1=np.dot(W,input_t)+np.dot(U,states_t)
in_h1是t时刻的隐层的值，W是输入层与隐层连接的权重，U是t时刻的隐层与t-1时刻的隐层连接的权重。这些权重在反向传播时都会进行更新。
注意： 每一时刻的参数U是一样的、W是一样的、b都是一样的，即：每个步骤的参数都是共享的。
简单循环网络（SRN）：只有一个隐层的循环网络。
循环神经网络满足通用近似定理，且是图灵完备的。
构建循环神经网络需要使用nn>RNNCell或nn.RNN。
如何使用nn.RNNCell和nn.RNN呢？
1. 从输入角度来看：nn.RNNCell输入参数是当前时刻的输入神经元值与前一时刻隐层的值，如果有多个时刻的输入，需要使用for循环遍历每一的输入值，同时要更新隐层的值。nn.RNN是一下把所有时刻的输入和每个隐层的初始值全部都输进去了。
2. 从输出角度来看： nn.RNNCell输出的是当前时刻的隐层输出。nn.RNN输出的是所有时刻最后一个隐层的输出值和最后时刻所有隐层的输出值。
循环神经网络都有哪些结构呢？
1）一对一：最简单，就是同样维度的一个输入，对应同样维度的一个输出，一些分类问题，我们可以用这个。比如说给你一句话，判断这句话是好是坏
2）一对多：他的输入只有一个，但那输出可以对应多个，应用于音乐的生成、图片的描述，比如说我输入一个音乐的种类，比如说我要一些欢快的音乐。那么我们可以输入欢快的音乐。那么他最后输出的是一个整套的音乐序列，一个音乐的序列是多个音符。在这里输张图片，通过这个隐藏层的计算，最后输出了一堆文字。也就是说针对于这一个图片的一些描述。
3）多对一：应用于句子的处理，或者说一些多分类的问题，比如说。多分类，在做模型训练的时候，我们可以训练这种多个类别的样本最后对应一个输出
4）多对多：一般有两种，一种是这个输入和输出具有不同维度的。另外一种，就是输入和输出具有相同维度的。就是这样的，那么针对于这个输入和输出是有不同维度的，一般来讲比如说这种翻译这种比如说谷歌翻译，百度翻译可以用这种。那么对于一些这个句子中的人名区别，是具有相同维度的。比如说，我说的是一个句子，输出的是这个句子中的一些人名或者一些地名，或者说一些机构名。
什么是encoder-decoder呢？
其实本质上也就是两个RNN构成的一个模型。输入序列和输出序列不需要严格对应关系，也不需要保持相同长度。
缺点：不论输入和输出的长度是什么，经过编码之后中间序列的长度一般是固定的。
第一个RNN（encoder）：它的输入是原始序列、hidden_0，我么要的输出是经过RNN后最终每个隐层的值。
第二个RNN(decoder)：他的输入是加了个结束标志的要预测的最终序列、和经过第一个RNN后最终每个隐层的值（上一个RNN的输出），输出是最终预测的序列。
字符是如何输入到第一个RNN中的呢？
视频中讲道：一般是将每一个字母转换为一个独热向量，encoder的输入要加一个结束标志，decoder的输入要加一个开始标志，decoder的输出要加一个结束标志。注意：所有单词都要先转换为一样的长度（所有要训练的单词中最长的单词的长度max_len），短的单词要进行填充。这样一个单词就是一个二维张量。每个时刻输入一个字母所对应的独热向量,经过max_len+1个时刻就可以将一个带有结束标志的完整的单词输入完。
使用one-hot编码有那些缺点，如何改进？
使用独热码，当序列较长时会使编码维度太高、稀疏、不能体现出单词或语义之间的相似程度。这时我们会采用embedding操作，对数据进行降维，本质上是通过矩阵乘法将高维特征映射到了低维。
在写代码时，直接调用Embedding就行，代码如下：
import torch
import torch.nn as nn
# 定义词汇表大小和嵌入向量维度
vocab_size = 5
embedding_dim = 3
# 定义嵌入层对象，第一个参数是输入数据的维度，第二个参数是我们希望的输出数据的维度
embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
#输入包含5个单词（"apple", "banana", "orange", "pear", "grape"）
# 定义输入数据（使用独热向量表示）
#input = torch.LongTensor([0, 1, 2, 3, 4])
input = torch.FloatTensor([[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]])
# 将独热向量表示转换为整数索引
input_indices = torch.argmax(input, dim=1)
# 应用嵌入层
embedded_input = embedding(input_indices)
# 获取输出
output = embedded_input.detach().numpy()
# 打印输出结果
print(output)
#输出结果：
#可以看到，不同单词的嵌入向量是不同的，并且它们之间具有一定的语义关系。
[[ 1.2816303 0.27656603 -0.79470354]
[-0.6038282 0.36949605 1.1003486 ]
[ 0.03112818 -0.3771999 -0.16694564]
[ 1.0627761 -0.30743012 -0.32057762]
[ 0.67417926 -0.5941497 -0.30978167]]
加上embedding之后，模型就变成了：
为什么输入是LongTensor?
在 PyTorch 中，LongTensor 类型是一种 64 位整数类型，通常用于表示索引或者标签等整数值。在嵌入层中，输入数据通常被表示为整数索引的方式，因此需要使用 LongTensor 类型。
具体而言，嵌入层的输入应该是一个一维的长整型张量（LongTensor），其中每个元素表示一个单词在词汇表中的索引。这些索引会被用于查找对应的词向量。如果我们使用独热向量来表示输入数据，则需要先将独热向量转换为整数索引，然后再将整数索引传递给嵌入层。
如果使用普通的整型张量（IntTensor）来表示输入数据，可能会出现溢出的问题。因为词汇表的大小可以非常大，如果使用32位整数，可能无法表示所有的索引。因此，在 PyTorch 中，通常使用 LongTensor 类型来表示整数索引。
这次试验花了好多时间在看那两个视频讲解上，有些地方不太清楚，就多看了几遍，可能理解的还不够全面，总之，还需要继续探索！！！
参考：
序列到序列模型，了解一下-知乎
Pytorch-序列到序列学习（seq2seq）-知乎
序列到序列模型(seq2seq) -博客园
【循环神经网络】5分钟搞懂RNN，3D动画深入浅出-b站
《PyTorch深度学习实践》完结合集-b站视频讲解
Seq2Seq 的 PyTorch 实现-博客
Seq2Seq 的 PyTorch 实现-b站视频讲解
循环神经网络（RNN与LSTM)-csdn
深度学习中Embedding的解释-csdn
详解深度学习之 Embedding
957
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
