RNN手写字体分类

循环神经网络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].