09-softmax回归

发表于 2024-04-23 更新于 2024-04-24 分类于动手学深度学习阅读次数：

动手学深度学习李沐

更新历史

24.04.24：初稿

系列

动手学深度学习笔记汇总

09-softmax回归

1.回归VS分类：

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

1.1 从回归到多类分类：

回归：

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

均方损失：

对类别进行一位有效编码

$y=[y_{1},y_{2},…,y_{n}]^{T}$
$y_{i}=\begin{cases}
1&i=y\\
2&otherwise
\end{cases}$
使用均方损失训练
最大值为预测
$
\hat{y}=\underset {i}{argmax}\quad o^{i}
$

无校验比例

对类别进行一位有效编码
最大值为预测
$
\hat{y}=\underset {i}{argmax}\quad o^{i}
$
需要更置信的识别正确类（大余量）
$
o_y-o_i\geq\Delta(y,i)
$

校验比例

输出匹配概率（$\hat{y}$非负，和为1）
$
\hat{y}=softmax(o)
$

$
\hat{y_i}=\frac{exp(o_i)}{\sum_{k} exp(o_k)}
$

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

1.2 Softmax和交叉熵损失

交叉熵用来衡量两个概率的区别$H(p,q)=\sum_{i} -p_{i}log(q_i)$
将它作为损失
$
l(y,\hat{y})=-\sum_{i}y_{i}log\hat{y_{i}}=-log\hat{y_y}
$

推导过程？
其梯度是真实概率和预测概率的区别
$
\partial_{o_{i}}l(y,\hat{y})=softmax(o)_{i}-y_{i}
$

Softmax回归是一个多类分类模型

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

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

2.损失函数

2.1 L2 Loss 均方损失

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

蓝色：y=0
绿色似然函数,高斯分布
损失函数的梯度，一次函数
梯度会随着结果逼近而下降

2.2 L1 Loss 绝对值损失函数

$
l(y,y^{‘})=\lvert y-y^{‘}\rvert
$

梯度保持不变，但在0处梯度随机

2.3Huber’s Robust Loss 鲁棒损失

结合L1 Loss和L2 Loss的优点

3.图片分类数据集

3.1 Fashion-MNIST数据集：

读取数据集

# 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式，
# 并除以255使得所有像素的数值均在0～1之间
# 转换为张量形式 trans
# 读取为训练集，测试集，读取为张量形式还不是图片形式
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)

数据集内图片大小
# 第一张图片的shape
mnist_train[0][0].shape
torch.Size([1, 28, 28])
表示图片为单通道（黑白）的28X28的图片

两个可视化函数

def get_fashion_mnist_labels(labels):  
  """返回Fashion-MNIST数据集的文本标签"""
  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):  
  """绘制图像列表"""
  figsize = (num_cols * scale, num_rows * scale)
  _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
  axes = axes.flatten()
  for i, (ax, img) in enumerate(zip(axes, imgs)):
      if torch.is_tensor(img):
          # 图片张量
          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

显示数据集图像

# 画2行每行9个，titles拿出
X,y = next(iter(data.DataLoader(mnist_train,batch_size=18)))
show_images(X.reshape(18,28,28),2,9,titles=get_fashion_mnist_labels(y))

定义load_data_fashion_mnist函数

def load_data_fashion_mnist(batch_size, resize=None):  
  """下载Fashion-MNIST数据集，然后将其加载到内存中"""
  trans = [transforms.ToTensor()]
  if resize:
      trans.insert(0, transforms.Resize(resize))
  trans = transforms.Compose(trans)
  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)
  return (data.DataLoader(mnist_train, batch_size, shuffle=True,
                          num_workers=get_dataloader_workers()),
          data.DataLoader(mnist_test, batch_size, shuffle=False,
                          num_workers=get_dataloader_workers()))

我们通过指定resize参数来测试load_data_fashion_mnist函数的图像大小调整功能。
train_iter, test_iter = load_data_fashion_mnist(32, resize=64)
for X, y in train_iter:
  print(X.shape, X.dtype, y.shape, y.dtype)
  break

4.从零实现softmax回归

softmax:

$$
softmax(X)_{ij}=\frac{exp(X_{ij})}{\sum_{k} exp(X_{ik})}
$$

def softmax(X):
    # 求每一个元素的指数计算
    X_exp = torch.exp(X)
    # 按行求和
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition

将图像展平，每个图像看做长度为784的向量，因为数据集有十个类别，所以网络输出维度为10。以此设定参数大小并初始化：

# 图片是一个三维的，拉长为一个向量,softmax回归输入为向量
num_inputs = 784
num_outputs = 10
# 用高斯回归初始权重，均值0，方差0.01，形状行列为输入输出个数，需要计算梯度
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
# 输出需要一个偏移
b = torch.zeros(num_outputs, requires_grad=True)

实现softmax回归模型：

def net(X):
    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_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

评估net精度

def evaluate_accuracy(net, data_iter):  
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
        net.eval()
    metric = 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]

class Accumulator:  
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * 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]

定义训练模型：

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

动画

class Animator: 
  """在动画中绘制数据"""
  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)

5.softmax的简洁实现

调用torch内的网络层

#train_iter 返回一个训练集测试集的迭代器
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))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight,std=0.01)

net.apply(init_weights)
loss=nn.CrossEntropyLoss()
trainer=torch.optim.SGD(net.parameters(),lr=0.1)
num_epochs=10
d2l.train_ch3(net,train_iter,test_iter,loss,num_epochs,trainer)

6.softmax回归Q&A

Q1:softlabel训练策略以及为什么有效？

softmax用指数很难逼近1，softlabel将正例和负例分别标记为0.9和0.1使结果逼近变得可能，这是一个常用的小技巧。

Q2:softmax回归和logistic回归？

logistic回归为二分类问题，是softmax回归的特例

Q3:为什么使用交叉熵，而不用相对熵，互信息熵等其他基于信息量的度量？

实际上使用哪一种熵的效果区别不大，所以哪种简单就用哪种

Q4:$y*log\hat{y}$ 为什么我们只关心正确类，而不关心不正确的类呢？

并不是不关心，而是不正确的的类标号为零，所以算式中不体现，如果使用softlabel策略，就会体现出不正确的类。

Q5:似然函数曲线是怎么得出来的？有什么参考意义？

最小化损失函数也意味着最大化似然函数，似然函数表示统计概率和模型的拟合程度。

Q6:在多次迭代之后欧如果测试精度出现上升后再下降是过拟合了吗？可以提前终止吗？

很有可能是过拟合，可以继续训练来观察是否持续下降

Q7:cnn网络主要学习到的是纹理还是轮廓还是所有内容的综合？

目前认为主要学习到的是纹理信息

Q8:softmax可解释吗？

单纯softmax是可解释的，可以在统计书籍中找到相关的解释。