softmax回归的简洁实现

:label:sec_softmax_concise

在 :numref:sec_linear_concise中， 我们发现(通过深度学习框架的高级API能够使实现) (softmax) 线性(回归变得更加容易)。 同样，通过深度学习框架的高级API也能更方便地实现softmax回归模型。 本节如在 :numref:sec_softmax_scratch中一样， 继续使用Fashion-MNIST数据集，并保持批量大小为256。

```{.python .input} from d2l import mxnet as d2l from mxnet import gluon, init, npx from mxnet.gluon import nn npx.set_np()

  2. ```{.python .input}
  3. #@tab pytorch
  4. from d2l import torch as d2l
  5. import torch
  6. from torch import nn

```{.python .input}

@tab tensorflow

from d2l import tensorflow as d2l import tensorflow as tf

  2. ```{.python .input}
  3. #@tab all
  4. batch_size = 256
  5. train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

初始化模型参数

如我们在 :numref:sec_softmax所述， [softmax回归的输出层是一个全连接层]。 因此，为了实现我们的模型， 我们只需在Sequential中添加一个带有10个输出的全连接层。 同样，在这里Sequential并不是必要的， 但它是实现深度模型的基础。 我们仍然以均值0和标准差0.01随机初始化权重。

```{.python .input} net = nn.Sequential() net.add(nn.Dense(10)) net.initialize(init.Normal(sigma=0.01))

  2. ```{.python .input}
  3. #@tab pytorch
  4. # PyTorch不会隐式地调整输入的形状。因此，
  5. # 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
  6. net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
  8. def init_weights(m):
  9.     if type(m) == nn.Linear:
  10.         nn.init.normal_(m.weight, std=0.01)
  12. net.apply(init_weights);

```{.python .input}

@tab tensorflow

net = tf.keras.models.Sequential() net.add(tf.keras.layers.Flatten(input_shape=(28, 28))) weight_initializer = tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.01) net.add(tf.keras.layers.Dense(10, kernel_initializer=weight_initializer))

  2. ## 重新审视Softmax的实现
  3. :label:`subsec_softmax-implementation-revisited`
  5. 在前面 :numref:`sec_softmax_scratch`的例子中，
  6. 我们计算了模型的输出，然后将此输出送入交叉熵损失。
  7. 从数学上讲，这是一件完全合理的事情。
  8. 然而，从计算角度来看，指数可能会造成数值稳定性问题。
  10. 回想一下，softmax函数$\hat y_j = \frac{\exp(o_j)}{\sum_k \exp(o_k)}$，
  11. 其中$\hat y_j$是预测的概率分布。
  12. $o_j$是未规范化的预测$\mathbf{o}$的第$j$个元素。
  13. 如果$o_k$中的一些数值非常大，
  14. 那么$\exp(o_k)$可能大于数据类型容许的最大数字，即*上溢*（overflow）。
  15. 这将使分母或分子变为`inf`（无穷大），
  16. 最后得到的是0、`inf`或`nan`（不是数字）的$\hat y_j$。
  17. 在这些情况下，我们无法得到一个明确定义的交叉熵值。
  19. 解决这个问题的一个技巧是：
  20. 在继续softmax计算之前，先从所有$o_k$中减去$\max(o_k)$。
  21. 你可以看到每个$o_k$按常数进行的移动不会改变softmax的返回值：
  23. $$
  24. \begin{aligned}
  25. \hat y_j & =  \frac{\exp(o_j - \max(o_k))\exp(\max(o_k))}{\sum_k \exp(o_k - \max(o_k))\exp(\max(o_k))} \\
  26. & = \frac{\exp(o_j - \max(o_k))}{\sum_k \exp(o_k - \max(o_k))}.
  27. \end{aligned}
  28. $$
  31. 在减法和规范化步骤之后，可能有些$o_j - \max(o_k)$具有较大的负值。
  32. 由于精度受限，$\exp(o_j - \max(o_k))$将有接近零的值，即*下溢*（underflow）。
  33. 这些值可能会四舍五入为零，使$\hat y_j$为零，
  34. 并且使得$\log(\hat y_j)$的值为`-inf`。
  35. 反向传播几步后，我们可能会发现自己面对一屏幕可怕的`nan`结果。
  37. 尽管我们要计算指数函数，但我们最终在计算交叉熵损失时会取它们的对数。
  38. 通过将softmax和交叉熵结合在一起，可以避免反向传播过程中可能会困扰我们的数值稳定性问题。
  39. 如下面的等式所示，我们避免计算$\exp(o_j - \max(o_k))$，
  40. 而可以直接使用$o_j - \max(o_k)$，因为$\log(\exp(\cdot))$被抵消了。
  42. $$
  43. \begin{aligned}
  44. \log{(\hat y_j)} & = \log\left( \frac{\exp(o_j - \max(o_k))}{\sum_k \exp(o_k - \max(o_k))}\right) \\
  45. & = \log{(\exp(o_j - \max(o_k)))}-\log{\left( \sum_k \exp(o_k - \max(o_k)) \right)} \\
  46. & = o_j - \max(o_k) -\log{\left( \sum_k \exp(o_k - \max(o_k)) \right)}.
  47. \end{aligned}
  48. $$
  50. 我们也希望保留传统的softmax函数，以备我们需要评估通过模型输出的概率。
  51. 但是，我们没有将softmax概率传递到损失函数中，
  52. 而是[**在交叉熵损失函数中传递未规范化的预测，并同时计算softmax及其对数**]，
  53. 这是一种类似["LogSumExp技巧"](https://en.wikipedia.org/wiki/LogSumExp)的聪明方式。
  55. ```{.python .input}
  56. loss = gluon.loss.SoftmaxCrossEntropyLoss()

```{.python .input}

@tab pytorch

loss = nn.CrossEntropyLoss(reduction=’none’)

  2. ```{.python .input}
  3. #@tab tensorflow
  4. loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

优化算法

在这里，我们(使用学习率为0.1的小批量随机梯度下降作为优化算法)。 这与我们在线性回归例子中的相同，这说明了优化器的普适性。

```{.python .input} trainer = gluon.Trainer(net.collect_params(), ‘sgd’, {‘learning_rate’: 0.1})

  2. ```{.python .input}
  3. #@tab pytorch
  4. trainer = torch.optim.SGD(net.parameters(), lr=0.1)

```{.python .input}

@tab tensorflow

trainer = tf.keras.optimizers.SGD(learning_rate=.1)

  2. ## 训练
  4. 接下来我们[**调用**] :numref:`sec_softmax_scratch`中(~~之前~~)
  5. (**定义的训练函数来训练模型**)。
  7. ```{.python .input}
  8. #@tab all
  9. num_epochs = 10
  10. d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

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

小结

  • 使用深度学习框架的高级API，我们可以更简洁地实现softmax回归。
  • 从计算的角度来看，实现softmax回归比较复杂。在许多情况下，深度学习框架在这些著名的技巧之外采取了额外的预防措施，来确保数值的稳定性。这使我们避免了在实践中从零开始编写模型时可能遇到的陷阱。

练习

  1. 尝试调整超参数，例如批量大小、迭代周期数和学习率，并查看结果。
  2. 增加迭代周期的数量。为什么测试精度会在一段时间后降低？我们怎么解决这个问题？

:begin_tab:mxnet Discussions :end_tab:

:begin_tab:pytorch Discussions :end_tab:

:begin_tab:tensorflow Discussions :end_tab: