使用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_size
self.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_size
return 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， 数据向量维度 = 28
images = images.reshape(-1, sequence_length, input_size).to(device)
labels = labels.to(device)
# Forward pass
outputs = model(images)
loss = criterion(outputs, labels)
# Backward and optimize
optimizer.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 = 0
total = 0
for 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))