12.26学习日志

11 softmax回归

1.概论

实际上是一个分类问题，预测一个离散类别，分类问题从回归的单输出变成了多输出，输出为i的元素Oi是预测为第i类的置信度

从回归到多类分类----使用均方损失训练

对类别进行一位有效编码，假如有n个类别从y1,y2,...,yn,假如第i类是真实类，那么yi=1，其余为0

选取Oi置信度最大值Oy为预测值

并不关心真正最大预测值为多少，而是在于Oy-Oi>>一个阈值，就是将其所属类别和其他类区分开来

希望输出是匹配概率，要求是非负，并且所有情况的概率和为1，对O进行softmax处理，得到y hat即为输出概率，具体的处理见下图：

比较真实概率和预测概率来计算损失，交叉熵常用来衡量两个概率的区别，将其作为损失

 

 2.损失函数
 

1>L2 Loss均方损失

当预测值和真实值相差较大，梯度较大，参数的更新值是比较多的，当靠近真实值，梯度会变小，参数更新幅度也就变小。缺点是当相差较大时，不希望有大的梯度，所以需要改进。

2>L1 Loss

解释线：在y=0的时候（横坐标），当某个参数使得y‘能取值为零，这个时候的参数就是最有可能接近样本参数。绿色的似然函数代表y’在哪取值，这个y’对应的参数概率是最大的。蓝色的线代表y’偏离y的程度。橙色是y’与y偏离程度的导数曲线。

当预测值离真实值比较远的时候，梯度一直是常数，权重更新不大，好处是具有稳定性，缺点是零点处不可导

3>Huber's Roburt Loss

当预测值和真实值相差较多的时候，用绝对误差，当靠近的时候梯度绝对值会越来越小，用平方误差，综合以上两种误差的优点，减1/2是为了连续性

3图像分类数据集

 导入Fashion-MNIST数据集

import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l

d2l.use_svg_display()
'''通过内置函数将FashionMNIST数据集下载并读取到内存中'''
trans=transforms.ToTensor()
mnist_train = torchvision.datasets.FashionMNIST(root="../data",train=True,transform=trans,download=True)
mnist_test = torchvision.datasets.FashionMNIST(root="../data",train=False,transform=trans,download=True)

print(len(mnist_train),len(mnist_test))

 两个可视化数据集的函数

def get_fasion_mnist_labels(labels):
    '''返回数据集的文本标签'''
    text_labels = ['t-shirt','trouser','pullover','dress','coat','sandal','shirt','sneaker','bag','ankle boot']
    return [text_labels[int(i)] for i in labels]

def show_images(imgs,num_rows,num_cols,titles=None,scale=1.5):
#scale=1.5 意味着每个子图的大小将是默认大小的1.5倍,num_rows：网格中的行数,num_cols：网格中的列数。
    '''Plot a list of images'''
    figsize = (num_cols * scale,num_rows * scale)#计算了整体图形的大小,num_cols * scale：表示列数乘以缩放比例，这部分决定了整个图形的宽度。
#num_rows * scale：表示行数乘以缩放比例，这部分决定了整个图形的高度。
    _, axes = d2l.plt.subplots(num_rows,num_cols,figsize=figsize)
#调用 Matplotlib 的 subplots 函数来创建一个包含 num_rows 行、num_cols 列的子图网格。figsize 参数用于指定整个图形的大小
#_: 由于我们在这里只关心 axes 变量，而不需要使用 Figure 对象，因此使用下划线 _ 来表示不需要的变量。
#axes: 是一个包含多个子图对象的数组。每个子图可以通过这个数组进行索引。

    axes = axes.flatten()#返回的axes是一个二维数组，表示网格中的子图。使用flatten将其展平为一维数组，以便更容易迭代处理。

    for i, (ax,img) in enumerate(zip(axes,imgs)):
    #i 是循环的索引，而 (ax, img) 是 zip(axes, imgs) 中每个元素的值。这样的结构使得在循环体内可以方便地同时访问当前迭代的索引和对应的元素。
    #enumerate(zip(axes, imgs))：使用 zip 函数将 axes 和 imgs 中的元素逐一配对，形成元组。enumerate 函数用于在循环中获取每个元组及其对应的索引。
        if torch.is_tensor(img):
            #检查图像是否是 PyTorch 张量
            ax.imshow(img.numpy())#如果是张量，将其转换为 NumPy 数组并使用 imshow 在子图上显示图像
        else:
            ax.imshow(img)# # 如果不是张量，直接使用 imshow 在子图上显示图像
    d2l.plt.show()

1.这些标签信息是事先与数据集一起提供的，因此在训练和测试时，每个图像都有一个标签，表示它所属的类别。在你的代码中，通过 get_fasion_mnist_labels 函数将这些数字标签映射为相应的文本标签，

2.(ax, img)：是一个元组，其中 ax 是当前迭代的子图对象，而 img 是当前迭代的图像对象。

3.子图对象 ax 被用来设置和显示相应的图像对象 img。

4.show_images 函数中的 d2l.plt.show() 负责显示整个图形，而不是每个子图。因此，你只需要在循环外部调用一次 show() 即可。 

5.ax 是由你通过 plt.subplots() 函数创建的子图对象（Axes 对象）。在 Matplotlib 中，subplots() 函数返回一个包含 Figure 和 Axes 对象的元组。ax.imshow(img) 这个语句使用了点号（.）语法，表示调用 ax 对象的 imshow 方法，并将 img 作为参数传递给这个方法。

抽取一些样本的图像及其对应的标签

X,y = next(iter(data.DataLoader(mnist_train,batch_size=18)))
show_images(X.reshape(18,28,28),2,9,titles=get_fasion_mnist_labels(y))

1. data.DataLoader(mnist_train, batch_size=18): 创建了一个 PyTorch 的 DataLoader 对象。DataLoader 可以用于将数据集划分成小批次，以便于训练模型。参数包括数据集 mnist_train 和批次大小 batch_size（在这里设置为18）。

2. iter(...): 将 DataLoader 对象转换为可迭代对象，从而可以使用 next(...) 函数获取下一个批次的数据。

3. next(...): 从可迭代对象中获取下一个元素，即下一个批次的数据。在这里，它返回一个包含输入数据 X 和对应标签 y 的元组。

使用 show_images 函数显示一个包含 18 个图像的子图网格。

读取一小批量的数据

'''读取一小批量的数据'''
batch_size = 256

def get_dataloader_workers():
    '''使用4个进程来并行读取数据'''
    return 4

train_iter = data.DataLoader(mnist_train,batch_size,shuffle=True,num_workers=get_dataloader_workers())

timer = d2l.Timer()
for X,y in train_iter:
    continue
#遍历 train_iter 中的每个批次，但只执行 continue 语句，即跳过循环体中的其他操作
print(f'{timer.stop():.2f}sec')
#使用计时器的 stop 方法获取经过的时间，并使用 :.2f 控制小数点后的位数。

目的是要保证读取数据的速度至少要大于训练数据的速度

4 Softmax回归从零开始实现

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

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
#训练集和测试集的迭代

'''设置输入特征和输出特征'''
num_inputs = 784
#展平每一个图像，视为长度为28*28的向量
num_outputs = 10
#数据集有十个类别

w = torch.normal(0,0.01,size=(num_inputs,num_outputs),requires_grad=True)
#随机采样w，均值为0，方差为1，行是样本，列是特征，需要计算梯度
b = torch.zeros(num_outputs,requires_grad=True)
#都设置为张量0，每个输出点只需一个偏移，所以只用10个，需要计算梯度

实现softmax 

'''实现softmax'''
def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1,keepdim=True) #沿着x轴求和，每行元素求和
    return X_exp/partition #广播机制

 实现softmax回归模型

'''实现softmax回归模型'''
def net(X):
    return softmax(torch.matmul(X.reshape((-1,w.shape[0])),w)+b)

1. X.reshape((-1, w.shape[0])): 这部分代码将输入 X 进行形状变换，将其展平为一个二维张量，其中的行数为 -1，列数为 w.shape[0]。w.shape[0] 表示权重矩阵 w 的行数，即输入特征的数量num_inputs。这里 -1 表示根据剩余的维度自动计算，确保张量的总元素个数保持不变。因为 w 的列数等于输入特征的数量，所以这里的变换目的是将输入数据 X 变为一个形状为 (batch_size, num_inputs) 的二维张量。

2. torch.matmul(..., w) + b: 这一部分进行了矩阵乘法和偏移的线性变换。首先，将展平后的输入 X (batch_size, num_inputs)与权重矩阵 w (num_inputs,num_outputs)进行矩阵乘法，得到的结果是一个形状为 (batch_size, num_outputs) 的矩阵。然后，加上偏移向量 b。

3. softmax(...): 最后，对线性变换的结果进行 softmax 操作，得到每个类别的概率分布

创建一个数据y_hat，使用y作为y_hat中概率的索引

'''创建一个数据y_hat，使用y作为y_hat中概率的索引'''
y=torch.tensor([0,2])
y_hat = torch.tensor([[0.1,0.3,0.6],[0.3,0.2,0.5]])
print(y_hat[[0,1],y])

y_hat[[0, 1], y]: 这是使用索引操作从 y_hat 中取值的语法。具体来说，[0, 1] 是用于选择行的索引，y 是用于选择列的索引。这样，它会选取矩阵中的两个位置，分别是 (0, y[0]) 和 (1, y[1]) 处的元素。

• 对于第一个位置 (0, y[0])，y[0] 的值是 0，所以会取出第一行第零列的元素，即 y_hat[0, 0]。

• 对于第二个位置 (1, y[1])，y[1] 的值是 2，所以会取出第二行第二列的元素，即 y_hat[1, 2]。

实现交叉熵损失函数 

'''实现交叉熵损失函数'''
def cross_entropy(y_hat,y):
    return -torch.log(y_hat[range(len(y_hat)),y])
# 使用这些索引从 y_hat 中选择每个样本对应真实标签的预测概率。
print(cross_entropy(y_hat,y))

将预测类别与真实y进行比较

'''将预测类别与真实y元素进行比较'''
def accuracy(y_hat,y):
    '''计算预测正确的数量'''
    if len(y_hat.shape)>1 and y_hat.shape[1]>1:
        y_hat=y_hat.argmax(axis=1) #将y_hat每一行中最大数的序号存在y_hat中
    cmp = y_hat.type(y.type) == y #cmp类型是bool，判断y_hat是否等于y返回True和False，在比较y_hat和y之前，先将y_hat类型变得和y一致
    return float(cmp.type(y.type).sum()) #将cmp类型转为整数型，True为1，因为y_hat有很多行，所以cmp最终是单列向量，计算出和

accuracy(y_hat,y)/len(y) #将预测准的个数和总数作比，得到准确率

评估任意模型在指定数据集上的准确率，以net为例：

def evaluate_accuracy(net,data_iter):
    '''计算在指定数据集上模型的精度'''
    if isinstance(net,data_iter):
        net.eval()
    metric = Accumulator(2)
    #创建了一个 Accumulator 对象，用于累加两个值，分别是正确预测的样本数量和总样本数量。
    for X,y in data_iter:
        metric.add(accuracy(net(X),y),y.numel())
    return metric[0]/metric[1]

在 PyTorch 中，调用 eval() 方法可以将模型切换到评估模式。如果net是一个数据迭代器，将其转为评估模式，通常是不用计算梯度。

• accuracy(net(X), y): 使用一个函数（这里假设存在名为 accuracy 的函数）计算模型在当前批次上的精度。
• y.numel(): 获取当前批次的样本数量，即标签张量 y 的元素个数
• metric.add(accuracy(net(X), y), y.numel()): 将当前批次的精度和样本数量添加到 Accumulator 中。
• metric.add(accuracy(net(X), y), y.numel()): 将当前批次的精度和样本数量添加到 Accumulator 中。

前面的accuracy函数是针对一个批次计算精确度，而evaluate_accuracy是针对一整个样本计算

 tips：

isinstance() 是 Python 的一个内置函数，用于检查一个对象是否是指定类或类型的实例。

isinstance(object, classinfo)
 

单次Softmax回归的训练 

def train_epoch_ch3(net,train_iter,loss,updater):
    if isinstance(net,torch.nn.Module):
        net.train()#模型调制训练模式
    metric = Accumulator(3)
    for X,y in train_iter:
    #遍历训练数据迭代器，对每个批次的数据进行如下操作：
        y_hat = net(X)
        l = loss(y_hat,y)
        if isinstance(updater,torch.optim.Optimizer):
        #如果 updater 是 PyTorch 的优化器（torch.optim.Optimizer 类型），则使用优化器的方式进行梯度更新；否则，使用自定义的梯度更新方式。
            updater.zero_grad()
            l.backward()
            updater.step()
            metric.add(
                float(l)*len(y),accuracy(y_hat,y),y.size().numel()
                        )
        else:
            l.sum().backward()
            # 计算损失的梯度，这里使用 l.sum() 是因为通常在一个批次中有多个样本，需要将每个样本的梯度进行累加，最终求得整个批次的梯度。
            updater(X.shape[0])
            #X的形状为(batch_size, input_features)，X.shape[0] 表示张量 X 的第一个维度的大小
            metric.add(float(l.sum()),accuracy(y_hat,y),y.numel())
    return metric[0]/metric[2],metric[1]/metric[2]
    #计算并返回平均损失和平均精度

 注意计算损失值的时候，应当获得当前批次所有样本的损失值进行累加。在优化器优化中，用l*len（y）得到是损失值的原因是，y包含了批次样本中所用标签是一个张量，而len（y）是y的第一个维度值，也就是样本数量，所以将得到的单个样本损失值乘样本数即为总损失值。

训练函数

def train_ch3(net,train_iter,test_iter,loss,num_epochs,updater):
    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_metrics+(test_acc)这个元组包含了三个值，分别是训练损失、训练准确率和测试准确率。
    train_loss,train_acc = train_metrics
    #将 train_metrics 这个元组（或列表）中的值分别赋给 train_loss 和 train_acc 两个变量
    assert train_loss<0.5,train_loss
    #检查训练损失是否小于 0.5。如果训练损失超过了 0.5，就会引发 AssertionError，
    assert train_acc<=1 and train_acc>0.7,train_acc
    #检查训练准确率是否在 0.7 到 1 之间。
    assert test_acc<= 1 and test_acc >0.7,test_acc

5 Softmax回归简洁实现

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

batch_size =256
train_iter,test_iter = d2l.load_data_fashion_mnist(batch_size)

net = nn.Sequential(nn.Flatten(),nn.Linear(784,10))
#nn.Sequential 创建了一个神经网络容器，其中包含两个层
'''对线性层权重进行初始化'''
def init_weights(m):
    if type(m)==nn.Linear:
        nn.init.normal_(m.weight,std=0.01)
        #nn.init.normal_（）以正态分布初始化方法，标准差为0.01

net.apply(init_weights)
#将初始化函数应用到模型的每个层上
'''交叉熵损失函数'''
loss=nn.CrossEntropyLoss()
'''使用小批量随机梯度下降作为优化算法'''
trainer = torch.optim.SGD(net.parameters(),lr=0.1)

num_epochs = 10
d2l.train_ch13(net,train_iter,test_iter,loss,trainer,num_epochs)