Softmax回归

目录

1.Softmax回归的从零开始实现

2.softmax回归的简洁实现

对重新审视softmax的实现的思考：

对交叉熵损失函数的思考：

小批量随机梯度下降算法的理解：

---

1.Softmax回归的从零开始实现

import torch
from IPython import display
from d2l import torch as d2l

#每次随机读256张图片
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

"""初始化模型参数"""
num_inputs = 784
#对于softmax的输入需要是一个向量，原来的输入是1*28*28的3d矩阵，28*28等于784
#拉成向量会损失掉很多空间信息，交给卷积神经网络继续
num_outputs = 10
#因为数据集有10个类，所以模型输出的维度为10

W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
#w的形状为784*10
b = torch.zeros(num_outputs, requires_grad=True)
#偏移是一个长为10的向量

"""定义softmax操作"""
X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
#定义了2*3的矩阵
X.sum(0, keepdim=True), X.sum(1, keepdim=True)
#结果输出：tensor([[5., 7., 9.]]), tensor([[ 6.], [15.]])
#分别按照0维和1维求和，然后保持维度

#实现softmax
def softmax(X):
    #对于矩阵来讲，就是对每一行作softmax
    X_exp = torch.exp(X)
    #对每一行作指数运算
    partition = X_exp.sum(1, keepdim=True)
    #按照维度1来求和，压缩列，就是对每一行求和，得出一个2维矩阵
    return X_exp / partition  # 这里应用了广播机制
    #X_exp的每一行除以 partition中对应行元素之和，因为X_exp(2*3),partion(2*1),满足广播机制

#我们将每个元素变成一个非负数。 此外，依据概率原理，每行总和为1
X = torch.normal(0, 1, (2, 5))
#矩阵x(2*5)
X_prob = softmax(X)
X_prob, X_prob.sum(1)
#结果输出：tensor([[0.2968, 0.4115, 0.0945, 0.1603, 0.0368],[0.2128, 0.5422, 0.0865, 
#0.1104, #0.0481]]),tensor([1.0000, 1.0000])
#说明把2*5的矩阵放进softmax之后，形状还是2*5没有改变，变化就是所有的值都为正了
#理论上来说x是呈正态分布，正负比例应该是一样的。按照1维压缩列，就是把所有行相加，
#输出2*1，没有保持维度输出就是一个向量，且每一行和为1


"""定义模型"""
def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)
    #对于输入X，需要的是一个批量大小*输入维数的矩阵，reshape成2d的矩阵，-1表示自己
    #算得的批量大小，W.shape[0]就是784，所以X被reshape成256*784的矩阵
    #拿到一个所有的元素大于0，而且行和为1的输出矩阵

"""定义损失函数"""
#创建一个数据样本y_hat，其中包含2个样本在3个类别的预测概率， 以及它们对应的标签y
y = torch.tensor([0, 2])
#定义一个长度为2的向量，表示两个真实的标号，y=[0,2]的意思是第一个样本是类别0，
#第二个样本是类别2，对应于真是样本的数据的one_hot编码是[1,0,0]和[0,0,1]
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
#有3类，对两个样本作预测就是一个2*3的矩阵，[0.1, 0.3, 0.6]是第0样本的预测值
# [0.3, 0.2, 0.5]是第1样本的预测值
y_hat[[0, 1], y]
#对0号样本，拿出y0对应的元素，对于1号样本，拿出y1下标对应的输出。
#因为y0等于0,所以对于0号样本，拿到的是0号元素0.1,y1=2，所以拿到了0.5
#这个操作的意思就是，给我了一个预测值，然后我就去拿出真实标号（样本真实属于的那个类）
#那个类的预测值进一步理解：y_hat[[0, 1], y] 使用的行索引是 [0, 1]，列索引是 y 即 [0, 2]。
#所以这个操作选择出的元素是 y_hat[0, 0] 和 y_hat[1, 2]

#实现交叉熵损失函数
def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])
    #对于每一行拿出来，    len为2，
    #使用one-hot编码，range(y_hat)是所有行,y是真实值所对应的列,这句话的意思就是锁定
    #y轴在x轴上根据labels抽取预测值
cross_entropy(y_hat, y)
#结果输出：tensor([2.3026, 0.6931])，
#2.3026是样本0的损失，0.6931是样本1的损失

"""分类精度"""
#将预测类别与真实y元素进行比较
def accuracy(y_hat, y):  #@save
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
    #len的长度反映了y_hat原本是一个几维的矩阵
    #这里要求y_hat是一个矩阵，而且第1维的长度，也就是列数也要大于1
        y_hat = y_hat.argmax(axis=1)
        #将每一行中元素值最大的那个下标存到y_hat里面，每一行的含义是批量中的一个样本
        #argmax是numpy中的一个函数，
        #常用于在数组中查找最大值所在的位置。只需要将需要查找最大值所在位置的数组作为
        #输入参数，即可获得最大值所在的索引。函数：numpy.argmax(array, axis)
        #array：代表输入数组；在axis=0时，就是固定列，寻找最大的行的索引，指定axis=1
        #就是固定行，返回列索引中的最大值。返回的会是一个一维的array。
        #解释为什么要取最大值：分类问题，y_hat表示你真实对这个真实样本的不同类别的预测值
        #所以取最大的预测值代表你再这个多分类问题中你的模型的决策

    cmp = y_hat.type(y.dtype) == y
    #cmp这是一个bool类型的tensor，因为 y_hat中存储的是每一行预测概率最大的列的索引，索引
    #就等于10个类别中间的一个，所以把索引和真实的类别作比较看是否相等，如果相等，cmp就
    #等于1就说明预测正确
    return float(cmp.type(y.dtype).sum())
    #把预测正确的样本次数加起来，z转成和y一样的形状，求和，再转成一个浮点数，将布尔
    #张量转换成整形时，True转换为1，False转换为0

accuracy(y_hat, y) / len(y)
#结果输出：0.5
#整个函数的含义是：找出来预测正确的样本数，再除以y的长度，就是预测正确的概率
#因为每一行是一个样本，y_hat中存了很多行，同时输出很多行，每一行的维度为10（因为有10类，
#每一行是一个样本），如果预测正确了，cmp对应位置就成1了，所有样本检测正确后求和，除以
#所有的物体数目，得到正确率。accuracy(y_hat, y)返回的是预测正确的次数的总和，除以总的
#样本真实的类别数，就等于预测正确的概率


#我们可以评估在任意模型net的精度
def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
    #isinstance()函数是python中的一个内置函数，作用：判断一个函数是否是一个已知类型，
    #类似type()。语法：isinstance ( object , classinfo )， object：实例对象。classinfo：
    #可以是直接或间接类名、基本类型或由它们组成的元组 如果对象的类型与参数二(classinfo)
    #的类型相同返回true，否则false。isinstance() 与 type() 区别：type() 不会认为子类是
    #一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。
    #torch.nn是专门为神经网络设计的模块化接口，nn.Module是nn中十分重要的类
        net.eval()  # 将模型设置为评估模式
        #作用是不计算梯度，只做一个forward path
        #model.eval()，不启用 BatchNormalization 和 Dropout。此时pytorch会自动把BN和
        #DropOut固定住，不会取平均，而是用训练好的值。不然的话，一旦test的batch_size过小，
        #很容易就会因BN层导致模型performance损失较大。Dropout可以比较有效的缓解过拟合的
        #发生，在一定程度上达到正则化的效果。过拟合具体表现在：模型在训练数据上损失函数
        #较小，预测准确率较高；但是在测试数据上损失函数比较大，预测准确率较低。Dropout
        #说的简单一点就是：我们在前向传播的时候，让某个神经元的激活值以一定的概率p停止
        #工作，这样可以使模型泛化性更强，因为它不会太依赖某些局部的特征
    metric = Accumulator(2)  # 正确预测数、预测总数
    #做一个累加器
    #Accumulator类，Accumulator(2)的理解：倘若这里的n为2，则此时self.data以[0.0, 0.0]
    #这样的列表展现出来
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
            #metric.add以是拿self.data的[0.0, 0.0]不断和[accuracy(net(X), y), y.numel()]
            #在相同的位置作累加，metric的形状还是1*2的向量。accuracy(net(X), y)返回的
            #是预测正确的次数的总和
    return metric[0] / metric[1]
    #返回的是分类正确的样本数除以总的样本数就拿到精度了。


class Accumulator:  #@save
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n
        #倘若这里的n为2，则此时self.data以[0.0, 0.0]这样的列表展现出来

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]
        #把self.data和args数组的对应位置上的数打包成一个，比如self.data = [1,2,3]，
        #args= [4,5,6]，zip(self.data, args)=[(1, 4), (2, 5), (3, 6)],a分别等于1，2，3
        #b分别等于4，5，6，再执行a + float(b)，简单来说，就是将两个数组对应位置上的元素累加

    def reset(self):
        self.data = [0.0] * len(self.data)
        

    def __getitem__(self, idx):
        return self.data[idx]

evaluate_accuracy(net, test_iter)
#结果输出：0.0598
#随机出来的模型和测试迭代器的精度是0.0598,因为类别数是10，

"""训练"""
#softmax回归的训练
def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    """训练模型一个迭代周期（定义见第3章）"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
        #将模型设置为训练模式：默认参数是Train。model.train（）会启动drop 和 BN，但是
        #model.train(False)不会。如果模型中有BN层(Batch Normalization）和Dropout，需要
        #在训练时添加model.train()，在测试时添加model.eval()。其中model.train()是保证BN层
        #用每一批数据的均值和方差，而model.eval()是保证BN用全部训练数据的均值和方差；
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    #用长度为3的迭代器累加需要的信息
    #metric=[0.0,0.0,0.0]
    for X, y in train_iter:
    #扫一遍数据
        # 计算梯度并更新参数
        y_hat = net(X)
        #计算预测值，net(X)返回的是一个矩阵，其中每行是一个样本，列代表10个分类，
        #y_hat中存储的是每个样本在10个类别中的预测概率
        l = loss(y_hat, y)
        #这里的loss是传入的损失函数，在调用该方法时传入cross_entropy
        if isinstance(updater, torch.optim.Optimizer):
        #updater是torch.optim.Optimizer
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            #先把梯度设成0
            l.mean().backward()
            #计算梯度
            updater.step()
            #对参数进行自更新
        else:
            # 使用定制的优化器和损失函数
            l.sum().backward()
            #l的输出是一系列的向量分别代表每个样本的损失，因此求和算梯度
            updater(X.shape[0])
            #再根据批量大小，updater一下
            
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
        #记录总的损失，以及分类正确的个数，以及样本的和总数
    # 返回训练损失和训练精度
    return metric[0] / metric[2], metric[1] / metric[2]


#定义一个在动画中绘制数据的实用程序类
class Animator:  #@save
    """在动画中绘制数据"""
    def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
                 ylim=None, xscale='linear', yscale='linear',
                 fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,
                 figsize=(3.5, 2.5)):
    #构造方法，参数有x,y坐标轴。legend在图上标明一个图例，用于说明每条曲线的文字显示
    #xlim显示的是x轴的作图范围，同时ylim显示的是y轴的作图范围。xscale，yscale的作用都是
    #设置坐标轴的缩放类型。设置为‘linear’时，x轴是均匀分布的；设置为‘log’时，x轴比例
    #尺逐渐增大。nrows=1, ncols=1,表示有1个画布，figsize表示画布大小
        # 增量地绘制多条线
        if legend is None:
            legend = []
        d2l.use_svg_display()
        # SVG是一种无损格式,意味着它在压缩时不会丢失任何数据，可以呈现无限数量的颜色。
        #d2l.use_svg_display() 意思是使用svg来显示图片，这样清晰度高一些。
        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
        #创建一个带有多个axes(坐标系/绘图区)的图，fig : 图对象。axes : 返回相应数量
        #的坐标系
        if nrows * ncols == 1:
        #如果只有一个图
            self.axes = [self.axes, ]
        # 使用lambda函数捕获参数
        self.config_axes = lambda: d2l.set_axes(
            self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
        self.X, self.Y, self.fmts = None, None, fmts

    def add(self, x, y):
        # 向图表中添加多个数据点
        if not hasattr(y, "__len__"):
        #hasattr()函数是Python内置函数之一，用于判断对象是否具有指定的属性或方法。
        #它接受两个参数：对象和属性或方法的名称。函数返回一个布尔值，如果对象具有指定的
        #属性或方法，则返回True，否则返回False。此处hasattr(y, "__len__")返回值为假
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
            #创建一个列表
        if not self.X:
        #self.X为假
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i, (a, b) in enumerate(zip(x, y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x, y, fmt in zip(self.X, self.Y, self.fmts):
            self.axes[0].plot(x, y, fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)

#实现一个训练函数， 它会在train_iter访问到的训练数据集上训练一个模型net。 该训练函数
#将会运行多个迭代周期（由num_epochs指定）。 在每个迭代周期结束时，利用test_iter访问到
#的测试数据集对模型进行评估。 我们将利用Animator类来可视化训练进度。
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  #@save
    """训练模型（定义见第3章）"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        #对整个数据扫一次更新模型
        #train_epoch_ch3拿到的是训练的损失和训练的精度
        test_acc = evaluate_accuracy(net, test_iter)
        #在测试数据集test_iter上评估一下精度
        #evaluate_accuracy返回的是分类正确的样本数除以总的样本数的测试的精度
        animator.add(epoch + 1, train_metrics + (test_acc,))
        #显示训练的误差，训练的精度，测试的误差，测试的精度
    train_loss, train_acc = train_metrics
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc
    #assert()：断言函数，当表达式为真时，程序继续往下执行，只是判断，不做任何处理；
    #当表达式为假时，抛出AssertionError错误，并将 [参数] 输出

#使用小批量随机梯度下降来优化模型的损失函数
lr = 0.1

def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)


num_epochs = 10
#训练10个迭代周期
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
#结果输出：一张记录了损失和精度的图片


"""预测"""
def predict_ch3(net, test_iter, n=6):  #@save
    """预测标签（定义见第3章）"""
    for X, y in test_iter:
        break
    trues = d2l.get_fashion_mnist_labels(y)
    #拿出真实标号
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    #拿出预测标号
    titles = [true +'\n' + pred for true, pred in zip(trues, preds)]
    d2l.show_images(
        X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])

predict_ch3(net, test_iter)

这是训练的结果。

现在训练已经完成，我们的模型已经准备好对图像进行分类预测。 给定一系列图像，我们将比较它们的实际标签（文本输出的第一行）和模型预测（文本输出的第二行）。

可以看出预测是比较准确的，全都分类正确了。

2.softmax回归的简洁实现

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
#一批量大小为256张图片
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)


"""初始化模型参数"""
#softmax回归的输出层是一个全连接层
# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
#nn.Flatten()把任何维度的tensor变成2d的tensor,其中第0维度保留，剩下的维度全部展成一个向量
#定义一个输入为784，输出为10的线性层，全连接层初始化nn.Linear(input_size, output_size)，
#把这两个串在一起放进Sequential类构造器里面

def init_weights(m):
#m就是当前层
    if type(m) == nn.Linear:
    #如果m是一个线性层，线性连接层又叫全连接层，是通过矩阵的乘法将前一层的矩阵变换为
    #下一层矩阵。W 被称为全连接层的权重weights，b 被称为全连接层的偏置bias
        nn.init.normal_(m.weight, std=0.01)
        #就把输入张量初始化成一个均值为0，标准差为0.01的随机值。
        #torch.nn.init.normal_(tensor, mean=0, std=1)，正态分布：从给定均值和标准差
        #的正态分布N(mean, std)中生成值，填充输入的张量或变量。.weight：得到的是一个p
        #arameter的变量，可以计算梯度的

net.apply(init_weights);
#按照每一层跑一下这个函数就可以完成初始化了
#net.apply(fn: Callable[[ForwardRef(‘Module’)], NoneType]) -> ~T
#model.apply(fn) 会递归地将函数 fn 应用到父模块的每个子模块以及model这个父模块自身。
#通常用于初始化模型的参数。


"""重新审视Softmax的实现"""
loss = nn.CrossEntropyLoss(reduction='none')
#nn.CrossEntropyLoss（weight=None,size_average=None,ignore_index=-100,
#reduce=None,reduction='mean'）
#reduction='none'表示逐个样本计算Loss,有多少个独立样本，就返回多少个Loss

"""优化算法"""
#使用学习率为0.1的小批量随机梯度下降作为优化算法
trainer = torch.optim.SGD(net.parameters(), lr=0.1)
#torch.optim.SGD(params,lr=, momentum=0, dampening=0,
#weight_decay=0, nesterov=False)。



"""训练"""
num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

"""
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  #@save
    """训练模型（定义见第3章）"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc,))
    train_loss, train_acc = train_metrics
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc
"""
#在从0实现softmax定义的训练函数

这是简洁版输出的结果，和以前一样，这个算法使结果收敛到一个相当高的精度，而且这次的代码比之前更精简了。

对重新审视softmax的实现的思考：

对交叉熵损失函数的思考：

语法：nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')

小批量随机梯度下降算法的理解：

SGD是最基础的优化方法，普通的训练方法, 需要重复不断的把整套数据放入神经网络NN中训练, 这样消耗的计算资源会很大.当我们使用SGD会把数据拆分后再分批不断放入 NN 中计算. 每次使用批数据, 虽然不能反映整体数据的情况, 不过却很大程度上加速了NN的训练过程, 而且也不会丢失太多准确率.

3.直播问答

问题1：softlabel选练策略以及为什么有效

答：用1位有效来表示标号，就是说有一串向量，其中只有一位为1，其他的都为0。用softmax去逼近全0，全1的分布。问题是很难用指数去逼近1，因为要指数变成1要求你的输出几乎接近无穷大，而剩下的都很小。所以很难用softmax去逼近0、1极端的数值。提出的方案就是，如果你是正确的类，就记成0.9,剩下的不正确的类就是0.1/(1/n),这就是softlabel,好处就是用softmax去你和0.9和很小的数是有可能的，是图片分类的一个小技巧。

问题2：softmax回归和logistic回归分析是一样的吗，如果不一样，有那些地方不同？

答：可以认为是一样的，logistic回归可以认为只有两类的时候用softmax，等于输出只有两个一个+1，一个-1，logistic是一个二分类的问题，只要输出一个类的预测，那么另一个类就等于1-已知类的预测概率。但是softmax加起来是等于1的，

问题3同问题2

问题4：为什么用交叉熵，不用相对熵，互信息扽等其他基于信息量的度量？

答：相对熵比较的是两个概率之间的区别，他比交叉熵的好处是他是一个对称的关系，I(p,q)=I(q,p)。没有特别大的原因不用。互信息不好算。我们只关心两个分布之间的距离。

问题5：

答：不是不关心不正确的类，是因为独热码编码把剩下类的概率变成0了，所以就可以忽略掉不正确的类。

问题8同问题9:

答：最小化损失等价于最大化似然函数，似然函数就是说有一个模型，给定数据的情况下，模型（就是所谓的权重）出现的概率有多大。我们要找到一个模型，使得给定的数据出现的概率是最大的，最合理的解释。

问题10：

答：对w作更新的时候需要两项，一项是学习率，一项是负的梯度方向。假设学习率是固定的情况下，不同的损失函数会导致算梯度的那个值发生变化，诗的每次走的步伐会有点不一样。

问题13：

答：是并行的，如果num_workers设置为4的话，在后端开4个python的进程来做分析

（后面还有很多问题我就没有看了）

参考：

torch.nn.Module模块简单介绍-CSDN博客

李沐的深度学习Accumulator怎么理解_python accumulator-CSDN博客

动手学深度学习Accumulator类_metric = accumulator(2)-CSDN博客

https://www.cnblogs.com/Henry-ZHAO/p/13230320.html
PyTorch6:nn.Linear&常用激活函数-腾讯云开发者社区-腾讯云

【pytorch】交叉熵损失函数 nn.CrossEntropyLoss()-CSDN博客【学习笔记】Pytorch深度学习—损失函数（一）_pytorch 损失函数 图像-CSDN博客【pytorch】交叉熵损失函数 nn.CrossEntropyLoss()-CSDN博客

pytorch优化器详解：SGD_pytorch sgd-CSDN博客

torch.optim.SGD-CSDN博客