MNIST數據集手寫數字識別

pytorch的MNIST數據集手寫數字識別(GPU)

數據集介紹

MNIST 包括6萬張28x28的訓練樣本，1萬張測試樣本，很多教程都會對它”下手”幾乎成爲一個 “典範”，可以說它就是計算機視覺裏面的Hello World。所以我們這裏也會使用MNIST來進行實戰。

前面在介紹卷積神經網絡的時候說到過LeNet-5，LeNet-5之所以強大就是因爲在當時的環境下將MNIST數據的識別率提高到了99%，這裏我們也自己從頭搭建一個卷積神經網絡，也達到99%的準確率

手寫數字識別

BATCH_SIZE=512 #大概需要2G的顯存
EPOCHS=20 # 總共訓練批次
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 讓torch判斷是否使用GPU，建議使用GPU環境，因爲會快很多

因爲Pytorch裏面包含了MNIST的數據集，所以我們這裏直接使用即可。 如果第一次執行會生成data文件夾，並且需要一些時間下載，如果以前下載過就不會再次下載了

由於官方已經實現了dataset，所以這裏可以直接使用DataLoader來對數據進行讀取

train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('data', train=True, download=True, 
                       transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=BATCH_SIZE, shuffle=True)

測試集

test_loader = torch.utils.data.DataLoader(
        datasets.MNIST('data', train=False, transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=BATCH_SIZE, shuffle=True)

下面我們定義一個網絡，網絡包含兩個卷積層，conv1和conv2，然後緊接着兩個線性層作爲輸出，最後輸出10個維度，這10個維度我們作爲0-9的標識來確定識別出的是那個數字

在這裏建議大家將每一層的輸入和輸出維度都作爲註釋標註出來，這樣後面閱讀代碼的會方便很多

class ConvNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 1,28x28
        self.conv1=nn.Conv2d(1,10,5) # 10, 24x24
        self.conv2=nn.Conv2d(10,20,3) # 128, 10x10
        self.fc1 = nn.Linear(20*10*10,500)
        self.fc2 = nn.Linear(500,10)
    def forward(self,x):
        in_size = x.size(0)
        out = self.conv1(x) #24
        out = F.relu(out)
        out = F.max_pool2d(out, 2, 2)  #12
        out = self.conv2(out) #10
        out = F.relu(out)
        out = out.view(in_size,-1)
        out = self.fc1(out)
        out = F.relu(out)
        out = self.fc2(out)
        out = F.log_softmax(out,dim=1)
        return out

我們實例化一個網絡，實例化後使用.to方法將網絡移動到GPU
優化器我們也直接選擇簡單暴力的Adam
下面定義一下訓練的函數，我們將訓練的所有操作都封裝到這個函數中

model = ConvNet().to(DEVICE)
optimizer = optim.Adam(model.parameters())
# 訓練函數
def train(model, device, train_loader, optimizer, epoch):
    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+1)%30 == 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()))
# 測試函數
def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    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() # 將一批的損失相加
            pred = output.max(1, keepdim=True)[1] # 找到概率最大的下標
            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)))

# 開始
for epoch in range(1, EPOCHS + 1):
    train(model, DEVICE, train_loader, optimizer, epoch)
    test(model, DEVICE, test_loader)

正確率99%