0%

TriDet

The detail of TriDet.

The Rank Loss Problem of Self Attention

  1. Self attention loses rank doubly exponentially with depth at initialization.(i.e. the more deep, the more same the outputs are)
  2. 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 函数通常定义如下：

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

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

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

熵

自信息量

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

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

交叉熵（Cross Entropy）

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

分解KL散度

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

第一项 $\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）是信息论中的一个基本概念，用来度量事件发生所带来的信息量。自信息量的公式为：

其中：

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

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

理想编码长度

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

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

使用近似分布进行编码

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

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

平均编码长度

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

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

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

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

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

举例说明

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

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

计算如下：

具体计算为：

这表示在真实分布 $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)$。交叉熵损失的公式为：

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

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

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

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

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

归纳偏置（Inductive Bias）

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

Attention机制的优势

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

  1. 广泛的归纳偏置：Attention机制的设计允许它能够处理更广泛的和更一般化的信息。这意味着它没有强加于数据的一些特定的假设，比如数据的顺序或空间关系。因此，Attention机制可以在不同类型的数据上表现出色，而不仅仅是在时间序列数据或图像数据上。

  2. 没有空间假设：因为Attention机制没有像CNN那样假设局部的空间关系，它可以学到更全局的信息。这使得Attention机制在很多任务上能够比CNN取得更好的结果，特别是在需要全局上下文信息的任务中。

  3. 代价：正因为Attention机制的假设更为一般化，它需要更多的数据和更大的模型来弥补其在具体结构信息（如序列和空间信息）上的不足。因此，尽管它可以达到甚至超越RNN和CNN的效果，但需要在数据和计算资源上进行更多的投入。

总结

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

softmax

Softmax求梯度的公式推导

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

其中，$\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时，我们得到：

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

将公式简化，我们得到：

进一步简化为：

情况 2: $i \neq j$

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

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

将公式简化，我们得到：

进一步简化为：

合并结果

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

其中，$\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}}$，其梯度为：

在极端情况下：

  • 当 $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}$ 进行缩放的原因

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

通过除以 $\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

    如何实现

  1. 分区：把数据空间分成许多“区域”，每个区域包含一些点。搜索时，先找到查询点所在的区域或相邻的区域，然后在这些区域中搜索最近的点。这就像图书馆中的书架，每个书架代表一个区域，书架上的书相对更接近。

  2. 树结构：使用树结构（如KD树或球树）来组织数据点。每次分支代表对空间的一次分割，最终将查询点快速引导至包含最近邻点的区域。

  3. 哈希：利用哈希函数将点映射到哈希表的桶中。相近的点通过哈希函数映射到相同或相近的桶，从而在搜索时可以直接定位到这些桶来查找最近邻。

分区

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

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

  • 位采样：根据特定位的数值，作为区分向量的依据。
  • 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:

  1. Experts: lots of small models that specialize in certain types of tasks.
  2. Gating Network: select the proper expert. 生成的概率分布，表示每个专家的激活值。
  3. 加权组合：被激活的专家 根据门控机制的权重进行加权组合，最终形成模型的输出。
    优势:
  4. 效率高，每次进激活几个专家。
  5. 可扩展性好：可以增加更多的专家提高模型的能力，而不显著增加计算成本。
  6. 灵活性强：不同专家可以专注于各种细分场景的任务。

    RAG

    Retrieval-augmented generation
    Main 2 steps:
  7. Retrieval information: external information, such as up-to-date documents, webs on the internet.
  8. 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

Sparse Convolution

卷积核结构

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

计算效率

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

应用领域

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

one-shot, few shot

![[lw1.png|650]]

Zero-Shot Learning (零次学习)

基本概念：

![[lw13.png]]

数据：

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

![[lw14.png]]

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

![[lw15.png]]

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

![[lw16.png]]

  1. 枢纽点问题（Hubness problem）
    在高维空间内，某些点 会成为 大多数点的 最近邻点。
    基于 岭回归 的方法 会 加重 该问题。

  2. 领域漂移 解决方法：
    样本 特征维度 > 语义维度。所以 X 映射到 语义空间 会 丢失信息。
    所以， 可先把 X 映射到 语义空间, 再把 语义空间 映射回去。
    这样可 保留 更多信息。

![[lw17.png]]

得到83.2%的准确率

  1. 枢纽点问题 解决方案 有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
则：

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

又例：
![[lw4.png]]

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

Color Jittering

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

  1. 亮度
  2. 对比度
  3. 饱和度

Beam search

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

sklearn 算法图鉴（待学习）?

![[lw49.png]]

K-Means Clusters

  1. K个初始点 的选择， 可用K-Means++算法，但也 无法避免 被 离群点 影响。
    1. K-Means++：选择距离已知 中心 最远的点 作为 新的中心点， 代码如下。
    2. 最好的方法是，多选择几次不同 的 初始点，分别聚类， 选择误差 最小的一个。
      [
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      # 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

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

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

KNN（K Nearest Neighbors）

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

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

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

方法：

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

![[lw100.png]]

Noisy Student

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

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

![[lw101.png]]

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

stochastic depth

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

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

cosine 学习率衰减策略

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

  1. 学习率光滑的下降

![[lw103.png]]

  1. 公式：

![[lw104.png]]

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

![[lw105.png]]

详情：
![[lw102.png]]

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

计算 模型 计算浮点数

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

L2 norm, L2 Normalize

![[lw202.png]]

迁移学习。

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

Closed book QA:

  1. 一般的QA，有一段话+一个问题，根据这段话，回答问题。
  2. 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

Adam

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
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

  1. Antonym: Well-posed problems.
  2. 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. )
  3. The ill-posed problem is compared to overfitting.
  4. 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

    ![[Figure_1.png]]

特点：

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

![[ds11.png]]

  1. 接近0时近似线性。
1
2
3
4
5
6
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()
1
2
3
4
5
6
7
8
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

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

    Instance segmentation

  2. Need to distinguish the same kind instances.
    ![[Pasted image 20230903105916.png]]

Panoramic segmentation

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

convex combination

$V’_i=\sum_{n}w_nV_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]]