Softmax 回归 + 损失函数 + 图片分类数据集

定义

• 回归：是估计一个连续的值
• 分类：预测一个离散的类别

比如手写数字识别就是分类问题

回归

• 但连续数值输出
• 自然区间R
• 跟真实值的区别作为损失

分类

• 通常多个输出
• 输出i是预测为第i类的置信度
• 从回归的单输出变成了多输出（其实多输出可以理解为对每个类别做回归）

从回归到对分类

均方损失

• 对类别进行有效的编码
• 使用均方损失训练
• 最大值为预测

无校验比例

• 对类别进行以为有效的编码
• 最大值为预测
• 需要更置信的识别正确类（大余量）
  即正确的类的权重减去其余任何一个类的权重还需要留有一定余量

校验比例

• 输出匹配概率（非负，和为1）

$$ \hat{y} = \text{softmax}(o) \\ \hat{y}_i = \frac{\exp(o_i)}{\sum_k \exp(o_k)} $$

$\hat{y} = \text{softmax}(o) $是一个长为n的向量，每个元素非负，而且他的和为1，下面的式子就是对o的每个值的运算，exp就是e的x次幂。分母就是对所有所有o求e的x次幂。

概率y和$\hat y$的区别作为损失

交叉熵损失

交叉熵常用于衡量俩个概率的区别

$$ H(p, q) = -\sum_{i=1}-{p_i \log(q_i)} $$

将它作为损失 loss函数

$$ l(y, \hat{y}) = -\sum_{i}{y_i \log{\hat{y}_i}} = -\log{\hat{y}_{y}}\\ 这里可以简写是因为只有一个元素为1，其他元素全部为0 $$

• p(x) 是真实分布中事件x的概率。
• q(x) 是预测分布中事件x的概率。
• log 函数的底数通常选择为自然对数 e（即 ⁡ln），但在某些情况下也可以选择为2。

这里是取正式事件的概率乘以ln预测事件的概率，然后累加起来

其梯度是真实概率和预测概率的区别

$$ \partial_{o_i} l(y, \hat{y}) = softmax(o)_i - y_i $$

softmax回归是一个多累分类模型

使用softmax操作子，得到每个类的预测置信度

使用交叉熵来衡量预测和标号的区别

损失函数

常見的损失函数有

l2 loss

$$ l(y, y') = -\frac{1}{2}(y - y')^2 $$

• 蓝色表示，y=0的时候，变换y'时的函数
• 绿色是似然函数
• 橙色表示损失函数的梯度

L1 loss

$$ l(y, y') = |y - y'| $$

y'大于0导数是1，y'小于0 导数是-1。问题是零点处不可导会有很大的变化

Huber's Robust Loss

$$ l(y, y') = \begin{cases} |y - y'| - \frac{1}{2} & \text{if } |y - y'| > 1 \\ \frac{1}{2}(y - y')^2 & \text{otherwise} \end{cases} $$

这是一个光滑的分段函数，当差距大于1时是绝对值，当真实值和预测值差距小于1时是平方误差

图像分类数据集测试

mnist数据集是图像分类中最广泛的数据集之一，作为基准数据集有点过于简单。

以下是加载数据集的方式

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


# 返回Fashion mnist数据集的文本标签
def get_fashion_mnist_labels(labels):
    """返回Fashion-MNIST数据集的文本标签"""
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
                   'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
    # 从索引list中，返回一个对应元素的list
    return [text_labels[int(i)] for i in labels]


def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):
    """绘制图像列表"""
    # 图像大小乘以尺寸
    figsize = (num_cols * scale, num_rows * scale)
    # matplotlib 绘图
    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
    # 把高纬度拉平 [[1,2][2,2]]=>[1,2,2,2]
    axes = axes.flatten()
    # zip函数的作用是返回一个迭代器，将可迭代对象打包成元素
    # enumerate获取索引，其实就是给每个元素增加了索引i
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            # 图片张量 转成numpy
            ax.imshow(img.numpy())
        else:
            # PIL图片
            ax.imshow(img)
        # 隐藏坐标轴
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes


def get_dataloader_workers():
    # 设置4个工作线程
    return 4


# 使用svg来显示
d2l.use_svg_display()
# 通过Totensor实例将图像数据从PIL类型变换成32为浮点数的格式
# 并除以255使得所有图像的数值在0到1之间
trans = transforms.ToTensor()
# 下载数据集，root是下载路径，train代表训练，transform代表拿出来得到是tensor，download是默认从网上下载
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)
# 60000个训练集 10000个测试集
# 形状是28*28
print(len(mnist_train), len(mnist_test), mnist_train[0][0].shape)

# iter()函数在Python中用于创建一个迭代器对象。
x, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))
# 展示18张照片，28*28像素的照片 2行，每一行9张图片
show_images(x.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y))

d2l.plt.show()

batch_size = 256

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
print(f'{timer.stop():.2f} sec')

不管如何定义输入和输出，进入softmax函数之前的一层，和softmax之后的一层，他的矩阵大小是相同的

y = torch.tensor([0, 2])
#简单来说是先拿0作用在y上，然后再将y作用在y_hat上
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
y_hat[[0, 1], y]
# 输出tensor([0.1000, 0.5000])
# 这样既可以拿到预期值和真实值的差异，这个概率输出一般是在softmax之后
# 计算交叉熵
def cross_entropy(y_hat, y):
    # 计算自然对数，拿出真实标号的预测值
    # 把预测值和输出值拿出来直接进行比较，计算每一项以及对应的交叉熵
    # 因为我们的目的是提高当前项的准确率我，所以我们只关心正确项的正确率
    return -torch.log(y_hat[range(len(y_hat)), 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)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

print(accuracy(y_hat, y) / len(y))#输出是0.5
class Accumulator:
    """For accumulating sums over `n` variables."""
    def __init__(self, n):
        """Defined in :numref:`sec_utils`"""
        self.data = [0.0] * n
    # args是一个特殊的语法，允许该方法接收任意数量的位置参数并将它们收集到一个名为args的元组中。
    #最终的作用是n个数，累加到data的n个变量
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

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

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

python 推导列表，new_list = [expression for item in iterable if condition]

• expression 是基于item的计算表达式，它的结果将被放入新列表中。
• for item in iterable 是一个for循环，遍历任何可迭代的对象（如列表、元组、集合、字符串等）。
• if condition 是一个可选的条件语句，只有当条件为真时，expression的结果才会被添加到新列表中。

softmax回归

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


def softmax(X):
    # 对于矩阵来说，我们是对每一行做softmax
    X_exp = torch.exp(X)
    # 按维度为1来求和 keepdim=true是保留原来维度
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition  # 这里用了广播机制，广播机制就是库自动对齐


# softmax回归
def net(X):
    # 对于输入X，我们把他reshape成批量大小的矩阵
    # 这里会被reshape成一个256 * 784的矩阵，W.shape[0]就是784
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)


# 计算交叉熵
def cross_entropy(y_hat, y):
    # 计算自然对数，拿出真实标号的预测值
    # 把预测值和输出值拿出来直接进行比较，计算每一项以及对应的交叉熵
    # 因为我们的目的是提高当前项的准确率我，所以我们只关心正确项的正确率
    return -torch.log(y_hat[range(len(y_hat)), y])


# 计算预测正确的数量
def accuracy(y_hat, y):
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        # 是求那一行最大值的下标
        # 也就是沿着y轴进行计算，这里的arg指的是argument
        y_hat = y_hat.argmax(axis=1)
    # cmp是 comparison 这里是转换俩者的类型进行比较，获得一个bool的tensor
    cmp = y_hat.type(y.dtype) == y
    # 返回预测的数量
    return float(cmp.type(y.dtype).sum())


# 计算在指定数据集上的精度
def evaluate_accuracy(net, data_iter):
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
        net.eval()
    metric = d2l.Accumulator(2)
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]




def train_epoch_ch3(net, train_iter, loss, updater):
    """训练模型一个迭代周期（定义见第3章）"""
    if isinstance(net, torch.nn.Module):
        net.train()
    metric = d2l.Accumulator(3)
    for X, y in train_iter:

        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()
            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]


class Animator:
    """For plotting data in animation."""

    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)):
        """Defined in :numref:`sec_utils`"""
        # Incrementally plot multiple lines
        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, ]
        # Use a lambda function to capture arguments
        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):
        # Add multiple data points into the figure
        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)
        d2l.plt.show()


def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    """训练模型（定义见第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


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


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

# 将展平每个图像，将它们视为长度784的向量。因为我们数据偶10个类别，所以输出维度为10
num_inputs = 784  # 28x28个像素
num_output = 10
# 创建一个形状为行数：num_inputs 列数：num_output，requires_grad代表需要计算梯度
W = torch.normal(0, 0.01, size=(num_inputs, num_output), requires_grad=True)
b = torch.zeros(num_output, requires_grad=True)

# y = torch.tensor([0, 2])
# y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
# print(accuracy(y_hat, y) / len(y))
lr = 0.1

num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)


def predict_ch3(net, test_iter, n=6):
    """预测标签（定义见第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)
d2l.plt.show()

简洁写法

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

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
# pytorch不会隐式地调整输入的形状
# 因此我们定义了展平层（flatten）在线性层之前调整网络输入形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))


def init_weight(m):
    # m的类型是一个线性的
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)


net.apply(init_weight)
loss = nn.CrossEntropyLoss()
# 使用学习率为0.1的小批量随机梯度下降最为优化算法，返回训练器
trainer = torch.optim.SGD(net.parameters(), lr=0.1)
num_epochs = 10
softmax_regression_2.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)