NNIST手写体CNN Pytorch实现——up主：刘二大人《PyTorch深度学习实践》

b站up主：刘二大人《PyTorch深度学习实践》
教程： https://www.bilibili.com/video/BV1Y7411d7Ys?p=6&vd_source=715b347a0d6cb8aa3822e5a102f366fe
$$\begin{gathered} 两层卷积层:torch.nn.Conv2d+最大池化+Flatten \\ 激活函数：ReLU \\ 交叉熵损失函数：nn.CrossEntropyLoss \\ 优化器：optim.Adam \\ 数据集：MNIST手写体 \end{gathered}$$
网络结构：

训练过程：

源码：

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                train=True,
                download=True,
                transform=transform)
train_loader = DataLoader(train_dataset,
              shuffle=True,
              batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist',
                train=False,
                download=True,
                transform=transform)
test_loader = DataLoader(test_dataset,
              shuffle=False,
              batch_size=batch_size)

class Net(torch.nn.Module):
  def __init__(self):
    super(Net, self).__init__()
    self.conv1 = torch.nn.Conv2d(1, 10, kernel_size = 5) #输入通道为1，kernel数量为10
    self.conv2 = torch.nn.Conv2d(10, 20, kernel_size = 5) #输入通道为10，kernel个数为20
    self.pooling = torch.nn.MaxPool2d(2) #池化kernel为2*2
    self.flatten = torch.nn.Flatten()
    self.fc = torch.nn.Linear(320, 10)


  def forward(self, x):
    batch_size = x.size(0)
    x = F.relu(self.pooling(self.conv1(x)))
    x = F.relu(self.pooling(self.conv2(x)))
    x = self.flatten(x)
    x = self.fc(x)
    return x

model = Net()
print(model, '\n')

criterion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

loss_val = []

def train(epoch):
  running_loss = 0.0
  for i, data in enumerate(train_loader, 0):
    inputs, target = data
    optimizer.zero_grad()
    outputs = model(inputs)
    # print('inputs = ', inputs.shape)
    # print('outputs = ', outputs.shape)
    # print('target = ', target.shape)
    loss = criterion(outputs, target)
    loss.backward()
    optimizer.step()

    running_loss += loss.item()

    if i%300 == 299:
      print('[%d,%5d]loss:%.3f'%(epoch+1,i+1,running_loss/300))
      loss_val.append(running_loss)
      running_loss = 0.0
  epoch_list.append(epoch+1)

def test():
  correct = 0
  total = 0
  with torch.no_grad():
    for data in test_loader:
      images, labels = data
      outputs = model(images)
      _, predicted = torch.max(outputs.data, dim = 1) #在outputs中找到最高概率的index赋值给predicted
      total += labels.size(0) #batch_size++ 也就是样本总数
      correct += (predicted == labels).sum().item()
  print('Accuracy on test set: %d %%' % (100 * correct / total))
  accuracy.append(correct/total)

accuracy = []
epoch_list = []

for epoch in range(3):
  train(epoch)
  test()

plt.plot(epoch_list, accuracy, c = 'b')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.show()