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

Horizon John

已于 2024-05-17 15:39:35 修改

阅读量3.5k

点赞数 9

文章标签：深度学习机器学习 PyTorch

于 2021-12-27 10:55:31 首次发布

本文链接：https://blog.csdn.net/weixin_45084253/article/details/122167179

版权

简单入门 PyTorch 专栏收录该内容

14 篇文章 104 订阅

订阅专栏

🤵 Author ：Horizon John

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

🎇 机器视觉篇：会变魔术 OpenCV

💥 深度学习篇：简单入门 PyTorch

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

💻 算法篇：再忙也别忘了 LeetCode

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

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

文章目录

Softmax_Classifier

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 %