通俗易懂！详解Softmax及求导过程、Python实现、交叉熵

---

前言

本文是对一篇国外的讲解Softmax的文章的翻译。

---

Softmax函数的输入是一个N维的向量，向量元素是任意实数，输出也是一个N维的向量，但是有如下性质：

1. 输出向量元素取值范围是(0, 1)
2. 对输出向量的所有元素求和时，和为1

Softmax函数是这样一个映射 $S(a):{\mathbb{R}}^N{\mathbb{R}}^N$

$$S(a):\left[\begin{array}{c}{a}_1\\ a_2\\ ...\\ a_N\end{array}\right]\left[\begin{array}{c}{S}_1\\ S_2\\ ...\\ S_N\end{array}\right]$$
并且对于每个元素，用的是如下公式
$$S_j=\frac{e^{a_j}}{{\sum }_{i=1}^N{e}^{a_k}},{\forall }_j\in 1...N$$
我们很容易看到，$S_j$永远是正数（因为式中全是对$e$求幂），并且由于在分母中包含了分子与其它正数求和，所以$0<S_j<1$。

举个例子，向量[1.0, 2.0, 3.0]通过Softmax变成了[0.09, 0.24, 0.67]。元素顺序不变，并且和为1。假如是[1.0, 2.0, 5.0]通过Softmax变成了[0.02, 0.05, 0.93]，同样是顺序不变，且和为1。可以注意到，0.93比另外2个数字大很多，而且在和为1的情况下，0.93已经占了绝大多数。直观地来讲，Softmax函数是“温柔”版的最大值函数，不同的是，Softmax没有直接取一个最大值，而是将所有元素变成各自占 $100\%$ 的不同比例，元素占比越大，Softmax最终的输出值就越大，当然其他元素得出的值就越小。[1]

一、概率学解释

Softmax的两个性质使得它非常适合用概率来解释，这也让Softmax在机器学习领域大有用途。在多分类任务中，我们希望给每个输入做一个标注，标注它属于每个类的概率是多大。

如果我们有N个类别，目标就是找到一个N维向量，每个元素代表这个样本是此类别的概率，这个向量元素求和是1。听起来是不是比较熟悉？

我们可以把Softmax解释成如下所示：
$$S_j=P(y=j|a)$$
其中，$y$代表输出的类别，范围是$1...N$，$a$是一个N维向量。有一个最基础的例子就是在多分类逻辑回归中，我们会把一个输入向量$x$和一个权重向量$w$做点积，然后这个点积被输入到Softmax中去计算概率。这种结构后面会讲到

我们可以发现，从概率学角度看，Softmax用于模型参数的最大似然估计是最优的，但是这超出了本文范围，具体可以看Deep Learning的第5章。

二、Softmax求导

1.向量微积分

在开始对Softmax进行求导之前，我们先看看如何对向量求导。

Softmax本质上是一个向量函数，输入输出都是向量，换句话说，Softmax有多个输入和多个输出，所以我们不能直接就问“Softmax的导数是什么”，我们应该这么问：

1. 在Softmax输出的向量中，我们要计算的是哪个元素的导数值？
2. 别忘了Softmax的输入也是向量，有多个元素，所以我们是在关于哪个变量在求偏导呢？

如果你觉得这个听起来很复杂，不要担心，向量微积分就是用来干这事的！我们要找的是这些偏导数：

$$\frac{\partial S_i}{\partial a_j}$$

这是$第i个输出关于第j个输入求偏导$，我们把这个记作：$D_j{S}_i$。

由于Softmax是 ${\mathbb{R}}^N{\mathbb{R}}^N$的函数，如果整体求导，我们实际上求的是一个$雅可比矩阵（JacobianMatrix）$：

$$DS=\left[\begin{array}{cccc}{D}_1{S}_1& \cdots & D_N{S}_1& \\ ⋮& \ddots & ⋮& \\ D_N{S}_1& \cdots & D_N{S}_N& \end{array}\right]$$

在机器学习的文章中，“梯度”常被用来代替“导数”。严格地说，“梯度”是仅针对于标量而定义的（比如机器学习中的损失函数），但对于像Softmax这样的向量函数来说，用“梯度”是不准确的，“雅可比矩阵”才是对向量函数的导数的名称，但是为了方便描述，大多数场合我也直接用“导数”来描述。

2.Softmax的导数

让我们开始计算 $D_j{S}_i（任意i和j）$：

$$\begin{array}{rl}{D}_j{S}_i& =\frac{\partial S_i}{\partial a_j}\\ & =\frac{\partial \frac{e^{a_j}}{{\sum }_{k=1}^N{e}^{a_k}}}{\partial a_j}\end{array}$$

我们使用一下分式函数求导公式：
$$\begin{gathered} 对于f(x)=\frac{g(x)}{h(x)} \\ {f}^{\prime }(x)=\frac{g^{\prime }(x)h(x)-h^{\prime }(x)g(x)}{h^2(x)} \end{gathered}$$

我们让 $g_i=e^{a_i}，h_i={\sum }_{k=1}^N{e}^{a_k}$ ，注意无论 $h_i$ 关于哪个 $a_j$ 求偏导结果都是 $e^{a_j}$，然而对于 $g_i$ 却不是这样， $g_i$ 对 $a_j$ 求偏导当且仅当 $i=j$ 的时候才是 $e^{a_j}$ ，因为只有 $i=j$ 时 $g_i$ 中才包含 $a_j$ ，否则偏导就是 0。

回到 $D_j{S}_i$ 的求导，为了简化，$\sum$ 代表 ${\sum }_{k=1}^N{e}^{a_k}$

如果 $i=j$：
$$\begin{array}{rl}\frac{\partial \frac{\exp (a_j)}{{\sum }_{k=1}^N\exp (a_k)}}{\partial a_j}& =\frac{e^{a_i}\sum -e^{a_j}{e}^{a_i}}{{\sum }^2}\\ & \\ & =\frac{e^{a_i}}{\sum }\frac{\sum -e^{a_j}}{\sum }\\ & \\ & =S_i(1-S_j)\end{array}$$

最终的式子用 $S_i$ 自己表示了 $S_i$ 自己的导数，当要求导的函数包含 $e^x$ 时，这是常用的一种技巧。

类似地，我们处理 $i\ne j$ 的情况：
$$\begin{array}{rl}\frac{\partial \frac{\exp (a_j)}{{\sum }_{k=1}^N\exp (a_k)}}{\partial a_j}& =\frac{0-e^{a_j}{e}^{a_i}}{{\sum }^2}\\ & \\ & =-\frac{e^{a_j}}{\sum }\frac{e^{a_i}}{\sum }\\ & \\ & =-S_j{S}_i\end{array}$$

总结一下：
$$f(x)=\{\begin{array}{rlr}& S_i(1-S_j)& i=j\\ & -S_j{S}_i& i\ne j\end{array}$$

我比较喜欢这种分开的形式，但是如果有比程序员在公式表达方面更准确的人的话，那一定是数学家们。这就是为什么你会在不同文章里看到对同一个公式的不同表达，但都是等价的。最常见的就是用了克罗内克函数：
$${\delta }_{ij}=\{\begin{array}{rlr}& 1& i=j\\ & 0& i\ne j\end{array}$$

合到一起就写成
$$D_j{S}_i=S_i({\delta }_{ij}-S_j)$$

这些公式说的都是同一件事，不同的文章还有其他一些写法：

1. 用矩阵公式来表达，用 $I$ 代替 $\delta$， $I$ 代表单位矩阵，就是把 $\delta$ 用矩阵形式表示了。
2. 用 $1$ 来表示克罗内克函数，也就是 $1函数$，$D_j{S}_i=S_i(1(i=j)-S_j)$ ，此处的 $1(i=j)$ 表示只有 $i=j$ 时函数值取1，否则取0。

这些简写形式在我们想计算更复杂的、基于Softmax的导数的其它导数的时候变得很有用，否则我们就需要每次都重述一遍，很麻烦。

三、Softmax的计算和稳定性

1.Python实现Softmax

代码如下

import numpy as np
def softmax(x):
    """计算向量 x 的 softmax."""
    exps = np.exp(x)
    return exps / np.sum(exps)

尝试一下吧：

In [146]: softmax([1, 2, 3])
Out[146]: array([ 0.09003057,  0.24472847,  0.66524096])

但是当我们输入比较大的数值时，会发生错误（溢出）：

In [148]: softmax([1000, 2000, 3000])
Out[148]: array([ nan,  nan,  nan])

Numpy使用的浮点数的数值范围是有限的，对于float64，最大可表示数的数量级是 $10^{308}$ ，Softmax中的 $e^x$ 导致很容易溢出，即使 $x$ 看起来没多大。

避免这个问题的一个好方法是将输入归一化，使其不要太大或太小，通过观察，我们可以像下面这样使用任意常数 $C$：
$$S_j=\frac{e^{a_j}}{{\sum }_{i=1}^N{e}^{a_k}}=\frac{C{e}^{a_j}}{{\sum }_{i=1}^{N}C{e}^{a_k}}$$
然后我们把 $C$ 放到指数上面，我们得到：
$$S_j=\frac{e^{a_j+ln(C)}}{{\sum }_{i=1}^N{e}^{a_k+ln(C)}}$$
因为 $C$ 是任意数字，所以我们可以写成：
$${S}_j=\frac{e^{a_j+D}}{{\sum }_{i=1}^N{e}^{a_k+D}}$$
其中 $D$ 是任意常数，这个公式和原本的 $S_j$ 是一样的，所以我们需要挑选一个 $D$ 使我们的计算在数值上更好（不要溢出）。一个比较好的选择就是对输入向量 $x$ 取其中的最大元素：
$$D=-max(a_1,a_2,\cdots ,a_N)$$

假设输入本身彼此之间不太远的话，这样可以把输入值全部“平移”到一个接近于零的范围。重要之处在于，这样把它们都变成了负数（当然最大的那个元素变成了0）。负的大指数会让式子的值最终变到0而不是无穷大，所以我们能更好地避免Nan。

代码如下

def stablesoftmax(x):
    """稳定的Softmax，防止溢出"""
    shiftx = x - np.max(x)
    exps = np.exp(shiftx)
    return exps / np.sum(exps)

现在代入数字试试：

In [150]: stablesoftmax([1000, 2000, 3000])
Out[150]: array([ 0.,  0.,  1.])

三、Softmax层及其导数

Softmax的常用于机器学习中，特别是在logistic回归中的Softmax层，我们将Softmax应用于完全连接层（矩阵乘法）的输出。



在这个图中，我们有一个有 $n$ 个特征的输入，和 $T$ 个可能的输出类。使用权值矩阵 $W$ 将 $x$ 转换为带有 $T$ 元素的向量（在机器学习中称为“Logits”），使用Softmax函数将Logits“坍塌”为一个概率向量，表示 $x$ 属于 $T$ 输出类中的每一个的概率。

我们如何计算这个“Softmax层”(全连接矩阵乘法后跟Softmax)的导数？当然是用链式法则！网上有很多关于这个公式的推导，但我想从基本原理入手，仔细地将多元链式法则应用到涉及到的函数的雅可比矩阵中。

在我们开始之前，有一点很重要:你可能认为 $x$ 是自变量，需要计算它的导数，但其实不是。事实上在机器学习中，我们要找到最优的权值矩阵 $W$ ，因此我们每一步梯度下降都要更新 $W$ ，因此，我们要计算这一层关于 $W$ 的导数。

我们先把这个式子写成向量函数的复合形式。首先我们做了一次矩阵乘法，记为 $g(W)$ ，因为输入是 $W_{N\times T}$ 输出是 $T$ ，所以是这样的结果 ：${\mathbb{R}}^{NT}{\mathbb{R}}^T$

接下来是Softmax，如果我们把对数向量表示为 $\lambda$ ，我们就有 $S(\lambda ):{\mathbb{R}}^T{\mathbb{R}}^T$ 。

综上我们就有了一个复合函数：
$$\begin{array}{rl}P(W)& =S(g(w))\\ & =(S\circ g)(W)\end{array}$$

应用链式法则，得到 $P(W)$ 的雅可比矩阵：
$$Dg=\left[\begin{array}{cccc}{D}_1{g}_1& \cdots & D_{NT}{g}_1& \\ ⋮& \ddots & ⋮& \\ D_1{g}_T& \cdots & D_{NT}{g}_T& \end{array}\right]$$

在某种意义上，权值矩阵 $W$ 被 线性化（linearize） 为一个长度为 $N\times T$ 的向量，如果您熟悉多维数组在内存的样子，那么应该很容易理解它是如何实现的。在我们的例子中，我们可以做的就是按行（row）的顺序将其线性化，即第一行算在一起的，然后是第二行诸如此类。在数学上，$W_{ij}$ 将会得到雅可比矩阵中的第 $(i-1)N+j$ 列的数字，至于 $Dg$ ，让我们回想一下 $g_1$是什么：
$$g1=W_{11}{x}_1+W_{12}{x}_2+\cdots +W_{1N}{x}_N$$

所以：
$$\begin{array}{rl}& \\ D_1{g}_1& =x_1\\ D_2{g}_1& =x_2\\ \cdots & \\ D_N{g}_1& =x_N\\ D_{N+1}{g}_1& =0\\ D_{NT}{g}_1& =0\end{array}$$

如果我们用相同的办法计算 $g_2\cdots g_T$ ，我们就得到了雅可比矩阵：
$$Dg=\left[\begin{array}{ccccccccc}{x}_1& x_2& \cdots & x_N& \cdots & 0& 0& \cdots & 0\\ ⋮& \ddots & \ddots & \ddots & \ddots & \ddots & \ddots & \ddots & ⋮\\ 0& 0& \cdots & 0& \cdots & x_1& x_2& \cdots & x_N\end{array}\right]$$

换个角度看，如果我们按照 $W_{ij}$ 分开看，就得到：
$$\begin{array}{rl}{D}_{ij}{g}_t& =\frac{\partial (W_{t1}{x}_1+W_{t2}{x}_2+\cdots +W_{tN}{x}_N)}{\partial W_{ij}}\\ & =\{\begin{array}{rlr}& x_j& i=t\\ & 0& i\ne t\end{array}\end{array}$$

这一项对应的是雅可比矩阵的第 $t$ 行，第 $(i-1)N+j$ 列。

最终$DS$ 和 $Dg$ 再做一次点积运算就得到了Softmax的完整的雅可比矩阵。注意 $P(W):{\mathbb{R}}^{NT}{\mathbb{R}}^T$ 符合雅可比矩阵的维度，因为 $DS$ 是 $T\times T$ 的而且 $Dg$ 是 $T\times NT$ ，所以它们点积就是 $T\times NT$。

在文献中，你会看到Softmax层的导数的一个非常简短的推导。这很好，因为所涉及的两个函数简单且众所周知。如果我们仔细计算 $DS$ 内的一行和 $Dg$ 内的一列的点积：
$$D_{ij}{P}_t=\sum _{k=1}^T{D}_k{S}_t\cdot D_{ij}{g}_k$$

$Dg$ 大部分是零，所以最终结果更简单。当且仅当 $i=k$ 时，$D_{ij}{g}_k$ 才不是0，所以：
$$\begin{array}{rl}& \\ D_{ij}{P}_t& =D_i{S}_t{x}_j\\ & =S_t({\delta }_{ti}-S_i)x_j\end{array}$$

所以完全有可能计算Softmax层的导数而不需要实际的雅可比矩阵乘法，这避免了昂贵的矩阵乘法。由于全连接层的雅可比矩阵是稀疏的，这样就避免了大部分的计算。

也就是说，我仍然觉得很重要的一点是展示这个导数是如何从复合函数雅可比矩阵的基本原理中产生的。这种方法的优点是，它适用于更复杂的复合函数，更复杂的复合函数意味着其中每个元素的导数的“封闭形式”如果用其他方法计算要困难得多。

四、Softmax 和交叉熵损失

我们已经看到Softmax函数是如何被用作神经网络的一部分，以及如何使用多元链式法则来计算它的导数。我们同样有必要看看与Softmax一起用于训练网络的一个损失函数：交叉熵（Cross Entropy）。

交叉熵有一个有趣的概率和信息理论解释，但这里我只关注他的运作特性。
对于两个离散的概率分布 $p$ 和 $q$ ，它们的交叉熵就是：
$$xent(p,q)=-\sum _{k}p(k)ln(q(k))$$
$k$ 代表这个分布所定义的随机变量的所有可能值，在我们的例子中有 $T$ 个输出类，所以 $k=1,2\cdots T$ 。

如果我们从Softmax的输出 $P$ 开始， $P$ 其实是一个概率分布[2]，另一个概率分布是真实的分类输出（也就是标签Label），通常用 $Y$ 表示， $Y$ 是一个 $1\times T$ 的one-hot向量，其中除了一个元素是1之外，所有元素都是0，值为1的元素表示模型预测的类别。

基于上面所述的情景，交叉熵损失公式就是：
$$xent(Y,P)=-\sum _{k=1}^{T}Y(k)ln(P(k))$$
$k$ 代表所有可能的输出类，$P(k)$ 为模型预测此输入属于这个类的概率，$Y(k)$ 是真实情况下，此输入属于这个类别的概率。我们用 $y$ 标记 $Y(k)$ 中唯一的、值为1的元素的下标。因为 $k\ne y$ 时， $Y(k)=0$ ，所以公式被化简为：
$$xent(P)=-ln(P(k))$$
交叉熵的雅可比矩阵是一个 $1\times T$ 的行向量，由于输入的 $P$ 也是 $1\times T$ 的，故：
$$Dxent(P)=\left[\begin{array}{cccc}{D}_{1}xent& D_{2}xent& \cdots & D_{T}xent\end{array}\right]$$
现在回想一下，$P$ 可以用输入的权值表示：$P(W)=S(g(W))$，所以：
$$xent(W)=(xent\circ P)(W)=xent(P(W))$$
我们可以再用链式法则来求xent的梯度：
$$Dxent(W)=D(xent\circ P)(W)=Dxent(P(W))\cdot DP(W)$$
我们来检验一下雅可比矩阵的维数是否成立。我们已经计算了 $DP(W{)}_{T\times NT}$ 和 $Dxent(P(W){)}_{1\times T}$ 所以结果雅可比矩阵是 $Dxent(W{)}_{1\times NT}$，结果成立，因为整个网络只有一个标量值输出（交叉熵损失）以及一个 $N\times T$ 的权值输入 $W$。

这里，有一个直接的方法化简 $Dxent(W)$，因为矩阵乘法中的很多元素最终消去了。注意 $xent(P)$ 只依赖于 $P$ 的第 $y$ 个元素，所以整个雅可比矩阵只有 $D_{y}xent\ne 0$ ：
$$Dxent(P)=\left[\begin{array}{ccccc}0& 0& D_{y}xent& \cdots & 0\end{array}\right]$$
其中 $D_{y}xent=-\frac{1}{P_y}$ 。

回到完整的雅可比矩阵，我们把 $Dxent(P)$ 乘以 $DP(W)$ 的每一列来得到结果行向量中的每一个元素，回想一下，行向量表示整个权值矩阵 $W$ 以行主序被“线性化”。下面公式中 $D_{ij}$ 表示行向量的第 $(i-1)N+j$ 个元素：
$$D_{ij}xent(W)=\sum _{k=1}^T{D}_{k}xent(P)\cdot D_{ij}{P}_k(W)$$
因为 $D_{k}xent(P)$ 只有第 $y$ 个元素是非零的，化简得到如下（代入上面化简的Softmax导数）：
$$\begin{gathered} \begin{array}{rl} \\ {D}_{ij}xent(W)& =D_{y}xent(P)\cdot D_{ij}{P}_y(W)\\ & =-\frac{1}{P_y}\cdot S_y({\delta }_{yi}-S_i)x_j\\ & =(S_i-{\delta }_{yi})x_j\end{array} \end{gathered}$$
根据定义，$P_y=S_y$，所以得到：
$$\begin{gathered} \begin{array}{rl} \\ {D}_{ij}xent(W)& =-\frac{1}{S_y}\cdot S_y({\delta }_{yi}-S_i)x_j\\ & =-({\delta }_{yi}-S_i)x_j\\ & =(S_i-{\delta }_{yi})x_j\end{array} \end{gathered}$$
再一次，即使在这种情况下，最终的结果是漂亮、干净，它不是必须这样，计算 $D_{ij}xent(W)$ 的公式最终可能是一个相当复杂的求和(或求和的求和)。雅可比矩阵乘法的技巧也许用不上，因为计算机可以为我们做所有的求和，我们所要做的就是计算各个函数的雅可比矩阵，这通常比较简单因为它们用于更简单的非复合函数，这就是链式法则的魅力和效用。

五、注释

[1] 为了更好地使用示例输入和Softmax输出，Michael Nielsen的在线书籍有一个很好的交互式Javascript可视化。

[2] 花一点时间回顾一下，根据定义，Softmax函数的输出确实是有效的离散概率分布。