Pytorch实现简单的数字识别（上）

import torch
import matplotlib.pyplot as plt

def plot_curve(data):
    # 先画一个曲线,以表示training下降的过程
    fig = plt.figure()
    plt.plot(range(len(data)), data, color='blue')
    plt.legend(['value'], loc='upper right')
    # 将辅助牌放置在上右侧
    plt.xlabel('step')
    # 输入x轴名称
    plt.ylabel('value')
    # 输入y轴名称
    plt.show()

def plot_result_image(img, label, name):
    # 以图像的方式输出识别出的结果
    fig = plt.figure()
    # 先输出空白图像
    for i in range(9):
        # 以迭代的方式，一次性输出9个图像
        plt.subplot(3, 3, i+1)
        # 3 * 3 的图片输出样式
        plt.tight_layout()
        plt.imshow(img[i][0]*0.3081+0.1307, cmap='gray', interpolation='none')
        plt.title('{}: {}'.format(name, label[i].item()))
        plt.xticks([])
        plt.yticks([])
        # 分别将x和y的刻度值设定为坐标轴刻度
    plt.show()

def one_hot(label, depth=10):
    out = torch.zero_(label.size(0), depth)
    idx = torch.LongTensor(label).view(-1, 1)
    out.scatter_(dim=1, index=idx, value=1)
    return out

import torch
from torch import nn
# nn用于完成神经网络间的相关操作
from torch.nn import functional as F
# F为神经网络运算的常用计算包
from torch import optim
# 引入优化工具包
import torchvision
# 视觉类深度学习需要引入torchvision视觉工具包
from utils import plot_curve, plot_result_image, one_hot
# 从utils.py中导入定义的工具
from torch.utils.data import DataLoader,Dataset
import matplotlib.pyplot as plt

batch_size = 512
# 同时并行处理512张图片
train_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST('mnist data', train=True, download=False,
                               # 更改download=True，以在线下载
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   # numpy数据转换为Tensor格式
                                   torchvision.transforms.Normalize(
                                       # 正则化
                                       (0.1307,), (0.3081,)
                                       # 设置参数，使数据均匀分布在0,1附近，以方便优化
                                   )
                               ])),
    batch_size=batch_size, shuffle=True
    # shuffle=True：随机打散
)

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

x, y = next(iter(train_loader))
class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        # 准备构建三层神经网络，每一层都是xw+b函数
        self.fc1 = nn.Linear(28*28, 256)
        # 构建线性层
        # 初始图片的像素是28*28，默认是从“大层到小层”的过程
        self.fc2 = nn.Linear(256, 64)
        self.fc3 = nn.Linear(64, 10)
        # 由于是十分类问题，因此最终输出是10个

    def forward(self, x):
        # 创建计算过程
        # x:[batch, 1, 28, 28]
        # 本次使用relu作为激活函数
        x = F.relu(self.fc1(x))
        # h1 = relu(xw + b1)
        x = F.relu(self.fc2(x))
        # h2 = relu(h1w2 + b2)
        # h3 = h2w3 + b3
        x = F.softmax(self.fc3(x))
        # 分类问题，可以加入softmax函数
        return x
        # 返回预测值