因為 softmax 回歸是如此基礎，我們相信您應該知道如何自己實現它。在這里，我們限制自己定義模型的 softmax 特定方面，并重用線性回歸部分的其他組件，包括訓練循環。

import torch
from d2l import torch as d2l

from mxnet import autograd, gluon, np, npx
from d2l import mxnet as d2l

npx.set_np()

from functools import partial
import jax
from flax import linen as nn
from jax import numpy as jnp
from d2l import jax as d2l

No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)

import tensorflow as tf
from d2l import tensorflow as d2l

4.4.1. Softmax

讓我們從最重要的部分開始：從標量到概率的映射。作為復習，請回憶一下在張量中沿特定維度的求和運算符，如第 2.3.6 節和 第 2.3.7 節中所討論的。給定一個矩陣，X我們可以對所有元素（默認情況下）或僅對同一軸上的元素求和。該axis變量讓我們計算行和列的總和：

X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
X.sum(0, keepdims=True), X.sum(1, keepdims=True)

(tensor([[5., 7., 9.]]),
 tensor([[ 6.],
     [15.]]))

X = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
X.sum(0, keepdims=True), X.sum(1, keepdims=True)

(array([[5., 7., 9.]]),
 array([[ 6.],
    [15.]]))

X = jnp.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
X.sum(0, keepdims=True), X.sum(1, keepdims=True)

(Array([[5., 7., 9.]], dtype=float32),
 Array([[ 6.],
    [15.]], dtype=float32))

X = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
tf.reduce_sum(X, 0, keepdims=True), tf.reduce_sum(X, 1, keepdims=True)

(,
 )

計算 softmax 需要三個步驟：（i）每一項取冪；(ii) 對每一行求和以計算每個示例的歸一化常數；(iii) 將每一行除以其歸一化常數，確保結果之和為 1。

(4.4.1)softmax(X)ij=exp?(Xij)∑kexp?(Xik).

分母的（對數）稱為（對數）配分函數。它是在統計物理學中引入的 ，用于對熱力學系綜中的所有可能狀態求和。實現很簡單：

def softmax(X):
  X_exp = torch.exp(X)
  partition = X_exp.sum(1, keepdims=True)
  return X_exp / partition # The broadcasting mechanism is applied here

def softmax(X):
  X_exp = np.exp(X)
  partition = X_exp.sum(1, keepdims=True)
  return X_exp / partition # The broadcasting mechanism is applied here

def softmax(X):
  X_exp = jnp.exp(X)
  partition = X_exp.sum(1, keepdims=True)
  return X_exp / partition # The broadcasting mechanism is applied here

def softmax(X):
  X_exp = tf.exp(X)
  partition = tf.reduce_sum(X_exp, 1, keepdims=True)
  return X_exp / partition # The broadcasting mechanism is applied here

對于任何輸入X，我們將每個元素變成一個非負數。每行總和為 1，這是概率所要求的。注意：上面的代碼對于非常大或非常小的參數并不穩健。雖然這足以說明正在發生的事情，但您不應 將此代碼逐字用于任何嚴肅的目的。深度學習框架內置了這樣的保護，我們將在未來使用內置的 softmax。

X = torch.rand((2, 5))
X_prob = softmax(X)
X_prob, X_prob.sum(1)

(tensor([[0.1560, 0.2128, 0.2260, 0.2372, 0.1680],
     [0.1504, 0.2473, 0.1132, 0.2779, 0.2112]]),
 tensor([1.0000, 1.0000]))

X = np.random.rand(2, 5)
X_prob = softmax(X)
X_prob, X_prob.sum(1)

(array([[0.17777154, 0.1857739 , 0.20995119, 0.23887765, 0.18762572],
    [0.24042214, 0.1757977 , 0.23786479, 0.15572716, 0.19018826]]),
 array([1., 1.]))

X = jax.random.uniform(jax.random.PRNGKey(d2l.get_seed()), (2, 5))
X_prob = softmax(X)
X_prob, X_prob.sum(1)

(Array([[0.17380024, 0.13607854, 0.29826194, 0.18967763, 0.20218161],
    [0.24212085, 0.19360834, 0.21299706, 0.17635451, 0.17491929]],   dtype=float32),
 Array([1., 1.], dtype=float32))

X = tf.random.uniform((2, 5))
X_prob = softmax(X)
X_prob, tf.reduce_sum(X_prob, 1)

(,
 )

4.4.2. 該模型

我們現在擁有了實現 softmax 回歸模型所需的一切。與我們的線性回歸示例一樣，每個實例都將由一個固定長度的向量表示。由于這里的原始數據包括28×28像素圖像，我們將每個圖像展平，將它們視為長度為 784 的向量。在后面的章節中，我們將介紹卷積神經網絡，它以更令人滿意的方式利用空間結構。

在 softmax 回歸中，我們網絡的輸出數量應該等于類的數量。由于我們的數據集有 10 個類，我們的網絡的輸出維度為 10。因此，我們的權重構成784×10矩陣加一個1×10 偏差的維行向量。與線性回歸一樣，我們W使用高斯噪聲初始化權重。偏差被初始化為零。

class SoftmaxRegressionScratch(d2l.Classifier):
  def __init__(self, num_inputs, num_outputs, lr, sigma=0.01):
    super().__init__()
    self.save_hyperparameters()
    self.W = torch.normal(0, sigma, size=(num_inputs, num_outputs),
               requires_grad=True)
    self.b = torch.zeros(num_outputs, requires_grad=True)

  def parameters(self):
    return [self.W, self.b]

class SoftmaxRegressionScratch(d2l.Classifier):
  def __init__(self, num_inputs, num_outputs, lr, sigma=0.01):
    super().__init__()
    self.save_hyperparameters()
    self.W = np.random.normal(0, sigma, (num_inputs, num_outputs))
    self.b = np.zeros(num_outputs)
    self.W.attach_grad()
    self.b.attach_grad()

  def collect_params(self):
    return [self.W, self.b]

class SoftmaxRegressionScratch(d2l.Classifier):
  num_inputs: int
  num_outputs: int
  lr: float
  sigma: float = 0.01

  def setup(self):
    self.W = self.param('W', nn.initializers.normal(self.sigma),
              (self.num_inputs, self.num_outputs))
    self.b = self.param('b', nn.initializers.zeros, self.num_outputs)

class SoftmaxRegressionScratch(d2l.Classifier):
  def __init__(self, num_inputs, num_outputs, lr, sigma=0.01):
    super().__init__()
    self.save_hyperparameters()
    self.W = tf.random.normal((num_inputs, num_outputs), 0, sigma)
    self.b = tf.zeros(num_outputs)
    self.W = tf.Variable(self.W)
    self.b = tf.Variable(self.b)

下面的代碼定義了網絡如何將每個輸入映射到輸出。請注意，我們將每個28×28reshape在將數據傳遞給我們的模型之前，將批處理中的像素圖像轉換為向量。

@d2l.add_to_class(SoftmaxRegressionScratch)
def forward(self, X):
  X = X.reshape((-1, self.W.shape[0]))
  return softmax(torch.matmul(X, self.W) + self.b)

@d2l.add_to_class(SoftmaxRegressionScratch)
def forward(self, X):
  X = X.reshape((-1, self.W.shape[0]))
  return softmax(np.dot(X, self.W) + self.b)

@d2l.add_to_class(SoftmaxRegressionScratch)
def forward(self, X):
  X = X.reshape((-1, self.W.shape[0]))
  return softmax(jnp.matmul(X, self.W) + self.b)

@d2l.add_to_class(SoftmaxRegressionScratch)
def forward(self, X):
  X = tf.reshape(X, (-1, self.W.shape[0]))
  return softmax(tf.matmul(X, self.W) + self.b)

4.4.3. 交叉熵損失

接下來我們需要實現交叉熵損失函數（ 4.1.2節介紹 ）。這可能是所有深度學習中最常見的損失函數。目前，深度學習的應用很容易拋出分類問題，遠遠超過那些更好地視為回歸問題的問題。

回想一下，交叉熵采用分配給真實標簽的預測概率的負對數似然。為了提高效率，我們避免使用 Python for 循環并改用索引。特別是，one-hot 編碼y允許我們選擇匹配項y^.

為了在行動中看到這一點，我們創建了樣本數據，y_hat其中包含 3 個類及其對應標簽的 2 個預測概率示例 y。正確的標簽是0和2分別（即一等和三等）。使用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]

tensor([0.1000, 0.5000])

現在我們可以通過對所選概率的對數進行平均來實現交叉熵損失函數。

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

cross_entropy(y_hat, y)

tensor(1.4979)

@d2l.add_to_class(SoftmaxRegressionScratch)
def loss(self, y_hat, y):
  return cross_entropy(y_hat, y)

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

array([0.1, 0.5])

Now we can implement the cross-entropy loss function by averaging over the logarithms of the selected probabilities.

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

cross_entropy(y_hat, y)

array(1.4978662)

@d2l.add_to_class(SoftmaxRegressionScratch)
def loss(self, y_hat, y):
  return cross_entropy(y_hat, y)

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

Array([0.1, 0.5], dtype=float32)

Now we can implement the cross-entropy loss function by averaging over the logarithms of the selected probabilities.

Note that to make use of jax.jit to speed up JAX implementations, and to make sure loss is a pure function, the cross_entropy function is re-defined inside the loss to avoid usage of any global variables or functions which may render the loss function impure. We refer interested readers to the JAX documentation on jax.jit and pure functions.

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

cross_entropy(y_hat, y)

Array(1.4978662, dtype=float32)

@d2l.add_to_class(SoftmaxRegressionScratch)
@partial(jax.jit, static_argnums=(0))
def loss(self, params, X, y, state):
  def cross_entropy(y_hat, y):
    return -jnp.log(y_hat[list(range(len(y_hat))), y]).mean()
  y_hat = state.apply_fn({'params': params}, *X)
  # The returned empty dictionary is a placeholder for auxiliary data,
  # which will be used later (e.g., for batch norm)
  return cross_entropy(y_hat, y), {}

y_hat = tf.constant([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
y = tf.constant([0, 2])
tf.boolean_mask(y_hat, tf.one_hot(y, depth=y_hat.shape[-1]))

Now we can implement the cross-entropy loss function by averaging over the logarithms of the selected probabilities.

def cross_entropy(y_hat, y):
  return -tf.reduce_mean(tf.math.log(tf.boolean_mask(
    y_hat, tf.one_hot(y, depth=y_hat.shape[-1]))))

cross_entropy(y_hat, y)

@d2l.add_to_class(SoftmaxRegressionScratch)
def loss(self, y_hat, y):
  return cross_entropy(y_hat, y)

4.4.4. 訓練

我們重用第 3.4 節fit中定義的方法來訓練具有 10 個 epoch 的模型。請注意，時期數 ( )、小批量大小 ( ) 和學習率 ( ) 都是可調整的超參數。這意味著雖然這些值不是在我們的主要訓練循環中學習到的，但它們仍然會影響我們模型的性能、bot vis-a-vis 訓練和泛化性能。在實踐中，您將希望根據數據的驗證拆分來選擇這些值，然后最終在測試拆分上評估您的最終模型。如第 3.6.3 節所述max_epochsbatch_sizelr，我們將 Fashion-MNIST 的測試數據視為驗證集，從而報告此拆分的驗證損失和驗證準確性。

data = d2l.FashionMNIST(batch_size=256)
model = SoftmaxRegressionScratch(num_inputs=784, num_outputs=10, lr=0.1)
trainer = d2l.Trainer(max_epochs=10)
trainer.fit(model, data)

data = d2l.FashionMNIST(batch_size=256)
model = SoftmaxRegressionScratch(num_inputs=784, num_outputs=10, lr=0.1)
trainer = d2l.Trainer(max_epochs=10)
trainer.fit(model, data)

data = d2l.FashionMNIST(batch_size=256)
model = SoftmaxRegressionScratch(num_inputs=784, num_outputs=10, lr=0.1)
trainer = d2l.Trainer(max_epochs=10)
trainer.fit(model, data)

data = d2l.FashionMNIST(batch_size=256)
model = SoftmaxRegressionScratch(num_inputs=784, num_outputs=10, lr=0.1)
trainer = d2l.Trainer(max_epochs=10)
trainer.fit(model, data)

4.4.5. 預言

現在訓練已經完成，我們的模型已準備好對一些圖像進行分類。

X, y = next(iter(data.val_dataloader()))
preds = model(X).argmax(axis=1)
preds.shape

torch.Size([256])

X, y = next(iter(data.val_dataloader()))
preds = model(X).argmax(axis=1)
preds.shape

(256,)

X, y = next(iter(data.val_dataloader()))
preds = model.apply({'params': trainer.state.params}, X).argmax(axis=1)
preds.shape

(256,)

X, y = next(iter(data.val_dataloader()))
preds = tf.argmax(model(X), axis=1)
preds.shape

TensorShape([256])

我們更感興趣的是我們標記錯誤的圖像。我們通過將它們的實際標簽（文本輸出的第一行）與模型的預測（文本輸出的第二行）進行比較來可視化它們。

wrong = preds.type(y.dtype) != y
X, y, preds = X[wrong], y[wrong], preds[wrong]
labels = [a+'n'+b for a, b in zip(
  data.text_labels(y), data.text_labels(preds))]
data.visualize([X, y], labels=labels)

wrong = preds.astype(y.dtype) != y
X, y, preds = X[wrong], y[wrong], preds[wrong]
labels = [a+'n'+b for a, b in zip(
  data.text_labels(y), data.text_labels(preds))]
data.visualize([X, y], labels=labels)

wrong = preds.astype(y.dtype) != y
X, y, preds = X[wrong], y[wrong], preds[wrong]
labels = [a+'n'+b for a, b in zip(
  data.text_labels(y), data.text_labels(preds))]
data.visualize([X, y], labels=labels)

wrong = tf.cast(preds, y.dtype) != y
X, y, preds = X[wrong], y[wrong], preds[wrong]
labels = [a+'n'+b for a, b in zip(
  data.text_labels(y), data.text_labels(preds))]
data.visualize([X, y], labels=labels)

4.4.6. 概括

到目前為止，我們開始獲得解決線性回歸和分類問題的一些經驗。有了它，我們已經達到了可以說是 1960-1970 年代統計建模的最先進水平。在下一節中，我們將向您展示如何利用深度學習框架更有效地實施該模型。

4.4.7. 練習

在本節中，我們根據 softmax 運算的數學定義直接實現了 softmax 函數。如第 4.1 節所述，這會導致數值不穩定。

測試如果softmax輸入的值為100？

測試如果softmax所有輸入中最大的小于?100？

通過查看相對于參數中最大條目的值來實施修復。

實現一個cross_entropy遵循交叉熵損失函數定義的函數∑iyilog?y^i.

在上面的代碼示例中嘗試一下。

為什么你認為它運行得更慢？

你應該使用它嗎？在哪些情況下有意義？

你需要注意什么？提示：考慮對數的定義域。

返回最有可能的標簽總是一個好主意嗎？例如，你會為了醫學診斷而這樣做嗎？你會如何嘗試解決這個問題？

假設我們要使用 softmax 回歸來根據某些特征預測下一個單詞。大詞匯量可能會帶來哪些問題？

試驗上面代碼的超參數。尤其：

繪制驗證損失如何隨著學習率的變化而變化。

當您更改小批量大小時，驗證和訓練損失是否會發生變化？在看到效果之前，您需要多大或多小？