PyTorch手寫數字識別(MNIST數據集)

https://blog.csdn.net/weixin_44613063/article/details/90815082

MNIST 手寫數字識別是一個比較簡單的入門項目，相當於深度學習中的 Hello World，可以讓我們快速了解構建神經網絡的大致過程。雖然網上的案例比較多，但還是要自己實現一遍。代碼采用 PyTorch 1.0 編寫並運行。

導入相關庫
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import torchvision
from torch.autograd import Variable
from torch.utils.data import DataLoader
import cv2

torchvision 用於下載並導入數據集

cv2 用於展示數據的圖像

獲取訓練集和測試集
# 下載訓練集
train_dataset = datasets.MNIST(root='./num/',
train=True,
transform=transforms.ToTensor(),
download=True)
# 下載測試集
test_dataset = datasets.MNIST(root='./num/',
train=False,
transform=transforms.ToTensor(),
download=True)

root 用於指定數據集在下載之后的存放路徑

transform 用於指定導入數據集需要對數據進行哪種變化操作

train是指定在數據集下載完成后需要載入的那部分數據，設置為 True 則說明載入的是該數據集的訓練集部分，設置為 False 則說明載入的是該數據集的測試集部分

download 為 True 表示數據集需要程序自動幫你下載

這樣設置並運行后，就會在指定路徑中下載 MNIST 數據集，之后就可以使用了。

數據裝載和預覽
# dataset 參數用於指定我們載入的數據集名稱
# batch_size參數設置了每個包中的圖片數據個數
# 在裝載的過程會將數據隨機打亂順序並進打包
batch_size = 64
#建立一個數據迭代器
# 裝載訓練集
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
# 裝載測試集
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=True)

在裝載完成后，可以選取其中一個批次的數據進行預覽：

# 實現單張圖片可視化
images, labels = next(iter(train_loader))
img = torchvision.utils.make_grid(images)

img = img.numpy().transpose(1, 2, 0)
std = [0.5, 0.5, 0.5]
mean = [0.5, 0.5, 0.5]
img = img * std + mean
print(labels)
cv2.imshow('win', img)
key_pressed = cv2.waitKey(0)

在以上代碼中使用了 iter 和 next 來獲取取一個批次的圖片數據和其對應的圖片標簽，然后使用 torchvision.utils 中的 make_grid 類方法將一個批次的圖片構造成網格模式。

預覽圖片如下：

並且打印出了圖片相對應的數字：

搭建神經網絡
# 卷積層使用 torch.nn.Conv2d
# 激活層使用 torch.nn.ReLU
# 池化層使用 torch.nn.MaxPool2d
# 全連接層使用 torch.nn.Linear

class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Sequential(nn.Conv2d(1, 6, 3, 1, 2), nn.ReLU(),
nn.MaxPool2d(2, 2))

self.conv2 = nn.Sequential(nn.Conv2d(6, 16, 5), nn.ReLU(),
nn.MaxPool2d(2, 2))

self.fc1 = nn.Sequential(nn.Linear(16 * 5 * 5, 120),
nn.BatchNorm1d(120), nn.ReLU())

self.fc2 = nn.Sequential(
nn.Linear(120, 84),
nn.BatchNorm1d(84),
nn.ReLU(),
nn.Linear(84, 10))
# 最后的結果一定要變為 10，因為數字的選項是 0 ~ 9

def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = x.view(x.size()[0], -1)
x = self.fc1(x)
x = self.fc2(x)
return x

前向傳播內容：

首先經過 self.conv1() 和 self.conv1() 進行卷積處理

然后進行 x = x.view(x.size()[0], -1)，對參數實現扁平化（便於后面全連接層輸入）

最后通過 self.fc1() 和 self.fc2() 定義的全連接層進行最后的分類

訓練模型
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
LR = 0.001

net = LeNet().to(device)
# 損失函數使用交叉熵
criterion = nn.CrossEntropyLoss()
# 優化函數使用 Adam 自適應優化算法
optimizer = optim.Adam(
net.parameters(),
lr=LR,
)

epoch = 1
if __name__ == '__main__':
for epoch in range(epoch):
sum_loss = 0.0
for i, data in enumerate(train_loader):
inputs, labels = data
inputs, labels = Variable(inputs).cuda(), Variable(labels).cuda()
optimizer.zero_grad() #將梯度歸零
outputs = net(inputs) #將數據傳入網絡進行前向運算
loss = criterion(outputs, labels) #得到損失函數
loss.backward() #反向傳播
optimizer.step() #通過梯度做一步參數更新

# print(loss)
sum_loss += loss.item()
if i % 100 == 99:
print('[%d,%d] loss:%.03f' %
(epoch + 1, i + 1, sum_loss / 100))
sum_loss = 0.0

測試模型
net.eval() #將模型變換為測試模式
correct = 0
total = 0
for data_test in test_loader:
images, labels = data_test
images, labels = Variable(images).cuda(), Variable(labels).cuda()
output_test = net(images)
_, predicted = torch.max(output_test, 1)
total += labels.size(0)
correct += (predicted == labels).sum()
print("correct1: ", correct)
print("Test acc: {0}".format(correct.item() /
len(test_dataset)))

訓練及測試的情況：

98% 以上的成功率，效果還不錯。
————————————————
版權聲明：本文為CSDN博主「Steven·簡談」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/weixin_44613063/article/details/90815082