Pytorch使用CNN实现手写数字识别

• 环境：python3、torch1.2.0(torch1.5.0也可以)、torchvision0.4.0
  
• 代码：（注：download=False第一次应该设为True，原因在代码注释里）

import torch 
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as data
import matplotlib.pyplot as plt

import torchvision  #数据库模块

torch.manual_seed(1) #reproducible

#Hyper Parameters
EPOCH = 1
BATCH_SIZE = 50
LR = 0.001

train_data = torchvision.datasets.MNIST(
    root='./mnist/', #保存位置
    train=True, #training set
    transform=torchvision.transforms.ToTensor(), #converts a PIL.Image or numpy.ndarray
                                        #to torch.FloatTensor(C*H*W) in range(0.0,1.0)
    download=False # 注意第一次执行时，当前目录下应该是没有mnist数据集的，这里需要设置成True
)

test_data = torchvision.datasets.MNIST(root='./mnist/')
#如果是普通的Tensor数据，想使用torch_dataset = data.TensorDataset(data_tensor=x, target_tensor=y)
#将Tensor转换成torch能识别的dataset
#批训练， 50 samples, 1 channel, 28*28, (50, 1, 28 ,28)
train_loader = data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# test_x = Variable(torch.unsqueeze(test_data.test_data, dim=1), volatile=True).type(torch.FloatTensor)[:2000]/255. # 这行代码中的volatile=True在torch1.5版本以上就不支持了（包括1.5版本）
with torch.no_grad():
    test_x = Variable(torch.unsqueeze(test_data.data, dim=1)).type(torch.FloatTensor)[:2000]/255.
test_y = test_data.targets[:2000]

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential( #input shape (1,28,28)
            nn.Conv2d(in_channels=1, #input height
                      out_channels=16, #n_filter
                     kernel_size=5, #filter size
                     stride=1, #filter step
                     padding=2 #con2d出来的图片大小不变
                     ), #output shape (16,28,28)
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2) #2x2采样，output shape (16,14,14)

        )
        self.conv2 = nn.Sequential(nn.Conv2d(16, 32, 5, 1, 2), #output shape (32,7,7)
                                  nn.ReLU(),
                                  nn.MaxPool2d(2))
        self.out = nn.Linear(32*7*7,10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1) #flat (batch_size, 32*7*7)
        output = self.out(x)
        return output

cnn = CNN()
print(cnn)

#optimizer
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)

#loss_fun
loss_func = nn.CrossEntropyLoss()

#training loop
for epoch in range(EPOCH):
    for i, (x, y) in enumerate(train_loader):
        batch_x = Variable(x)
        batch_y = Variable(y)
        #输入训练数据
        output = cnn(batch_x)
        #计算误差
        loss = loss_func(output, batch_y)
        #清空上一次梯度
        optimizer.zero_grad()
        #误差反向传递
        loss.backward()
        #优化器参数更新
        optimizer.step()
        if i % 50 == 0:
            test_output = cnn(test_x)
            test_pred = torch.max(test_output, 1)[1].data
            test_accuracy = float((test_pred == test_y).sum().item()) / float(test_y.size(0))
            print('epoch:', epoch, 'Train loss: ', loss.data.cpu().numpy(), 'Test Accuracy:', test_accuracy)


test_output =cnn(test_x[:10])
pred_y = torch.max(test_output,1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10])

• 运行结果截图：