008_wz_ledr_pytorch深度学习实战_第九讲——多分类问题

一、目的

使用softmax函数对Minist数据集进行分类

二、编程

2.1 softmax函数

我们先来了解一下什么是softmax激活函数：

softmax函数，又称归一化指数函数，它是二分类函数sigmoid在多分类上的推广，目的是将多分类的结果以概率的形式展现出来。下图展示了softmax的计算方法：

概率有两个性质：

1）预测的概率为非负数；
2）各种预测结果概率之和等于1。

softmax就是将在负无穷到正无穷上的预测结果按照这两步转换为概率的。

softmax如何将多分类输出转换为概率，可以分为两步：

1）分子：通过指数函数，将实数输出映射到零到正无穷。
2）分母：将所有结果相加，进行归一化。
详见一分钟理解softmax函数（超简单）。

2.2 编程

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.optim as optim
import torch.nn.functional as F

# 准备数据集
batch_size = 64
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])

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

# 构造网络模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        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):
        # 将C*W*H三维张量变为二维张量，用于深度深度学习处理
        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))
        # 最后一层不进行激活，不做非线性变换
        return self.l5(x)


model = Net()

# 构造损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

def train(epoch):
    running_loss = 0
    for batch_idx, data in enumerate(train_loader, 0):
        # 获得一个批次的输入与标签
        inputs, target = data
        # 开始训练
        optimizer.zero_grad()
        # 正向传播
        y_pred = model(inputs)
        # 计算损失
        loss = criterion(y_pred, target)
        # 反向传播
        loss.backward()
        # 更新梯度
        optimizer.step()

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


def test():
    correct = 0
    total = 0
    # 不计算梯度
    with torch.no_grad():
        for data in test_loader:
            inputs, labels = data
            prec = model(inputs)
            '''
            torch.max(input, dim) 函数
            输入:
            input是softmax函数输出的一个tensor
            dim是max函数索引的维度0/1，0是每列的最大值，1是每行的最大值
            输出:
            函数会返回两个tensor，第一个tensor是每行的最大值，softmax的输出中最大的是1，
            所以第一个tensor是全1的tensor；第二个tensor是每行最大值的索引。
            '''
            _, predicted = torch.max(prec.data, dim=1)  # predicated为维度（784，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)
        test()

2.3 结果

[1,   300] loss: 2.176
[1,   600] loss: 0.941
[1,   900] loss: 0.417
accuracy on test set: 90 % 
[2,   300] loss: 0.318
[2,   600] loss: 0.265
[2,   900] loss: 0.231
accuracy on test set: 94 % 
[3,   300] loss: 0.193
[3,   600] loss: 0.169
[3,   900] loss: 0.153
accuracy on test set: 95 % 
[4,   300] loss: 0.128
[4,   600] loss: 0.129
[4,   900] loss: 0.115
accuracy on test set: 96 % 
[5,   300] loss: 0.098
[5,   600] loss: 0.099
[5,   900] loss: 0.093
accuracy on test set: 96 % 
[6,   300] loss: 0.078
[6,   600] loss: 0.079
[6,   900] loss: 0.073
accuracy on test set: 96 % 
[7,   300] loss: 0.059
[7,   600] loss: 0.066
[7,   900] loss: 0.059
accuracy on test set: 96 % 
[8,   300] loss: 0.048
[8,   600] loss: 0.051
[8,   900] loss: 0.053
accuracy on test set: 96 % 
[9,   300] loss: 0.039
[9,   600] loss: 0.042
[9,   900] loss: 0.044
accuracy on test set: 97 % 
[10,   300] loss: 0.031
[10,   600] loss: 0.034
[10,   900] loss: 0.035
accuracy on test set: 97 % 

可以看到基本到97%的准确率就是极限，原因在全连接深度学习，不能学习到图片局部特征细节，可以使用CNN来改进。

三、参考

一分钟理解softmax函数（超简单）
PyTorch 深度学习实践 第9讲