“他山之石，可以攻玉”，站在巨人的肩膀才能看得更高，走得更遠。在科研的道路上，更需藉助東風才能更快前行。為此，我們特別蒐集整理了一些實用的程式碼連結，資料集，軟體，程式設計技巧等，開闢“他山之石”專欄，助你乘風破浪，一路奮勇向前，敬請關注。

地址：https://www.zhihu.com/people/sun-xu-sen-30

01

資料集介紹

本文使用的是PyTorch自帶的MNIST資料集，該資料集中為PIL Image，size=28x28。資料儲存形式為(data, target)，其中data為PIL Image，target該圖片表示的數字。如下所示：

(<PIL.Image.Image image mode=L size=28x28 at 0x175EF44F160>, 5)

02

模型搭建

input：torch.Size([64, 1, 28, 28])after conv1: torch.Size([64, 32, 26, 26])after conv2: torch.Size([64, 64, 24, 24])after max_pool2d: torch.Size([64, 64, 12, 12])after flatten: torch.Size([64, 9216])after fc1: torch.Size([64, 128])after fc2: torch.Size([64, 10])after log_softmax: torch.Size([64, 10])

由各層的輸出結果可以看出，batch_size為64，網路結構圖中tensor在各層的變化與輸出一致。

2.1 匯入庫檔案

from __future__ import print_functionimport argparseimport torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torchvision import datasets, transformsfrom torch.optim.lr_scheduler import StepLR

2.2 網路結構定義

class Net(nn.Module):    def __init__(self):        super(Net, self).__init__()        self.conv1 = nn.Conv2d(1, 32, 3, 1)        self.conv2 = nn.Conv2d(32, 64, 3, 1)        self.dropout1 = nn.Dropout(0.25)        self.dropout2 = nn.Dropout(0.5)        self.fc1 = nn.Linear(9216, 128)        self.fc2 = nn.Linear(128, 10)    def forward(self, x):        x = self.conv1(x)        # print("after conv1: {}".format(x.shape))        x = F.relu(x)        x = self.conv2(x)        # print("after conv2: {}".format(x.shape))        x = F.relu(x)        x = F.max_pool2d(x, 2)        # print("after max_pool2d: {}".format(x.shape))        x = self.dropout1(x)        x = torch.flatten(x, 1)        # print("after flatten: {}".format(x.shape))        x = self.fc1(x)        # print("after fc1: {}".format(x.shape))        x = F.relu(x)        x = self.dropout2(x)        x = self.fc2(x)        # print("after fc2: {}".format(x.shape))        output = F.log_softmax(x, dim=1)        # print("after log_softmax: {}".format(output.shape))        return output

2.3 transform究竟是幹什麼的？

相信大家在讀取資料集的時候，經常見到下面這段程式碼

transform = transforms.Compose([        transforms.ToTensor(),        transforms.Normalize((0.1307,), (0.3081,))        ])

彆著急，我們一個個來看，首先看transforms.ToTensor()

簡單來說，就是把PIL Image或者 numpy.ndarray型別的資料轉化為張量tensor。原來的在[0, 255]的具有(HxWxC)形式的PIL Image或numpy.ndarray資料，被轉換為[0.0, 1.0]範圍並且shape變為(CxHxW)。

前面我們看到資料集的格式為PIL Image，這個函式就是將之前的PIL Image變為tensor，後續才可以對其進行一系列操作。

再看transforms.Normalize()

對一個tensor進行歸一化，傳入的兩個引數為元組形式，分別為mean和std

相當於一個容器，將若干個transforms組合到一起。

2.4 DataLoader

taet1 = datasets.MNIST('../data', train=True, download=True,                   transform=transform)train_loader = torch.utils.data.DataLoader(dataset1, **train_kwargs)

簡而言之，DataLoader的作用就是對傳入的資料集進行取樣sample，返回一個可迭代的物件。注意到前面定義的batch_size為64，那麼在這裡，每次返回的可迭代物件的size就是64。

2.5 最佳化器定義

# 最佳化器optimizer = optim.Adadelta(model.parameters(), lr=args.lr)# 調整學習率scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)

其中StepLR是用來調整學習率的，具體的調整策略本文暫且不討論，在之後的博文中對集中調整學習率的方法統一討論。在這裡只需知道隨著epoch的增加，learning rate會改變即可。

03

train

train的流程非常簡單，首先設定為train模式，分批次讀入資料，最佳化器梯度置零，資料透過網路，計算損失，反向傳播，權重更新。如下

def train(args, model, device, train_loader, optimizer, epoch):    # 設定為train模式    model.train()    # 分批次讀入資料    for batch_idx, (data, target) in enumerate(train_loader):        data, target = data.to(device), target.to(device)        # 最佳化器梯度置零        optimizer.zero_grad()        # 資料透過網路        output = model(data)        # 計算損失        loss = F.nll_loss(output, target)        # 反向傳播        loss.backward()        # 權重更新        optimizer.step()        if batch_idx % args.log_interval == 0:            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(                epoch, batch_idx * len(data), len(train_loader.dataset),                100. * batch_idx / len(train_loader), loss.item()))            if args.dry_run:                break

04

test

test的流程與train略有不同，首先要設定為test模式，這是要防止改變已訓練好的權重。接著在with torch.no_grad()中讓資料透過網路，計算損失和預測是否正確即可。如下

def test(model, device, test_loader):    # 設定為test模式    model.eval()    test_loss = 0    correct = 0    # 不進行計算圖的構建，即沒有grad_fn屬性    with torch.no_grad():        for data, target in test_loader:            data, target = data.to(device), target.to(device)            output = model(data)            test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability            correct += pred.eq(target.view_as(pred)).sum().item()    test_loss /= len(test_loader.dataset)    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(        test_loss, correct, len(test_loader.dataset),        100. * correct / len(test_loader.dataset)))

05

整合訓練測試

def main():    # Training settings    # 宣告一個parser    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')    # 新增引數    parser.add_argument('--batch-size', type=int, default=64, metavar='N',                        help='input batch size for training (default: 64)')    parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',                        help='input batch size for testing (default: 1000)')    parser.add_argument('--epochs', type=int, default=14, metavar='N',                        help='number of epochs to train (default: 14)')    parser.add_argument('--lr', type=float, default=1.0, metavar='LR',                        help='learning rate (default: 1.0)')    parser.add_argument('--gamma', type=float, default=0.7, metavar='M',                        help='Learning rate step gamma (default: 0.7)')    parser.add_argument('--no-cuda', action='store_true', default=False,                        help='disables CUDA training')    parser.add_argument('--dry-run', action='store_true', default=False,                        help='quickly check a single pass')    parser.add_argument('--seed', type=int, default=1, metavar='S',                        help='random seed (default: 1)')    parser.add_argument('--log-interval', type=int, default=10, metavar='N',                        help='how many batches to wait before logging training status')    parser.add_argument('--save-model', action='store_true', default=False,                        help='For Saving the current Model')    # 讀取命令列引數    args = parser.parse_args()    use_cuda = not args.no_cuda and torch.cuda.is_available()    torch.manual_seed(args.seed)    device = torch.device("cuda" if use_cuda else "cpu")    train_kwargs = {'batch_size': args.batch_size}    test_kwargs = {'batch_size': args.test_batch_size}    if use_cuda:        cuda_kwargs = {'num_workers': 1,                       'pin_memory': True,                       'shuffle': True}        train_kwargs.update(cuda_kwargs)        test_kwargs.update(cuda_kwargs)    transform = transforms.Compose([        transforms.ToTensor(),        transforms.Normalize((0.1307,), (0.3081,))        ])    dataset1 = datasets.MNIST('../data', train=True, download=True,                       transform=transform)    dataset2 = datasets.MNIST('../data', train=False,                       transform=transform)    train_loader = torch.utils.data.DataLoader(dataset1, **train_kwargs)    test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)    model = Net().to(device)    optimizer = optim.Adadelta(model.parameters(), lr=args.lr)    scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)    for epoch in range(1, args.epochs + 1):        train(args, model, device, train_loader, optimizer, epoch)        test(model, device, test_loader)        scheduler.step()    if args.save_model:        torch.save(model.state_dict(), "mnist_cnn.pt")

06

模型結果

07

摸魚建議

摸魚也是最近接觸PyTorch這個框架，在學習過程中遇到了一些問題，也總結了一些經驗。下面是摸魚遇到的一些問題以及解決方式

Q1：為什麼網路的結構是這樣定義的？有什麼理由嗎？

A1：其實剛開始摸魚也不清楚為什麼網路要這樣設計，後來在Andrew Ng的課上，老師提起過一嘴，說這個沒有什麼特別的原因，如果非要說一個原因的話那就是它在實驗上的表現很好。所以我們在學習的過程中，可以借鑑那些經典的網路結構，以此為基礎改進來形成我們自己的網路架構。同樣網路中的引數也是一般採用設計者給出的會比較好。

Q2：transform，DataLoader等等的到底是幹嘛的？在好多地方看到過但還是比較模糊

A2：確實，在看官方文件的時候，經常看到這兩段程式碼。相信看完本文應該就可以解決這個問題了，至於要如何解決類似的問題，我的一個建議是瞭解資料的源格式以及你想要的的目的格式。其實transform不難理解，就是進行一個數據格式的轉換，但是如果不瞭解資料的源格式，可能對這塊就會比較模糊。