PyTorch深度学习实践 Lecture09 Softmax 分类器

Author ：Horizon Max

✨ 编程技巧篇：各种操作小结

机器视觉篇：会变魔术 OpenCV

深度学习篇：简单入门 PyTorch

神经网络篇：经典网络模型

算法篇：再忙也别忘了 LeetCode

视频链接：Lecture 09 Softmax_Classifier
文档资料：

//Here is the link:
课件链接：https://pan.baidu.com/s/1vZ27gKp8Pl-qICn_p2PaSw
提取码：cxe4

Softmax_Classifier

概述

前面都在说 " 回归（regression）" 与 " 二分类（classification）" 问题；

这一篇使用 Softmax 作为分类器解决 " 多分类（classification）" 问题；

前面说到的 Logistic_Regression（逻辑斯蒂回归）使用到的是 Sigmoid 函数，可以将输出值转换到（0，1）范围：

Softmax Layer

数学表达式：

总的来说：计算每一个输出值的占比（所有输出值的对数各自 除以 他们对数的和），这样算出来的值 均为非负数 且 和为1 。

1）分子： 通过指数函数，将实数输出映射到零到正无穷；
2）分母： 将所有结果相加，进行归一化处理。

如下图所示，蓝色表示 输出值 ，中间绿色的表示 Softmax Layer ，最右边三个值为最后输出的 值 ：

Logistic与Softmax比较：

1）Logistic 用于 二分类 问题，而 Softmax 用于 多分类 问题；

2）从概率角度，Softmax 属于 多项式 分布，而 Logistic 属于 伯努利 分布。

注：
CrossEntropyLoss() 交叉熵损失 函数又称 Softmax 损失函数。
使用 Sigmoid 作为激活函数时，其损失函数应设置为 binary_crossentropy（）（二值交叉熵）；

附：
二值交叉熵/对数表达式：

CrossEntropyLoss() 函数：

Model

这里使用的是经典数据集：MNIST DataSet

MNIST数据集是由 0 到 9 的 手写数字图像 构成；

训练集和测试集里各含名称为 0-9 的10个文件夹，共 60000张 训练集，10000 张测试集。

利用 PytTorch 搭建一个模型进行训练+测试，以下是模型结构图 ：

Code

# Here is the code :

import torch
from torchvision import transforms     # for constructing dataloader
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F    # for using function relu()
import torch.optim as optim     # for constructing optimizer


# 1 prepare dataset

batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,), (0.3081,))])  # 归一化, (均值, 方差) MINIST数据集经验值

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)


# 2 design model using class

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):
        x = x.view(-1, 784)     # .viwe()中的 -1 可以自己计算值的大小
        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()


# 3 construct loss and optimizer

criterion = torch.nn.CrossEntropyLoss()      # 交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


# 4 training cycle

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):   # enumerate( , 0)  自动编号 从0开始

        inputs, target = data
        optimizer.zero_grad()

        # forward, backward, update
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        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:
            images, labels = data
            outputs = model(images)
            _, 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)
        test()

函数链接： enumerate( )

运行结果

[1,   300] loss: 2.207
[1,   600] loss: 0.953
[1,   900] loss: 0.440
accuracy on test set: 89 % 
[2,   300] loss: 0.325
[2,   600] loss: 0.273
[2,   900] loss: 0.236
accuracy on test set: 93 % 
[3,   300] loss: 0.185
[3,   600] loss: 0.175
[3,   900] loss: 0.160
accuracy on test set: 95 % 
[4,   300] loss: 0.130
[4,   600] loss: 0.121
[4,   900] loss: 0.121
accuracy on test set: 96 % 
[5,   300] loss: 0.090
[5,   600] loss: 0.093
[5,   900] loss: 0.100
accuracy on test set: 96 % 
[6,   300] loss: 0.075
[6,   600] loss: 0.078
[6,   900] loss: 0.074
accuracy on test set: 96 % 
[7,   300] loss: 0.064
[7,   600] loss: 0.062
[7,   900] loss: 0.062
accuracy on test set: 97 % 
[8,   300] loss: 0.047
[8,   600] loss: 0.052
[8,   900] loss: 0.053
accuracy on test set: 97 % 
[9,   300] loss: 0.042
[9,   600] loss: 0.042
[9,   900] loss: 0.041
accuracy on test set: 97 % 
[10,   300] loss: 0.030
[10,   600] loss: 0.032
[10,   900] loss: 0.036
accuracy on test set: 97 % 

附录：相关文档资料

PyTorch 官方文档： PyTorch Documentation
PyTorch 中文手册： PyTorch Handbook

《PyTorch深度学习实践》系列链接：

  Lecture01 Overview
  Lecture02 Linear_Model
  Lecture03 Gradient_Descent
  Lecture04 Back_Propagation
  Lecture05 Linear_Regression_with_PyTorch
  Lecture06 Logistic_Regression
  Lecture07 Multiple_Dimension_Input
  Lecture08 Dataset_and_Dataloader
  Lecture09 Softmax_Classifier
  Lecture10 Basic_CNN
  Lecture11 Advanced_CNN
  Lecture12 Basic_RNN
  Lecture13 RNN_Classifier