RNN 循环神经网络
循环神经网络（Recurrent Neural Network，RNN）是一种神经网络结构，专门用于处理序列数据。
RNN结构原理
RNN架构中，网络通过循环把信息从一个处理步骤传递到下一个，这个循环结构被称为隐藏层状态或者隐藏状态。可以捕捉并储存已经出处理的序列元素信息。
这个过程可以简化为
s t = f ( U ⋅ x t + W ⋅ s t − 1 ) s_t=f(\mathbf{U}·x_t+\mathbf{W}·s_{t-1}) st=f(U⋅xt+W⋅st−1)
U是输入到隐藏的权重矩阵
W是隐藏到隐藏的权重
输出层 O t {O}{t} Ot = g(V s t {s}{t} st)
V是隐藏层到输出层的矩阵
python
import numpy as np
import torch
import torch.nn as nn
# 假设输入3个时间步
x = np.random.rand(3,2)
# 一个样本的输入，如文本中的一句话，一个样本中的3个特征，一句话有3个词，每个特征的维度是2，词向量的维度是2
# 定义rnn参数
input_size = 2
hidden_size = 3
output_size = 4
# 初始化权重和偏置
W_xh = np.random.rand(input_size,hidden_size) # 输入到隐藏
W_hh = np.random.rand(hidden_size,hidden_size) # 隐藏到隐藏
W_hy = np.random.rand(hidden_size,output_size) # 隐藏到输出
bh = np.zeros(hidden_size) # 隐藏层偏置
by = np.zeros(output_size) # 输出层偏置
# 激活函数
def tanh(x):
return np.tanh(x)
# 初始化隐藏状态
H_prev = np.zeros(hidden_size)
x1 = x[0] # 得到第一个输入特征 文本序列中的第一个词
H1 = tanh(np.dot(x1,W_xh)+H_prev+bh)
print('隐藏1：',H1)
O1 = np.dot(H1,W_hy)+by
print('输出1：',O1)
x2 = x[1]
H2 = tanh(np.dot(x2,W_xh)+np.dot(H1,W_hh)+bh)
print('隐藏2：',H2)
O2 = np.dot(H2,W_hy)+by
print('输出2：',O2)
x3 = x[1]
H3 = tanh(np.dot(x3,W_xh)+np.dot(H2,W_hh)+bh)
print('隐藏3：',H3)
O3 = np.dot(H3,W_hy)+by
print('输出3：',O2)RNNcell
python
import torch
import torch.nn as nn
x = torch.randn(10,6,5) # 10批次大小 6词数 5向量维度
# 一次输入10句话，一句话中有6个词（特征），词向量维度是5（特征维度）
class RNN(nn.Module):
def __init__(self,input_size,hidden_size,batch_first=True):
# input_size 输入的词向量维度，特征维度
# hidden_size 隐藏状态的张量维度
# batch_first 第一维度是否是batch，如果是，需要维度转换，以符合RNNcell的输入
super().__init__()
self.rnn_cell = nn.RNNCell(input_size,hidden_size)
self.hidden_size = hidden_size
self.batch_first = batch_first
def __initialize_hidden(self,batch_size):
# 初始化隐藏状态 第一个时间步没有隐藏的输入，需要初始化
return torch.zeros((batch_size,self.hidden_size))
def forward(self,x,init_hidden=None):
# 得到数据的各个维度
if self.batch_first: # 维度转换 以符合cell输入
bach_size,seq_size,input_size = x.size()
x = x.permute(1,0,2)
else:
seq_size,bach_size,input_size = x.size()
hiddens = [] # 储存隐藏状态
if init_hidden is None: # 如果是第一个输入
init_hidden = self.__initialize_hidden(bach_size)
init_hidden = init_hidden.to(x.device) # 同步设备
hidden_t = init_hidden
for t in range(seq_size):
hidden_t = self.rnn_cell(x[t],hidden_t)
hiddens.append(hidden_t)
hiddens = torch.stack(hiddens) # 堆叠所有时间步隐藏输出，合并为一个张量
if self.batch_first:
hiddens = hiddens.permute(1,0,2)
print(hiddens)
return hiddens
model = RNN(5,8) # imput_size 词向量的维度 hidden_size 输出的维度 隐藏状态的张量维度
outputs = model(x)
print(outputs.shape) # torch.Size([10, 6, 8])**这里并没有进行out的输出，只是获得了隐藏状态，在实际的需求中，需要增加其他的结构如线性层对隐藏状态进行操作 **
RNN
基于pytorch实现
python
import torch
import torch.nn as nn
# 超参数设置
batch_size,seq_size,input_size = 10,6,5 # 批次 句子长度 词向量维度
hidden_size = 3 # 隐藏状态的张量维度
# 数据
x = torch.rand(batch_size,seq_size,input_size)
# 初始化隐藏状态
h_prev = torch.zeros(batch_size,hidden_size)
# 创建RNN
rnn = nn.RNN(input_size, hidden_size,batch_first=True) # batch_first=True是否转化
out, hide= rnn(x,h_prev.unsqueeze(0)) # 返回值 第一个值为输出 第二个值是状态信息
print(out.shape) # torch.Size([10, 6, 3])
print(hide.shape) # torch.Size([1, 10, 3])biRNN双向RNN
双向RNN，使得模型能够学习到序列中某一点前后的上下文信息
python
import torch
import torch.nn as nn
# 超参数设置
batch_size,seq_size,input_size = 10,6,5 # 批次 句子长度 词向量维度
hidden_size = 3 # 隐藏状态的张量维度
# 数据
x = torch.rand(batch_size,seq_size,input_size)
# 初始化隐藏状态
h_prev = torch.zeros(batch_size,hidden_size)
# 创建RNN
rnn = nn.RNN(input_size, hidden_size,batch_first=True,bidirectional=True) # batch_first=True是否转化
out, hide= rnn(x) # 返回值 第一个值为输出 第二个值是状态信息
print(out.shape) # torch.Size([10, 6, 6]) 这里直接合并了双向的隐藏状态
print(hide.shape) # torch.Size([2, 10, 3]) 输出的是正向和反向的隐藏状态