DBNet详解

DBNet论文解读。

转置卷积

![[Pasted image 20240819151630.png|600]]
![[Pasted image 20240819152239.png|600]]

stride = 1, 无 padding的实现：

def trans_conv(X, K):
    h, w = K.shape
    Y = torch.zeros((X.shape[0] + h - 1, X.shape[1] + w - 1))
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            Y[i: i + h, j: j + w] += X[i, j] * K
    return Y

验证：

X = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
trans_conv(X, K)
# output
%%  tensor([[ 0.,  0.,  1.],
        [ 0.,  4.,  6.],
        [ 4., 12.,  9.]]) %%

用 torch实现：

X, K = X.reshape(1, 1, 2, 2), K.reshape(1, 1, 2, 2)
tconv = nn.ConvTranspose2d(1, 1, kernel_size=2, bias=False) # 前两个参数分别是：输入通道数、输出通道数
tconv.weight.data = K
tconv(X)
# output:
%% tensor([[[[ 0.,  0.,  1.],
          [ 0.,  4.,  6.],
          [ 4., 12.,  9.]]]], grad_fn=<ConvolutionBackward0>) %%

若 padding=1, 则输出的 shape变成 $1*1$

tconv = nn.ConvTranspose2d(1, 1, kernel_size=2, padding=1, bias=False)
tconv.weight.data = K
tconv(X)
# output
%% tensor([[[[4.]]]], grad_fn=<ConvolutionBackward0>) %%

若 stride = 2, 则输出增加尺寸：
![[Pasted image 20240819160859.png|600]]

tconv = nn.ConvTranspose2d(1, 1, kernel_size=2, stride=2, bias=False)
tconv.weight.data = K
tconv(X)
%% tensor([[[[0., 0., 0., 1.],
          [0., 0., 2., 3.],
          [0., 2., 0., 3.],
          [4., 6., 6., 9.]]]], grad_fn=<ConvolutionBackward0>) %%

若卷积的超参数和转置卷积的超参数相同，则卷积输入的 shape与转置卷积输出的 shape相同：

X = torch.rand(size=(1, 10, 16, 16))
conv = nn.Conv2d(10, 20, kernel_size=5, padding=2, stride=3)
tconv = nn.ConvTranspose2d(20, 10, kernel_size=5, padding=2, stride=3)
tconv(conv(X)).shape == X.shape
%% True %%

转置的由来：
普通卷积：

X = torch.arange(9.0).reshape(3, 3)
K = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
Y = d2l.corr2d(X, K)
Y
%% tensor([[27., 37.],
        [57., 67.]]) %%

把卷积变成矩阵相乘：

def kernel2matrix(K):
    k, W = torch.zeros(5), torch.zeros((4, 9))
    k[:2], k[3:5] = K[0, :], K[1, :]
    W[0, :5], W[1, 1:6], W[2, 3:8], W[3, 4:] = k, k, k, k
    return W

W = kernel2matrix(K)
W
%% tensor([[1., 2., 0., 3., 4., 0., 0., 0., 0.],
        [0., 1., 2., 0., 3., 4., 0., 0., 0.],
        [0., 0., 0., 1., 2., 0., 3., 4., 0.],
        [0., 0., 0., 0., 1., 2., 0., 3., 4.]]) %%

1
2
3

Y == torch.matmul(W, X.reshape(-1)).reshape(2, 2)
%% tensor([[True, True],
        [True, True]]) %%

实施转置矩阵：

Z = trans_conv(Y, K)
Z == torch.matmul(W.T, Y.reshape(-1)).reshape(3, 3)
%% tensor([[True, True, True],
        [True, True, True],
        [True, True, True]]) %%

Refs:

转置卷积_哔哩哔哩_bilibili

交叉熵损失_VS_L1Loss

以DBNet的概率图和二值图用交叉熵损失，阈值图用 L1 loss为例：

概率图和二值图涉及的是分类任务，因此需要损失函数能够有效地评估和优化模型的分类性能。L1 损失主要用于回归任务，其计算方法和目标不适合处理分类任务中的概率分布问题。

1. 任务性质的不同

概率图：概率图输出的是每个像素属于文本区域的概率值，通常在 [0, 1] 范围内。目标是估计概率分布，表示像素属于文本区域的置信度。这是一个分类任务的输出。
二值图：二值图是概率图经过阈值化处理得到的二分类结果。其目标是将像素分类为文本区域（1）或背景区域（0）。尽管结果是二值的，但其生成过程中依赖于概率图的输出。
L1 损失：L1 损失（绝对误差损失）用于回归任务，通过计算预测值与真实值之间的绝对差异来优化模型。在分类任务中，这种损失函数不适合处理概率分布。

2. 交叉熵损失的适用性

分类任务的适应性：交叉熵损失是一种专门用于分类任务的损失函数。它通过计算预测概率分布与真实标签之间的差异来衡量分类性能，适用于处理概率图和二值图。
概率分布的匹配：交叉熵损失能够衡量概率分布之间的距离，它通过优化模型的预测概率分布来提高分类准确性。

3. L1 损失的局限性

不适合分类任务：L1 损失用于回归任务，计算预测值与真实值之间的绝对差异。在分类任务中，尤其是概率分布的处理上，L1 损失不能有效地捕捉概率分布与真实标签之间的差异。
忽视分类错误：即使预测概率值接近真实值，L1 损失只关注预测值与真实值的绝对差异，不能充分反映最终分类决策的准确性。例如，真实标签为 1 时，预测概率为 0.49 的分类可能被误认为是背景区域 0，这种分类错误可能无法通过 L1 损失有效反映。

4. 交叉熵损失的优越性

分类错误的惩罚：交叉熵损失直接处理分类任务，能够显著反映分类错误的严重性。例如，对于真实标签 1 和预测概率值 0.49，交叉熵损失会计算 $-\log(0.49)$，值较大，能够更好地反映分类错误。
优化概率分布：交叉熵损失优化预测概率分布，减少与真实标签之间的差异，适合处理分类任务中的细微差别，从而提高分类的准确性。

总结

L1 损失关注的是预测值与真实值之间的绝对差异，不适合处理分类任务中的概率分布问题。交叉熵损失专门用于分类任务，能够有效地优化概率分布与真实标签之间的差异，从而更好地处理分类任务中的细微差别。

交叉熵损失的数值不稳定性

为了处理数值不稳定的问题，通常会在计算过程中加入一个小的常数 $\epsilon$，使得 $x_i$ 和 $1 - x_i$ 永远不会完全为 0。这样可以避免对数函数的无穷大负值。常见的处理方法是：

对概率值进行剪裁（Clipping）：在计算对数之前，将 $x_i$ 的值限制在一个很小的范围内，例如 $[\epsilon, 1 - \epsilon]$，其中 $\epsilon$ 是一个非常小的常数（如 $10^{-8}$）。这样可以防止对数操作中出现极端的负值。

修改后的交叉熵损失计算公式为：

$L = - \sum_{i} \left[ y_i \log (\max(x_i, \epsilon)) + (1 - y_i) \log (\max(1 - x_i, \epsilon)) \right]$

各种卷积类型

普通卷积

![[Pasted image 20240816114238.png|700]]

空洞卷积（Dilated Convolution）

![[Pasted image 20240816134747.png|700]]
空洞卷积（Dilated Convolution） 是一种扩展传统卷积操作的方法，旨在增加卷积核的感受野（receptive field），即卷积操作能够覆盖的输入图像的区域范围，同时不增加计算复杂度或引入额外的参数。空洞卷积主要在语义分割、物体检测等任务中用于捕获多尺度信息。

1. 传统卷积的局限性

在传统卷积中，卷积核（filter）的感受野与卷积核的大小直接相关。例如，一个 $3 \times 3$ 的卷积核只能覆盖一个 $3 \times 3$ 的局部区域。如果需要覆盖更大的区域，通常的做法是增大卷积核的尺寸或通过多层卷积堆叠来逐步扩大感受野。

然而，这样做会带来以下问题：

增大卷积核尺寸会显著增加参数量，导致模型更容易过拟合。
通过多层堆叠卷积层会增加计算量，同时也会导致特征图尺寸的急剧缩小（尤其是伴随着下采样操作时）。

2. 空洞卷积的引入

空洞卷积通过在卷积核的元素之间引入空洞（dilation rate），即在相邻卷积核元素之间插入一定数量的“空”元素，从而在不增加参数数量的情况下扩展卷积核的感受野。

3. 原理细节

空洞率（dilation rate）: 空洞卷积的核心参数是空洞率 $d$（dilation rate）。当 $d = 1$ 时，空洞卷积退化为普通卷积；当 $d > 1$ 时，卷积核的元素之间会插入 $d-1$ 个“空”的位置。
扩展感受野: 通过设置较大的空洞率，卷积核可以在更大的输入图像区域上进行采样，而无需增加卷积核的大小。例如，一个 $3 \times 3$ 的卷积核在空洞率 $d = 2$ 时，其实际感受野变为 $5 \times 5$，而卷积核的参数量依然是 $3 \times 3$ 的。
卷积操作: 在空洞卷积中，每个卷积核元素采样的位置是由空洞率决定的，而不再是连续的。例如，当 $d = 2$ 时，一个 $3 \times 3$ 的卷积核会跳过一个像素进行采样，即采样位置为原卷积核的 $(0, 0)$, $(0, 2)$, $(2, 0)$, $(2, 2)$ 等。

4. 数学表述

给定输入特征图 $x$ 和卷积核 $w$，传统卷积可以表示为：

$y(p) = \sum_{k} w(k) \cdot x(p + k)$

其中 $p$ 是当前卷积的位置，$k$ 是卷积核的索引。

在空洞卷积中，卷积公式变为：

$y(p) = \sum_{k} w(k) \cdot x(p + d \cdot k)$

其中 $d$ 是空洞率，$d \cdot k$ 表示在输入特征图中偏移的实际位置。

5. 应用与优势

增加感受野: 空洞卷积可以显著扩大感受野，适合需要捕获全局信息的任务，如语义分割中的场景理解。
减少计算量: 通过空洞卷积，可以在保持感受野扩大的同时，避免参数量和计算复杂度的显著增加。
多尺度特征融合: 空洞卷积常与多尺度特征融合技术结合使用，以同时捕获不同尺度的上下文信息。

6. 实际效果

空洞卷积在实际应用中，尤其是语义分割任务中，能够有效地提升模型对复杂场景的理解能力，同时保持计算资源的高效利用。这种技术已经被广泛应用于如DeepLab系列模型中。

空洞卷积提供了一种优雅的方式，使得卷积神经网络在处理需要大范围上下文信息的任务时，能够在不增加太多计算负担的前提下，获得更大的感受野。

Deformable Convolution

![[Pasted image 20240816140244.png|700]]
![[Pasted image 20240816141209.png|700]]

![[Pasted image 20240816140536.png|700]]

优势与应用

适应性: 可变形卷积能够根据输入内容调整卷积核的位置，因此在处理具有较大变形的对象时，表现更好。
提高检测精度: 在目标检测、语义分割等任务中引入可变形卷积，可以显著提高模型的检测精度，尤其是在处理形变多样的对象时。
广泛应用: 可变形卷积在各种计算机视觉任务中得到了广泛应用，如目标检测（Deformable R-CNN）、语义分割（Deeplab系列）等。

实际效果

在实际应用中，可变形卷积能够有效提升模型对目标形变的适应能力，使得网络在面对更复杂的视觉场景时，能够保持更高的准确性和鲁棒性。

这种技术的引入，极大地扩展了卷积神经网络在处理非刚性对象时的能力，为许多计算机视觉任务的改进提供了新的思路。

可变形卷积中的 $\Delta p$ 是通过什么网络得到的？

是的，在可变形卷积（Deformable Convolution）中，生成偏移量 $\Delta p$ 的网络通常是通过一个传统的卷积神经网络得到的。

具体过程如下：

卷积操作生成偏移量:
- 在可变形卷积中，首先会对输入特征图（与主要可变形卷积层相同）进行一次标准的卷积操作，这个卷积层专门用于生成偏移量 $\Delta p$。
- 这个卷积层的卷积核大小通常与后续实际执行可变形卷积的卷积核大小相同。例如，如果可变形卷积的核大小为 $3 \times 3$，那么生成偏移量的卷积层的核大小也是 $3 \times 3$。
通道数计算:
- 偏移量 $\Delta p$ 的通道数为 $2 \times \text{kernel size} \times \text{kernel size}$。这是因为每个卷积核位置都需要两个偏移值（一个在 x 方向，一个在 y 方向），而卷积核有 $k \times k$ 个位置。
- 以 $3 \times 3$ 的卷积核为例，$\Delta p$ 的通道数为 $2 \times 3 \times 3 = 18$。
使用传统卷积层:
- 生成 $\Delta p$ 的卷积层是一个传统的卷积层，这意味着它的参数是通过标准的反向传播算法进行训练和优化的。
- 输入这个卷积层的特征图经过标准卷积操作后，输出的通道数即为上述的 $2 \times k \times k$。
卷积层的具体作用:
- 这个卷积层的目的是生成每个位置的偏移量 $\Delta p$，这些偏移量在后续的可变形卷积中用于调整卷积核的位置，使得卷积核能够更好地适应输入图像的几何变形。

例子说明：

假设有一个输入特征图，其通道数为 $C$（例如 64），卷积核大小为 $3 \times 3$。生成偏移量的卷积层接受这个输入特征图，并输出通道数为 18（即 $2 \times 3 \times 3$）的特征图，其中每个像素点包含 18 个值，这 18 个值表示在该位置上 $3 \times 3$ 卷积核的 9 个点的 x 和 y 方向的偏移量。

总结来说，生成 $\Delta p$ 的卷积层确实是一个传统的卷积层，其参数通过训练数据进行学习，并在整个网络中与其他层一起优化。这个卷积层可以看作是一个辅助模块，用于为可变形卷积提供灵活的采样位置。

Refs: Deformable Convolution ｜可变形卷积_哔哩哔哩_bilibili

Adam/AdamW

全程：Adaptive Moment Estimation（自适应动量估计）

指数加权平均

预测一个商店，第七天的营业额：

![[Pasted image 20240814140739.png|500]]
![[Pasted image 20240814140916.png|500]]
在前几天，v与真实值$\theta$ 相差较大，所以用 $1-\beta ^{2}$ 进行修正。
由下图可知，经过修正后的$V^{correct}$ 更加准确。随着t的增大， $1-\beta ^{t}$ 趋近于 1。
![[Pasted image 20240814141149.png|500]]

SGD

问题：有的地方梯度很大，有的地方梯度很小，如下图，b的梯度大，所在 b出现了震荡。

![[Pasted image 20240814141952.png|268]] ![[Pasted image 20240814142110.png|575]]

Momentum

利用梯度的指数加权平均值来更新参数。
对于如上图 b的震荡，表示 b的梯度有正有负，所有进行加权平均后会趋向于变小，如下图所示。
![[Pasted image 20240814142633.png|400]]

RMSProp

全称：Root Mean Square Propagation
不使每个参数更新时差异过大。
$\varepsilon$ : 防止分母为 0.
![[Pasted image 20240814143415.png|400]]

Adam

是Momentum和RMSProp算法结合。
![[Pasted image 20240814144336.png|600]]

AdamW

只在 Adam基础上加了一项：weight decay，即权重衰减。

![[Pasted image 20240814144602.png|600]]

weight decay并不完全L2正则如下图所示，因为 L2 norm直接改变了Loss，而weight decay是再参数更新时加入了一个很小的项。
两者在 SGD中效果一样，但再 Adam中，因为会 loss进行各种加权平均，所有和weight decay不同的。
![[Pasted image 20240814144838.png|600]]

Adam/AdamW参数量

因为梯度一般是个很小的值，所以需要用 float32来存储。
![[Pasted image 20240814145307.png|450]]

分类中的 IoU

IoU: Intersection over Union
某类别 IoU = 该类别分类正确数量 / (该类别真实数量 + 错误预测为该类别数量)
该概念与目标检测中的 IoU类似：

![[Pasted image 20240812164532.png]]

The Rank Loss Problem of Self Attention

Self attention loses rank doubly exponentially with depth at initialization.(i.e. the more deep, the more same the outputs are)
The skip connections and MLPs mitigate this situation.

Why:
![[#convex combination]]

[[TriDet#The second question Attention in Temporal Dimension.|Self attention is Convex combination]]

Attention is Not All You Need: Pure Attention Loses Rank Doubly Exponentially with Depth

温度系数

是的，在深度学习中，温度系数（temperature coefficient）确实对 softmax 函数起作用。温度系数 $T$ 是用来调节 softmax 函数输出概率分布的一个参数。具体来说，softmax 函数通常定义如下：

$\text{softmax}(z_i) = \frac{e^{z_i}}{\sum_{j} e^{z_j}}$

引入温度系数 $T$ 后的 softmax 函数定义为：

$\text{softmax}(z_i) = \frac{e^{z_i / T}}{\sum_{j} e^{z_j / T}}$

温度系数的作用是通过调整 $T$ 的值来控制输出概率的“平滑”程度。当 $T$ 趋近于零时，softmax 的输出会更加接近于 one-hot 编码，即概率分布会更加尖锐，接近于0或1。而当 $T$ 趋近于无穷大时，softmax 的输出会趋近于均匀分布，即所有类别的概率相等。

温度系数在实践中有许多应用，例如在知识蒸馏（knowledge distillation）中，通过调整温度系数来使学生模型（student model）更好地学习教师模型（teacher model）的软标签（soft targets）。

熵

自信息量

$I(x) = -\log P(x)$
其中

P(x)是事件 x发生的概率
I(x)是事件x的信息量
当概率越小，越不常见，信息量越大。

交叉熵（Cross Entropy）

交叉熵度量的是两个概率分布之间的平均编码长度。分布 ( P ) 的真实信息量为 ( -\log P(x) )，但使用 ( Q ) 进行编码时的平均信息量为 ( -\log Q(x) )。交叉熵定义为：

$H(P, Q) = -\sum_x P(x) \log Q(x)$

经典的二分类的交叉熵损失

经典的二分类的交叉熵损失中，一般不是负样本因为 label为 0，都被省略了吗？

你提到的情况是部分正确的，但省略负样本的说法可能有些误解。我们来详细解释一下二分类问题中的交叉熵损失是如何计算的。

在二分类问题中，对于每个样本，我们有一个标签 $y$，其值为 0 或 1。模型输出的预测概率为 $\hat{y}$，表示预测为正类的概率。交叉熵损失通常定义为：

$\text{Loss} = -[y \cdot \log(\hat{y}) + (1-y) \cdot \log(1-\hat{y})]$

这个公式包含了两个部分：

正样本 ($y = 1$)：
- 当 $y = 1$ 时，损失为： $-\log(\hat{y})$ 这个部分是我们希望最大化的，表示模型正确预测正样本的概率。
负样本 ($y = 0$)：
- 当 $y = 0$ 时，损失为： $-\log(1-\hat{y})$ 这个部分是我们希望最小化的，表示模型正确预测负样本的概率（即输出接近0）。

因此，负样本的损失是不会被省略的，只是因为当 $y = 0$ 时，第一个项 $y \cdot \log(\hat{y})$ 为 0，被省略的是正样本的损失项（因为它不贡献于此）。

在实际实现时，如果我们专注于正样本（例如在一些特定应用场景下），有时候我们会只计算正样本的损失。但是在标准的二分类交叉熵损失计算中，负样本的损失也是被明确计算的，用来确保模型能够正确识别负样本。这与前面讨论的公式一致，只不过两者的表达形式稍有不同。

分解KL散度

将KL散度公式进行分解，使用对数的性质 $\log \frac{a}{b} = \log a - \log b$：

$D_{KL}(P \| Q) = \sum_x P(x) \log P(x) - \sum_x P(x) \log Q(x)$

第一项 $\sum_x P(x) \log P(x)$是 P 分布的熵（Entropy），记为 $H(P)$：
$H(P) = -\sum_x P(x) \log P(x)$

第二项$-\sum_x P(x) \log Q(x)$ 是 $P$ 和 $Q$分布的交叉熵$H(P, Q)$。

KL散度可以用来表示在使用Q来近似P时所带来的信息损失（编码效率下降，比如原本需要 6 个比特就能编码的信息，现在需要 8 个，这 2 个的差值就是信息损失）。
在教师-学生模型中，可以通过衡量学生经过 softmax后的分布和教师的KL散度来知道学生的学习。 ^f594ee

这里的信息损失：

除了编码效率的下降，我们还可以通过其他例子来说明和量化信息损失。以下是几个常见的例子：

1. 预测模型中的信息损失

在机器学习和统计学中，KL散度可以用来衡量两个概率分布之间的差异，尤其是在预测模型中。例如，当我们训练一个分类模型时，模型预测的类别分布（$Q$）与真实的类别分布（$P$）之间的差异可以通过KL散度来量化。更高的KL散度表示预测分布与真实分布的差异更大，这意味着模型的预测质量较差。

2. 数据压缩中的信息损失

在数据压缩领域，如果我们使用不准确的概率模型$Q$来进行压缩，那么压缩后的数据需要更多的空间来存储，从而导致信息损失。例如，在图像压缩中，如果我们用近似模型来替代真实的图像像素分布，压缩后的图像质量会下降，导致信息丢失，这可以用KL散度来量化。

3. 自然语言处理中的信息损失

在自然语言处理中，KL散度可以用来衡量生成模型与真实语言分布之间的差异。例如，使用语言模型生成文本时，生成的文本分布$Q$与真实文本分布$P$之间的差异可以通过KL散度来衡量。更高的KL散度表示生成的文本与真实文本的差异更大，意味着生成的文本质量较差。

为什么 $Q(x)$ 比 $P(x)$ 需要更多比特来编码

在信息论中，编码长度指的是对一个事件进行编码所需要的比特数。编码长度越短，表示信息被压缩得越好。为了更好地理解这个概念，我们可以通过以下几个方面来解释：

自信息量（Self-Information）

自信息量（Self-Information）是信息论中的一个基本概念，用来度量事件发生所带来的信息量。自信息量的公式为：

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

其中：

$P(x)$ 是事件 $x$ 发生的概率。
$I(x)$ 是事件 $x$ 的自信息量。

自信息量表示当事件 $x$ 发生时所带来的信息量。概率 $P(x)$ 越小，自信息量 $I(x)$ 越大。换句话说，越不常见的事件发生时带来的信息量越大。

理想编码长度

在理想情况下，我们希望对事件 $x$ 进行编码，使得编码长度正好等于事件的自信息量。这样可以保证编码的效率和精确度。理想编码长度为：

$L(x) = -\log P(x)$

这意味着，如果我们知道事件 $x$ 的真实概率 $P(x)$，我们可以使用 $-\log P(x)$ 比特来对事件 $x$ 进行编码。

使用近似分布进行编码

在实际应用中，我们可能无法准确知道事件 $x$ 的真实概率 $P(x)$，而是使用一个近似概率 $Q(x)$ 进行编码。在这种情况下，编码长度变为：

$L(x) = -\log Q(x)$

如果 $Q(x)$ 与 $P(x)$ 越接近，编码长度 $-\log Q(x)$ 就越接近理想编码长度 $-\log P(x)$。

平均编码长度

对于整个概率分布，我们关心的是使用近似分布 $Q$ 进行编码时的平均编码长度。这就是交叉熵的意义：

$H(P, Q) = -\sum_x P(x) \log Q(x)$

交叉熵 $H(P, Q)$ 表示在真实分布 $P$ 下，使用近似分布 $Q$ 进行编码时的平均编码长度。它衡量的是在真实分布 $P$ 下，我们需要多少比特来编码事件 $x$ 。

因为 $Q(x)$ 不是 $P(x)$，可能会有以下几种情况：

低概率事件被高估：如果 $Q(x)$ 对某些低概率事件 $x$ 给出了相对较高的概率（比 $P(x)$ 高），这些事件的编码长度会比理想情况下短，但因为它们实际发生的频率较低，这种情况不会显著影响整体的平均编码长度。
高概率事件被低估：如果 $Q(x)$ 对某些高概率事件 $x$ 给出了相对较低的概率（比 $P(x)$ 低），这些事件的编码长度会比理想情况下长，因为这些事件实际发生的频率较高，这种情况会显著增加整体的平均编码长度。

举例说明

假设我们有两个分布 $P$ 和 $Q$：

$P(x) = \begin{cases} 0.5 & x = 1 \\ 0.25 & x = 2 \\ 0.125 & x = 3 \\ 0.125 & x = 4 \end{cases}$ $Q(x) = \begin{cases} 0.4 & x = 1 \\ 0.3 & x = 2 \\ 0.2 & x = 3 \\ 0.1 & x = 4 \end{cases}$

使用 $Q$ 进行编码的平均编码长度（交叉熵）为：

$H(P, Q) = -\sum_x P(x) \log Q(x)$

计算如下：

$H(P, Q) = -(0.5 \log 0.4 + 0.25 \log 0.3 + 0.125 \log 0.2 + 0.125 \log 0.1)$

具体计算为：

$H(P, Q) = -[0.5 \times (-0.916) + 0.25 \times (-1.737) + 0.125 \times (-2.322) + 0.125 \times (-3.322)]$ $H(P, Q) = -( -0.458 - 0.43425 - 0.29025 - 0.41525 )$ $H(P, Q) = 1.598$

这表示在真实分布 $P$ 下，使用近似分布 $Q$ 进行编码时的平均编码长度为 1.598 比特。

总结

不匹配的概率分布 $Q(x)$ 会导致一些事件的编码长度变得更长，从而增加了整体的平均编码长度。这就是为什么 $Q(x)$ 比 $P(x)$ 需要更多比特来编码的原因。

交叉熵损失

交叉熵损失（Cross Entropy Loss）是机器学习和深度学习中常用的一种损失函数，主要用于分类问题。它衡量的是两个概率分布之间的差异，通常是模型预测的概率分布与真实标签的概率分布之间的差异。

在分类任务中，假设有 $n$ 类，模型预测的概率分布为 $\mathbf{p} = (p_1, p_2, \ldots, p_n)$，真实的概率分布（即真实标签的one-hot表示）为 $\mathbf{q} = (q_1, q_2, \ldots, q_n)$。交叉熵损失的公式为：

$L = -\sum_{i=1}^{n} q_i \log(p_i)$

对于二分类问题，假设模型的输出为 $p$，真实标签为 $y$，那么交叉熵损失可以简化为：

$L = - (y \log(p) + (1 - y) \log(1 - p))$

在神经网络的训练过程中，交叉熵损失常常与Softmax激活函数结合使用，因为Softmax可以将模型的输出转换为一个概率分布，使得交叉熵损失能够更有效地衡量预测值与真实值之间的差异。

使用交叉熵损失的优点包括：

数值稳定性：与均方误差（MSE）相比，交叉熵损失在处理概率分布时更加稳定，特别是当预测值接近真实值时，梯度不会变得过小。
梯度信息丰富：交叉熵损失提供的梯度信息更为丰富，能够更有效地指导模型的学习过程。

总的来说，交叉熵损失是分类任务中的一个标准选择，尤其是在深度学习模型中应用广泛。

归纳偏置（Inductive Bias）

归纳偏置（Inductive Bias）指的是一种机器学习模型在学习过程中所做的假设，这些假设帮助模型在有限的数据中学习，并在未知数据上进行预测。不同的模型具有不同的归纳偏置，它们决定了模型在不同类型的数据上表现的好坏。

Attention机制的优势

在你的问题中，Attention机制比RNN和CNN表现更好，尽管它不对数据的顺序进行建模，这背后主要是因为Attention机制具有更广泛的归纳偏置。具体来说：

广泛的归纳偏置：Attention机制的设计允许它能够处理更广泛的和更一般化的信息。这意味着它没有强加于数据的一些特定的假设，比如数据的顺序或空间关系。因此，Attention机制可以在不同类型的数据上表现出色，而不仅仅是在时间序列数据或图像数据上。
没有空间假设：因为Attention机制没有像CNN那样假设局部的空间关系，它可以学到更全局的信息。这使得Attention机制在很多任务上能够比CNN取得更好的结果，特别是在需要全局上下文信息的任务中。
代价：正因为Attention机制的假设更为一般化，它需要更多的数据和更大的模型来弥补其在具体结构信息（如序列和空间信息）上的不足。因此，尽管它可以达到甚至超越RNN和CNN的效果，但需要在数据和计算资源上进行更多的投入。

总结

总的来说，归纳偏置是指导机器学习模型如何处理和理解数据的关键假设。不同模型的归纳偏置不同，使得它们在不同类型的数据和任务上有不同的表现。Attention机制的广泛归纳偏置使其在很多任务上表现优异，但也需要更多的数据和更大的模型来弥补其对具体结构信息处理能力的不足。

softmax

$\text{softmax}(z_i) = \frac{e^{z_i}}{\sum_{j} e^{z_j}}$

Softmax求梯度的公式推导

Softmax函数是机器学习中常用的激活函数，特别是在多分类任务中。它将一个向量中的每个分量映射为0到1之间的值，并且这些值的和为1。Softmax函数的公式为：

$\sigma(\mathbf{z})_i = \frac{e^{z_i}}{\sum_{j=1}^K e^{z_j}}$

其中，$\mathbf{z}$是输入向量，$z_i$是向量$\mathbf{z}$的第i个分量，K是向量$\mathbf{z}$的长度。

为了推导Softmax函数的梯度，我们需要计算它对输入$\mathbf{z}$的导数。具体来说，我们希望计算$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_j}$。

步骤 1: Softmax的偏导数

首先，记$\sigma(\mathbf{z})i = \frac{e^{z_i}}{\sum{k=1}^K e^{z_k}}$。

对第i个分量进行导数计算有两种情况：$i = j$和$i \neq j$。

情况 1: $i = j$

当i等于j时，我们得到：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_i} = \frac{\partial}{\partial z_i} \left( \frac{e^{z_i}}{\sum_{k=1}^K e^{z_k}} \right)$

使用商的导数法则，我们有：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_i} = \frac{ \left( e^{z_i} \cdot \sum_{k=1}^K e^{z_k} \right) - \left( e^{z_i} \cdot e^{z_i} \right) }{\left( \sum_{k=1}^K e^{z_k} \right)^2}$

将公式简化，我们得到：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_i} = \frac{ e^{z_i} \left( \sum_{k=1}^K e^{z_k} - e^{z_i} \right) }{\left( \sum_{k=1}^K e^{z_k} \right)^2}$

进一步简化为：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_i} = \sigma(\mathbf{z})_i \left( 1 - \sigma(\mathbf{z})_i \right)$

情况 2: $i \neq j$

当i不等于j时，我们得到：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_j} = \frac{\partial}{\partial z_j} \left( \frac{e^{z_i}}{\sum_{k=1}^K e^{z_k}} \right)$

同样使用商的导数法则，我们有：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_j} = \frac{ 0 \cdot \sum_{k=1}^K e^{z_k} - e^{z_i} \cdot e^{z_j} }{\left( \sum_{k=1}^K e^{z_k} \right)^2}$

将公式简化，我们得到：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_j} = - \frac{ e^{z_i} \cdot e^{z_j} }{\left( \sum_{k=1}^K e^{z_k} \right)^2}$

进一步简化为：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_j} = -\sigma(\mathbf{z})_i \sigma(\mathbf{z})_j$

合并结果

结合以上两种情况，我们可以写出Softmax函数对输入向量$\mathbf{z}$的梯度公式：

$\frac{\partial \sigma(\mathbf{z})_i}{\partial z_j} = \sigma(\mathbf{z})_i (\delta_{ij} - \sigma(\mathbf{z})_j)$

其中，$\delta{ij}$是Kronecker delta函数，当$i=j$时，$\delta{ij}=1$，否则$\delta_{ij}=0$。

总结一下，Softmax函数的梯度推导过程涉及对输入向量的每个分量进行求导，并且结果表示为矩阵形式，该矩阵的每个元素是上述两种情况之一。

Softmax函数在输入值范围较大时会导致梯度消失，而不是梯度爆炸

梯度消失的原因

当Softmax函数的输入值范围较大时，Softmax的输出值会非常极端，即某些输出值接近1，而其他输出值接近0。这会导致在计算梯度时，梯度值会非常小，从而导致梯度消失。

具体分析

对于Softmax函数 $\sigma(\mathbf{z})i = \frac{e^{z_i}}{\sum{k} e^{z_k}}$，其梯度为：

$\frac{\partial \sigma(z_i)}{\partial z_j} = \sigma(z_i) (\delta_{ij} - \sigma(z_j))$

在极端情况下：

当 $z_i$ 远大于其他所有 $z_k$ 时，$\sigma(z_i)$ 接近1，而$\sigma(z_j)$（$j \neq i$）接近0。
这种情况下，$\sigma(z_i) (1 - \sigma(z_i))$ 会接近0，而 $\sigma(z_i) (-\sigma(z_j))$ 也会接近0。

因此，梯度值会非常小，导致梯度消失。

使用 $\sqrt{d_k}$ 进行缩放的原因

为了避免这种梯度消失的问题，自注意力机制中对点积进行缩放：

$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V$

通过除以 $\sqrt{d_k}$：

缩小点积的值，使得输入值不会过大，从而使得Softmax的输出值更为均匀，不至于过于极端。
使得Softmax输入值的方差变为1，确保输入值处于一个合理的范围内，避免梯度消失。

总结

使用 $\sqrt{d_k}$ 进行缩放，主要目的是防止由于输入值范围较大导致的梯度消失问题。通过控制输入值的范围，可以确保Softmax函数的输出值更为均匀，从而避免梯度消失，确保网络的稳定训练。

所以，Softmax函数在输入值范围较大时，确实主要会导致梯度消失，而不是梯度爆炸。

OOD accuracy

out-of-distribution (OOD) accuracy

向量的高效搜索

近似最邻近（Approximate Nearest Neighbor, ANN）搜索
向量量化：将高维向量映射为低纬，在根据相似度分桶。
分布式检索：当数据量极大时，可在多台服务器上并行处理。
索引结构优化：不懂，略。
近似最邻近
Approximate Nearest Neighbor, ANN
如何实现

分区：把数据空间分成许多“区域”，每个区域包含一些点。搜索时，先找到查询点所在的区域或相邻的区域，然后在这些区域中搜索最近的点。这就像图书馆中的书架，每个书架代表一个区域，书架上的书相对更接近。
树结构：使用树结构（如KD树或球树）来组织数据点。每次分支代表对空间的一次分割，最终将查询点快速引导至包含最近邻点的区域。
哈希：利用哈希函数将点映射到哈希表的桶中。相近的点通过哈希函数映射到相同或相近的桶，从而在搜索时可以直接定位到这些桶来查找最近邻。

分区

桶划分：通过相似度，并确保每个区域数量大致相同。
区域定位：如树，从根节点一直到叶子结点，这里每个节点代表一个区域。
相邻区域搜索：搜索向量所在区域及附近区域。
距离计算：计算向量所在区域及附近区域中所以向量的相似度，找到最相似的。

三种局部敏感哈希函数原理

位采样：根据特定位的数值，作为区分向量的依据。
MinHash：专注于比较集合之间的相似度。对于一个集合，用一组哈希函数，分别计算集合中所有元素，得到一组最小值，那这些最小值作为集合的指纹。用较短的哈希值代表集合，特别适合大数据集，在保持高精度的同时，减少计算复杂度。
SimHash：用于文本等相似度的比较。取每个元素中的一系列特征，每个特征的向量表示长度相同，数值随机且固定。然后用数据分析等方法获得每个特征等权重，再加权求和。然后整流，对于向量中的值，大于0，则设为1，否则便是0。这样边得到了固定长度的二进制哈希指纹。

Incremental learning

Also known as online learning, continual learning, or lifelong learning.
Continuously update the model as new data arrives, while retaining important old information(to avoid catastrophic forgetting).
Key aspects:
1. Continuous Adaptation
2. Handling Concept Drift
3. Memory Management
4. Computational Efficiency
5. Application Areas
6. Algorithms and Techniques

思维链方法（CoT）

让模型一步步去解决问题，而不是一下子去跳到答案。
思维链方法（CoT）解释
 思维链示例

MoE

Mixture of Experts
Two parts:

Experts: lots of small models that specialize in certain types of tasks.
Gating Network: select the proper expert. 生成的概率分布，表示每个专家的激活值。
加权组合：被激活的专家根据门控机制的权重进行加权组合，最终形成模型的输出。
优势:
效率高，每次进激活几个专家。
可扩展性好：可以增加更多的专家提高模型的能力，而不显著增加计算成本。
灵活性强：不同专家可以专注于各种细分场景的任务。
RAG
Retrieval-augmented generation
Main 2 steps:
Retrieval information: external information, such as up-to-date documents, webs on the internet.
Generation: input the retrieval information and the input query into LLM (GPT etc.) to generate answers.

Pros: the response are greatly enhanced by the incorporation of external information

经典的 RAG: 问题—-> 向量数据库—->找到相关的 chunks(段落)—->把检索到的段落和问题组成 prompt —-> 大模型 —-> 回复

Sparse Convolution

卷积核结构

普通：密集
稀疏：有许多零，不参与训练。

计算效率

普通：缦
稀疏：快。常用于训练、推理的加速。

应用领域

普通：需要全局信息和特征密集表示的应用。
稀疏：
1. 大规模图像、点云等稀疏数据（使普通卷积运算时，计算复杂度很高）。
2. 可用于需要快速推理的应用，如无人驾驶的感知任务。

one-shot, few shot

![[lw1.png|650]]

Zero-Shot Learning (零次学习)

基本概念：

![[lw13.png]]

数据：

训练集图片$X{tr}$、类别标签$Y{tr}$
测试集图片$X{te}$、类别标签$Y{te}$
训练集、测试集各类别的描述：$A{tr}$、$A{te}$: 语意向量的每一维代表一种属性。比如是否有尾巴，1代表有，0代表无。
其中描述A：
1. 人工标注。
2. 自学习。（效果差很多）
目前研究方式：
1. 获取合适的类别描述A。(集中于 nlp 方法，发展缓慢，难度大)
2. 建立合适的分类模型。（易出成果）
每个类别向量$y_i \in Y$与语义向量$a_i \in A$一一对应，故可忘记 Y。
我们要做的，是建立特征空间与语义空间之间的映射。
岭回归：带范数约束的均方误差。

![[lw14.png]]

$\Omega ()$通常为2范数约束， $\eta $为超参，对 W求导，并让导为0，即可求出W的值

![[lw15.png]]

上诉结果较naive, 精度为59.1%，可建立更好模型。
ZSL 存在的问题：
1. 领域漂移问题（domain shift problem）:
  同样的特征，但差别很大，如马的尾巴和猪的尾巴。

![[lw16.png]]

枢纽点问题（Hubness problem）
在高维空间内，某些点会成为大多数点的最近邻点。
基于岭回归的方法会加重该问题。
领域漂移解决方法：
样本特征维度 > 语义维度。所以 X 映射到语义空间会丢失信息。
所以，可先把 X 映射到语义空间, 再把语义空间映射回去。
这样可保留更多信息。

![[lw17.png]]

得到83.2%的准确率

枢纽点问题解决方案有2:
1. 若模型为岭回归，则可以建立语义空间到特征空间的映射。

![[lw18.png]]

      得到76.5%的正确率

2. 可用生成模型：不太懂

参考： https://zhuanlan.zhihu.com/p/34656727

top-1 accuracy VS top-5 accuracy

拿一张 blueberry图片预测，得：
cherry: 0.35
raspberry: 0.25
blueberry: 0.2
strawberry: 0.1
apple: 0.06
orange: 0.04
则：

top-1 acc: blueberry != cherry, False.
top-5 acc: blueberry 在概率最高的前五个预测， True.

又例：
![[lw4.png]]

top-1 acc: 2/5
top-5 acc: 3/5

Color Jittering

图像增强的一种，随机改变：

亮度
对比度
饱和度

Beam search

nlp中，用来生成相识问，没有类似ctc中的“-”符号，所以token都是有意义的，不可消。
ctc中，每次一步（3*3=9路径），都需要合并，再取top-3.

sklearn 算法图鉴（待学习）?

![[lw49.png]]

K-Means Clusters

K个初始点的选择，可用K-Means++算法，但也无法避免被离群点影响。

K-Means++：选择距离已知中心最远的点作为新的中心点，代码如下。

最好的方法是，多选择几次不同的初始点，分别聚类，选择误差最小的一个。
[

# coding: utf-8
import math
import random
from sklearn import datasets

def euler_distance(point1: list, point2: list) -> float:
    """
    计算两点之间的欧拉距离，支持多维
    """
    distance = 0.0
    for a, b in zip(point1, point2):
        distance += math.pow(a - b, 2)
    return math.sqrt(distance)

def get_closest_dist(point, centroids):
    min_dist = math.inf  # 初始设为无穷大
    for i, centroid in enumerate(centroids):
        dist = euler_distance(centroid, point)
        if dist < min_dist:
            min_dist = dist
    return min_dist

def kpp_centers(data_set: list, k: int) -> list:
    """
    从数据集中返回 k 个对象可作为质心
    """
    cluster_centers = []
    cluster_centers.append(random.choice(data_set))
    d = [0 for _ in range(len(data_set))]
    for _ in range(1, k):
        total = 0.0
        for i, point in enumerate(data_set):
            d[i] = get_closest_dist(point, cluster_centers) # 与最近一个聚类中心的距离
            total += d[i]
        total *= random.random()
        for i, di in enumerate(d): # 轮盘法选出下一个聚类中心；
            total -= di
            if total > 0:
                continue
            cluster_centers.append(data_set[i])
            break
    return cluster_centers

if __name__ == "__main__":
    iris = datasets.load_iris()
    print(kpp_centers(iris.data, 4))

1	[array([6.2, 2.2, 4.5, 1.5]), array([5.1, 3.7, 1.5, 0.4]), array([4.8, 3.4, 1.6, 0.2]), array([7.4, 2.8, 6.1, 1.9])]

参考文档： https://zhuanlan.zhihu.com/p/32375430

如何选择中心数量K: 手肘法
误差下降突然平缓的点，就是K
有时聚类的K比较主观。
缺点：
1. K值、初始点不好找。
2. 得到的结果是局部最优。
3. 受离群点影响较大。

参考文档： https://zhuanlan.zhihu.com/p/75477709

KNN（K Nearest Neighbors）

根据最近的K个数据点，来判断预测数据点的类别。
优点：
1. 简单易用。
2. 不需要训练。
3. 预测效果好。
4. 对异常值不敏感。
缺点：
1. 对内存要求高，需存储所有训练数据的特征向量。
2. 预测可能很慢：需要和所有数据进行比对。
3. 对数据规模敏感。

参考文档： https://zhuanlan.zhihu.com/p/61341071

Self-training（半监督学习方法）

方法：

利用标号数据训练一个模型
用该模型对未标号的数据进行预测，取置信度较大的预测结果，获得伪标签。
联合真实数据、伪标签数据，从头训练一个新的模型，获得新模型。
重复2，3步。

![[lw100.png]]

Noisy Student

论文： Self-training with Noisy Student improves ImageNet classification（CVPR2020）

在伪标签数据和真实数据对模型（student model）训练时，该模型一般比用于生成伪标签的模型（teacher model）要大。因为在训练student model时，使用了大量 noisy的方法（起的扩充样本的作用）：数据增强、dropout、stochastic depth. 所以 student model应该比teacher model容量要大。
与 self-straining类似，主要区别：给学生加了噪声。
在作为teacher model时，对 unlable的数据，并为进行噪声干扰。
需平衡数据，每类数量相同时效果最好。

![[lw101.png]]

参考文献： https://zhuanlan.zhihu.com/p/164597142

stochastic depth

随机的对batch中的样本进行删除。
该结构只可应用于shot-cut这类残差结构里，通过原始X加上随机去除样本后经过残差块的输出，这样，某些样本的前向推理深度就随机下降了。

参考文献： https://www.zhihu.com/question/540433389/answer/2629056736

cosine 学习率衰减策略

论文《SGDR: Stochastic Gradient Descent with Warm Restarts》

学习率光滑的下降

![[lw103.png]]

公式：

![[lw104.png]]

在周期性重启时，需要把学习率从最低调到最高：

![[lw105.png]]

详情：
![[lw102.png]]

参考文献： https://www.cxyzjd.com/article/Roaddd/113260677

计算模型计算浮点数

卷积层： feature map 的宽高通道数 卷积核的宽高输出通道数
全连接层：全连接的矩阵的宽高
所以，计算量主要在卷积层，参数量在线性层。

L2 norm, L2 Normalize

![[lw202.png]]

迁移学习。

就是先预训练一个模型，在下游任务上做微调。

Closed book QA:

一般的QA，有一段话+一个问题，根据这段话，回答问题。
Closed book QA：直接就只有一个问题，要求得到答案。

FLOPs

FLOPS：注意全大写，是floating point operations per second的缩写，意指每秒浮点运算次数，理解为计算速度。是一个衡量硬件性能的指标。
FLOPs：注意s小写，是floating point operations的缩写（s表复数），意指浮点运算数，理解为计算量。可以用来衡量算法/模型的复杂度。
卷积层 FLOPs 计算：

![[lw224.png]]

参考文档： https://zhuanlan.zhihu.com/p/137719986

GLUE:

![[lw236.png]]
![[lw237.png]]

参考文档： https://paperswithcode.com/method/gelu

EMA

![[lw238.png]]

参考文档： https://www.investopedia.com/terms/e/ema.asp

NMS

Non Maximum Suppression
Step 1 : Select the prediction S with highest confidence score and remove it from P and add it to the final prediction list keep. (keep is empty initially).
Step 2 : Now compare this prediction S with all the predictions present in P. Calculate the IoU of this prediction S with every other predictions in P. If the IoU is greater than the threshold thresh_iou for any prediction T present in P, remove prediction T from P.
Step 3 : If there are still predictions left in P, then go to Step 1 again, else return the list keep containing the filtered predictions.

import torch


def nms_pytorch(P : torch.tensor ,thresh_iou : float):
    """
    Apply non-maximum suppression to avoid detecting too many
    overlapping bounding boxes for a given object.
    Args:
        boxes: (tensor) The location preds for the image 
            along with the class predscores, Shape: [num_boxes,5].
        thresh_iou: (float) The overlap thresh for suppressing unnecessary boxes.
    Returns:
        A list of filtered boxes, Shape: [ , 5]
    """
 
    # we extract coordinates for every 
    # prediction box present in P
    x1 = P[:, 0]
    y1 = P[:, 1]
    x2 = P[:, 2]
    y2 = P[:, 3]
 
    # we extract the confidence scores as well
    scores = P[:, 4]
 
    # calculate area of every block in P
    areas = (x2 - x1) * (y2 - y1)
     
    # sort the prediction boxes in P
    # according to their confidence scores
    order = scores.argsort()
 
    # initialise an empty list for 
    # filtered prediction boxes
    keep = []
     
 
    while len(order) > 0:
         
        # extract the index of the 
        # prediction with highest score
        # we call this prediction S
        idx = order[-1]
 
        # push S in filtered predictions list
        keep.append(P[idx])
 
        # remove S from P
        order = order[:-1]
 
        # sanity check
        if len(order) == 0:
            break
         
        # select coordinates of BBoxes according to 
        # the indices in order
        xx1 = torch.index_select(x1,dim = 0, index = order)
        xx2 = torch.index_select(x2,dim = 0, index = order)
        yy1 = torch.index_select(y1,dim = 0, index = order)
        yy2 = torch.index_select(y2,dim = 0, index = order)
 
        # find the coordinates of the intersection boxes
        xx1 = torch.max(xx1, x1[idx])
        yy1 = torch.max(yy1, y1[idx])
        xx2 = torch.min(xx2, x2[idx])
        yy2 = torch.min(yy2, y2[idx])
 
        # find height and width of the intersection boxes
        w = xx2 - xx1
        h = yy2 - yy1
         
        # take max with 0.0 to avoid negative w and h
        # due to non-overlapping boxes
        w = torch.clamp(w, min=0.0)
        h = torch.clamp(h, min=0.0)
 
        # find the intersection area
        inter = w*h
 
        # find the areas of BBoxes according the indices in order
        rem_areas = torch.index_select(areas, dim = 0, index = order) 
 
        # find the union of every prediction T in P
        # with the prediction S
        # Note that areas[idx] represents area of S
        union = (rem_areas - inter) + areas[idx]
         
        # find the IoU of every prediction in P with S
        IoU = inter / union
 
        # keep the boxes with IoU less than thresh_iou
        mask = IoU < thresh_iou
        order = order[mask]
     
    return keep


# Let P be the following
P = torch.tensor([
    [1, 1, 3, 3, 0.95],
    [1, 1, 3, 4, 0.93],
    [1, 0.9, 3.6, 3, 0.98],
    [1, 0.9, 3.5, 3, 0.97]
])
nms_pytorch(P,0.5)

[tensor([1.0000, 0.9000, 3.6000, 3.0000, 0.9800])]

Refs: https://learnopencv.com/non-maximum-suppression-theory-and-implementation-in-pytorch/#:~:text=Non%20Maximum%20Suppression%20(NMS)%20is,arrive%20at%20the%20desired%20results.

ill-posed problems

Antonym: Well-posed problems.
Well-posed: 3 conditions:
1. a solution exists,
2. the solution is unique,
3. the solution’s behavior changes continuously with the initial conditions.(when x changes little, the result y changes little too. )
The ill-posed problem is compared to overfitting.
often because small changes in input can lead to large changes in output, making them unstable or difficult to resolve without additional constraints or regularization.
sigmoid
$\sigma(x) = \frac{1}{1 + e^{-x}}$ ![[Figure_1.png]]

特点：

把输入归一化到（0， 1）
可微分的阈值单元，与模拟真实神经元阈值较像。
在隐含层中已很少使用，求导后最大值为0.25，会造成梯度消失，被relu取代。

![[ds11.png]]

接近0时近似线性。

import torch
from d2l import torch as d2l
x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
y = torch.sigmoid( x)
d2l.plot(x.detach(), y.detach(), 'x', 'sigmoid(x)', figsize=(5, 2.5))
d2l.plt.show()

import torch
from d2l import torch as d2l
x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
y = torch.sigmoid( x)
if hasattr(x.grad, 'data'):
    x.grad.data.zero_()
y.backward(torch.ones_like(x), retain_graph=True)
d2l.plot(x.detach(), x.grad, 'x', 'grad of sigmoid', figsize=(5, 2.5))

(semantic, Instance, Panoramic) segmentation

semantic segmentation

Be pure for pixel classification, don’t need to distinguish the same kind instances.
![[Pasted image 20230903105909.png]]
Instance segmentation
Need to distinguish the same kind instances.
![[Pasted image 20230903105916.png]]

Panoramic segmentation

Segment all objection including the background.
![[Pasted image 20230903110051.png|400]]

convex combination

$V’i=\sum{n}wnV_n$, Where $W_n\ge0$ and $\sum{n}w_n=1$

Like the below, the convex combination of those input points must be in Convex Hull.
![[Pasted image 20230904205822.png|575]]
and, the biggest angle of the convex combination is must be equal to or less than the biggest angle of the original input points(features). (assuming the input points don’t contain the origin)
![[Pasted image 20230904210239.png|575]]

转置卷积

交叉熵损失_VS_L1Loss

1. 任务性质的不同

2. 交叉熵损失的适用性

3. L1 损失的局限性

4. 交叉熵损失的优越性

总结

交叉熵损失的数值不稳定性

各种卷积类型

普通卷积

空洞卷积（Dilated Convolution）

1. 传统卷积的局限性

2. 空洞卷积的引入

3. 原理细节

4. 数学表述

5. 应用与优势

6. 实际效果

Deformable Convolution

优势与应用

实际效果

可变形卷积中的 $\Delta p$ 是通过什么网络得到的？

具体过程如下：

例子说明：

Adam/AdamW

指数加权平均

SGD

Momentum

RMSProp

Adam

AdamW

Adam/AdamW参数量

分类中的 IoU

The Rank Loss Problem of Self Attention

温度系数

熵

自信息量

交叉熵（Cross Entropy）

经典的二分类的交叉熵损失

分解KL散度

这里的信息损失：

1. 预测模型中的信息损失

2. 数据压缩中的信息损失

3. 自然语言处理中的信息损失

为什么 $Q(x)$ 比 $P(x)$ 需要更多比特来编码

自信息量（Self-Information）

理想编码长度

使用近似分布进行编码

平均编码长度

举例说明

总结

交叉熵损失

归纳偏置（Inductive Bias）

Attention机制的优势

总结

softmax

Softmax求梯度的公式推导

步骤 1: Softmax的偏导数

情况 1: $i = j$

情况 2: $i \neq j$

合并结果

Softmax函数在输入值范围较大时会导致梯度消失，而不是梯度爆炸

梯度消失的原因

具体分析

使用 $\sqrt{d_k}$ 进行缩放的原因

总结

OOD accuracy

向量的高效搜索

近似最邻近

如何实现

分区

三种局部敏感哈希函数原理

Incremental learning

思维链方法（CoT）

MoE

RAG

Sparse Convolution

卷积核结构

计算效率

应用领域

one-shot, few shot

计算模型计算浮点数