[Pytorch]＜动手学深度学习＞pytorch笔记-----SoftMax回归

1.引入需求:分类问题

让我们考虑一个简单的图像分类问题，其输入图像的高和宽均为2像素，且色彩为灰度。这样每个像素值都可以用一个标量表示。我们将图像中的4像素分别记为x1,x2,x3,x4​。假设训练数据集中图像的真实标签为狗、猫或鸡（假设可以用4像素表示出这3种动物），这些标签分别对应离散值y1,y2,y3.

我们通常使用离散的数值来表示类别，例如y1=1,y2=2,y3=3。如此，一张图像的标签为1、2和3这3个数值中的一个。虽然我们仍然可以使用回归模型来进行建模，并将预测值就近定点化到1、2和3这3个离散值之一，但这种连续值到离散值的转化通常会影响到分类质量。因此我们一般使用更加适合离散值输出的模型来解决分类问题。

2.SoftMax回归数学模型

softmax回归跟线性回归一样将输入特征与权重做线性叠加。与线性回归的一个主要不同在于，softmax回归的输出值个数等于标签里的类别数。因为一共有4种特征和3种输出动物类别，所以权重包含12个标量（带下标的w）、偏差包含3个标量（带下标的b），且对每个输入计算o1,o2,o3这3个输出：

下图用神经网络图描绘了上面的计算。softmax回归同线性回归一样，也是一个单层神经网络。由于每个输出o1,o2,o3​的计算都要依赖于所有的输入x1,x2,x3,x4，softmax回归的输出层也是一个全连接层。

既然分类问题需要得到离散的预测输出，一个简单的办法是将输出值oioi​当作预测类别是ii的置信度，并将值最大的输出所对应的类作为预测输出。例如，如果o1​,o2​,o3​分别为0.1,10,0.1,由于o2最大，那么预测类别为2，其代表猫。

然而，直接使用输出层的输出有两个问题。一方面，由于输出层的输出值的范围不确定，我们难以直观上判断这些值的意义。例如，刚才举的例子中的输出值10表示“很置信”图像类别为猫，因为该输出值是其他两类的输出值的100倍。但如果o1=o3=,那么输出值10却又表示图像类别为猫的概率很低。另一方面，由于真实标签是离散值，这些离散值与不确定范围的输出值之间的误差难以衡量。

softmax运算解决了以上两个问题。它通过下式将输出值变换成值为正且和为1的概率分布：

 容易看出且每个预测概率均在0-1之间，因此​是合法的概率分布。这时候，如果=0.8，不管其余两个预测​的值是多少，我们都知道图像类别为猫的概率是80%。

 3.单样本分类的矢量计算表达式

为了提高计算效率，我们可以将单样本分类通过矢量计算来表达。在上面的图像分类问题中，假设softmax回归的权重和偏差参数分别为

 设高和宽分别为2个像素的图像样本i的特征为

 输出层的输出为

 预测为狗、猫或鸡的概率分布为

 softmax回归对样本i分类的矢量计算表达式为

4.小批量样本分类的矢量表达式

为了进一步提升计算效率，我们通常对小批量数据做矢量计算。广义上讲，给定一个小批量样本，其批量大小为n，输入个数（特征数）为d，输出个数（类别数）为q。设批量特征为。假设softmax回归的权重和偏差参数分别为和。softmax回归的矢量计算表达式为

 其中的加法运算使用了广播机制

5.交叉熵损失函数

使用softmax运算后可以更方便地与离散标签计算误差,softmax运算将输出变换成一个合法的类别预测分布。实际上，真实标签也可以用类别分布表达：对于样本i，我们构造向量 ，使其第（样本i类别的离散数值）个元素为1，其余为0。这样我们的训练目标可以设为使预测概率分布尽可能接近真实的标签概率分布,我们可以像线性回归那样使用平方损失函数。然而，想要预测分类结果正确，我们其实并不需要预测概率完全等于标签概率。例如，在图像分类的例子里，如果，那么我们只需要​一个预测值比其他两个预测值大就行了。而平方损失则过于严格,改善上述问题的一个方法是使用更适合衡量两个概率分布差异的测量函数。其中，交叉熵（cross entropy）是一个常用的衡量方法：

 其中带下标的是向量中非0即1的元素，需要注意将它与样本i类别的离散数值，即不带下标的区分。在上式中，我们知道向量中只有第个元素​为1，其余全为0，于是。也就是说，交叉熵只关心对正确类别的预测概率，因为只要其值足够大，就可以确保分类结果正确。当然，遇到一个样本有多个标签时，例如图像里含有不止一个物体时，我们并不能做这一步简化。但即便对于这种情况，交叉熵同样只关心对图像中出现的物体类别的预测概率。

假设训练数据集的样本数为nn，交叉熵损失函数定义为

 其中代表模型参数。同样地，如果每个样本只有一个标签，那么交叉熵损失可以简写成。从另一个角度来看，我们知道最小化等价于最大化，即最小化交叉熵损失函数等价于最大化训练数据集所有标签类别的联合预测概率。

6.模型评价

在训练好softmax回归模型后，给定任一样本特征，就可以预测每个输出类别的概率。通常，我们把预测概率最大的类别作为输出类别。如果它与真实类别（标签）一致，说明这次预测是正确的。我们使用准确率（accuracy）来评价模型的表现。它等于正确预测数量与总预测数量之比。

7.手动实现SoftMax回归

import torch
import torchvision
import numpy as np
import sys

from d2lzh_pytorch import evaluate_accuracy

sys.path.append("..")  # 为了导入上层目录的d2lzh_pytorch
import d2lzh_pytorch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)  # 下载服饰数据集

num_inputs = 784  # 输入的数据为28*28的图片
num_outputs = 10  # 输出为10分类的种类

W = torch.tensor(np.random.normal(0, 0.01, (num_inputs, num_outputs)), dtype=torch.float)  # 初始化权重
b = torch.zeros(num_outputs, dtype=torch.float)  # 初始化偏置

W.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)


# 进行以e为底数的求幂 均值计算概率
def softmax(X):
    X_exp = X.exp()
    partition = X_exp.sum(dim=1, keepdim=True)
    return X_exp / partition  # 这里应用了广播机制


y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
y = torch.LongTensor([0, 2])
y_hat.gather(1, y.view(-1, 1))


# y=([[0],
#    [2]])
# 对gather()函数的理解
# a = torch.Tensor([[1,2],
#                  [3,4]])
# 参数为dim=1时
# b = torch.gather(a,1,torch.LongTensor([[0,0],[1,0]]))
# 1. 按顺序取b各个元素行号 第0行 第0行 第1行 第1行 列号待定：[(0,y)(0,y)][(1,y)(1,y)]
# 2. 取b对应各个元素值做列号 0 0 1 0 ：[(0,0)(0,0)][(1,1)(1,0)]
# 3. 根据得到的索引在输入中取值
# [1,1],[4,3]
# 参数为dim=0时
# c = torch.gather(a,0,torch.LongTensor([[0,0],[1,0]]))
# 1. 取各个元素列号：0 1 0 1 [(x,0)(x,1)][(x,0)(x,1)]
# 2. 取各个元素值做行号 0 0 1 0：[(0,0)(0,1)][(1,0)(0,1)]
# 3. 根据得到的索引在输入中取值
# [1,2],[3,2]

def accuracy(y_hat, y):
    return (y_hat.argmax(dim=1) == y).float().mean().item()
    # argmax函数 取行中最大值(最大的概率)的下标  如果与y指示的真实标签相同 则计入准确率


def net(X):
    return softmax(torch.mm(X.view((-1, num_inputs)), W) + b)


#  将测试集或训练集的数据转为X(NxINPUT) * W权重(INPUTXOUTPUT) + b偏置  = NxOUTPUT 结果  得到y_hat

def cross_entropy(y_hat, y):
    return - torch.log(y_hat.gather(1, y.view(-1, 1)))


num_epochs, lr = 5, 0.1


# def evaluate_accuracy(data_iter, net):
#     acc_sum, n = 0.0, 0
#     for X, y in data_iter:
#         acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
#         n += y.shape[0]
#     return acc_sum / n


# 本函数已保存在d2lzh包中方便以后使用
def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
              params=None, lr=None, optimizer=None):
    for epoch in range(num_epochs):
        train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
        for X, y in train_iter:
            y_hat = net(X)
            l = loss(y_hat, y).sum()
            # 梯度清零
            if optimizer is not None:  # 如果指定了优化器
                optimizer.zero_grad()  # 将优化器梯度清零
            elif params is not None and params[0].grad is not None:  # 如果指定了需要更新的Tensor 这里是[W,b]
                for param in params:  # 将其依次清零
                    param.grad.data.zero_()
            l.backward()  # 求梯度
            if optimizer is None:  # 如果没有指定优化器
                d2l.sgd(params, lr, batch_size)  # 使用sgd方法
            else:
                optimizer.step()  # “softmax回归的简洁实现”一节将用到

            train_l_sum += l.item()  # 求损失率之和
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()  # 求准确率之和
            n += y.shape[0]  # 求计算的次数(y矩阵的行数)
        test_acc = evaluate_accuracy(test_iter, net)  # 计算平均准确率
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f'
              % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))


train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, batch_size, [W, b], lr)

# 绘制预测图像
X, y = iter(test_iter).next()

true_labels = d2l.get_fashion_mnist_labels(y.numpy())
pred_labels = d2l.get_fashion_mnist_labels(net(X).argmax(dim=1).numpy())
titles = [true + '\n' + pred for true, pred in zip(true_labels, pred_labels)]

d2l.show_fashion_mnist(X[0:9], titles[0:9])

8.使用nn网络实现SoftMax回归

import torch
from torch import nn
from torch.nn import init
import numpy as np
import sys
from collections import OrderedDict
from d2lzh_pytorch import FlattenLayer
sys.path.append("..")
import d2lzh_pytorch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)  # 下载数据集
num_inputs = 784
num_outputs = 10
num_epochs = 5

net = nn.Sequential(
    # FlattenLayer(),
    # nn.Linear(num_inputs, num_outputs)
    OrderedDict([
        ('flatten', FlattenLayer()),
        ('linear', nn.Linear(num_inputs, num_outputs))
    ])
)

nn.init.normal_(net.linear.weight, mean=0, std=0.01)  #  前一个参数是要初始化的Tensor 初始化均值为0 标准差0.01的正态分布权重w
nn.init.constant_(net.linear.bias, val=0)  # 前一个参数是要初始化的Tensor 以val填充 初始化偏置w为0

loss = nn.CrossEntropyLoss()  # 将Softmax归一化的过程和交叉熵评估概率的过程合并

optimizer = torch.optim.SGD(net.parameters(), lr=0.1)  # 建立一个学习率为0.1的小批量随机梯度下降的优化器

d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)  #调用训练函数进行训练