09Softmax Classifer

本讲小结

• 1，主要讲解了交叉熵损失函数，交叉熵损失函数可以等价为softmax+NLLloss(负对数损失函数)。
• 2，基于交叉熵损失函数讲解了手写数据集的训练、分类。
• 3，torchvision里面的transform的使用，这一部分推荐看土堆的教程。

1,多分类问题网络设计

• 一种设计思路是有多少个分类就有多少个输出，每个输出对应一个类别的概率，越接近1，说明这个输出越接近真实标签；如下图，手写数字有0-9十个数字，做成输出十个输出。这样每个输出实际上相当于一个二分类问题，每个输出之间是独立，没有耦合关系。但实际上，这明显是有问题的。因为对一个手写数字图片，假设它被神经网络认为是1的概率为0.9，如果按照以上的设计思路，它被认为是7的概率也许是0.8，这无疑增加了对正确数据的判别难度。
  
• 另一种设计思路是输出一个概率分布，变成一个耦合问题。概率分布满足所有类别概率相加等于1。这样，针对一个手写数字，神经网络输出认为它是1的概率最大时，认为是其他数字的概率必然会被抑制。这就引出了本小结的Softmax激活函数。
  

2,$Softmax激活函数公式$

• P ( y = i ) = e z i ∑ j = 0 K − 1 e z j , i ∈ { 0 , … , K − 1 } {\LARGE {\huge } } 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}

• 本讲的Softmax激活函数的例子，假设神经网络做一个三分类问题，神经元输出针对三分类分数为$[0.2,0.1,-0.1]$，然后经过指数变换，得到$[1.22,1.11,0.9]$,然后分别除以指数变换后的和得到最终的概率分布$[0.38,0.34,0.28]$,$0.38+0.34+0.28=1$,说明Softmax激活函数完美的将神经元输出的分数转变成类别概率分布。
  

3,负对数似然损失

• 实际上，交叉熵损失就是在Softmax激活之后接一个负对数似然损失。
  
• pytorch官网对该函数的解释很清楚了，并且推荐直接使用交叉熵损失。
  

4,交叉熵损失

• 实际上要理解上面的负对数似然损失，还要理解类别标签的one-hot编码。做损失计算的时候，我们对于类别的编码不是实数编码，比如有10个类的手写数据集，可不是0-0,1-1,2-2…这样的编码。此时再解释上面的例子，one-hot编码，认为第一个位置位真，其余位置为假，所以$-ln(0.38)=0.9729$，注意这里的公式，实际上是以自然数e为底数，只是公式那样写而言。如果以10为底数，结果是不一样的。
• 如下代码：

import numpy as np
 
targets = np.array([1, 0, 0]) # one-hot编码，认为第一个位置位真，其余位置为假
 
outputs = np.array([0.2, 0.1, -0.1]) 
 
y_pred = np.exp(z) / np.exp(z).sum() #softmax
 
loss = (- y * np.log(y_pred)).sum()
 
print(loss)  #0.9729189131256584

• 改变一个真值的位置，认为最后一个输出位才是真值，则直接可以计算得出$-ln(0.28)=1.2729$，,代码如下所示：
  
• 再来做一个实验，上面指针对一个样本做交叉熵损失，那假如是一个batch呢？以该样本为例，复制三份，第一个样本认为第一位是真值，第二样本认为第二位是真值，第三个样本则是第三个。根据前面的计算，很容易验证得到$（0.9729+1.2729+(-in(0.34))/3=1.1082$，这里有误差很正常，因为我们计算是保留小数的。

手写数据集分类

• 图像基本知识，图像上的每一个像素点数值为0-255。对于单通道的手写数据集，其实就是一个二维的矩阵。
  

5,代码范式

模型结构

6,本小节代码

# 0.导库
import torch
# 构建DataLoader的库
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
# 使用函数relu()的库
import torch.nn.functional as F
# 构建优化器的库
import torch.optim as optim

# 1.准备数据集
batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),  # 将PIL图像转化成Tensor
    # 正则化，归一化，0.1307是均值，0.3081是标准差，这两个值是根据所有数据集算出来的
    transforms.Normalize((0.1307,), (0.3081,))

])

train_dataset = datasets.MNIST(root='./datasets/data/',
                               train=True,
                               download=True,
                               transform=transform)

train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)

test_dataset = datasets.MNIST(root='./datasets/data/',
                              train=False,
                              download=True,
                              transform=transform)

test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)


# 2.设计模型
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)
        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)  # 注意最后一层不做激活

# 利用GPU训练
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Net()
model.to(device)

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


# 4.训练过程
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()
        # forward + backward + update
        outputs = model(inputs.to(device))
        loss = criterion(outputs, target.to(device))
        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))


# 4.测试过程
def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 测试时不会计算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images.to(device)).cpu()
            _, predicted = torch.max(outputs.data, dim=1)  # 沿着维度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()

实验结果

• 测试集上精确度达到0.97，几乎是完美的效果了。
  

一些其他实验

• transform的实验，一张图像经过PIL读取进来，其格式是$(W,H,C)$大小的张量。transform.Totensor首先把张量格式转变成$(C,W,H)$,然后把像素值压缩到0-1之间。