如何使用Pytorch迅速寫一個Mnist數據分類器
一段時間沒有更新博文，想着也該寫兩篇文章玩玩了。而從一個簡單的例子作為開端是一個比較不錯的選擇。本文章會手把手地教讀者構建一個簡單的Mnist(Fashion-Mnist同理)的分類器，並且會使用相對完整的Pytorch訓練框架，因此對於初學者來說應該會是一個方便入門且便於閱讀的文章。本文的代碼來源於我剛學Pytorch時的小項目，可能在形式上會有引用一些github上的小代碼。同時文風可能會和我之前看的一些外國博客有點相近。
本文適用對象： 剛入門的Pytorch新手，想要用Pytorch來完成作業的魚干。
那么就開始coding吧。
首先，你需要安裝好Python 3+,Pytorch 1.0+,我個人使用的是Pytorch1.4，我想1.0以上的版本都可以使用。
然后在想要的位置，新建一個main.py的文件，然后就可以開始敲鍵盤了。
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets
from torchvision import transforms
import torch.utils.data
import argparse
第一步自然是導入相應的包。前面的都是Pytorch的包，最后一句導入的argparse便於用來修改訓練的參數，這在Pytorch復現深度學習模型時非常常見。
model_names = ['Net','Net1']
parser = argparse.ArgumentParser(description='PyTorch Mnist Training')
parser.add_argument('-a', '--arch', metavar='ARCH', default='Net', choices=model_names,
help='model archtecture: ' + '|'.join(model_names) + '(default:Net)')
parser.add_argument('--epochs', default=5, type=int, metavar='N', help='number of total epochs')
parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum')
parser.add_argument('-b', '--batchsize', default=32, type=int, metavar='N', help='mini-batch size')
parser.add_argument('--lr', '--learning-rate', default=1e-2, type=float, metavar='LR', help='initial learning rata',
dest='lr')
args=vars(parser.parse_args())
第一行的model_names是一個list，用來存儲我們之后會實現的兩種網絡結構的名字。然后我定義了一個argparse的對象，關於argparse可以自尋一些教程觀看，大概只需要知道可以從指令行輸入參數即可。在parser中又定義了arch(使用的網絡)，epochs(迭代輪次)，momentum(梯度動量大小)，batchsize(一次送入的圖片量大小)，learning-rate(學習率)參數。之前的model_name也正是用在arch參數中，限定了網絡框架將會從此二者中選擇其一。
def main():
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#parameter
batch_size = args["batchsize"]
lr = args["lr"]
momentum = args["momentum"]
num_epochs = args["epochs"]
主函數中，先定義cuda對象，便於使用gpu並行運算。在#parameter中，我們把一些從命令行中獲得的參數引入到相應的變量中，以便后續書寫。
#prepare the dataset
mnist_data = datasets.MNIST("./mnist_data",train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=(0.13,),std=(0.31,))
]))
'''
mnist_data = datasets.FashionMNIST("./fashion_mnist_data", train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=(,), std=(,))
]))
'''
train_loader = torch.utils.data.DataLoader(
mnist_data,batch_size=batch_size,shuffle=True, num_workers=1,pin_memory=True
)
test_loader = torch.utils.data.DataLoader(
mnist_data,batch_size=batch_size,shuffle=True, num_workers=1,pin_memory=True
)
之后將引入Pytorch中datasets包自帶的MNIST集，download參數設置為True，以便於本地沒有Mnist數據集時直接下載，之后會在當前目錄下創建一個mnist_data的文件夾以存放數據，。transform中的transforms.ToTensor()是用於將圖片形式的數據轉換成tensor類型，而transforms.Normalize(mean=(0.13,),std=(0.31,))則是將tensor類型的數據進行歸一化，這里的0.13和0.31可以直接使用。如果你想要使用注釋中的FashionMNIST數據集則需要使用的是注釋中的內容，當然，mean和std需要另外求解。
之后，定義train_loader和test_loader，將數據集作為可迭代的對象使用。shuffle=True以實現亂序讀取數據，一般都會這么設置。num_workers和pin_memory都會影響到數據讀取速度，前者是會在讀取時創建多少個進程，后者是影響到數據讀入到GPU中，一般來說，對於這個項目前者設置為1已經夠用，后者設置為True和False都不影響。在更大型的項目中，如果設備較好，前者可以設置大一些。
model = Net1().to(device) if args["arch"]=='Net1' else Net().to(device)
optimizer = torch.optim.SGD(model.parameters(),lr=lr,momentum=momentum)
criteon = nn.CrossEntropyLoss().to(device)
第一行是model實例化，並且會根據args["arch"]選擇是用Net還是Net1，to(device)會將model放置於device上運行。第二行定義了一個優化器，使用的是SGD，並且放入model的參數、學習率和動量大小。criteon定義損失函數，這邊使用的是交叉熵函數，這一損失函數在分類問題中十分常用。
#train
for epoch in range(num_epochs):
train(model,device,train_loader,optimizer,epoch,criteon)
test(model,device,test_loader,criteon)
torch.save(model.state_dict(), "mnist_{}.pth".format(num_epochs))
這就是訓練過程，在其中又使用了train和test兩個函數(下面會說)，根據num_epochs數目進行循環。循環結束后，torch.save將會把模型的參數model.state_dict()以mnist_{}.pth的形式存放到當前文件夾下。
def train(model,device,train_loader,optimizer,epoch,criteon):
class_name = model.__class__.__name__
model.train()
loss = 0
for idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
pred = model(data)
if class_name == 'Net':
loss = F.nll_loss(pred, target)
elif class_name == 'Net1':
loss = criteon(pred, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if idx % 100 == 0:
print("train epoch: {}, iteration: {}, loss: {}".format(epoch, idx, loss.item()))
這里定義了train函數的訓練過程。class_name中存放了當前使用的模型名字。 model.train()開啟訓練模式。在for idx, (data, target) in enumerate(train_loader):取出當前數據集的idx，data和種類target。循環中，先把data和target放置於device上，pred = model(data)會進行一次前傳，獲得相應數據的預測種類pred。
對不同的模型，我采用了不同定義損失函數的方式，這里需要結合下面的模型結構來看。optimizer.zero_grad()會將上輪累計的梯度清空，之后loss.backward()梯度反向傳播，利用optimizer.step()更新參數。而當if idx % 100 == 0:也就是迭代的數據批次到達100的倍數了，就會輸出相關信息。
def test(model,device,test_loader,criteon):
class_name = model.__class__.__name__
model.eval()
total_loss = 0 #caculate total loss
correct = 0
with torch.no_grad():
for idx, (data, target) in enumerate(test_loader):
data, target = data.to(device), target.to(device)
pred = model(data)
if class_name == 'Net':
total_loss += F.nll_loss(pred, target,reduction="sum").item()
elif class_name == 'Net1':
total_loss += criteon(pred, target).item()
correct += pred.argmax(dim=1).eq(target).sum().item()
total_loss /= len(test_loader.dataset)
acc = correct/len(test_loader.dataset)
print("Test loss: {}, Accuracy: {}%".format(total_loss,acc*100))
test函數總體結構類似，model.eval()將會把模型調整測試模式，with torch.no_grad():來聲明測試模式下不需要積累梯度信息。correct += pred.argmax(dim=1).eq(target).sum().item()則是會計算出預測對了的數目，之后通過total_loss計算總誤差和acc計算准確率。
class Net(nn.Module):
def __init__(self):
super(Net,self).__init__()
self.conv1 = nn.Conv2d(1, 20, kernel_size=5,stride=1)
self.conv2 = nn.Conv2d(20,50,kernel_size=5,stride=1)
self.fc1 = nn.Linear(4*4*50, 500)
self.fc2 = nn.Linear(500, 10)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x,2,2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x,2,2)
x = x.view(-1,4*4*50)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = F.log_softmax(x,dim=1)
return x
Net不過是一個具有兩個卷積層和兩個線性全連層的網絡。self.conv1 = nn.Conv2d(1, 20, kernel_size=5,stride=1)表示conv1是一個接受1個channel的tensor輸出20個channel的tensor，且卷積大小為5，步長為1的卷積層。self.fc1 = nn.Linear(4*4*50, 500)則是接收一個4 * 4 * 50長的一維tensor並且輸出長為500的一維tensor。
前傳函數forward中，x作為輸入的數據，輸入后會通過 conv1->relu->pooling->conv2->relu->pooling->view將多維tensor轉化成一維tensor->fc1->relu->fc2->log_softmax來獲得最終的x的值。這里就需要提train和test函數中的if和elif語句了。使用的時Net時，loss = F.nll_loss(pred, target)，這是因為log_softmax之后使用nll_loss和直接使用 nn.CrossEntropyLoss()是等效的，因此：
class Net1(nn.Module):
def __init__(self):
super(Net1,self).__init__()
self.conv_unit=nn.Sequential(
nn.Conv2d(1, 20, kernel_size=5,stride=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2,stride=2),
nn.Conv2d(20,50,kernel_size=5,stride=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.fc_unit=nn.Sequential(
nn.Linear(4*4*50, 500),
nn.ReLU(),
nn.Linear(500, 10)
)
def forward(self, x):
x = self.conv_unit(x)
x = x.view(-1,4*4*50)
x = self.fc_unit(x)
return x
Net1中最后並沒有使用log_softmax，是因為直接在train的過程中，使用了nn.CrossEntropyLoss()。此外，Net1和Net不同的地方也就是在結構中使用了nn.Sequential()來單元化卷積層和全連層。
if __name__ == '__main__':
main()
之后就可以使用了！
在命令行中使用：
$ python main.py
就會按照默認的參數訓練一個Mnist分類器了。
第三輪的效果:
train epoch: 2, iteration: 1300, loss: 0.010509848594665527
train epoch: 2, iteration: 1400, loss: 0.0020529627799987793
train epoch: 2, iteration: 1500, loss: 0.0027058571577072144
train epoch: 2, iteration: 1600, loss: 0.010049819946289062
train epoch: 2, iteration: 1700, loss: 0.0352507084608078
train epoch: 2, iteration: 1800, loss: 0.009431719779968262
Test loss: 0.01797709318200747, Accuracy: 99.42833333333333%
如果希望查看參數列表，則可以在命令行使用：
$ python main.py -h
就會出現：
usage: main.py [-h] [-a ARCH] [--epochs N] [--momentum M] [-b N] [--lr LR]
PyTorch Mnist Training
optional arguments:
-h, --help show this help message and exit
-a ARCH, --arch ARCH model archtecture: Net|Net1(default:Net)
--epochs N number of total epochs
--momentum M momentum
-b N, --batchsize N mini-batch size
--lr LR, --learning-rate LR
initial learning rata
於是如果想要使用Net1，lr為0.001的方式訓練，就可以按照這樣:
$ python main.py -a Net1 --lr 0.001
第三輪結果:
train epoch: 2, iteration: 1200, loss: 0.03096039593219757
train epoch: 2, iteration: 1300, loss: 0.060124486684799194
train epoch: 2, iteration: 1400, loss: 0.08865253627300262
train epoch: 2, iteration: 1500, loss: 0.13717596232891083
train epoch: 2, iteration: 1600, loss: 0.003894627094268799
train epoch: 2, iteration: 1700, loss: 0.06881710141897202
train epoch: 2, iteration: 1800, loss: 0.03184908628463745
Test loss: 0.0013615453808257978, Accuracy: 98.69666666666667%
至此，你獲得了一個Mnist訓練器的訓練方法。