经常使用softmax分类器
以Mnist数据集为例：
这里有10种数据类型，那么其对应输出该如何写？
我们希望y1-10之间具有竞争性：也就是其中一个多了，其他几个就得小。此外还希望他们所有加起来的总和为1。
但上面这两个条件sigmoid函数无法满足，所以就有了下面这样的模型；
softmax对应的公式：
假设
是最后一层的输出。分子用
是为了确保其值大于0，搭配上分母就可以实现求和后的值为1了；
softmax层的例子
经过softmax之后的结果
可以看到，不管输出有多少项，只有一项是非0的。但是这样一来，原来的损失计算函数：
会有损失为0的项，而这对于训练模型来说是没有意义的；
那么新的Loss就是：；
这样一来，对应的流程图就变成了：
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()
print(loss)
#0.9729189131256584
变化后的伪代码：
import torch
#用了交叉熵之后的y得是一个长整型张量
y =torch.LongTensor([0])
z = torch.Tensor([0.2, 0.1, -0.1])
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(z, y)
print(loss)
具体例子：
import torch
criterion = torch.nn.CrossEntropyLoss()
#有三个样本，分别属于第2/0/1类
Y = torch.LongTensor([2, 0, 1])
#这里的y_pred里的值都是线性层的原始输出
Y_pred1 = torch.Tensor([[0.1, 0.2, 0.9], #第2类样本
[1.1, 0.1, 0.2], #第0类样本
[0.2, 2.1, 0.1]]) #第1类样本
Y_pred2 = torch.Tensor([[0.8, 0.2, 0.3],
[0.2, 0.3, 0.5],
[0.2, 0.2, 0.5]])
l1 = criterion(Y_pred1, Y)
l2 = criterion(Y_pred2, Y)
print("Batch Loss1 = ", l1.data, "\nBatch Loss2=", l2.data)
#Batch Loss1 = tensor(0.4966)
#Batch Loss2= tensor(1.2389)
• CrossEntropyLoss <==> LogSoftmax + NLLLoss（具体用哪个得看实际需求）
将之前的那个数字的数据集进行数字化，以5为例：
数值越大，颜色越深
这次加上了测试的部分，也就是说要一边训练，一边测试并以此评估性能；
- 引入一堆包
import torch
#前三项是为了构造DataLoader
from torchvision import transforms #transforms是一种针对图像进行数据处理的工具
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F #这次此用Relu作为激活函数了
import torch.optim as optim
- 准备数据集
ToTensor的工作目标
这里张量对应的1,28,28分别是C（通道，可以理解为底色个数？黑白的就是1，彩色的是3）、宽和高
#开始先来设置一下batch_size
batch_size = 64
#compose函数可以把若干个方法整合在一起
transform = transforms.Compose([
transforms.ToTensor() #这玩意儿可以把PIL图片（就是那些个数字的格式）转为张量
,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)
模型可视化：
注意，最后一个输出层是不需要激活函数的，而是用交叉熵损失去算softmax；
输入的是一个四阶的张量，但是我们需要的是一个二维的张量，那么就把合并成一个1行784列（28* 28）的张量；接下来就是不断地降维，最后转为一个输出为0~ 9的值，表示每个数字的取值概率一样的
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)
model = Net()
- 构造损失和优化器
criterion = torch.nn.CrossEntropyLoss()
#momentume是冲量，就是一个帮助冲破局部最小值的参数
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()
#每计算300次迭代输出一次来减少开销
if batch_idx % 300 == 299:
print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
running_loss = 0.0
def test():
#在test中不需要计算梯度，直接用torch.no_grad()就不会再计算了
correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
outputs = model(images)
#使用max来找出最大的值从而判定归属类
#找的是最大值的下标，返回的是：每行的最大值，最大值的下标
_, 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()
可以看到，到了97%之后就上不去了，这是因为对于局部信息的处理不太行，也就是用的都是特别高级别的特征，而没有低级的特征，但是这都是人工方法，深度学习一般不推荐。
深度学习可以通过CNN实现较为全面的特征提取
作业： https://www.kaggle.com/c/otto-group-product-classification-challenge/data
