如何使用Pytorch迅速寫一個Mnist數據分類器
- 2020 年 3 月 8 日
- 筆記
如何使用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 xNet不過是一個具有兩個卷積層和兩個線性全連層的網絡。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 xNet1中最後並沒有使用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訓練器的訓練方法。
