循环神经网络RNN不仅可以用来处理序列数据，还可以用来处理图像数据，这是因为一张图像可以看做一组很长的像素点组成的序列。
下面将使用RNN对MINIST数据集建立分类器，首先导入需要的库和相关模块。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import time
import copy
import torch
from torch import nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torch.utils.data as Data
from torchvision import transforms
import hiddenlayer as hl
在导入数据进行数据准备工作时，可以直接从torchvision库的datasets模块导入MINIST手写字体的训练数据集合测试数据集，然后使用Data.DataLoader()函数将两个数据集定义为数据加载器，其中每个batch包含64张图像，最后得到训练集数据加载器，其中每个batch包含64张图像，最后得到训练集数据加载器train_loader，与测试集数据加载器test_loader，程序如下：
train_data =torchvision.datasets.MNIST(
root="./data/MINIST",train=True,transform=transforms.ToTensor(),
download=False
)
train_loader=Data.DataLoader(
dataset=train_data,batch_size=64,shuffle=True,num_workers=2
)
test_data=torchvision.datasets.MNIST(
root="./data/MNIST",train=False,transform=transforms.ToTensor(),
download=False
)
test_loader=Data.DataLoader(
dataset=test_data,batch_size=64,shuffle=True,num_workers=2
)
在导入的数据集中，训练集包含60000张28*28的灰度图像，测试机包含10000张28*28的灰度图像。
搭建一个RNN分类器首先需要定义一个RNNimc类，如下程序所示：
class RNNimc(nn.Module):
def __init__(self,input_dim,hidden_dim,layer_dim,output_dim):
"""
:param input_dim: 输入数据的维度
:param hidden_dim: RNN神经元个数
:param layer_dim: RNN层数
:param output_dim: 隐藏层输出的维度
"""
super(RNNimc,self).__init__()
self.hidden_dim=hidden_dim
self.layer_dim=layer_dim
self.rnn=nn.RNN(input_dim,hidden_dim,layer_dim,batch_first=True,
nonlinearity='relu')
self.fc1=nn.Linear(hidden_dim,output_dim)
def forward(self,x):
out, h_n = self.rnn(x, None)
out = self.fc1(out[:, -1, :])
return out
上面程序定义了RNNimc类，在调用时需要输入4个参数，参数input_dim表示输入数据的维度，针对图像分类器，其值是图片中每行数据像素点量，针对手写字体数据其值等于28；参数hidden_dim表示搭建RNN网络层中包含神经元的个数；参数layer_dim表示在RNN网络层中有多少层RNN神经元；参数output_dim则表示在使用全连接层进行分类时输出的维度，可以使用数据的类别数表示，MNIST数据集表示为10.
在RNNimc类调用nn.RNN（）函数时，参数batch_first=True表示使用的数据集中batch在数据的第一个维度，参数nonlinearity='relu'表示RNN层使用的激活函数为ReLU函数。从RNNimc类的forward（）函数中，发现网络的self.run()层的输入由两个参数，第一个参数为需要分析的数据x，第二个参数则为隐藏层的初始输出，这里使用None代替，表示使用全0进行初始化。而输出则包含两个参数，其中out表示RNN最后一层的输出特征，h_n表示隐藏层的输出。在将RNN层和全连接分类层连接时，将全连接层网络作用于最后一个时间点的out输出。
定义好RNNimc类之后，则定义相应的参数取值，再调用该函数类得到网络结构，程序如下：
上面的程序可得到如下的输出：
在定义的MyRNNimc网络中，包含两个层级，一个是包含128个RNN神经元的RNN层，另一个是输入128个神经元，输出10个神经元的全连接层。针对网络结构将使用HiddenLayer库将其可视化，程序如下所示：
对定义好的网络模型使用训练集进行训练，需要定义优化器和顺势函数，优化器使用torch.optim.RMSprop()定义，损失函数这使用交叉熵顺势nn.CrossEntropyLoss()函数定义，并且使用训练集对网络训练30个epoch。
optimizer=torch.optim.RMSprop(MyRNNimc.parameters(),lr=0.0003)
criterion=nn.CrossEntropyLoss()#损失函数
train_loss_all=[]
train_acc_all=[]
test_loss_all=[]
test_acc_all=[]
num_epochs=30
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch,num_epochs-1))
MyRNNimc.train() #设置模式为训练模式
corrects=0
train_num=0
for step,(b_x,b_y) in enumerate(train_loader):
xdata = b_x.view(-1,28,28)
output=MyRNNimc(xdata)
pre_lab=torch.argmax(output,1)
loss=criterion(output,b_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss+=loss.item()*b_x.size(0)
corrects+=torch.sum(pre_lab==b_y.data)
train_num+=b_x.size(0)
train_loss_all.append(loss/train_num)
train_acc_all.append(corrects.double().item()/train_num)
print('{} Train Loss:{:.4f} Train Acc:{:.4f}'.format(
epoch,train_loss_all[-1],train_acc_all[-1]
))
MyRNNimc.eval（)
corrects=0
test_num=0
for step,(b_x,b_y) in enumerate(test_loader):
xdata=b_x.view(-1,28,28)
output=MyRNNimc(xdata)
pre_lab=torch.argmax(output,1)
loss=criterion(output,b_y)
loss+=loss.item()*b_x.size(0)
corrects+=torch.sum(pre_lab==b_y.data)
test_num+=b_x.size(0)
test_loss_all.append(loss/test_num)
test_acc_all.append(corrects.double().item()/test_num)
print('{} Test Loss:{:.4f} Test Acc:{:.4f}'.format(
epoch,test_loss_all[-1],test_acc_all[-1]
))
在上面的程序中，没使用训练集对网络进行一轮训练，都会使用测试机来测试当前网络的分类效果，针对训练集和测试机的每个epoch顺势和预测精度，都保存在train_loss_all、train_acc_all、test_acc_all、test_loss_all四个列表中。在每个epoch中使用MyRNNimc.train（）将网络切换为训练模式，使用MyRNNimc.eval（)将网络切换为验证模式。针对网络的输入x，需要从图像数据集[batch,channel,height,width]转换为[batch,time_step,input_dim]，即从[64,1,28,28]转换为[64,28,28].
