1. 实现SRN
(1)使用Numpy
import numpy as np
inputs=np.array([[1.,1.],[1.,1.],[2.,2.]])
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('inputs is',inputs)
state_t=np.zeros(2,)
print('state_t is',state_t)
print('----------------')
#遍历输入的每一组x
for input_t in inputs:
print('inputs is',input_t)
print('state_t is',state_t)
#全连接【tanh(输入*线性权重)】+延迟器*状态权重
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('--------------')
(2)在1的基础上,增加激活函数tanh
import numpy as np
inputs = np.array([[1., 1.], [1., 1.], [2., 2.]])
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('inputs is', inputs)
state_t = np.zeros(2, )
print('state_t is', state_t)
print('----------------')
# 增加激活函数
# 遍历输入的每一组x
for input_t in inputs:
print('inputs is', input_t)
print('state_t is', state_t)
# 全连接【tanh(输入*线性权重)】+延迟器*状态权重
x1 = np.dot([w1, w3], input_t[0])
x1 = np.tanh(x1)
in_h1 = x1 + np.dot([U2, U4], state_t)
x2 = np.dot([w2, w4], input_t[1])
x2 = np.tanh(x2)
in_h2 = x2 + np.dot([U1, U3], state_t)
# 更新延迟期
state_t = (in_h1, in_h2)
# 全连接
output_y1 = np.dot([w5, w7], [in_h1[0], in_h2[0]])
output_y2 = np.dot([w6, w8], [in_h1[1], in_h2[1]])
print('output_y is', output_y1, output_y2)
print('--------------')
(3)使用nn.RNNCell实现
import torch
batch_size=1
input_size=2
seq_len=3#序列长度:[1.,1.],[1.,1.],[2.,2.]
hidden_size=2#隐藏层维度:[1.,1.]
output_size=2#输出层维度
#RNNCell
cell=torch.nn.RNNCell(input_size=input_size,hidden_size=hidden_size)
for name,params in cell.named_parameters():
if name.startswith("weight"):#权重设置【1或0】
torch.nn.init.ones_(params)
else:
torch.nn.init.zeros_(params)
#线性层
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]]])
#隐藏层初始设置为0
hidden=torch.zeros(batch_size,hidden_size)
output=torch.zeros(batch_size,output_size)
#输出
for idx,inputs in enumerate(seq):
#用===划开
print('='*20,idx,'='*20)
print('Input:',inputs)
print('hidden:',hidden)
#求解循环网络单元
hidden=cell(inputs,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(): # 初始化参数【1或0】
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]))
2. 实现“序列到序列”
观看视频,学习RNN原理,并实现视频P12中的教学案例
1. 实例实现
import torch
batch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2
num_layers = 1
cell = torch.nn.RNN(input_size=input_size, hidden_size=hidden_size,
num_layers=num_layers, batch_first=True)
# (seqLen, batchSize, inputSize)
inputs = torch.randn(batch_size, seq_len, input_size)
hidden = torch.zeros(num_layers, batch_size, hidden_size)
out, hidden = cell(inputs, hidden)
print('Output size:', out.shape)
print('Output:', out)
print('Hidden size: ', hidden.shape)
print('Hidden: ', hidden)
2. 序列到序列程序
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()))
由图可知,加入嵌入层的循环神经网络训练出来的效果最好,loss最低。
3. “编码器-解码器”的简单实现
- 编码器:将输入编程成中间表达形式(特征)
- 解码器:将中间表示解码成输出
- 编码器:将文本表示成向量
- 解码器:向量表示成输出
(参考:
)
# code by Tae Hwan Jung(Jeff Jung) @graykode, modify by wmathor
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)}#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]) # n_step=max_len(=5)
n_hidden = 128#隐藏状态的维度
n_class = len(letter2idx) #分类
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) # 不需要 one-hot 表示
# 转成张量
return torch.Tensor(enc_input_all), torch.Tensor(dec_input_all), torch.LongTensor(dec_output_all)
'''
对应维度:6个样本
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')]
'''
#得到encoding、decoding【in/out】
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)
# 建立模型
class Seq2Seq(nn.Module):
def __init__(self):
super(Seq2Seq, self).__init__()
#调用RNN
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_input(=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)
#loss/optimizet\r
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:
# 隐藏层形状 [num_layers * num_directions, batch_size, n_hidden]
h_0 = torch.zeros(1, batch_size, n_hidden).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
(enc_input_batch, dec_intput_batch, dec_output_batch) = (enc_input_batch.to(device), dec_input_batch.to(device), dec_output_batch.to(device))
# pred : [n_step+1, batch_size, n_class]------>[batch_size, n_step+1(=6), n_class]
pred = model(enc_input_batch, h_0, dec_intput_batch)
pred = pred.transpose(0, 1)
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()
# 模型测试
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
RNN
网络结构
一个典型的单层RNN网络,结果如下所示。其实很简单就是一个神经元(蓝色模块),针对时序输入信号分别输入网络中,网络再每个时序进行输出,其中通过一个状态量记录时序信息。
多层的RNN,上一次的输出ht是下一层的输入。
(1)torch.nn.RNNCell(input_size, hidden_size, bias=True, nonlinearity='tanh')
- input_size – 输入 x 中预期特征的数量
- hidden_size – 隐藏状态下的特征数量 h
- 偏差 – 如果 False ,则该层不使用偏差权重 b_ih 和 b_hh 。默认值: True
- 非线性 – 使用的非线性。可以是 'tanh' 或 'relu' 。默认: 'tanh'
输入数据的格式:
- 形状 (batch, input_size) 的输入:包含输入特征的张量
- 形状 (batch, hidden_size) 的隐藏:包含批次中每个元素的初始隐藏状态的张量。没有说明的,就默认初始化为零。
输出数据的形状(batch,hidden_size):包含没批次中,下一个隐藏的张量。
在了解了基本的输入和输出数据的基本格式之后,至少对nn.RNNCell的使用就不成问题了。
输入分为两部分:第一部分就是批次输入的数据特征,第二部分就是隐藏状态的张量(默认为零),可以自定义隐藏状态的特征数量,也就是上面的hidden_size。
(2)torch.nn.RNN(*args, **kwargs)
参数:
- input_size – 输入 x 中预期特征的数量
- hidden_size – 隐藏状态下的特征数量 h
- num_layers – 循环层数。例如,设置 num_layers=2 意味着将两个 RNN 堆叠在一起形成 stacked RNN ,第二个 RNN 接收第一个 RNN 的输出并计算最终结果。默认值:1
- 非线性 – 使用的非线性。可以是 'tanh' 或 'relu' 。默认: 'tanh'
- batch_first – 如果为 True ,则输入和输出张量作为 (batch, seq, feature) 提供。默认值: False
- dropout – 如果非零,则在除最后一层之外的每个 RNN 层的输出上引入 Dropout 层,dropout 概率等于 dropout 。默认值:0
- 双向 – 如果是 True ,则成为双向 RNN。默认: False
RNN比RNNCell多了num_layers,即循环层数.
5.谈一谈对“序列”、“序列到序列”的理解
(1)什么是序列
所谓序列,指的是一块可存放多个值的连续内存空间,这些值按一定顺序排列,可通过每个值所在位置的编号(称为索引)访问它们。
(2)什么是序列到序列
使用两个循环神经网络,将一个语言序列直接转换到另一个语言序列。
Seq2seq模型的特点主要有以下两点:
1.处理序列数据: Seq2Seq模型能处理任意长度的输入序列,甚至不限定于语言或文本这种结构化的数据。
⒉训练灵活性强: Seq2Seq模型可以同时训练编码器和解码器,因此训练过程更加平滑和容易调参。
6.总结本周理论课和作业,写心得体会
本次作业我印象最深的是序列到序列,我对seq2seq进行了编程,对于序列和序列到序列也有自己的一些理解并且进行了相关学习,在官网上进行搜索了解了nn.RNNCell、nn.RNN的用法和参数。
参考:
【23-24 秋学期】NNDL 作业9 RNN - SRN-CSDN博客
【23-24 秋学期】NNDL 作业9 RNN - SRN-CSDN博客