多分类问题Softmax Classifier

在之前做糖尿病数据集的时候做的二分类问题，因为只有两类，所以只需要输出一个概率值，另一个概率值用1去减去就可以得到

实际上在大多数数据集中是在处理一个多分类问题，例如MNIST中有10类标签

神经网络如何设计

我们在输出的时候，在原来只有p（y=1）的输出变为10个输出，这样就可以输出每一个样本属于每一个分类的概率，可能出现大多数分类都是高概率，这其中肯定是矛盾的，希望在输出的分类的概率需要满足一个分布的要求，满足离散分类

• 全部概率>0

• 总概率 = 1

Softmax Layer

在处理多分类问题的时候，在前面的神经网络还是采用Sigmoid Layer，在最终输出层中我们使用Softmax Layer

下面我们就要针对分布要求，看看Softmax Layer是如何设计的

P ( y = i ) = e z i ∑ j = 0 K − 1 e z j , i ∈ { 0 , … , K − 1 } P(y=i)=\frac{e^{z_{i}}}{\sum_{j=0}^{K-1} e^{z_{j}}}, i \in\{0, \ldots, K-1\} P(y=i)=∑j=0K−1​ezj​ezi​​,i∈{0,…,K−1}

• 在分子部分，我们可以满足全部概率>0

• 在分母部分，满足总概率 = 1

假设我们有三个分类，经过线性之后我们有了三个输出值（0.2，0.1，-0.1），之后经过exp、sum、divide这三步，最终得到这三个类的概率y hat

Loss function

我们使用one-hot独热编码来解决多分类这个问题，只会保存Y=1的项

$$\mathrm{Loss}(\hat{Y},Y)=-Y\log \hat{Y}$$

在torch中有这么一个损失，NLLLoss（Negative Log Likelihood Loss），这个函数的功能是：Y输入的就是标签号

在Numpy中的Cross Entropy

在PyTorch中的Cross Entropy，提供了交叉熵损失这个函数

我们来看一个具体的例子，加入有三个样本，分别属于（2，0，1）类

第一个预测中Y_pred1对应得分类都比较准确，所以损失会小

第二个预测中Y_pred2对应得分类都不准确，所以损失会比较大

交叉熵损失和NLL损失之间的关系

MNIST Dataset

在数据集中一个图像是28*28=784个像素点组成的，每一个像素点的取值是0-255。

做一个线性映射到0-1的区间，我们可以看到在矩阵中就表示了图的形状

多分类实现MNIST Dataset

按照四个步骤，最后要加上测试集

工具包部分

其中用到的transforms针对图像进行一些处理，还用到了relu激活函数所需要用到torch.nn.functional

Prepare Dataset

用transform把原始PIL的图像转换为Tensor的图像格式

这个过程就可以用transforms中的ToTensor来实现

其中Normalize中第一个（0.1307,）就是求mean，第二个（0.3081,）就是std标准化,这两个值是在计算了整个数据集的mean和std得到的结果，所用到的归一化方程如下

$$Pixe{l}_{\text{norm }}=\frac{{\text{ Pixel }}_{\text{origin }}-\text{ mean }}{\text{ std }}$$

Design Model

输入图像为（N,1,28,28）其中有N个样本。

第一步就是把（1,28,28）这个三阶张量变成向量，用view函数来改变张量的形状（-1，784）二阶张量，第一个值是-1代表自动去算它的值是多少，比如N为64，则把-1 变为64，第二个值是图像的像素点，最后我们拿到的是N*784的矩阵，经过一系列的层，输出层得到（N，10），10个类

我们来看一下代码

Construct Loss and Optimizer

在criterion中我们使用交叉熵损失CrossEntropyLoss

在optimizer中我们使用更好的优化方法，带有冲量momentum（相当于是赋予梯度惯性，让它尽可能跳出局部最低点），设置为0.5来优化训练过程

Train and Test

将epoch封装在train函数中，输出300次迭代输出一次损失

优化器在优化之前就选择清零

在test函数中，我们只需要计算前向传播

我们在做完预测得到输出矩阵，每个样本都有一行，一行有10个量，我们要求最大值的下标是多少，使用torch.max，dim=1指的是行数，反之为0，指列数。返回的值是两个，每一行的最大值和每一行最大值的下标

最后可以计算准确率=正确数/总数

在训练的过程中只需要调用函数即可，也可以每十轮输出一次测试

在输出中我们可以看到loss在减少，accuracy在上升，但可能会存在极限

完整代码

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

# prepare dataset

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)


# 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)  # -1其实就是自动获取mini_batch
        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()

# construct loss and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


# training cycle forward, backward, update

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        # 获得一个批次的数据和标签
        inputs, target = data
        optimizer.zero_grad()
        # 获得模型预测结果(64, 10)
        outputs = model(inputs)
        # 交叉熵代价函数outputs(64,10),target（64）
        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)  # dim = 1 列是第0个维度，行是第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()

运行结果：

[1,  300] loss: 2.161
[1,  600] loss: 0.838
[1,  900] loss: 0.429
accuracy on test set: 89 % 
[2,  300] loss: 0.329
[2,  600] loss: 0.269
[2,  900] loss: 0.237
accuracy on test set: 93 % 
[3,  300] loss: 0.192
[3,  600] loss: 0.179
[3,  900] loss: 0.157
accuracy on test set: 95 % 
[4,  300] loss: 0.139
[4,  600] loss: 0.126
[4,  900] loss: 0.119
accuracy on test set: 96 % 
[5,  300] loss: 0.096
[5,  600] loss: 0.098
[5,  900] loss: 0.101
accuracy on test set: 96 % 
[6,  300] loss: 0.080
[6,  600] loss: 0.077
[6,  900] loss: 0.078
accuracy on test set: 97 % 
[7,  300] loss: 0.063
[7,  600] loss: 0.064
[7,  900] loss: 0.064
accuracy on test set: 97 % 
[8,  300] loss: 0.051
[8,  600] loss: 0.058
[8,  900] loss: 0.048
accuracy on test set: 97 % 
[9,  300] loss: 0.041
[9,  600] loss: 0.044
[9,  900] loss: 0.045
accuracy on test set: 97 % 
[10,  300] loss: 0.033
[10,  600] loss: 0.036
[10,  900] loss: 0.036
accuracy on test set: 97 %