pytorch-手写数字问题

手写数字问题

数据集

经典数据集Mnist

代码个人理解

代码分为两部分：mnist_train与utils一个负责训练一个负责绘图

utils

首先绘图必须调用torch跟matplotlib
数据放入后，表格的横纵坐标跟标签
plot_curve:绘制MNIST数据集进行训练时损失函数曲线

import  torch
from    matplotlib import pyplot as plt


def plot_curve(data):
    fig = plt.figure()
    plt.plot(range(len(data)), data, color=\'blue\')
    plt.legend([\'value\'], loc=\'upper right\')
    plt.xlabel(\'step\')
    plt.ylabel(\'value\')
    plt.show()

plot_image:对于训练和识别过程，可以很方便的将训练结果可视化

def plot_image(img, label, name):

    fig = plt.figure()
    for i in range(6):
        plt.subplot(2, 3, i + 1)
        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([])
    plt.show()

one-hot编码:pytorch内部还未实现
One-Hot编码是分类变量作为二进制向量的表示。这首先要求将分类值映射到整数值。然后，每个整数值被表示为二进制向量，除了整数的索引之外，它都是零值，它被标记为1。

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

mnist_train

import  torch
from    torch import nn
from    torch.nn import functional as F
from    torch import optim
import  torchvision
from matplotlib import pyplot as plt
from utils import plot_image, plot_curve, one_hot

通过torch vision实现的。
torchvision是PyTorch的一个图形库，服务于PyTorch深度学习框架，构建计算机视觉模型
torchvision.transforms：常用的图像预处理方法，利用Compose将对图片的操作整合起来
torchvision.datasets：常用的datasets数据集实现，如MNIST,CIFAR10等
torchvision.model：常用的模型预训练，如LeNet，ResNet，VGG等
解释一下这里的ToTensor：数据归一化到均值为0，方差为1（是将数据除以255），即图像进来以后，先进行通道转换，然后判断图像类型，若是uint8类型，就除以255；否则返回原图。
而这里的Normalize是对数据按通道进行标准化，即减去均值，再除以方差
其中，0.1307和0.3081是mnist数据集的均值和标准差，因为mnist数据值都是灰度图，所以图像的通道数只有一个，因此均值和标准差各一个。要是imagenet数据集的话，由于它的图像都是RGB图像，因此他们的均值和标准差各3个，分别对应其R,G,B值。例如([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])就是Imagenet dataset的标准化系数（RGB三个通道对应三组系数）。数据集给出的均值和标准差系数，每个数据集都不同的，都是数据集提供方给出的。
input[channel] = (input[channel] - mean[channel]) / std[channel]

batch_size = 512
# step1. load dataset
train_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST(\'mnist_data\', train=True, download=True,
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   torchvision.transforms.Normalize(
                                       (0.1307,), (0.3081,))
                               ])),
    batch_size=batch_size, shuffle=True)

test_loader = torch.utils.data.DataLoader(
    torchvision.datasets.MNIST(\'mnist_data/\', train=False, download=True,
                               transform=torchvision.transforms.Compose([
                                   torchvision.transforms.ToTensor(),
                                   torchvision.transforms.Normalize(
                                       (0.1307,), (0.3081,))
                               ])),
    batch_size=batch_size, shuffle=False)
    #因为对RGB图片而言，数据范围是[0-255]的，需要先经过ToTensor除以255归一化到[0,1]之后，再通过Normalize计算过后，将数据归一化到[-1,1]。那transform.Normalize()是怎么工作的呢？以上面代码为例，ToTensor()能够把灰度范围从0-255变换到0-1之间，而后面的transform.Normalize()则把0-1变换到(-1,1)

x, y = next(iter(train_loader))
print(x.shape, y.shape, x.min(), x.max())
plot_image(x, y, \'image sample\')

这里采用的是最最最基本的线性层连接，共有三层，激活函数采用的relu函数

在这里Linear会把28*28的图像铺平展开为784个元素的一维数组后进行处理，在forward内不断传给下一层。

这个地方只写了前向传播的forward（），并没有写反向传播的backward（）是因为在pytorch的求导过程中，有以下两种情况：

如果是标量对向量求导(scalar对tensor求导)，那么就可以保证上面的计算图的根节点只有一个，此时不用引入grad_tensors参数，直接调用backward函数即可
如果是(向量)矩阵对(向量)矩阵求导(tensor对tensor求导)，实际上是先求出Jacobian矩阵中每一个元素的梯度值(每一个元素的梯度值的求解过程对应上面的计算图的求解方法)，然后将这个Jacobian矩阵与grad_tensors参数对应的矩阵进行对应的点乘，得到最终的结果

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()

        # xw+b
        self.fc1 = nn.Linear(28*28, 256)
        self.fc2 = nn.Linear(256, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        # x: [b, 1, 28, 28]
        # h1 = relu(xw1+b1)
        x = F.relu(self.fc1(x))
        # h2 = relu(h1w2+b2)
        x = F.relu(self.fc2(x))
        # h3 = h2w3+b3
        x = self.fc3(x)

        return x

创建网络后加入优化器的参数，初始化损失函数后开始训练，这里的x = x.view(x.size(0), 28*28)就是对x进行变化，由x:[b, 1, 28, 28] => [b, 784]，

net = Net()#创建网络
#[w1, b1, w2, b2, w3, b3]
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)


train_loss = []

for epoch in range(3):

    for batch_idx, (x, y) in enumerate(train_loader):

        # x: [b, 1, 28, 28], y: [512]
        # [b, 1, 28, 28] => [b, 784]
        x = x.view(x.size(0), 28*28)
        # => [b, 10]
        out = net(x)
        # [b, 10]
        y_onehot = one_hot(y)
        # loss = mse(out, y_onehot)
        loss = F.mse_loss(out, y_onehot)

        optimizer.zero_grad()
        loss.backward()
        # w\' = w - lr*grad
        optimizer.step()

        train_loss.append(loss.item())

        if batch_idx % 10==0:
            print(epoch, batch_idx, loss.item())

将得到的损失函数放入utils里的制图

plot_curve(train_loss)
#we get optimal [w1, b1, w2, b2, w3, b3]

预测值pred取结果中间概率最大的index值作为他的label，可以用过argmax返回最大值的索引，上述代码即可以理解为在dim=1处，取最大值索引而正确值correct是将y和pred之间做一个比较，利用sum（）可得到当前batch中预测结果正确的一个总个数，最终是Tensor类型，再将其转换为数据类型，加上item（），最后total_correct累加之后就是调用工具函数将数据可视化

total_correct = 0
for x,y in test_loader:
    x  = x.view(x.size(0), 28*28)
    out = net(x)
    # out: [b, 10] => pred: [b]
    pred = out.argmax(dim=1)
    correct = pred.eq(y).sum().float().item()
    total_correct += correct

total_num = len(test_loader.dataset)
acc = total_correct / total_num
print(\'test acc:\', acc)

x, y = next(iter(test_loader))
out = net(x.view(x.size(0), 28*28))
pred = out.argmax(dim=1)
plot_image(x, pred, \'test\')