pytorch简单易懂实现mnist数据集的显示和分类

1.mnist手写数据集的下载

import torch
import torchvision
import matplotlib.pyplot as plt
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
torch.manual_seed(1)

EPOCH=1#训练整批数据多少次
BATCH_SIZE=64#每次批数的数据量
LR=0.001#学习率，学习率的设置直接影响着神经网络的训练效果
#建议把加载手写数据集的方式固定，免得之后重复下载
train_data=torchvision.datasets.MNIST(#训练数据
     root= './mnist/',
     train=True,
     transform=torchvision.transforms.ToTensor(),
     download=False#这里我已经下载好了，所以选False
     )
test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)#测试数据集
# 批训练
train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

可以说mnist手写数据集相当于pytorch的一个“Hello World”一点儿也不夸张，但要掌握这个Hello World对新手来说还是有难度的。

2.可视化mnist手写数据集

# 数据可视化
images, label = next(iter(train_loader))
images_example = torchvision.utils.make_grid(images)
images_example = images_example.numpy().transpose(1,2,0) # 将图像的通道值置换到最后的维度，符合图像的格式
mean = [0.5,0.5,0.5]
std = [0.5,0.5,0.5]
images_example = images_example * std + mean
plt.imshow(images_example )
plt.show()

将一个批数的数据进行整体可视化显示，但是很多时候我们只想看到其它 一个手写数字，那么我们可以采取以下方式实现：

image_array,_=train_data[0]#把一个批数的训练数据的第一个取出
image_array=image_array.reshape(28,28) #转换成28*28的矩阵
plt.imshow(image_array)
plt.show()

CNN的搭建

with torch.no_grad():
     test_x=Variable(torch.unsqueeze(test_data.data, dim=1)).type(torch.FloatTensor)/255.#数据
test_y=test_data.targets#标签
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_filters输出
                kernel_size=5,      # filter size滤波核大小
                stride=1,           # filter movement/step步长
                padding=2,      # 如果想要 con2d 出来的图片长宽没有变化, padding=，(kernel_size-1)/2 当 stride=1填充
            ),      # output shape (16, 28, 28)
            nn.ReLU(),    # activation
            nn.MaxPool2d(kernel_size=2),    # 在 2x2 空间里向下采样, output shape (16, 14, 14)
        )
        self.conv2 = nn.Sequential(  # input shape (16, 28, 28)
            nn.Conv2d(16, 32, 5, 1, 2),  # output shape (32, 14, 14)
            nn.ReLU(),  # activation
            nn.MaxPool2d(2),  # output shape (32, 7, 7)
        )
        self.out = nn.Linear(32 * 7 * 7, 10)   # fully connected layer, output 10 classes
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)   # 展平多维的卷积图成 (batch_size, 32 * 7 * 7)
        output = self.out(x)
        return output

CNN的搭建是手写数据集的核心，关键是理解最后的self.out，这个手写数据集是0-9，也就是有10个类别，它就是一个分类问题，10个类别输出的话就是10个，对输出的10个采用relu阶跃函数，选择这10个值中最大的标签就是对应的预测值

对一个批数据进行预测

cnn = CNN()
print(cnn)  # 显示神经网络
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)   # Adam优化函数
loss_func = nn.CrossEntropyLoss()   # 损失函数（损失函数分很多种，CrossEntropyLoss适用于作为多分类问题的损失函数）
# training and testing
for epoch in range(EPOCH):#训练批数
    for step, (x, y) in enumerate(train_loader):   # 每个批数的批量
        b_x = Variable(x)   # batch x
        b_y = Variable(y)   # batch y
        output = cnn(b_x)               # cnn output
        loss = loss_func(output, b_y)   # cross entropy loss
        optimizer.zero_grad()           # 梯度清零
        loss.backward()                 # 损失函数的反向传导
        optimizer.step()                 # 对神经网络中的参数进行更新
test_output = cnn(test_x)
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y.numpy(), 'real number')

训练结果：

这个的训练结果还是蛮好的，大家可以根据自己的需要更改学习率，和优化函数看一看，说不定可以加深大家的理解