watch: PyTorch - 刘二 09 | Multi-classification Task

手写数字数据集有10个类别，

如果对每一类别按照二分类问题（是/不是）计算概率的话，每种类别的概率互相独立，与真实情况中，各结果之间互相抑制的事实矛盾。

样本的分类结果满足一个概率分布，这就要求属于各类的概率都要大于0，而且概率之和为1。

二分类问题只需要计算一个概率（另一个是互补），所以十分类问题只需要计算9个概率，但是第10个分类的计算方式与前9个不统一，就导致需要构造一些额外的计算图处理特殊情况，无法最大化地实现并行计算，所以希望所有类别的概率运算处理都是一样的。

所以除了最后一层，前面的层还是用sigmoid，最后一层用softmax激活函数，满足：

$$ \begin{cases} P(y=i) ≥ 0 \\ \sumᵢ₌₀^9 P(y=i) =1 \end{cases} $$

假设 $Z^l \in \mathbb R^K$ 是最后一个线性层 $l$ 的输出，共有K个类别，则经过 Softmax函数，线性层的输出变成概率分布：

$$ P(y=i) = \frac{e^{Z_i}}{\sum_{j=0}^{K-1} e^{Z_j}},\ i\in\{0,\cdots, K-1 \} $$

分子使用指数运算从而恒大于零，分母是各输出之和，实现归一化。

对于二分类问题（样本标签Y=1,0）交叉熵：$-(1\cdot log \hat{Y} + 0\cdot log(1-\hat{Y}))$。

对于三分类问题（样本标签Y=1,0,0），交叉熵：$-(1 \cdot log \hat{Y}₁+ 0 + 0)$

不管有多少类，只有1项是非零的。零项对训练没有意义，所以损失函数直接写为：$Loss(\hat{Y}, Y) = -Y log \hat{Y}$

例如最后一个线性层的输出为：

$$ [^{\_{0.2}} \_{^{0.1} \_{-0.1}}] \overset{\rm Exponent}{\longrightarrow} [^{_{1.22}} _{^{1.11} _{0.90}}] \overset{\rm Divide\ sum}{\longrightarrow} [^{\_{0.38}} \_{^{0.34} \_{0.28}}] \overset{-Y log \hat{Y}}{\longrightarrow} Loss $$

对预测值先求对数，再数乘以样本 label (-Y)，被称为Negative Log Likelihood Loss (NLLLoss)，用numpy实现此计算过程：

1
2
3
4
5
6


import numpy as np
y = np.array([1,0,0])   #样本标签
z = np.array([0.2, 0.1, -0.1])  #线性层的输出
y_pred = np.exp(z) / np.exp(z).sum() #预测值归一化
loss = (- y* np.log(y_pred)).sum()   #取对数乘以-Y，就是NLLLoss
print(loss)

如果把softmax函数也算到损失函数中，在pytorch中叫做交叉熵损失：Torch.nn.CrossEntropyLoss()。这样的话，神经网络的最后一个线性层不要做激活，直接传给交叉熵损失：

1
2
3
4
5
6


import torch
y = torch.LongTensor([0])   #长整型 (第0个类别)
z = torch.Tensor([[0.2, 0.1, -0.1]])    #线性层输出
criterion = torch.nn.CrossEntropyLoss() #定义损失函数
loss = criterion(z,y)   #计算损失
print(loss)

Mini-Batch: batch_size=3。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import torch
criterion = torch.nn.CrossEntropyLoss()
Y = torch.LongTensor([2,0,1])   #三条样本，分别属于第2类，第0类，第1类,用于索引真实类别对应的预测值
Y_pred1 = torch.Tensor( [0.1, 0.2, 0.9], #(2)classified
                        [1.1, 0.1, 0.2], #(0)classified
                        [0.2, 2.1, 0.1]) #(1)classified
Y_pred2 = torch.Tensor( [0.8, 0.2, 0.3], #(0)misclassified
                        [0.2, 0.3, 0.5], #(2)misclassified
                        [0.2, 0.2, 0.5]) #(2)misclassified
loss1 = criterion(Y_pred1, Y)   #损失较小 0.4966
loss2 = criterion(Y_pred1, Y)   # 1.2389
print("Batch Loss1=", loss1.data,"\nBatch Loss2=",loss2.data)

MNIST Dataset

图像是28×28的矩阵。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85



## 引入包
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

## 准备数据
batch_size = 64
transform = transforms.Compose([    #把一系列对象组成一个pipeline
    transforms.ToTensor(),  #把整数像素值0-255转变为图像张量：值0-1，维度：CxWxH (1x28x28)，方便卷积
    transforms.Normalize((0.1307,), (0.3081,)) ])   #归一化，减去均值,除以标准差, 使所有的像素值满足0-1分布

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 = dataset.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):
        self.l1 = torch.nn.Linear(784, 512) #线性层把784维变成512维
        self.l2 = torch.nn.Linear(512, 256) #将到256
        self.l3 = torch.nn.Linear(256, 128) #将到128
        self.l4 = torch.nn.Linear(128, 64)  #将到64
        self.l5 = torch.nn.Linear(64, 10)  #将到10，输出(N,10)的矩阵
    
    def forward(self, x):   #向前计算输出
        x = x.view(-1, 784) #改变张量的形状，把一张图像变成一个二阶的张量（矩阵）784列，-1表示自动计算行数N
        x = F.relu(self.l1(x))  #输入l1，对输出做激活
        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() #经过softmax，求对数，乘以-Y
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5) #模型较大，用冲量


## 训练和测试
def train(epoch):       #一轮训练的运算
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):  #取出训练样本
        inputs, target = data   #取出样本和标签
        optimizer.zero_grad()   #梯度清零

        outputs = model(inputs) 
        loss = criterion(outputs, target) #前馈:计算输出和损失
        loss.backward()     #反馈
        optimizer.step()    #更新一步权重

        running_loss += loss.item() #累计损失
        if batch_idx %300 == 299    #每300批（因为从0开始数）输出一次loss
            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(image)  #计算预测值 Nx10 的矩阵

            _, predicted = torch.max(outputs.data, dim=1) #找出每一行中最大值的下标, 即所属类别，和它的值。dim=1表示沿着行方向寻找（0是列方向）

            total += labels.size(0) #测试样本总数N
            correct += (predicted == labels).sum().item() #正确分类的个数
    print("Accuracy on test set: %d %%" % (100*correct /total))


if __name__ == '__main__':
    for epoch in range(10): #训练10轮
        train(epoch)
        if epoch %10 ==9:
            test()

Table of contents

MNIST Dataset