大家好，我是紅色石頭！
在上一篇文章：
這可能是神經網絡 LeNet-5 最詳細的解釋了！詳細介紹了卷積神經網絡 LeNet-5 的理論部分。今天我們将使用 Pytorch 來實作 LeNet-5 模型，并用它來解決 MNIST資料集的識别。
正文開始！
一、使用 LeNet-5 網絡結建構立 MNIST 手寫數字識别分類器
MNIST是一個非常有名的手寫體數字識别資料集，訓練樣本：共60000個，其中55000個用于訓練，另外5000個用于驗證；測試樣本：共10000個。MNIST資料集每張圖檔是單通道的，大小為28x28。
1.1 下載下傳并加載資料，并做出一定的預先處理
由于 MNIST 資料集圖檔尺寸是 28x28 單通道的，而 LeNet-5 網絡輸入 Input 圖檔尺寸是 32x32，是以使用 transforms.Resize 将輸入圖檔尺寸調整為 32x32。
首先導入 PyToch 的相關算法庫：
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import time
from matplotlib import pyplot as plt pipline_train = transforms.Compose([
#随機旋轉圖檔
transforms.RandomHorizontalFlip(),
#将圖檔尺寸resize到32x32
transforms.Resize((32,32)),
#将圖檔轉化為Tensor格式
transforms.ToTensor(),
#正則化(當模型出現過拟合的情況時，用來降低模型的複雜度)
transforms.Normalize((0.1307,),(0.3081,))
])
pipline_test = transforms.Compose([
#将圖檔尺寸resize到32x32
transforms.Resize((32,32)),
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))
])
#下載下傳資料集
train_set = datasets.MNIST(root="./data", train=True, download=True, transform=pipline_train)
test_set = datasets.MNIST(root="./data", train=False, download=True, transform=pipline_test)
#加載資料集
trainloader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=False) 這裡要解釋一下 Pytorch MNIST 資料集标準化為什麼是 transforms.Normalize((0.1307,), (0.3081,))？
标準化（Normalization）是神經網絡對資料的一種經常性操作。标準化處理指的是：樣本減去它的均值，再除以它的标準差，最終樣本将呈現均值為 0 方差為 1 的資料分布。
神經網絡模型偏愛标準化資料，原因是均值為0方差為1的資料在 sigmoid、tanh 經過激活函數後求導得到的導數很大，反之原始資料不僅分布不均（噪聲大）而且數值通常都很大（本例中數值範圍是 0~255），激活函數後求導得到的導數則接近與 0，這也被稱為梯度消失。是以說，資料的标準化有利于加快神經網絡的訓練。
除此之外，還需要保持 train_set、val_set 和 test_set 标準化系數的一緻性。标準化系數就是計算要用到的均值和标準差，在本例中是((0.1307,), (0.3081,))，均值是 0.1307，标準差是 0.3081，這些系數都是資料集提供方計算好的資料。不同資料集就有不同的标準化系數，例如([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])就是 ImageNet dataset 的标準化系數（RGB三個通道對應三組系數），當需要将 Imagenet 預訓練的參數遷移到另一神經網絡時，被遷移的神經網絡就需要使用 Imagenet的系數，否則預訓練不僅無法起到應有的作用甚至還會幫倒忙。
1.2 搭建 LeNet-5 神經網絡結構，并定義前向傳播的過程
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Conv2d(1, 6, 5)
self.relu = nn.ReLU()
self.maxpool1 = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.maxpool2 = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(16*5*5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.conv1(x)
x = self.relu(x)
x = self.maxpool1(x)
x = self.conv2(x)
x = self.maxpool2(x)
x = x.view(-1, 16*5*5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
output = F.log_softmax(x, dim=1)
return output 1.3 将定義好的網絡結構搭載到 GPU/CPU，并定義優化器
#建立模型，部署gpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = LeNet().to(device)
#定義優化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
1.4 定義訓練過程
def train_runner(model, device, trainloader, optimizer, epoch):
#訓練模型, 啟用 BatchNormalization 和 Dropout, 将BatchNormalization和Dropout置為True
model.train()
total = 0
correct =0.0
#enumerate疊代已加載的資料集,同時擷取資料和資料下标
for i, data in enumerate(trainloader, 0):
inputs, labels = data
#把模型部署到device上
inputs, labels = inputs.to(device), labels.to(device)
#初始化梯度
optimizer.zero_grad()
#儲存訓練結果
outputs = model(inputs)
#計算損失和
#多分類情況通常使用cross_entropy(交叉熵損失函數), 而對于二分類問題, 通常使用sigmod
loss = F.cross_entropy(outputs, labels)
#擷取最大機率的預測結果
#dim=1表示傳回每一行的最大值對應的列下标
predict = outputs.argmax(dim=1)
total += labels.size(0)
correct += (predict == labels).sum().item()
#反向傳播
loss.backward()
#更新參數
optimizer.step()
if i % 1000 == 0:
#loss.item()表示目前loss的數值
print("Train Epoch{} \t Loss: {:.6f}, accuracy: {:.6f}%".format(epoch, loss.item(), 100*(correct/total)))
Loss.append(loss.item())
Accuracy.append(correct/total)
return loss.item(), correct/total 1.5 定義測試過程
def test_runner(model, device, testloader):
#模型驗證, 必須要寫, 否則隻要有輸入資料, 即使不訓練, 它也會改變權值
#因為調用eval()将不啟用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置為False
model.eval()
#統計模型正确率, 設定初始值
correct = 0.0
test_loss = 0.0
total = 0
#torch.no_grad将不會計算梯度, 也不會進行反向傳播
with torch.no_grad():
for data, label in testloader:
data, label = data.to(device), label.to(device)
output = model(data)
test_loss += F.cross_entropy(output, label).item()
predict = output.argmax(dim=1)
#計算正确數量
total += label.size(0)
correct += (predict == label).sum().item()
#計算損失值
print("test_avarage_loss: {:.6f}, accuracy: {:.6f}%".format(test_loss/total, 100*(correct/total))) 1.6 運作
LeNet-5 網絡模型定義好，訓練函數、驗證函數也定義好了，就可以直接使用 MNIST 資料集進行訓練了。
# 調用
epoch = 5
Loss = []
Accuracy = []
for epoch in range(1, epoch+1):
print("start_time",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
loss, acc = train_runner(model, device, trainloader, optimizer, epoch)
Loss.append(loss)
Accuracy.append(acc)
test_runner(model, device, testloader)
print("end_time: ",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),'\n')
print('Finished Training')
plt.subplot(2,1,1)
plt.plot(Loss)
plt.title('Loss')
plt.show()
plt.subplot(2,1,2)
plt.plot(Accuracy)
plt.title('Accuracy')
plt.show() 
最終在 10000 張測試樣本上，average_loss降到了 0.00228，accuracy 達到了 97.72%。可以說 LeNet-5 的效果非常好！
1.7 儲存模型
print(model)
torch.save(model, './models/model-mnist.pth') #儲存模型 LeNet-5 的模型會 print 出來，并将模型模型指令為 model-mnist.pth 儲存在固定目錄下。
LeNet(
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(relu): ReLU()
(maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
1.8 手寫圖檔的測試
下面，我們将利用剛剛訓練的 LeNet-5 模型進行手寫數字圖檔的測試。
import cv2
if __name__ == '__main__':
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = torch.load('./models/model-mnist.pth') #加載模型
model = model.to(device)
model.eval() #把模型轉為test模式
#讀取要預測的圖檔
img = cv2.imread("./images/test_mnist.jpg")
img=cv2.resize(img,dsize=(32,32),interpolation=cv2.INTER_NEAREST)
plt.imshow(img,cmap="gray") # 顯示圖檔
plt.axis('off') # 不顯示坐标軸
plt.show()
# 導入圖檔，圖檔擴充後為[1，1，32，32]
trans = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)#圖檔轉為灰階圖，因為mnist資料集都是灰階圖
img = trans(img)
img = img.to(device)
img = img.unsqueeze(0) #圖檔擴充多一維,因為輸入到儲存的模型中是4維的[batch_size,通道,長，寬]，而普通圖檔隻有三維，[通道,長，寬]
# 預測
output = model(img)
prob = F.softmax(output,dim=1) #prob是10個分類的機率
print("機率：",prob)
value, predicted = torch.max(output.data, 1)
predict = output.argmax(dim=1)
print("預測類别：",predict.item()) 輸出：
機率：tensor([[2.0888e-07, 1.1599e-07, 6.1852e-05, 1.5797e-04, 1.4975e-09, 9.9977e-01,
1.9271e-06, 3.1589e-06, 1.2186e-07, 4.3405e-07]],
grad_fn=<SoftmaxBackward>)
預測類别：5
模型預測結果正确！
以上就是 PyTorch 建構 LeNet-5 卷積神經網絡并用它來識别 MNIST 資料集的例子。全文的代碼都是可以順利運作的，建議大家自己跑一邊。
所有完整的代碼我都放在 GitHub 上，GitHub位址為：
https://github.com/RedstoneWill/ObjectDetectionLearner/tree/main/LeNet-5也可以點選閱讀原文進入~