手写数字数据集有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()
|