怎么使用PyTorch實現MLP并在MNIST數據集上驗證

這篇文章給大家分享的是有關怎么使用PyTorch實現MLP并在MNIST數據集上驗證的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

簡介

這是深度學習課程的第一個實驗，主要目的就是熟悉 Pytorch 框架。MLP 是多層感知器，我這次實現的是四層感知器，代碼和思路參考了網上的很多文章。個人認為，感知器的代碼大同小異，尤其是用 Pytorch 實現，除了層數和參數外，代碼都很相似。

Pytorch 寫神經網絡的主要步驟主要有以下幾步：

1 構建網絡結構

2 加載數據集

3 訓練神經網絡（包括優化器的選擇和 Loss 的計算）

4 測試神經網絡

下面將從這四個方面介紹 Pytorch 搭建 MLP 的過程。

項目代碼地址：lab1

過程

構建網絡結構

神經網絡最重要的就是搭建網絡，第一步就是定義網絡結構。我這里是創建了一個四層的感知器，參數是根據 MNIST 數據集設定的，網絡結構如下：

# 建立一個四層感知機網絡
class MLP(torch.nn.Module):  # 繼承 torch 的 Module
  def __init__(self):
    super(MLP,self).__init__()  # 
    # 初始化三層神經網絡 兩個全連接的隱藏層，一個輸出層
    self.fc1 = torch.nn.Linear(784,512) # 第一個隱含層 
    self.fc2 = torch.nn.Linear(512,128) # 第二個隱含層
    self.fc3 = torch.nn.Linear(128,10)  # 輸出層
    
  def forward(self,din):
    # 前向傳播， 輸入值：din, 返回值 dout
    din = din.view(-1,28*28)    # 將一個多行的Tensor,拼接成一行
    dout = F.relu(self.fc1(din))  # 使用 relu 激活函數
    dout = F.relu(self.fc2(dout))
    dout = F.softmax(self.fc3(dout), dim=1) # 輸出層使用 softmax 激活函數
    # 10個數字實際上是10個類別，輸出是概率分布，最后選取概率最大的作為預測值輸出
    return dout

網絡結構其實很簡單，設置了三層 Linear。隱含層激活函數使用 Relu; 輸出層使用 Softmax。網上還有其他的結構使用了 droupout，我覺得入門的話有點高級，而且放在這里并沒有什么用，搞得很麻煩還不能提高準確率。

加載數據集

第二步就是定義全局變量，并加載 MNIST 數據集：

# 定義全局變量
n_epochs = 10   # epoch 的數目
batch_size = 20 # 決定每次讀取多少圖片

# 定義訓練集個測試集，如果找不到數據，就下載
train_data = datasets.MNIST(root = './data', train = True, download = True, transform = transforms.ToTensor())
test_data = datasets.MNIST(root = './data', train = True, download = True, transform = transforms.ToTensor())
# 創建加載器
train_loader = torch.utils.data.DataLoader(train_data, batch_size = batch_size, num_workers = 0)
test_loader = torch.utils.data.DataLoader(test_data, batch_size = batch_size, num_workers = 0)

這里參數很多，所以就有很多需要注意的地方了：

root 參數的文件夾即使不存在也沒關系，會自動創建

transform 參數，如果不知道要對數據集進行什么變化，這里可自動忽略

batch_size 參數的大小決定了一次訓練多少數據，相當于定義了每個 epoch 中反向傳播的次數

num_workers 參數默認是 0，即不并行處理數據；我這里設置大于 0 的時候，總是報錯，建議設成默認值

如果不理解 epoch 和 batch_size，可以上網查一下資料。（我剛開始學深度學習的時候也是不懂的）

訓練神經網絡

第三步就是訓練網絡了，代碼如下：

# 訓練神經網絡
def train():
  # 定義損失函數和優化器
  lossfunc = torch.nn.CrossEntropyLoss()
  optimizer = torch.optim.SGD(params = model.parameters(), lr = 0.01)
  # 開始訓練
  for epoch in range(n_epochs):
    train_loss = 0.0
    for data,target in train_loader:
      optimizer.zero_grad()  # 清空上一步的殘余更新參數值
      output = model(data)  # 得到預測值
      loss = lossfunc(output,target) # 計算兩者的誤差
      loss.backward()     # 誤差反向傳播, 計算參數更新值
      optimizer.step()    # 將參數更新值施加到 net 的 parameters 上
      train_loss += loss.item()*data.size(0)
    train_loss = train_loss / len(train_loader.dataset)
    print('Epoch: {} \tTraining Loss: {:.6f}'.format(epoch + 1, train_loss))

訓練之前要定義損失函數和優化器，這里其實有很多學問，但本文就不講了，理論太多了。

訓練過程就是兩層 for 循環：外層是遍歷訓練集的次數；內層是每次的批次（batch）。最后，輸出每個 epoch 的 loss。（每次訓練的目的是使 loss 函數減小，以達到訓練集上更高的準確率）

測試神經網絡

最后，就是在測試集上進行測試，代碼如下：

# 在數據集上測試神經網絡
def test():
  correct = 0
  total = 0
  with torch.no_grad(): # 訓練集中不需要反向傳播
    for data in test_loader:
      images, labels = data
      outputs = model(images)
      _, predicted = torch.max(outputs.data, 1)
      total += labels.size(0)
      correct += (predicted == labels).sum().item()
  print('Accuracy of the network on the test images: %d %%' % (
    100 * correct / total))
  return 100.0 * correct / total

這個測試的代碼是同學給我的，我覺得這個測試的代碼特別好，很簡潔，一直用的這個。

代碼首先設置 torch.no_grad()，定義后面的代碼不需要計算梯度，能夠節省一些內存空間。然后，對測試集中的每個 batch 進行測試，統計總數和準確數，最后計算準確率并輸出。

通常是選擇邊訓練邊測試的，這里先就按步驟一步一步來做。

有的測試代碼前面要加上 model.eval()，表示這是訓練狀態。但這里不需要，如果沒有 Batch Normalization 和 Dropout 方法，加和不加的效果是一樣的。

完整代碼

'''
系統環境: Windows10
Python版本: 3.7
PyTorch版本: 1.1.0
cuda: no
'''
import torch
import torch.nn.functional as F  # 激勵函數的庫
from torchvision import datasets
import torchvision.transforms as transforms
import numpy as np

# 定義全局變量
n_epochs = 10   # epoch 的數目
batch_size = 20 # 決定每次讀取多少圖片

# 定義訓練集個測試集，如果找不到數據，就下載
train_data = datasets.MNIST(root = './data', train = True, download = True, transform = transforms.ToTensor())
test_data = datasets.MNIST(root = './data', train = True, download = True, transform = transforms.ToTensor())
# 創建加載器
train_loader = torch.utils.data.DataLoader(train_data, batch_size = batch_size, num_workers = 0)
test_loader = torch.utils.data.DataLoader(test_data, batch_size = batch_size, num_workers = 0)


# 建立一個四層感知機網絡
class MLP(torch.nn.Module):  # 繼承 torch 的 Module
  def __init__(self):
    super(MLP,self).__init__()  # 
    # 初始化三層神經網絡 兩個全連接的隱藏層，一個輸出層
    self.fc1 = torch.nn.Linear(784,512) # 第一個隱含層 
    self.fc2 = torch.nn.Linear(512,128) # 第二個隱含層
    self.fc3 = torch.nn.Linear(128,10)  # 輸出層
    
  def forward(self,din):
    # 前向傳播， 輸入值：din, 返回值 dout
    din = din.view(-1,28*28)    # 將一個多行的Tensor,拼接成一行
    dout = F.relu(self.fc1(din))  # 使用 relu 激活函數
    dout = F.relu(self.fc2(dout))
    dout = F.softmax(self.fc3(dout), dim=1) # 輸出層使用 softmax 激活函數
    # 10個數字實際上是10個類別，輸出是概率分布，最后選取概率最大的作為預測值輸出
    return dout

# 訓練神經網絡
def train():
  #定義損失函數和優化器
  lossfunc = torch.nn.CrossEntropyLoss()
  optimizer = torch.optim.SGD(params = model.parameters(), lr = 0.01)
  # 開始訓練
  for epoch in range(n_epochs):
    train_loss = 0.0
    for data,target in train_loader:
      optimizer.zero_grad()  # 清空上一步的殘余更新參數值
      output = model(data)  # 得到預測值
      loss = lossfunc(output,target) # 計算兩者的誤差
      loss.backward()     # 誤差反向傳播, 計算參數更新值
      optimizer.step()    # 將參數更新值施加到 net 的 parameters 上
      train_loss += loss.item()*data.size(0)
    train_loss = train_loss / len(train_loader.dataset)
    print('Epoch: {} \tTraining Loss: {:.6f}'.format(epoch + 1, train_loss))
    # 每遍歷一遍數據集，測試一下準確率
    test()

# 在數據集上測試神經網絡
def test():
  correct = 0
  total = 0
  with torch.no_grad(): # 訓練集中不需要反向傳播
    for data in test_loader:
      images, labels = data
      outputs = model(images)
      _, predicted = torch.max(outputs.data, 1)
      total += labels.size(0)
      correct += (predicted == labels).sum().item()
  print('Accuracy of the network on the test images: %d %%' % (
    100 * correct / total))
  return 100.0 * correct / total

# 聲明感知器網絡
model = MLP()

if __name__ == '__main__':
  train()

10 個 epoch 的訓練效果，最后能達到大約 85% 的準確率?？梢赃m當增加 epoch，但代碼里沒有用 gpu 運行，可能會比較慢。

pytorch的優點

1.PyTorch是相當簡潔且高效快速的框架；2.設計追求最少的封裝；3.設計符合人類思維，它讓用戶盡可能地專注于實現自己的想法；4.與google的Tensorflow類似，FAIR的支持足以確保PyTorch獲得持續的開發更新；5.PyTorch作者親自維護的論壇 供用戶交流和求教問題6.入門簡單

感謝各位的閱讀！關于“怎么使用PyTorch實現MLP并在MNIST數據集上驗證”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！