动手学深度学习--课堂笔记softmax回归的从零开始实现

softmax 回归是 logistic 回归的一般形式，logistic 回归用于二分类，而 softmax 回归用于多分类,主要估算输入数据  归属于每一类的概率，它输出值个数等于标签中的类别数，是单层神经网络，每个输出的计算依赖于所有的输入。 

即：

     

      

1.导入包

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)

每次随机读取256张图片，通过调用.load_data_fashion_mnist()函数(上一节)返回训练集迭代器(train_iter)、测试集迭代器(test_iter).

2.初始化模型参数

num_inputs = 784#softmax回归输入的是向量，所以需要把28*28的图片转换成向量，即：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)#初始化偏移量b(向量为10）

权重将构成一个784×10的矩阵， 偏置将构成一个1×10的行向量。 与线性回归一样，我们将使用正态分布初始化我们的权重W，偏置初始化为0。

简单回顾：定义一个矩阵X，对所有元素求和

当调用sum运算符时，我们可以指定保持在原始张量的轴数，而不折叠求和的维度(keepdim=True)。

X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
X.sum(0, keepdim=True), X.sum(1, keepdim=True)#0为按行输出，1为按列输出

矩阵：                   X.sum(0, keepdim=True):[5.0, 7.0, 9.0]，即输出行向量，两行上下相加

1.0	2.0	3.0
4.0	5.0	6.0

    X.sum(1, keepdim=True):[6.0, 15.0]，即输出列向量，每一行相加

 3.定义softmax操作(X为一个矩阵,对矩阵的每一行进行softmax)

def softmax(X):
    X_exp = torch.exp(X)#进行指数运算
    partition = X_exp.sum(1, keepdim=True)#按列求和
    return X_exp / partition  # 这里应用了广播机制。第i行/第i个元素

进行验证:(对于任何随机输入，我们将每个元素变成一个非负数。 此外，依据概率原理，每行总和为1)

X = torch.normal(0, 1, (2, 5))#将X定义为一个均值为0，方差为1的2*5的矩阵
X_prob = softmax(X)#放入softmax模型中进行计算
X_prob, X_prob.sum(1)

4.定义softmax回归模型

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)#reshape函数将每张原始图像展平为向量

reshape(-1):会根据所给的新的shape的信息，自动计算补足shape缺失的值

shape[0]:表示矩阵的行数；shape[1]:表示矩阵的列数

X.reshape((-1, W.shape[0])):X矩阵为256*784。-1代表批量的大小；W.shape[0]代表W矩阵的行数

numpy.matmul():返回两个数组的矩阵乘积

5.定义损失函数

根据标号将对应的预测值取出,y作为y_hat的索引

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

 y_hat:2个样本在3个类别中的预测值，

第一个样本的3种预测概率                        第二个样本的3种预测值概率

0.1

0.3

0.6

0.3

0.2

0.5

y_hat[[0,1], y]:[[0,1], [0, 2]]--->(0,0)(1,2),                  即(0,0)表示第一个样本的第一类 (0.1) ;                                                                                           (1,2)表示第二个样本的第三类 (0.5)   

实现交叉熵损失函数

def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

cross_entropy(y_hat, y)

 交叉熵 = -log(预测的类别的概率)

len(y_hat):输出y_hat的行数

range(len(y_hat)):得到每一个样本

y_hat[range(len(y_hat)), y]:得到的是每一个样本的真实类别对应的一个概率

cross_entropy():交叉熵损失函数

 6.分类精度

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

def accuracy(y_hat, y):  #@save
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:#y_hat是二维矩阵并且列数大于1
        y_hat = y_hat.argmax(axis=1)#每一行中最大的下标存到y_hat中
    cmp = y_hat.type(y.dtype) == y#将y_hat转变成与y相同的数据类型并进行比较。形成bool类型(0错，1对)
    return float(cmp.type(y.dtype).sum())# 计算总的相同数

type() 返回数据结构类型（list、dict、numpy.ndarray 等）

dtype() 返回数据元素的数据类型（int、float等）

accuracy(y_hat, y) / len(y)

最后输出的结果为0.5：

通过y_hat = y_hat.argmax(axis=1)得到y_hat为(2, 2),而y为(0, 2),可以看出只有第二个样本的预测值与实际标签是一样的。所以两个样本的分类精度率为1/2=0.5.

对于任意数据迭代器data_iter可访问的数据集，可评估在任意模型net的准确率

def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
        net.eval()#将模型设置为评估模式:得出的结果只用来评估模型的准确率，不做反向传播
    metric = Accumulator(2)#Accumulator用于对多个变量进行累加 这里是在Accumulator实例中创建了2个变量，分别用于存储正确预测的数量(0）和预测的总数量(1)
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]#分类正确的样本数/总样本数

torch.nn.Module:torch.nn是为神经网络设计的模块化接口。nn.Module是nn中的类，该类是所有神经网络模块的基类。

eval() :用来执行一个字符串表达式，并返回表达式的值

Accumulator():累加器

torch.no_grad():一般用于神经网络的推理阶段, 表示张量的计算过程中无需计算梯度

numel()函数：返回数组中元素的个数

accuracy(net(X), y)：net(X)将X放入net模型中进行softmax回归计算；

                                  accuracy(net(X), y)计算所有预测正确的样本数

Accumulate累加器的实现：

在Accumulate实例中创建了2个变量， 分别用于存储正确预测的数量和预测的总数量

class Accumulator:  #@save
    """在n个变量上累加"""
    def __init__(self, n):# 构造函数的初始长度为n，初始值为0
        self.data = [0.0] * n

    def add(self, *args): # 将训练损失、训练精度、训练样本数进行累加
        self.data = [a + float(b) for a, b in zip(self.data, args)]# zip()就是把两个参数打包成一个数据结构，a就是原来的值，b就是我们输入的值。

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

    def __getitem__(self, idx): # 取出训练损失、训练精度或训练样本数
        return self.data[idx]

evaluate_accuracy(net, test_iter)

7.训练

def train_epoch_ch3(net, train_iter, loss, updater):  #@save
    """训练模型一个迭代周期（定义见第3章）"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)#创建长度为3的累加器
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()#梯度设置为0
            l.mean().backward()#计算梯度
            updater.step()#更新
        else:
            # 使用定制的优化器和损失函数
            l.sum().backward()
            updater(X.shape[0])
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练精度
    return metric[0] / metric[2], metric[1] / metric[2]#metric[0]是损失样本数目；metric[1]是训练正确的样本数；metric[2]是总的样本数

isinstance() :来判断一个对象是否是一个已知的类型，类似 type()

torch.optim.Optimizer：pytorch中用来优化模型权重的类

定义在一个动画中绘制数据的实用程序类

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)):
        # 增量地绘制多条线
        if legend is None:
            legend = []
        d2l.use_svg_display()
        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
        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__"):
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        if not 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)

实现一个训练函数

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):#num_epochs训练次数
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)#train_epoch_ch3训练模型，返回精确率和错误率
        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.1。

lr = 0.1

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

开始训练

迭代周期（num_epochs）和学习率（lr）都是可调节的超参数。通过更改它们的值，我们可以提高模型的分类准确率。

num_epochs = 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)