Pytorch深度学习-用MNIST数据集做多分类

糖尿病数据集来源：torchvision中的datasets带的MNIST数据集

1.Mnist数据集分为两部分，分别含有60000张训练图片和10000张测试图片

2.每一张图片包含2828个像素。Mnist数据集把代表一张图片的二维数据转开成一个向量，长度为2828=784。因此在Mnist的训练数据集中mnist.train.images是一个形状为[60000, 784]的张量

3.第一个维度数字用来索引图片，第二个维度数字用来索引每张图片中的像素点，图片里的某个像素的强度值介于0-1之间

4.模型输出是一个长度为10的向量，其中每个值代表了该图片属于0-9的概率，其中概率最大的值可以作为本次输出的分类结果

这是一个典型的多分类问题，可以用Softmax函数来解决

1. 数据集构建

每个像素点即每条数据中的值范围为0-255，有的数字过大不利于训练且难以收敛，故将其归一化到（0-1）之间

# 数据集处理
# transforms.ToTensor()---shape从(H,W,C)->(C,H,W), 每个像素点从(0-255)映射到(0-1):直接除以255
# transforms.Normalize()---先将输入归一化到(0,1),像素点通过"(x-mean)/std",将每个元素分布到(-1,1)
transform = transforms.Compose([
    transforms.ToTensor(),  
    transforms.Normalize(std=(0.1307,), mean=(0.3081,))  
])

# 1.准备数据集

train_dataset = datasets.MNIST(root="../DataSet/mnist",
                               train=True,
                               transform=transform,
                               download=True)
test_dataset = datasets.MNIST(root="../DataSet/mnist",
                              train=False,
                              transform=transform,
                              download=True)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

2. 用Pytorch提供的DataLoader来加载数据集

# dataset:数据集 batch_size:mini-batch的大小 shuffle:是否打乱数据集顺序
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)

3.采用全连接的神经网络来构建模型，最后接Softmax来处理output

# 构建网络模型
class Module(torch.nn.Module):
    def __init__(self):
        super(Module, self).__init__()
        # 因为把图片展开成一个向量作为全连接的输入，所以这里输入的特征长度是28*28=784
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        x = self.l5(x)
        # softmax 函数的作用包含在 CrossEntropyLoss 中
        return x

4. 构建损失函数和优化器

损失函数采用CrossEntropyLoss
优化器采用 SGD 随机梯度优化算法

# 构建损失函数和优化器
# softmax 函数的作用包含在 CrossEntropyLoss 中,交叉熵算法
criterion = torch.nn.CrossEntropyLoss()  
opt = optim.SGD(params=model.parameters(), lr=0.01, momentum=0.5)

5.完整代码

# -*- codeing = utf-8 -*-
# @Software : PyCharm

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

batch_size = 64

# transforms.ToTensor()---shape从(H,W,C)->(C,H,W), 每个像素点从(0-255)映射到(0-1):直接除以255
# transforms.Normalize()---先将输入归一化到(0,1),像素点通过"(x-mean)/std",将每个元素分布到(-1,1)
transform = transforms.Compose([
    transforms.ToTensor(),  
    transforms.Normalize(std=(0.1307,), mean=(0.3081,))  
])

# 1.准备数据集
train_dataset = datasets.MNIST(root="../DataSet/mnist",
                               train=True,
                               transform=transform,
                               download=False)
test_dataset = datasets.MNIST(root="../DataSet/mnist",
                              train=False,
                              transform=transform,
                              download=False)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)


# 2.构建网络模型---模型时针对单个样本的处理情况
class Module(torch.nn.Module):
    def __init__(self):
        super(Module, self).__init__()
        # 因为把图片展开成一个向量作为全连接的输入，所以这里输入的特征长度是28*28=784
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        x = self.l5(x)
        # softmax 函数的作用包含在 CrossEntropyLoss 中
        return x


model = Module()
# 3.构造损失器和优化器
criterion = torch.nn.CrossEntropyLoss()  # softmax 函数的作用包含在 CrossEntropyLoss 中,交叉熵算法
opt = optim.SGD(params=model.parameters(), lr=0.01, momentum=0.5)


# 4.训练数据集
def train(epoch):
    runing_loss = 0
    for batch_idx, (inputs, target) in enumerate(train_loader, 0):
        opt.zero_grad()
        y_pred_data = model(inputs)
        loss = criterion(y_pred_data, target)
        loss.backward()
        opt.step()

        runing_loss += loss.item()
        if batch_idx % 300 == 299:
            print("[%5d, %5d] loss: %3.f" % (epoch + 1, batch_idx + 1, runing_loss / 300))
            runing_loss == 0.0


# 5.测试数据集
def verify():
    correct = 0
    total = 0
    with torch.no_grad():  # 该语句下的所有tensor在进行反向传播时,不会被计算梯度
        for (images, labels) in test_loader:
            # 数据进入模型进行计算
            outputs = model(images)
            # 沿着维度为1的方向(行方向) 寻找每行最大元素的值与其下标
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print("Accuracy on test set: %d%%" % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        verify()
        # 使用全连接的神经网络准确率在 97% 左右

6.结果展示

result.png