RNN - SRN

  简单循环网络（Simple Recurrent Network，SRN）只有一个隐藏层的神经网络．

1、实现SRN

（1）使用Numpy

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.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.]])  # 初始化输入序列
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实现

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)

（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)
 
# 线性层
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中的教学案例

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)
#(seaLen. batchSize.indutSizeinputs = torch. randn(batch size, seg len, input size)hidden = torch.zeros(num layers,batch size, hidden size)
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)

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)}

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 是循环神经网络（RNN）中的一个时间步（time-step），代表处理单个输入的循环单元。
用途：
通常在循环中使用，逐个时间步处理序列。
可以用于手动控制循环计算的流程。
初始化：
参数包括输入大小、隐藏大小以及可选的非线性激活函数。
示例：

import torch.nn as nn

输入大小 = 10
隐藏大小 = 20
rnn_cell = nn.RNNCell(输入大小, 隐藏大小)

nn.RNN：
定义： nn.RNN 是一个更高层次的抽象，用于处理整个序列。它在内部使用 nn.RNNCell 在每个时间步上进行循环计算。
用途：
在处理序列时更方便。
自动将RNN单元应用于每个时间步。
初始化：
参数包括输入大小、隐藏大小、循环层的数量以及可选的非线性激活函数。
示例：

import torch.nn as nn

输入大小 = 10
隐藏大小 = 20
循环层数 = 2
rnn = nn.RNN(输入大小, 隐藏大小, num_layers=循环层数)

注意：
nn.RNN 可以以批处理的方式处理序列，而 nn.RNNCell 需要对批处理进行显式处理。
nn.RNN 返回每个时间步的输出和隐藏状态。
如果需要对循环计算进行更多手动控制，可能更倾向于使用 nn.RNNCell；如果希望在处理序列时有一个更高级的接口，通常更方便使用 nn.RNN。

总的来说，nn.RNNCell是构建RNN的基础组件，而nn.RNN则是在此基础上构建更复杂的RNN结构。

5.谈一谈对“序列”、“序列到序列”的理解 

序列是一系列按照特定顺序排列的元素或数据点。这些元素可以是字符、数字、符号或其他类型的数据。序列通常用于表示时间上的变化或数据之间的关系。

例如，文本可以被看作是字符序列，时间序列可以表示为按时间排序的数据点序列。

在深度学习中，序列数据常常涉及到时间或空间上的顺序，因此RNN被广泛用于处理这类数据。序列问题的例子包括语言建模、时间序列预测、语音识别等。

序列到序列是一种深度学习模型架构，旨在处理输入和输出都是可变长度序列的任务。

Seq2Seq 模型基于编码器-解码器结构。编码器将输入序列编码成固定长度的向量，然后解码器将此向量转换为目标序列。这使得模型能够处理不同长度的输入和输出序列。

    Seq2seq模型的核心思想是利用神经网络学习从输入序列到目标序列的映射关系。它具有一些优点，例如可以处理变长输入和输出序列、能够生成自然语言文本等。然而，它也面临着一些挑战，例如训练数据需要大量标注数据、模型容易产生语法错误等。

6.总结本周理论课和作业，写心得体会 

1、RNN的本质是线性层

2、RNN虽然图看上去很麻烦但是很简单就是循环，它的每一层的输入都是本层的输入和上一层的输入之和

3、nn.RNNCell实例都代表一个单层的RNN，它可以被视为一个函数，输入为前一步的隐藏状态和当前步的输入，输出为当前步的隐藏状态，它将序列上的每个时刻分开来处理。nn.RNNCell的输入维度和隐藏状态维度是可以设置的。nn.RNN用于构建更复杂的循环神经网络，可以包含一个或多个nn.RNNCell层

4、batch_first=True指的是在处理数据时，将数据按照批次的形式进行操作。这意味着在输入到神经网络或其他机器学习模型之前，数据会被重新组织或布局，使得第一个维度为批次大小(batch size)，而不是默认的序列长度。

例如，对于一个句子，如果我们将其视为一个序列，那么默认情况下，PyTorch将其视为第一个维度（即序列长度）。但如果我们将batch_first=True，则PyTorch会将其视为第二个维度。这样，我们的数据形状将从(序列长度, 批量大小, 特征维度)变为(批量大小, 序列长度, 特征维度)。

5、RNN的参数量主要来自于其内部的权重矩阵，这些权重矩阵的大小取决于输入数据的维度和隐藏状态的维度。

假设RNN的输入数据的维度为input_dim，隐藏状态的维度为hidden_dim，那么RNN每层的参数量可以计算如下：

1. 输入层到隐藏层的权重矩阵，需要的参数量为input_dim * hidden_dim。
2. 隐藏层到隐藏层的权重矩阵需要的参数量为hidden_dim * hidden_dim。
3. 如果存在输出层，那么输出层到隐藏层的权重矩阵需要的参数量为output_dim*hidden_dim。

参考博客：

12.循环神经网络（基础篇）_哔哩哔哩_bilibili

Seq2Seq的PyTorch实现 - mathor (wmathor.com)

【23-24 秋学期】NNDL 作业9 RNN - SRN-CSDN博客