面试中经常会问到损失函数的相关问题，本文推导了深度学习中常用损失函数的计算公式和反向传播公式，并使用numpy实现。

---

定义损失函数基类：

class Loss:
    
    def loss(self, predictions, targets):
        raise NotImplementedError
    
    def grad(self, predictions, targets):
        raise NotImplementedError

定义损失函数中会用到的数学函数

def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))


def softmax(x, dim=-1):
    x_max = np.max(x, axis=dim, keepdims=True)
    # 减去最大值，防止上溢
    x_exp = np.exp(x - x_max)
    return x_exp / np.sum(x_exp, axis=dim, keepdims=True)


def log_softmax(x, dim=-1):
    x_max = np.max(x, axis=dim, keepdims=True)
    x_exp = np.exp(x - x_max)
    exp_sum = np.sum(x_exp, axis=dim, keepdims=True)
    return x - x_max - np.log(exp_sum)


def one_hot(labels, n_classes):
    return np.eye(n_classes)[labels.reshape(-1)]

MAE

平均绝对误差（Mean Absolute Error）：模型预测值$y$和真实值$\hat{y}$之间距离的平均值
$$loss=\frac{1}{n}\sum _i|y_i-{\hat{y}}_i|$$

$$grad=\frac{1}{n}sign(y-\hat{y})$$

class MAE(Loss):

    def loss(self, predictions, targets):
        return np.sum(np.abs(predictions - targets)) / targets.shape[0]

    def grad(self, predictions, targets):
        return np.sign(predictions - targets) / targets.shape[0]

MSE

均方差损失（Mean Squared Error Loss)：模型预测值$y$和真实值$\hat{y}$之间差值平方的平均值
$$loss=\frac{1}{2n}\sum _i||y_i-{\hat{y}}_i|{|}^2$$

$$grad=\frac{1}{n}(y-\hat{y})$$

class MSE(Loss):

    def loss(self, predictions, targets):
        return 0.5 * np.sum((predictions - targets) ** 2) / targets.shape[0]

    def grad(self, predictions, targets):
        return (predictions - targets) / targets.shape[0]

Huber Loss

结合了MAE和MSE的优点，也被称为 Smooth Mean Absolute Error

在误差较小时使用MSE，误差较大时使用MAE
$$loss=\frac{1}{n}\{\begin{array}{rl}& 0.5\ast \sum _i||y_i-{\hat{y}}_i|{|}^2,|y_i-\hat{y}|<\delta \\ & \sum _i\delta |y_i-{\hat{y}}_i|-0.5\ast {\delta }^2,otherwise\end{array}$$

$$grad=\frac{1}{n}\{\begin{array}{rl}& y-\hat{y},|y-\hat{y}|<\delta \\ & \delta sign(y-\hat{y}),otherwise\end{array}$$

---

MAE, MSE, Huber Loss函数曲线

class HuberLoss(Loss):

    def __init__(self, delta=1.0):
        self.delta = delta

    def loss(self, predictions, targets):
        dist = np.abs(predictions - targets)
        l2_mask = dist < self.delta
        l1_mask = ~l2_mask
        l2_loss = 0.5 * (predictions - targets) ** 2
        l1_loss = self.delta * dist - 0.5 * self.delta ** 2
        total_loss = np.sum(l2_loss * l2_mask + l1_loss * l1_mask) / targets.shape[0]
        return total_loss

    def grad(self, predictions, targets):
        error = predictions - targets
        l2_mask = np.abs(error) < self.delta
        l1_mask = ~l2_mask
        l2_grad = error
        l1_grad = self.delta * np.sign(error)
        total_grad = l2_grad * l2_mask + l1_grad * l1_mask
        return total_grad / targets.shape[0]

Cross Entropy Loss

熵

熵定义为：信息的数学期望。
$$H=-\sum _{i}p(x_i)log(p(x_i))$$
KL散度

KL散度（Kullback-Leibler Divergence）也叫做相对熵，用于度量两个概率分布之间的差异程度，p相对q的KL散度为
$$D_q(p)=H_q(p)-H(p)=\sum _{x}plog(p)-plog(q)$$
交叉熵

预测概率分布q与真实概率分布p的差异
$$H_q(p)=-\sum _{x}plog(q)$$
详细推导：
$$loss=-\frac{1}{N}\sum _{i=1}^N\sum _{k=1}^K{\hat{y}}_i^k\cdot log\_softmax(y_i^k)=-\sum _{i=1}^{N}log\_softmax(y_i^c)$$
$y^c$是标签，$\hat{y}$是标签的独热编码，$y$是预测概率向量，向量长度等于$y$的类别$K$

化简：
$$CE=-log\_softmax(y^c)=-log(\frac{exp(y^c)}{{\sum }_{k=1}^{K}exp(y^k)})=-y^c+log(\sum _{k=1}^{K}exp(y^k))$$

求导：
$$grad=\frac{1}{N}\sum _{i=1}^N\frac{\partial C{E}_i}{\partial y_i}=\frac{1}{N}\sum _{i=1}^{N}softmax(y_i)-{\hat{y}}_i$$

class CrossEntropy(Loss):

    def loss(self, predictions, targets):
        # targets是one-hot向量
        ce = -log_softmax(predictions, dim=1) * targets
        return np.sum(ce) / targets.shape[0]

    def grad(self, predictions, targets):
        logits = softmax(predictions, dim=1)
        return (logits - targets) / targets.shape[0]

上面的代码中不同类别的权重是相等的，如果不同类别的样本数量差异过大，可以调整不同类别的权重。

顺便实现一下KL散度

注意，交叉熵的标签是one-hot向量，KL散度的标签是概率分布向量

下面是更通用的推导，$\hat{y}$是概率向量，${\sum }_{k=1}^K{\hat{y}}^k=1$
$$CE=-\sum _{k=1}^K{\hat{y}}^{k}log\_softmax(y^c)=-\sum _{k=1}^K{\hat{y}}^{k}log(\frac{exp(y^k)}{{\sum }_{k=1}^{K}exp(y^k)})=-\sum _{k=1}^K[y_i^k-log(\sum _{k=1}^{K}exp(y^k))]\cdot {\hat{y}}_i^k=log(\sum _{k=1}^{K}exp(y^k))-\sum _{k=1}^K{y}_i^k\cdot {\hat{y}}_i^k$$

$$grad=\frac{1}{N}\sum _{i=1}^N\frac{\partial C{E}_i}{\partial y_i}=\frac{1}{N}\sum _{i=1}^{N}softmax(y_i)-{\hat{y}}_i$$

class KLDivLoss(Loss):

    def loss(self, predictions, targets):
        # targets是概率向量
        ce = (log_softmax(targets) - np.log(predictions)) * targets
        return np.sum(ce) / targets.shape[0]

    def grad(self, predictions, targets):
        logits = softmax(predictions, dim=1)
        return (logits - targets) / targets.shape[0]

---

扩展：

为什么在分类任务中，用交叉熵而不是MSE？

以Logistic Regression为例，分别用交叉熵和MSE推导反向传播过程
$$f_{w,b}(x)=\sigma (\sum _i{w}_i{x}_i+b)$$
其中，$\sigma$是Sigmoid激活函数，f是预测值，0 < f(x) < 1

1.交叉熵
L = − [ y l n ( f ( x ) ) + ( 1 − y ) l n ( 1 − f ( x ) ) ] y ∈ { 0 , 1 } L = -[yln(f(x)) + (1-y)ln(1-f(x))] \quad y \in \{0,1\} L=−[yln(f(x))+(1−y)ln(1−f(x))]y∈{0,1}
反向传播：
$$\frac{\partial L(w,b)}{\partial w}=-[y\frac{\partial ln(f(x))}{\partial w}+(1-y)\frac{\partial (1-ln(f(x)))}{\partial w}]$$
令 $z=wx+b$，
$$\frac{\partial ln(f(x))}{\partial z}=\frac{\partial ln(\sigma (z))}{\partial z}=1-\sigma (z)\frac{\partial (1-ln(f(x)))}{\partial w}=-\sigma (z)$$

$$\frac{\partial L(w,b)}{\partial z}\frac{\partial z}{\partial w}=-[y(1-\sigma (z))+(1-y)(-\sigma (z))]\frac{\partial z}{\partial w}=-(y-\sigma (z))x$$

梯度下降：
$$w_t=w_{t-1}-\eta \sum _i(-(y_i-\sigma (wx+b))x_i)$$

• 当标签$y$和预测值$f(x)$差距越大，梯度越大，下降的越快

2.MSE
L = 1 2 ( f ( x ) − y ) 2 y ∈ { 0 , 1 } L = \frac{1}{2}(f(x) - y)^2 \quad y \in \{0,1\} L=21​(f(x)−y)2y∈{0,1}
反向传播：
$$\frac{\partial L(w,b)}{\partial w}=(f(x)-y)\frac{\partial f(x)}{\partial w}$$
同令 $z=wx+b$，
$$\frac{\partial f(x)}{\partial z}\frac{\partial z}{\partial w}=\sigma (z)(1-\sigma (z))x$$

$$\frac{\partial L(w,b)}{\partial w}=(f(x)-y)f(x)(1-f(x))x$$

• 当$y=0$，$f(x)$趋近1时，因为有$1-f(x)$这一项，梯度会消失，然而预测是完全错误的
• 当$y=1$，$f(x)$趋近0时，因为有$f(x)$这一项，梯度也会消失，预测完全错误

总结：

​交叉熵损失函数关于输入权重的梯度表达式与预测值与真实值的误差成正比且不含激活函数的梯度，而均方误差损失函数关于输入权重的梯度表达式中则含有，由于常用的sigmoid/tanh等激活函数存在梯度饱和区，使得MSE对权重的梯度会很小，参数w调整的慢，训练也慢，而交叉熵损失函数则不会出现此问题，其参数w会根据误差调整，训练更快，效果更好。

---

参考资料：

borgwang/tinynn: A lightweight deep learning library