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

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

讓我們從最重要的部分開始：從標(biāo)量到概率的映射。作為復(fù)習(xí)，請回憶一下在張量中沿特定維度的求和運算符，如第 2.3.6 節(jié)和 第 2.3.7 節(jié)中所討論的。給定一個矩陣，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) 對每一行求和以計算每個示例的歸一化常數(shù)；(iii) 將每一行除以其歸一化常數(shù)，確保結(jié)果之和為 1。

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

分母的（對數(shù)）稱為（對數(shù)）配分函數(shù)。它是在統(tǒng)計物理學(xué)中引入的 ，用于對熱力學(xué)系綜中的所有可能狀態(tài)求和。實現(xiàn)很簡單：

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，我們將每個元素變成一個非負數(shù)。每行總和為 1，這是概率所要求的。注意：上面的代碼對于非常大或非常小的參數(shù)并不穩(wěn)健。雖然這足以說明正在發(fā)生的事情，但您不應(yīng) 將此代碼逐字用于任何嚴肅的目的。深度學(xué)習(xí)框架內(nèi)置了這樣的保護，我們將在未來使用內(nèi)置的 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. 該模型

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

在 softmax 回歸中，我們網(wǎng)絡(luò)的輸出數(shù)量應(yīng)該等于類的數(shù)量。由于我們的數(shù)據(jù)集有 10 個類，我們的網(wǎng)絡(luò)的輸出維度為 10。因此，我們的權(quán)重構(gòu)成784×10矩陣加一個1×10 偏差的維行向量。與線性回歸一樣，我們W使用高斯噪聲初始化權(quán)重。偏差被初始化為零。

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)

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

@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. 交叉熵損失

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

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

為了在行動中看到這一點，我們創(chuàng)建了樣本數(shù)據(jù)，y_hat其中包含 3 個類及其對應(yīng)標(biāo)簽的 2 個預(yù)測概率示例 y。正確的標(biāo)簽是0和2分別（即一等和三等）。使用y中概率的指標(biāo)y_hat，我們可以有效地挑選出術(shù)語。

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

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

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. 訓(xùn)練

我們重用第 3.4 節(jié)fit中定義的方法來訓(xùn)練具有 10 個 epoch 的模型。請注意，時期數(shù) ( )、小批量大小 ( ) 和學(xué)習(xí)率 ( ) 都是可調(diào)整的超參數(shù)。這意味著雖然這些值不是在我們的主要訓(xùn)練循環(huán)中學(xué)習(xí)到的，但它們?nèi)匀粫绊懳覀兡Ｐ偷男阅堋ot vis-a-vis 訓(xùn)練和泛化性能。在實踐中，您將希望根據(jù)數(shù)據(jù)的驗證拆分來選擇這些值，然后最終在測試拆分上評估您的最終模型。如第 3.6.3 節(jié)所述max_epochsbatch_sizelr，我們將 Fashion-MNIST 的測試數(shù)據(jù)視為驗證集，從而報告此拆分的驗證損失和驗證準確性。

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. 預(yù)言

現(xiàn)在訓(xùn)練已經(jīng)完成，我們的模型已準備好對一些圖像進行分類。

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

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

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. 概括

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

4.4.7. 練習(xí)

在本節(jié)中，我們根據(jù) softmax 運算的數(shù)學(xué)定義直接實現(xiàn)了 softmax 函數(shù)。如第 4.1 節(jié)所述，這會導(dǎo)致數(shù)值不穩(wěn)定。

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

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

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

實現(xiàn)一個cross_entropy遵循交叉熵損失函數(shù)定義的函數(shù)∑iyilog?y^i.

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

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

你應(yīng)該使用它嗎？在哪些情況下有意義？

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

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

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

試驗上面代碼的超參數(shù)。尤其：

繪制驗證損失如何隨著學(xué)習(xí)率的變化而變化。

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