使用RNN对MNIST手写数字进行分类。RNN和LSTM模型结构

pytorch中的LSTM的使用让人有点头晕，这里讲述的是LSTM的模型参数的意义。

---

1、加载数据集

import torch 
import torchvision
import torch.nn as nn
import torchvision.transforms as transforms
import torch.utils.data as Data device  = torch.device('cuda' if torch.cuda.is_available() else 'cpu')sequence_length = 28 
input_size = 28 
hidden_size = 128 
num_layers = 2 
num_classes = 10 
batch_size = 128 
num_epochs = 2 
learning_rate = 0.01 train_dataset = torchvision.datasets.MNIST(root='./data/',train=True,transform=transforms.ToTensor(),download=True)
test_dataset = torchvision.datasets.MNIST(root='./data/',train=False,transform=transforms.ToTensor())train_loader = Data.DataLoader(dataset=train_dataset,batch_size=batch_size,shuffle=True)
test_loader = Data.DataLoader(dataset=test_dataset,batch_size=batch_size)

---

 2、构建RNN模型

• input_size – 输入的特征维度

• hidden_size – 隐状态的特征维度

• num_layers – 层数（和时序展开要区分开）

• bias – 如果为False，那么LSTM将不会使用，默认为True。

• batch_first – 如果为True，那么输入和输出Tensor的形状为(batch, seq, feature)

• dropout – 如果非零的话，将会在RNN的输出上加个dropout，最后一层除外。

• bidirectional – 如果为True，将会变成一个双向RNN，默认为False

       1、上面的参数来自于文档，最基本的参数是input_size, hidden_size, num_layer三个。input_size：输入数据向量维度，在这里为28；hidden_size：隐藏层特征维度，也是输出的特征维度，这里是128；num_layers：lstm模块个数，这里是2。

       2、h0和c0的初始化维度为（num_layer，batch_size, hidden_size）

       3、lstm的输出有out和（hn，cn），其中out.shape = torch.Size([128, 28, 128])，对应（batch_size，时序数，隐藏特征维度），也就是保存了28个时序的输出特征，因为做的分类，所以只需要最后的输出特征。所以取出最后的输出特征，进行全连接计算，全连接计算的输出维度为10（10分类）。

       4、batch_first这个参数比较特殊：如果为true，那么输入数据的维度为（batch, seq, feature），否则为（seq, batch, feature）

       5、num_layers：lstm模块个数，如果有两个，那么第一个模块的输出会变成第二个模块的输入。

       总结：构建一个LSTM模型要用到的参数，（输入数据的特征维度，隐藏层的特征维度，lstm模块个数）；时序的个数体现在X中, X.shape = (batch_size,  时序长度， 数据向量维度)。

       可以理解为LSTM可以根据我们的输入来实现自动的时序匹配，从而达到输入长短不同的功能。

class RNN(nn.Module):def __init__(self, input_size,hidden_size,num_layers, num_classes):super(RNN, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layers#input_size - 输入特征维度#hidden_size - 隐藏状态特征维度#num_layers - 层数（和时序展开要区分开），lstm模块的个数#batch_first为true，输入和输出的形状为（batch, seq, feature），true意为将batch_size放在第一维度，否则放在第二维度self.lstm = nn.LSTM(input_size,hidden_size,num_layers,batch_first = True)  self.fc = nn.Linear(hidden_size, num_classes)def forward(self,x):#参数：LSTM单元个数， batch_size， 隐藏层单元个数 h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)   #h0.shape = (2, 128, 128)c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)#输出output :  (seq_len, batch, hidden_size * num_directions)#（h_n, c_n）:最后一个时间步的隐藏状态和细胞状态#对out的理解：维度batch, eq_len, hidden_size，其中保存着每个时序对应的输出，所以全连接部分只取最后一个时序的#out第一维batch_size，第二维时序的个数，第三维隐藏层个数，所以和lstm单元的个数是无关的out,_ = self.lstm(x, (h0, c0))  #shape = torch.Size([128, 28, 128])out = self.fc(out[:,-1,:])  #因为batch_first = true，所以维度顺序batch, eq_len, hidden_sizereturn out

 训练部分

model = RNN(input_size,hidden_size, num_layers, num_classes).to(device)
print(model)#RNN(
#  (lstm): LSTM(28, 128, num_layers=2, batch_first=True)
#  (fc): Linear(in_features=128, out_features=10, bias=True)
#)criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)total_step = len(train_loader)
for epoch in range(num_epochs):for i,(images, labels) in enumerate(train_loader):#batch_size = -1, 序列长度 = 28， 数据向量维度 = 28images = images.reshape(-1, sequence_length, input_size).to(device)labels = labels.to(device)# Forward passoutputs = model(images)loss = criterion(outputs, labels)# Backward and optimizeoptimizer.zero_grad()loss.backward() optimizer.step()if (i+1) % 100 == 0:print(outputs.shape)print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' .format(epoch+1, num_epochs, i+1, total_step, loss.item()))

---

# Test the model
with torch.no_grad():correct = 0total = 0for images, labels in test_loader:images = images.reshape(-1, sequence_length, input_size).to(device)labels = labels.to(device)outputs = model(images)_, predicted = torch.max(outputs.data, 1)total += labels.size(0)correct += (predicted == labels).sum().item()print('Test Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total))