本篇部落格主要介紹在PyTorch框架下，基於LSTM實現手寫數字的識別。

在介紹LSTM長短時記憶網路之前，我先介紹一下RNN(recurrent neural network)迴圈神經網路.

RNN是一種用來處理序列資料的神經網路，序列資料包括我們說話的語音、一段文字等等。它的出現是為了讓網路自己有記憶能力，每個網路模組把資訊傳給下一個模組，它的網路結構如下：

對於輸入的一段序列資料（X1,X2,X3,X4……）給出預測的結果（Y1，Y2，Y3，Y4……），如果是一個文字情感分類問題，那麼將前幾個Y值抹去，剩下最後一個Y，即是一段文字的預測的情感分類結果。

當進行梯度下降法更新引數時，RNN會出現梯度消失或者梯度下降的問題。當每層的權值W小於1，那麼誤差傳到最開始，結果接近於0，梯度消失；當每層的權值W大於1，那麼誤差傳到第一層，結果會變得無窮大，梯度爆炸。

為了避免這個問題，我們引出了LSTM長短時記憶網路，該網路主要用來延緩記憶衰退。

LSTM的網路結構如下：

它將前一個時刻的輸出Y也傳給了下一個時刻，並且中間單元加了一個判斷資訊是否有用的功能，這樣的話，就可以將讓網路自己選擇要記憶有用的資訊，遺忘無用的資訊。主要通過三個門來實現---輸入門、遺忘門和輸出門。

在識別MNIST手寫數字時，我們可以把28*28畫素的一幅圖片，按行輸入，每一行對應一個時刻，這樣有28個X輸入，有1個Y輸出，將每行的畫素值類比成一個序列資料。

以下程式碼測試了在測試資料的準確率，以及取前10個測試資料的結果。

import torch
from torch import nn
from torch.autograd import Variable
import torchvision.datasets as dsets
import torch.utils.data as Data
import matplotlib.pyplot as plt
import torchvision

torch.manual_seed(1)

EPOCH = 1
BATCH_SIZE = 64
TIME_STEP = 28
INPUT_SIZE = 28
LR = 0.01
DOWNLOAD_MNIST = False

train_data = dsets.MNIST(
    root = './mnist',
    train = True,
    transform = torchvision.transforms.ToTensor(),
    download = DOWNLOAD_MNIST,
)

test_data = torchvision.datasets.MNIST(root='./mnist',train=False)

train_loader = Data.DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True)

test_x = Variable(torch.unsqueeze(test_data.test_data,dim=1),volatile=True).type(torch.FloatTensor)/255
test_y = test_data.test_labels

class RNN(nn.Module):
    def __init__(self):
        super(RNN,self).__init__()

        self.rnn = nn.LSTM(
            input_size=28,
            hidden_size=64,
            num_layers=1,
            batch_first=True,
        )

        self.out = nn.Linear(64,10)

    def forward(self,x):
        r_out, (h_n, h_c) = self.rnn(x, None)

        out = self.out(r_out[:,-1,:])
        return out

rnn = RNN()
print(rnn)

optimizer = torch.optim.Adam(rnn.parameters(),lr=LR)
loss_func = nn.CrossEntropyLoss()

for epoch in range(EPOCH):
    for step,(x,y) in enumerate(train_loader):
        b_x = Variable(x.view(-1,28,28))
        b_y = Variable(y)

        output = rnn(b_x)
        loss = loss_func(output,b_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if step%50 == 0:
            test_output = rnn(test_x.view(-1,28,28))
            pred_y = torch.max(test_output,1)[1].data.numpy().squeeze()
            accuracy = sum(pred_y == test_y)/float(test_y.size(0))
            print('Epoch: ',epoch, '| train loss:%.4f' %loss.data[0],'| test accuracy:%.2f' %accuracy)

test_output = rnn(test_x[:10].view(-1,28,28))
pred_y = torch.max(test_output,1)[1].data.numpy().squeeze()
print(pred_y,'prediction number')
print(test_y[:10].numpy(),'real number')
 

執行結果：