B站 刘二大人&＃xff1a;循环神经网络&＃xff08;基础篇&＃xff09;

目录

1、RNN概念

2、numLayers含义

3、RNN使用

4、利用RNN Cell训练hello转换到ohlol

5、Embedding编码方式

1、RNN概念

        RNN Cell是线性层。

         隐层是RNN Cell里线性层矩阵w的行数。

         使用RNN Cell:

import torchbatch_size &＃61; 1 # 批处理大小
seq_len &＃61; 3 # 序列长度
input_size &＃61; 4 # 输入维度
hidden_size &＃61; 2 # 隐层维度cell &＃61; torch.nn.RNNCell(input_size&＃61;input_size, hidden_size&＃61;hidden_size) # 初始化# (seq, batch, features)
dataset &＃61; torch.randn(seq_len, batch_size, input_size)
hidden &＃61; torch.zeros(batch_size, hidden_size)# 这个循环就是处理seq_len长度的数据
for idx, data in enumerate(dataset):print(&＃39;&＃61;&＃39; * 20, idx, &＃39;&＃61;&＃39; * 20)print(&＃39;Input size:&＃39;, data.shape, data)hidden &＃61; cell(data, hidden)print(&＃39;hidden size:&＃39;, hidden.shape, hidden)print(hidden)

2、numLayers含义

3、RNN使用

        input_size和hidden_size: 输入维度和隐层维度

        batch_size: 批处理大小

        seq_len: 序列长度

        num_layers: 隐层数目

        使用RNN&＃xff1a;

import torchbatch_size &＃61; 1 # batch_size: 批处理大小
seq_len &＃61; 3 # seq_len: 序列长度
input_size &＃61; 4 # input_size&＃xff1a;输入维度
hidden_size &＃61; 2 # hidden_size: 隐层维度
num_layers &＃61; 1 # num_layers: 隐层数目cell &＃61; torch.nn.RNN(input_size&＃61;input_size, hidden_size&＃61;hidden_size, num_layers&＃61;num_layers)# (seqLen, batchSize, inputSize)
inputs &＃61; torch.randn(seq_len, batch_size, input_size)
hidden &＃61; torch.zeros(num_layers, batch_size, hidden_size)out, hidden &＃61; cell(inputs, hidden)print(&＃39;Output size:&＃39;, out.shape) # (seq_len, batch_size, hidden_size)
print(&＃39;Output:&＃39;, out)
print(&＃39;Hidden size:&＃39;, hidden.shape) # (num_layers, batch_size, hidden_size)
print(&＃39;Hidden:&＃39;, hidden)

4、利用RNN Cell训练hello转换到ohlol

 

         代码如下&＃xff1a;

import torch
input_size &＃61; 4
hidden_size &＃61; 4
batch_size &＃61; 1idx2char &＃61; [&＃39;e&＃39;, &＃39;h&＃39;, &＃39;l&＃39;, &＃39;o&＃39;]
x_data &＃61; [1, 0, 2, 3, 3] # hello中各个字符的下标
y_data &＃61; [3, 1, 2, 3, 2] # ohlol中各个字符的下标one_hot_lookup &＃61; [[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1]]
x_one_hot &＃61; [one_hot_lookup[x] for x in x_data] # (seqLen, inputSize)inputs &＃61; torch.Tensor(x_one_hot).view(-1, batch_size, input_size)
labels &＃61; torch.LongTensor(y_data).view(-1, 1)
# torch.Tensor默认是torch.FloatTensor是32位浮点类型数据&＃xff0c;torch.LongTensor是64位整型
print(inputs.shape, labels.shape)class Model(torch.nn.Module):def __init__(self, input_size, hidden_size, batch_size):super(Model, self).__init__()self.batch_size &＃61; batch_sizeself.input_size &＃61; input_sizeself.hidden_size &＃61; hidden_sizeself.rnncell &＃61; torch.nn.RNNCell(input_size&＃61;self.input_size, hidden_size&＃61;self.hidden_size)def forward(self, inputs, hidden):hidden &＃61; self.rnncell(inputs, hidden) # 输入和隐层转换为下一个隐层# shape of inputs:(batchSize, inputSize),shape of hidden:(batchSize, hiddenSize),return hiddendef init_hidden(self):return torch.zeros(self.batch_size, self.hidden_size) # 生成全0的h0net &＃61; Model(input_size, hidden_size, batch_size)criterion &＃61; torch.nn.CrossEntropyLoss()
optimizer &＃61; torch.optim.Adam(net.parameters(), lr&＃61;0.1)for epoch in range(15):loss &＃61; 0optimizer.zero_grad()hidden &＃61; net.init_hidden()print(&＃39;Predicted string:&＃39;, end&＃61;&＃39;&＃39;)for input, label in zip(inputs, labels):hidden &＃61; net(input, hidden)# 注意交叉熵在计算loss的时候维度关系&＃xff0c;这里的hidden是([1, 4]), label是 ([1])loss &＃43;&＃61; criterion(hidden, label)_, idx &＃61; hidden.max(dim &＃61; 1)print(idx2char[idx.item()], end&＃61;&＃39;&＃39;)loss.backward()optimizer.step()print(&＃39;, Epoch [%d/15] loss&＃61;%.4f&＃39; % (epoch&＃43;1, loss.item()))


结果&＃xff1a;

 

5、Embedding编码方式

       独热编码向量维度过高&＃xff1b;
       独热编码向量稀疏&＃xff0c;每个向量是一个为1其余为0&＃xff1b;
       独热编码是硬编码&＃xff0c;编码情况与数据特征无关&＃xff1b;
       采用一种低维度的、稠密的、可学习数据的编码方式&＃xff1a;Embedding。

         代码&＃xff1a;

import torchinput_size &＃61; 4
num_class &＃61; 4
hidden_size &＃61; 8
embedding_size &＃61; 10
batch_size &＃61; 1
num_layers &＃61; 2
seq_len &＃61; 5idx2char_1 &＃61; [&＃39;e&＃39;, &＃39;h&＃39;, &＃39;l&＃39;, &＃39;o&＃39;]
idx2char_2 &＃61; [&＃39;h&＃39;, &＃39;l&＃39;, &＃39;o&＃39;]x_data &＃61; [[1, 0, 2, 2, 3]]
y_data &＃61; [3, 1, 2, 2, 3]# inputs 维度为&＃xff08;batchsize&＃xff0c;seqLen&＃xff09;
inputs &＃61; torch.LongTensor(x_data)
# labels 维度为&＃xff08;batchsize*seqLen&＃xff09;
labels &＃61; torch.LongTensor(y_data)class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.emb &＃61; torch.nn.Embedding(input_size, embedding_size)self.rnn &＃61; torch.nn.RNN(input_size&＃61;embedding_size,hidden_size&＃61;hidden_size,num_layers&＃61;num_layers,batch_first&＃61;True)self.fc &＃61; torch.nn.Linear(hidden_size, num_class)def forward(self, x):hidden &＃61; torch.zeros(num_layers, x.size(0), hidden_size)x &＃61; self.emb(x) # 进行embedding处理x, _ &＃61; self.rnn(x, hidden)x &＃61; self.fc(x)return x.view(-1, num_class)net &＃61; Model()criterion &＃61; torch.nn.CrossEntropyLoss()
optimizer &＃61; torch.optim.Adam(net.parameters(), lr&＃61;0.05)for epoch in range(15):optimizer.zero_grad()outputs &＃61; net(inputs)loss &＃61; criterion(outputs, labels)loss.backward()optimizer.step()_, idx &＃61; outputs.max(dim&＃61;1)idx &＃61; idx.data.numpy()print(&＃39;Predicted string: &＃39;, &＃39;&＃39;.join([idx2char_1[x] for x in idx]), end&＃61;&＃39;&＃39;)print(", Epoch [%d/15] loss &＃61; %.3f" % (epoch &＃43; 1, loss.item()))

        结果&＃xff1a;