最近正值秋招季，很多同学都在忙着温习深度学习相干的基础知识应答面试和口试。这段时间，正好发现自己基础知识也比拟单薄，想系统性的温习和整顿一下。基于这样一个出发点，最近筹备开始一个名为【CV知识点扫盲】的专题文章，帮忙本人和更多人温习计算机视觉中的基础知识，也心愿可能对正在找工作的同学有帮忙。

1、 机器学习中常见的损失函数及其利用场景？

用于分类问题：

0-1损失函数：

$$L_{0-1}(f, y)=1_{f y \leq 0}$$

0-1损失函数能够直观的刻画分类的错误率，然而因为其非凸，非润滑的特点，使得算法很难对其进行间接优化

Hinge损失函数(SVM)

$$L_{\text {hinge }}(f, y)=\max \{0,1-f y\}$$

Hinge损失函数是0-1损失函数的一个代理损失函数，也是其紧上界，当$f y \geq 0$ 时，不对模型做惩办。能够看到，hinge损失函数在$f y=1$处不可导，因而不能用梯度降落法对其优化，只能用次梯度降落法。

Logistic损失函数

$$L_{\text {logistic }}(f, y)=\log _{2}(1+\exp (-f y))$$

Logistic损失函数是0-1损失函数的另一个代理损失函数，它也是0-1损失函数的凸上界，且该函数处处润滑。然而该损失函数对所有样本点都惩办，因而对异样值更加敏感。当预测值$ f ∈ [ − 1 , 1 ] $时，另一个罕用的代理损失函数是穿插熵损失函数

Cross-Entropy损失函数

$$L_{\text {cross entropy }}(f, y)=-\log _{2}\left(\frac{1+f y}{2}\right)$$

穿插熵损失函数也是0-1损失函数的润滑凸上界

Exponential损失函数(AdaBoost)

$$L_{\text {exponential }}(f, y)=e^{-f y}$$

指数损失函数是AdaBoost里应用的损失函数，同样地，它对异样点较为敏感，鲁棒性不够

Logistic损失函数(LR)

$$L_{\text {logloss }}(y, p(y \mid x))=-\log (p(y \mid x))$$

逻辑回归$ p ( y ∣ x ) $的表达式如下：

$$P\left(Y=y^{(i)} \mid x^{(i)}, \theta\right)=\left\{\begin{array}{l}h_{\theta}\left(x^{(i)}\right)=\frac{1}{1+e^{\theta_{x}}}, y^{(i)}=1 \\ 1-h_{\theta}\left(x^{(i)}\right)=\frac{e^{\theta^{T_{x}}}}{1+e^{\theta_{x}}}, y^{(i)}=0,\end{array}\right.$$

将下面两个式子合并，可得第 i 个样本被正确预测的概率：

$$P\left(Y=y^{(i)} \mid x^{(i)}, \theta\right)=\left(h_{\theta}\left(x^{(i)}\right)\right)^{y^{(i)}}\left(1-h_{\theta}\left(x^{(i)}\right)\right)^{1-y^{(i)}}$$

对于所有的样本，因为生成过程是独立的，因而

$$P(Y \mid X, \theta)=\Pi_{i=1}^{N}\left(h_{\theta}\left(x^{(i)}\right)\right)^{y^{(i)}}\left(1-h_{\theta}\left(x^{(i)}\right)\right)^{1-y^{(i)}}$$

最终的损失函数如下：

$$\mathcal{J}(\theta)=-\sum_{i=1}^{N}\left[y^{(i)} \log \left(h_{\theta}\left(x^{(i)}\right)\right)+\left(1-y^{(i)}\right) \log \left(1-h_{\theta}\left(x^{(i)}\right)\right)\right]$$

用于回归问题：

对于回归问题，$Y=\mathbb{R}$，咱们心愿$f\left(x^{(i)}, \theta\right)=y^{(i)}$

平方损失函数(最小二乘法)

$$L_{\text {square }}(f, y)=(f-y)^{2}$$

平方损失函数是润滑的，能够用梯度降落法求解，然而，当预测值和实在值差别较大时，它的惩办力度较大，因而对异样点较为敏感。

相对损失函数

$$L_{\text {absolute }}(f, y)=|f-y|$$

相对损失函数对异样点不那么敏感，其鲁棒性比平方损失更强一些，然而它在$f=y$处不可导

Huber损失函数

$$L_{H u b e r}(f, y)=\left\{\begin{array}{l}\frac{1}{2}(f-y)^{2},|f-y| \leq \delta \\ \delta|f-y|-\frac{1}{2} \delta^{2},|f-y|>\delta,\end{array}\right.$$

Huber损失函数在 ∣ f − y ∣较小时为平方损失，在 ∣ f − y ∣ 较大时为线性损失，且处处可导，对异样点鲁棒性较好。

Log-cosh损失函数

$$L_{\log -\cosh }(f, y)=\log (\cosh (f-y))$$

其中 $\cosh (x)=\left(e^{x}+e^{-x}\right) / 2$，log-cosh损失函数比均方损失函数更加润滑，具备huber损失函数的所有长处，且二阶可导。因而能够应用牛顿法来优化计算，然而在误差很大状况下，一阶梯度和Hessian会变成定值，导致牛顿法生效。

分位数损失函数

$$L_{\gamma}(f, y)=\sum_{i: y_{i}<f_{i}}(1-\gamma)\left|y_{i}-f_{i}\right|+\sum_{i: y_{i} \geq f_{i}} \gamma\left|y_{i}-f_{i}\right|$$

预测的是指标的取值范畴而不是值。 是所需的分位数，其值介于0和1之间， 等于0.5时，相当于MAE。设置多个 值，失去多个预测模型，而后绘制成图表，即可晓得预测范畴及对应概率(两个 值相减)

用于检索问题

Triplet loss

$$\sum_{i}^{N}\left[\left\|f\left(x_{i}^{a}\right)-f\left(x_{i}^{p}\right)\right\|_{2}^{2}-\left\|f\left(x_{i}^{a}\right)-f\left(x_{i}^{n}\right)\right\|_{2}^{2}+\alpha\right]_{+}$$

[]\_+相当于一个ReLU函数。三元组的形成：从训练数据集中随机选一个样本，该样本称为Anchor，而后再随机选取一个和Anchor属于同一类的样本和不同类的样本,这两个样本对应的称为Positive 和Negative，由此形成一个三元组。

通过学习，让正样本特色表白之间的间隔尽可能小，而负样本的特色表白之间的间隔尽可能大，并且要让正样本之间的间隔和负样本之间的间隔之间有一个最小的距离（margin）。 损失函数如下所示：

Sum Hinge Loss & Max Hinge Loss

Triplet loss 的输出是 (a, p, n)，个别的做法是 b 个$\left(a_{i}, p_{i}\right) i \in[0, b]$pair 对，咱们对 pi 旋转一下失去$\left(p_{1}, p_{2}, \ldots, p_{b}, p_{0}\right)$作为负样本列表。最初失去一个一维的 loss 向量$\left(l_{1}, l_{2} \ldots, l_{b}\right)$。

Triplet loss 实际上只思考了由 a 和 p 组成矩阵的局部状况产生的loss，咱们实际上能够对 a、p 产生的类似度矩阵中所有非对角线的负样本进行计算损失，从而充分利用 batch 内的信息，通过这个思路咱们能够失去 Sum Hinge Loss 如下，Triplet loss 的计算中是用的 L2 间隔，这里改为了余弦类似度，所以之前的 ap - an + margin，改为了 an - ap + margin 了，指标是让 an 的类似度更小，ap 的类似度更大

Sum Hinge Loss：

$$\ell_{S H}(i, c)=\sum_{\hat{c}}[\alpha-s(i, c)+s(i, \hat{c})]{+}+\sum{\hat{i}}[\alpha-s(i, c)+s(\hat{i}, c)]_{+}$$

Max Hinge Loss：

VSE++ 提出了一个新的损失函数max hinge loss，它主张在排序过程中应该更多地关注艰难负样例，艰难负样本是指与anchor靠得近的负样本，试验后果也显示max hinge loss性能比之前罕用的排序损失sum hinge loss好很多：

$$\ell_{M H}(i, c)=\max {c^{\prime}}\left[\alpha+s\left(i, c^{\prime}\right)-s(i, c)\right]{+}+\max {i^{\prime}}\left[\alpha+s\left(i^{\prime}, c\right)-s(i, c)\right]{+}$$

Max Hinge Loss pytorch 代码如下：

def cosine_sim(im, s):    """Cosine similarity between all the image and sentence pairs    """    return im.mm(s.t())class MaxHingLoss(nn.Module):    def __init__(self, margin=0.2, measure=False, max_violation=True):        super(MaxHingLoss, self).__init__()        self.margin = margin        self.sim = cosine_sim        self.max_violation = max_violation    def forward(self, im, s):        an = self.sim(im, s) # an        diagonal = scores.diag().view(im.size(0), 1)        ap1 = diagonal.expand_as(scores)        ap2 = diagonal.t().expand_as(scores)        # query2doc retrieval        cost_s = (self.margin + an - ap1).clamp(min=0)        # doc2query retrieval        cost_im = (self.margin + an - ap2).clamp(min=0)        # clear diagonals        mask = torch.eye(scores.size(0)) > .5        I = Variable(mask)        if torch.cuda.is_available():            I = I.cuda()        cost_s = cost_s.masked_fill_(I, 0)        cost_im = cost_im.masked_fill_(I, 0)        # keep the maximum violating negative for each query        if self.max_violation:            cost_s = cost_s.max(1)[0][:1]            cost_im = cost_im.max(0)[0][:1]        return cost_s.mean() + cost_im.mean()        # or # return cost_s.sum() + cost_im.sum()

Info NCE

Info NCE loss是NCE的一个简略变体，它认为如果你只把问题看作是一个二分类，只有数据样本和噪声样本的话，可能对模型学习不敌对，因为很多噪声样本可能本就不是一个类，因而还是把它看成一个多分类问题比拟正当（但这里的多分类 k 指代的是负采样之后负样本的数量），于是就有了InfoNCE loss 函数如下：

$$L_{q}=-\log \frac{\exp \left(q \cdot k_{+} / \tau\right)}{\left.\sum_{i=0}^{k} \exp \left(q \cdot k_{i} / \tau\right)\right)}$$

其中$q \cdot k$相当于是 logits， $\tau$是温度系数，整体和 cross entropy 是十分相近的。

用于检测问题：

类别损失

Softmax+穿插熵

对于二分类而言，穿插熵损失函数模式如下：

$$\mathrm{L}=-\mathrm{ylog} y^{\prime}-(1-y) \log \left(1-y^{\prime}\right)=\left\{\begin{array}{ll}-\log y^{\prime}, & y=1 \\ -\log \left(1-y^{\prime}\right), & y=0\end{array}\right.$$

穿插熵损失函数通过一直放大两个散布的差别，使预测后果更牢靠。

Focal Loss

focal loss出于论文Focal Loss for Dense Object Detection，次要是为了解决one-stage指标检测算法中正负样本比例重大失衡的问题，升高了大量简略负样本在训练中所占的比重，可了解为是一种艰难样本开掘。focal loss是在穿插熵损失函数上批改的。具体改良：

$$\mathrm{L}_{f l}=\left\{\begin{array}{cc}-\alpha\left(1-y^{\prime}\right)^{\gamma} \log y^{\prime}, & y=1 \\ -(1-\alpha) y^{\prime \gamma} \log \left(1-y^{\prime}\right), & y=0\end{array}\right.$$

其中>0(文章中取2）使得缩小易分类样本的损失，更关注艰难的、错分的样本。例如为2，对于正类样本而言，预测后果为0.95必定是简略样本，所以（1-0.95）的次方就会很小，这时损失函数值就变得更小。而预测概率为0.3的样本其损失绝对很大。对于负类样本而言同样，预测0.1的后果该当远比预测0.7的样本损失值要小得多。对于预测概率为0.5时，损失只缩小了0.25倍，所以更加关注于这种难以辨别的样本。这样缩小了简略样本的影响，大量预测概率很小的样本叠加起来后的效应才可能比拟无效。
此外退出均衡因子，用来均衡正负样本自身的比例不均，文中取值为0.25，即正样本比负样本占比小，这是因为负例易分

地位损失

L1（MAE），L2（MSE），smooth L1损失函数

利用L1，L2或者smooth L1损失函数，来对4个坐标值进行回归。smooth L1损失函数是在Fast R-CNN中提出的。三个损失函数，如下所示：

$$L 1=|x|\\L 2=x^{2}\\smoothL1 =\left\{\begin{array}{cc}0.5 x^{2} & \text { if }|x|<1 \\ |x|-0.5 & \text { otherwise }\end{array}\right.$$

从损失函数对x的导数可知：L1损失函数对x的导数为常数，不会有梯度爆炸的问题，但其在0处不可导，在较小损失值时，失去的梯度也绝对较大，可能造成模型震荡不利于收敛。L2损失函数处处可导，但因为采纳平方运算，当预测值和实在值的差值大于1时，会放大误差。尤其当函数的输出值间隔核心值较远的时候，应用梯度降落法求解的时候梯度很大，可能造成梯度爆炸。同时当有多个离群点时，这些点可能占据Loss的次要局部，须要就义很多无效的样本去弥补它，所以L2 loss受离群点的影响较大。smooth L1完满的避开了L1和L2损失的毛病：

  • 在[-1,1]之间就是L2损失，解决L1在0处有折点
  • 在[-1，1]区间以外就是L1损失，解决离群点梯度爆炸问题
  • 当预测值与实在值误差过大时，梯度值不至于过大
  • 当预测值与实在值误差很小时，梯度值足够小

上述3个损失函数存在以下有余：

  • 上述三个损失函数在计算bounding box regression loss时，是独立的求4个点的loss，而后相加失去最终的损失值，这种做法的前提是四个点是互相独立的，而实际上是有肯定相关性的
  • 理论评估检测后果好坏的指标是IoU，这两者是不等价的，多个检测框可能有雷同的loss，但IoU差别很大
IoU Loss

IoU loss的定义如下：

$$L_I= 1-\frac{P \cap G}{P \cup G}$$

其中P代表预测框，G代表实在框。

GIoU loss

IoU反映了两个框的重叠水平，在两个框不重叠时，IoU衡等于0，此时IoU loss恒等于1。而在指标检测的边界框回归中，这显然是不适合的。因而，GIoU loss在IoU loss的根底上思考了两个框没有重叠区域时产生的损失。具体定义如下：

$$L_{G}=1-I o U+R(P, G)=1-I o U+\frac{|C-P \cup G|}{|C|}$$

其中，C示意两个框的最小突围矩形框，R(P,G)是惩办项。从公式能够看出，当两个框没有重叠区域时，IoU为0，但R仍然会产生损失。极限状况下，当两个框间隔无穷远时，R→1

DIoU Loss

IoU loss和GIoU loss都只思考了两个框的重叠水平，但在重叠水平雷同的状况下，咱们其实更心愿两个框能挨得足够近，即框的核心要尽量凑近。因而，DIoU在IoU loss的根底上思考了两个框的中心点间隔，具体定义如下：

$$L_{G}=1-I o U+R(P, G)=1-I o U+\frac{\rho^{2}(p, g)}{c^{2}}$$

其中，示意预测框和标注框核心端的间隔，p和g是两个框的中心点。c示意两个框的最小突围矩形框的对角线长度。当两个框间隔有限远时，中心点间隔和外接矩形框对角线长度有限迫近，R→1。

CIoU Loss

DIoU loss思考了两个框中心点的间隔，而CIoU loss在DIoU loss的根底上做了更具体的度量，具体包含：

  • 重叠面积
  • 中心点间隔
  • 长宽比

具体定义如下：

$$L_{G}=1-I o U+R(P, G)=1-I o U+\frac{\rho^{2}(p, g)}{c^{2}}+\alpha v$$

$$v=\frac{4}{\pi^{2}}\left(\arctan \frac{w^{g}}{h^{g}}-\arctan \frac{w^{p}}{h^{p}}\right)^{2}\\\alpha=\frac{v}{(1-I o U)+v}$$

用于宰割问题

dice Loss

dice loss 源于dice系数，是用于度量汇合类似度的度量函数，通常用于计算两个样本之间的类似度，公式如下：

$$Dice =\frac{2|\mathrm{X} \cap Y|}{|X|+|Y|}$$

那么对应的dice loss的公式如下：

$$Dice loss =1-\frac{2|\mathrm{X} \cap Y|}{|X|+|Y|}$$

依据dice loss的定义能够看出，dice loss是一种区域相干的loss，也即意味着某像素点的loss以及梯度值不仅和该点的label和预测值相干，也与其余点的label及预测值相干。dice loss可用于样本极度不平衡的状况，而在个别状况下应用dice loss会对反向流传有不利的影响，使得训练不稳固。

穿插熵

语义宰割工作中最罕用的损失函数是穿插熵，通过一一比照每个像素失去损失值。

每个像素对应的损失函数为：

$$pixel - loss =-\sum_{\text {classes }}\left(y_{c} \log \left(p_{c}\right)\right)$$

$y_{c}$为一个one-hot向量，取值只有[0, 1]，$p_c$为网络预测值通过softmax或sigmoid函数之后的概率值。

整个图像的损失就是每个像素的损失求均匀。穿插熵损失函数实用于大多数语义宰割场景中，然而当前景像素的数量远小于背景像素的数量时，此时背景的损失占主导地位，导致网络性能不佳。

带权值的穿插熵

针对类别不均衡的问题，通过给每个类别增加一个权重系数来缓解。加上权重之后的公式如下：

$$pixel - loss =-\sum_{c}^{\text {classes }}\left(w_{c} y_{c} \log \left(p_{c}\right)\right)$$

其中$w_{c}=\frac{N-N_{c}}{N}$，$N$示意总的像素个数，而$N_c$示意GT类别为c的像素个数。

2、为什么不能将辨认精度作为指标？

以数字辨认工作为例，咱们想取得的是能进步辨认精度的参数，特意再导入一个损失函数不是有些重复劳动吗？也就是说，既然咱们的指标是取得使辨认精度尽可能高的神经网络，那不是应该把辨认精度作为指标吗？

在进行神经网络的学习时，不能将辨认精度作为指标，因为如果以辨认精度为指标，导数大多数状况下都为0。导数为0会导致权重参数的更新会停下来。

3、 为什么LogSoftmax比Softmax更好？

log\_softmax可能解决函数overflow和underflow，放慢运算速度，进步数据稳定性。

因为softmax会进行指数操作，当上一层的输入，也就是softmax的输出比拟大的时候，可能就会产生overflow。同理当输出为正数且绝对值也很大的时候，会分子、分母会变得极小，有可能四舍五入为0，导致下溢出。

只管在数学示意式上是对softmax在取对数的状况。然而在实操中是通过：

$$\log \left[f\left(x_{i}\right)\right]=\log \left(\frac{e^{x_{i}}}{e^{x_{1}}+e^{x_{2}}+\ldots+e^{x_{n}}}\right)\\=\log \left(\frac{\frac{e^{x_{i}}}{e^{M}}}{\frac{e^{x_{1}}}{e^{M}}+\frac{e^{2}}{e^{M}}+\ldots+\frac{e^{x_{n}}}{e^{M}}}\right)=\log \left(\frac{e^{\left(x_{i}-M\right)}}{\sum_{j}^{n} e^{\left(x_{j}-M\right)}}\right)\\=\log \left(e^{\left(x_{i}-M\right)}\right)-\log \left(\sum_{j}^{n} e^{\left(x_{j}-M\right)}\right)=\left(x_{i}-M\right)-\log \left(\sum_{j}^{n} e^{\left(x_{j}-M\right)}\right)$$

来实现，其中 $M=\max \left(x_{i}\right), i=1,2, \cdots, n$，即 M为所有$x_{i}$中最大的值。能够解决这个问题，在放慢运算速度的同时，能够放弃数值的稳定性。

4、 什么是label smoothing？为什么要用label smoothing？

label smoothing是一种正则化的形式，全称为Label Smoothing Regularization(LSR)，即标签平滑正则化。

在传统的分类工作计算损失的过程中，是将实在的标签做成one-hot的模式，而后应用穿插熵来计算损失。而label smoothing是将实在的one hot标签做一个标签平滑解决，使得标签变成又概率值的soft label.其中，在实在label处的概率值最大，其余地位的概率值是个十分小的数。

在label smoothing中有个参数epsilon，形容了将标签软化的水平，该值越大，通过label smoothing后的标签向量的标签概率值越小，标签越平滑，反之，标签越趋向于hard label，在训练ImageNet-1k的试验里通常将该值设置为0.1。

5、在用sigmoid或softmax作为激活函数的时候，为什么要用穿插熵损失函数，而不必均方误差损失函数？

1. 因为穿插熵损失函数能够完满解决平方损失函数权重更新过慢的问题，具备“误差大的时候，权重更新快；误差小的时候，权重更新慢”的良好性质。
2. sigmoid作为激活函数的时候，如果采纳均方误差损失函数，那么这是一个非凸优化问题，不宜求解。而采纳穿插熵损失函数仍然是一个凸优化问题，更容易优化求解。

公式推导详解见：https://blog.csdn.net/weixin\_41888257/article/details/104894141

6、 对于穿插熵损失函数（Cross-entropy）和 平方损失（MSE）的区别？

1. 概念区别

均方差损失函数（MSE）：简略来说，均方误差（MSE）的含意是求一个batch中n个样本的n个输入与冀望输入的差的平方的平均值。

Cross-entropy（穿插熵损失函数)：穿插熵是用来评估以后训练失去的概率分布与实在散布的差别状况。它刻画的是理论输入（概率）与冀望输入（概率）的间隔，也就是穿插熵的值越小，两个概率分布就越靠近。

2. 利用场景

MSE更适宜回归问题，穿插熵损失函数更适宜分类问题。

7、什么是KL散度？

KL散度定义

KL(Kullback-Leibler divergence)散度多利用于概率论或信息论中，又可称绝对熵(relative entropy)。它是用来形容两个概率分布P和Q的差别的一种办法。

KL具备非对称性，即D(P||Q) ≠ D(Q||P)。
在信息论中，D(P||Q) 示意用概率分布Q来拟合实在散布P时，产生的信息损耗，其中P示意实在散布，Q示意P的拟合散布

KL散度公式定义

对于离散型随机变量有：

$$\mathrm{D}(\mathrm{P} \| \mathrm{Q})=\sum_{i \in X} P(i) *\left[\log \left(\frac{P(i)}{Q(i)}\right)\right]$$

对于连续型随机变量有：

$$\mathrm{D}(\mathrm{P} \| \mathrm{Q})=\int_{x} P(x) *\left[\log \left(\frac{P(i)}{Q(i)}\right)\right] d x$$

KL散度的物理定义

在信息论中，它是用来度量应用基于Q散布的编码来编码来自P散布的样本均匀所需的额定的比特(bit)个数。
在机器学习畛域，是用来度量两个函数的类似水平或者相近水平。

8、手写IOU、GIOU、DIOU、CIOU的代码

IOU代码及后果展现如下

import cv2import numpy as npdef IOU_score(box1,box2):        """        计算两个区域的iou的值        para: box1 区域1的两个角的坐标值  x1,y1,x2,y2        para: box2 区域2的两个角的坐标值  x1,y1,x2,y2        """        # 两个框的交        iou_x1 = max(box1[0], box2[0])        iou_y1 = max(box1[1], box2[1])        iou_x2 = min(box1[2], box2[2])         iou_y2 = min(box1[3], box2[3])        # 下面求进去的为交加的两个角的坐标        area_inter = max(0,(iou_x2 - iou_x1)) * max(0 , (iou_y2 - iou_y1))        # 计算两个区域的并集        area_all = ((box1[2] - box1[0]) * (box1[3] - box1[1])) + ((box2[2] - box2[0]) * (box2[3] - box2[1])) - area_inter                center_x = int((iou_x1 + iou_x2) / 2)        center_y = int((iou_y2 + iou_y1) / 2)        return float(area_inter / area_all) , (center_x,center_y)def main():    img = np.zeros((512,512,3), np.uint8)       img.fill(255)    box1 = [50,50,300,300]    box2 = [51,51,301,301]    cv2.rectangle(img, (box1[0],box1[1]), (box1[2],box1[3]), (0, 0, 255), 2)    cv2.rectangle(img, (box2[0],box2[1]), (box2[2],box2[3]), (255, 0, 0), 2)    IOU , center = IOU_score(box1,box2)    font = cv2.FONT_HERSHEY_SIMPLEX    cv2.putText(img,"IOU = %.2f"%IOU,center,font,0.8,(0,0,0),2)    cv2.imshow("image",img)    cv2.waitKey()    cv2.destroyAllWindows()if __name__ == "__main__":    main()

GIOU代码及后果展现如下

import cv2import numpy as npdef GIOU_score(box1,box2):        """        计算两个区域的iou的值        para: box1 区域1的两个角的坐标值  x1,y1,x2,y2        para: box2 区域2的两个角的坐标值  x1,y1,x2,y2        """        # 两个框的交        iou_x1 = max(box1[0], box2[0])        iou_y1 = max(box1[1], box2[1])        iou_x2 = min(box1[2], box2[2])         iou_y2 = min(box1[3], box2[3])        g_iou_x1 = min(box1[0], box2[0])         g_iou_y1 = min(box1[1], box2[1])        g_iou_x2 = max(box1[2], box2[2])         g_iou_y2 = max(box1[3], box2[3])        # 下面求进去的为交加的两个角的坐标        area_inter = max(0,(iou_x2 - iou_x1)) * max(0 , (iou_y2 - iou_y1))        # 计算两个区域的并集        area_union = max(0,((box1[2] - box1[0]) * (box1[3] - box1[1])) + ((box2[2] - box2[0]) * (box2[3] - box2[1])) - area_inter)        # 计算最小外接矩形        area_all = max(0,(g_iou_x2 - g_iou_x1) * (g_iou_y2 - g_iou_y1))        g_iou = max(0,area_inter/area_union) - max(0,area_all - area_union) / area_all         return float(g_iou) , (iou_x1,iou_y1,iou_x2,iou_y2) , (g_iou_x1,g_iou_y1,g_iou_x2,g_iou_y2)def main():    img = np.zeros((512,512,3), np.uint8)       img.fill(255)    box1 = [50,50,300,300]    box2 = [100,100,400,400]    IOU , area_inter , area_all = GIOU_score(box1,box2)    font = cv2.FONT_HERSHEY_SIMPLEX    cv2.putText(img,"GIOU = %.2f"%IOU,(area_inter[0]+30,area_inter[1]+30),font,0.8,(0,0,0),2)    cv2.rectangle(img, (box1[0],box1[1]), (box1[2],box1[3]), (255, 0, 0),  thickness = 3)    cv2.rectangle(img, (box2[0],box2[1]), (box2[2],box2[3]), (0, 255, 0), thickness = 3)    cv2.rectangle(img, (area_all[0],area_all[1]), (area_all[2],area_all[3]), (0, 0, 255), thickness = 3)        cv2.imshow("image",img)    cv2.waitKey()    cv2.destroyAllWindows()if __name__ == "__main__":    main()

DIOU代码及后果展现如下

import cv2import numpy as npdef DIOU_score(box1,box2):        """        计算两个区域的iou的值        para: box1 区域1的两个角的坐标值  x1,y1,x2,y2        para: box2 区域2的两个角的坐标值  x1,y1,x2,y2        """        # 两个框的交        iou_x1 = max(box1[0], box2[0])        iou_y1 = max(box1[1], box2[1])        iou_x2 = min(box1[2], box2[2])         iou_y2 = min(box1[3], box2[3])        d_x1 = max(0, (box1[2] + box1[0])/2)        d_y1 = max(0, (box1[3] + box1[1])/2)        d_x2 = max(0, (box2[2] + box2[0])/2)        d_y2 = max(0, (box2[3] + box2[1])/2)        c_x1 = min(box1[0], box2[0])         c_y1 = min(box1[1], box2[1])        c_x2 = max(box1[2], box2[2])         c_y2 = max(box1[3], box2[3])        # 下面求进去的为交加的两个角的坐标        area_inter = max(0,(iou_x2 - iou_x1)) * max(0 , (iou_y2 - iou_y1))        # 计算两个区域的并集        area_union = max(0,((box1[2] - box1[0]) * (box1[3] - box1[1])) + ((box2[2] - box2[0]) * (box2[3] - box2[1])) - area_inter)        # 计算最小外接矩形        c_2 = max(0,(c_x2 - c_x1))**2 + max(0,(c_y2 - c_y1))**2        d_2 =  max(0,(d_x2 - d_x1))**2 + max(0,(d_y2 - d_y1))**2        g_iou = max(0,area_inter/area_union) - d_2/c_2        return float(g_iou) , (iou_x1,iou_y1,iou_x2,iou_y2) , (c_x1,c_y1,c_x2,c_y2), (int(d_x1),int(d_y1),int(d_x2),int(d_y2))def main():    img = np.zeros((512,512,3), np.uint8)       img.fill(255)    box1 = [50,50,300,300]    box2 = [250,80,400,350]    IOU , area_inter , area_all , short_line = DIOU_score(box1,box2)    font = cv2.FONT_HERSHEY_SIMPLEX    cv2.putText(img,"GIOU = %.2f"%IOU,(area_inter[0]+30,area_inter[1]+30),font,0.8,(0,0,0),2)    cv2.rectangle(img, (box1[0],box1[1]), (box1[2],box1[3]), (255, 0, 0),  thickness = 3)    cv2.rectangle(img, (box2[0],box2[1]), (box2[2],box2[3]), (0, 255, 0), thickness = 3)    cv2.rectangle(img, (area_all[0],area_all[1]), (area_all[2],area_all[3]), (0, 0, 255), thickness = 3)    cv2.line(img, (short_line[0],short_line[1]), (short_line[2],short_line[3]), (200,45,45),5)    cv2.line(img, (area_all[0],area_all[1]), (area_all[2],area_all[3]), (64,78,0),5)        cv2.imshow("image",img)    cv2.waitKey()    cv2.destroyAllWindows()if __name__ == "__main__":    main()

CIOU代码及后果展现如下

import cv2import numpy as npfrom math import pi,atandef CIOU_score(box1,box2):        """        计算两个区域的iou的值        para: box1 区域1的两个角的坐标值  x1,y1,x2,y2        para: box2 区域2的两个角的坐标值  x1,y1,x2,y2        """        # 两个框的交        iou_x1 = max(box1[0], box2[0])        iou_y1 = max(box1[1], box2[1])        iou_x2 = min(box1[2], box2[2])         iou_y2 = min(box1[3], box2[3])        d_x1 = max(0, (box1[2] + box1[0])/2)        d_y1 = max(0, (box1[3] + box1[1])/2)        d_x2 = max(0, (box2[2] + box2[0])/2)        d_y2 = max(0, (box2[3] + box2[1])/2)        c_x1 = min(box1[0], box2[0])         c_y1 = min(box1[1], box2[1])        c_x2 = max(box1[2], box2[2])         c_y2 = max(box1[3], box2[3])        w_gt = max(0,box2[2] - box2[0])        h_gt = max(0,box2[3] - box2[1])        w    = max(0,box1[2] - box1[0])        h    = max(0,box1[3] - box1[1])        # 下面求进去的为交加的两个角的坐标        area_inter = max(0,(iou_x2 - iou_x1)) * max(0 , (iou_y2 - iou_y1))        # 计算两个区域的并集        area_union = max(0,((box1[2] - box1[0]) * (box1[3] - box1[1])) + ((box2[2] - box2[0]) * (box2[3] - box2[1])) - area_inter)        iou = max(0,area_inter/area_union)        c_2 = max(0,(c_x2 - c_x1))**2 + max(0,(c_y2 - c_y1))**2        d_2 =  max(0,(d_x2 - d_x1))**2 + max(0,(d_y2 - d_y1))**2        v = 4/pi**2 * (atan(w_gt/h_gt) - atan(w/h))**2        alpha = v / (1-iou + v)        c_iou = iou - d_2/c_2 - alpha * v        return float(c_iou) , (iou_x1,iou_y1,iou_x2,iou_y2) , (c_x1,c_y1,c_x2,c_y2), (int(d_x1),int(d_y1),int(d_x2),int(d_y2))def main():    img = np.zeros((512,512,3), np.uint8)       img.fill(255)    box1 = [50,50,300,300]    box2 = [100,80,200,260]    IOU , area_inter , area_all , short_line = CIOU_score(box1,box2)    font = cv2.FONT_HERSHEY_SIMPLEX    cv2.putText(img,"GIOU = %.2f"%IOU,(area_inter[0]+30,area_inter[1]+30),font,0.8,(0,0,0),2)    cv2.rectangle(img, (box1[0],box1[1]), (box1[2],box1[3]), (255, 0, 0),  thickness = 3)    cv2.rectangle(img, (box2[0],box2[1]), (box2[2],box2[3]), (0, 255, 0), thickness = 3)    cv2.rectangle(img, (area_all[0],area_all[1]), (area_all[2],area_all[3]), (0, 0, 255), thickness = 3)    cv2.line(img, (short_line[0],short_line[1]), (short_line[2],short_line[3]), (200,45,45),5)    cv2.line(img, (area_all[0],area_all[1]), (area_all[2],area_all[3]), (64,78,0),5)        cv2.imshow("image",img)    cv2.waitKey()    cv2.destroyAllWindows()if __name__ == "__main__":    main()

9、代价函数，损失函数、指标函数、危险函数的区别？

  • 损失函数（Loss Function ）是定义在单个样本上的，算的是一个样本的误差。
  • 代价函数（Cost Function）是定义在整个训练集上的，是所有样本误差的均匀，也就是损失函数的均匀。
  • 指标函数（Object Function）定义为：最终须要优化的函数。等于教训危险+构造危险（也就是代价函数 + 正则化项）。代价函数最小化，升高教训危险，正则化项最小化升高。
  • 危险函数(risk function)，危险函数是损失函数的冀望，这是因为咱们输入输出的(X,Y)遵循一个联结散布，然而这个联结散布是未知的，所以无奈计算。然而咱们是有历史数据的，就是咱们的训练集，f(x) 对于训练集的均匀损失称作教训危险(empirical risk)，即，所以咱们的指标就是最小化 称为教训危险最小化。

10、噪声、偏差和方差的区别是啥？

  • 噪声：形容了在当前任务上任何学习算法所能达到的冀望泛化误差的下界，即刻画了学习问题自身的难度。说人话，就是数据中的有些标签不是真的标签，也是无限噪声的标签。
  • 偏差：是指预测后果与实在值之间的差别，排除噪声的影响，偏差更多的是针对某个模型输入的样本误差，偏差是模型无奈精确表白数据关系导致，比方模型过于简略，非线性的数据关系采纳线性模型建模，偏差较大的模型是错的模型。
  • 方差：不是针对某一个模型输入样本进行断定，而是指多个(次)模型输入的后果之间的离散差别，留神这里写的是多个模型或者屡次模型，即不同模型或同一模型不同工夫的输入后果方差较大，方差是由训练集的数据不够导致，一方面量 (数据量) 不够，无限的数据集适度训练导致模型简单，另一方面质(样本品质)不行，测试集中的数据分布未在训练集中，导致每次抽样训练模型时，每次模型参数不同，输入的后果都无奈精确的预测出正确后果。

11、MSE对于异样样本的鲁棒性差的问题怎么解决？

  1. 如果异样样本无意义，能够进行异样值的平滑或者间接删除。
  2. 如果异样样本有意义，须要模型把这些有意义的异样思考进来，则从模型侧思考应用表达能力更强的模型或复合模型或分群建模等；
  3. 在损失层面抉择更鲁棒的损失函数。

12、熵的相干知识点？

  • 信息量 度量一个事件的不确定性水平，不确定性越高则信息量越大，个别通过事件产生的概率来定义不确定性，信息量则是基于概率密度函数的log运算，用以下式子定义：

$$I(x)=-\log p(x)$$

  • 信息熵 掂量的是一个事件汇合的不确定性水平，就是事件汇合中所有事件的不确定性的冀望，公式定义如下：

$$H(X)=-\sum_{x \in X}[p(x) \log p(x)]$$

  • 绝对熵(KL散度) kl散度，从概统角度登程，示意用于两个概率分布的差别的非对称掂量，kl散度也能够从信息实践的角度登程，从这个角度登程的kl散度咱们也能够称之为绝对熵，实际上形容的是两个概率分布的信息熵的差值：

$$K L(P \| Q)=\sum P(x) \log \frac{P(x)}{Q(x)}$$

kl散度和余弦间隔一样，不满足间隔的严格定义；非负且不对称。

  • js散度 公式如下：

$$J S(P \| Q)=\frac{1}{2} K L(P(x))\left\|\frac{P(x)+Q(x)}{2}+\frac{1}{2} K L(Q(x))\right\| \frac{P(x)+Q(x)}{2}$$

js散度的范畴是[0,1],雷同则是0，相同为1。相较于KL，对类似度的判断更精确;同时，js散度满足对称性 JS(P||Q)=JS(Q||P)

  • 穿插熵 公式如下：

$$H(P, Q)=-\sum p \log q=H(P)+D_{k l}(P \| Q)$$

可见,穿插熵就是真值散布的信息熵与KL散度的和,而真值的熵是确定的,与模型的参数 无关,所以梯度降落求导时，优化穿插熵和优化kl散度（绝对熵）是一样的；

  • 联结熵 公式如下：

$$H(X, Y)=-\sum_{x, y} p(x, y) \log p(x, y)$$

联结熵实际上掂量的是两个事件汇合，通过组合之后造成的新的大的事件汇合的信息熵；

  • 条件熵 公式如下：

$$H(Y \mid X)=H(X, Y)-H(X)$$

事件汇合Y的条件熵=联结熵-事件汇合X的信息熵，用来掂量在事件汇合X已知的根底上，事件汇合Y的不确定性的缩小水平；

13、怎么掂量两个散布的差别？

应用KL散度或者JS散度

14、Huber Loss 有什么特点？

Huber Loss 联合了 MSE 和 MAE 损失，在误差靠近 0 时应用 MSE，使损失函数可导并且梯度更加稳固；在误差较大时应用 MAE 能够升高 outlier 的影响，使训练对 outlier 更加强壮。毛病是须要额定地设置一个超参数。

15、如何了解Hinger Loss？

能够看到，当x大于某个值的时候，loss为0，当x小于某个值的时候，那就须要算loss了，阐明模型对小于阈值的样本进行了惩办，而且越大惩办的越厉害，对于大于阈值的样本不进行惩办，总的来说就是该损失函数寻找一个边界，对具备可信的样本不惩办，对不可信的样本或者超出决策边界的样本进行惩办。

已建设深度学习公众号——FightingCV，欢送大家关注！！！

面向小白的顶会论文外围代码学习：https://github.com/xmu-xiaoma...

退出交换群，请增加小助手wx：FightngCV666，备注：地区-学校（公司）-名称

参考：

https://blog.csdn.net/zuolixiangfisher/article/details/88649110

https://zhuanlan.zhihu.com/p/514859125

https://blog.csdn.net/weixin\_43750248/article/details/116656242

https://blog.csdn.net/hello\_dear\_you/article/details/121078919

https://blog.csdn.net/weixin\_41888257/article/details/104894141

https://blog.csdn.net/weixin\_37763870/article/details/103026505

https://blog.csdn.net/to\_be\_little/article/details/124674924

https://zhuanlan.zhihu.com/p/548782472

本文由mdnice多平台公布