计算机视觉准备八股中

一边记录一边看，这段实习跑路之前运行完3DGAN，弄完润了，现在开始记忆八股

1.CLIP模型的主要创新点：

图像和文本两种不同模态数据之间的深度融合、对比学习、自监督学习

2.等效步长是每一步操作步长的乘积

3.卷积层计算输入输出的公式：

4.a=np.random.randn(3,3) b=np.random.randn(3,1) ，那么c=a*b的维度应该是，*是元素乘法，会触发广播机制，b会变为形状（3，3），最终c的形状是（3，3）

5.带宽（Bandwidth）是指在单位时间内，网络或通信系统能够传输的数据量，通常以比特每秒（bps）为单位表示。它是衡量数据传输能力的重要指标，带宽越大，传输数据的速度越快

减少模型层数据和缩小输入尺寸可以有效降低深度学习推理的带宽需求。

6.解决样本不均衡的方法有Focal Loss、数据增强、多样本欠采样

7.Dice损失常用于图像分割、目标检测、自然语言处理

8.某个矩阵的某个特征值为0，则为奇异矩阵,不满秩；行列式为0的方阵称为奇异矩阵。

矩阵的奇异值是矩阵A乘A转置的特征值的平方根。如果矩阵有特征值为0，则其对应的奇异值也为0。因此，特征值为0的矩阵至少有一个奇异值为0
奇异矩阵的定义要求矩阵必须是方阵（即行数和列数相等）。如果矩阵不是方阵，则无法讨论其是否为奇异矩阵

9.不是任意矩阵都能特征分解；并不是所有方阵的特征值都是实数；奇异矩阵至少有一个特征值为 0；矩阵B可以分解为A和A转置，若A为行满秩，则B的特征向量一定正交

10.同一台电脑两次运算一个浮点运算的值可能不同；浮点数不满足结合律；浮点数不能批量填充 0 比特；正常浮点数乘除法仍是正常浮点数

11.手写kmeans聚类

import numpy as np
import matplotlib.pyplot as plt

def initialize_centroids(X, k):
    """随机初始化k个质心"""
    indices = np.random.choice(X.shape[0], k, replace=False)
    return X[indices]

def assign_clusters(X, centroids):
    """将每个样本分配到最近的质心"""
    distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
    return np.argmin(distances, axis=1)

def update_centroids(X, labels, k):
    """根据分配更新质心位置"""
    return np.array([X[labels == i].mean(axis=0) for i in range(k)])

def k_means(X, k, max_iters=100, tol=1e-4):
    """K-means算法实现"""
    # 初始化质心
    centroids = initialize_centroids(X, k)
    for _ in range(max_iters):
        # 保存旧质心
        old_centroids = centroids
        # 分配样本到最近质心
        labels = assign_clusters(X, centroids)
        # 更新质心
        centroids = update_centroids(X, labels, k)
        # 检查质心移动是否小于容差
        if np.all(np.linalg.norm(centroids - old_centroids, axis=1) < tol):
            break
    return centroids, labels

# 示例：生成测试数据
np.random.seed(42)
X = np.random.rand(300, 2)  # 300个二维数据点

# 运行K-means算法
k = 3
centroids, labels = k_means(X, k)

# 可视化结果
plt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis')
plt.scatter(centroids[:, 0], centroids[:, 1], c='red', s=200, alpha=0.75, marker='X')
plt.title("K-means Clustering")
plt.show()

12.因为做了医学图像的实习，得看一下论文，主要是下面这几篇，同事的功劳也是我的功劳，发动功劳转移

Breaking the Dilemma of Medical Image-to-image Translation

Wasserstein GAN

Improved Training of Wasserstein GANs

13.SVM，看下面的四个链接，讲的挺详细，组会当时是我同门讲的，哥们划水

机器学习：深入解析SVM的核心概念【一、间隔与支持向量】_svm核心-CSDN博客文章浏览阅读1.5k次，点赞11次，收藏32次。在数学和物理中，一个平面或超平面的法向量是一个垂直于该平面的向量。在SVM的上下文中，超平面是决策边界，用来划分不同类别的数据点。SVM 的目标是构建一个具有最大间隔的决策边界，而间隔边界的设定≥1\geq +1≥1和≤−1\leq -1≤−1为了确保数学模型的一致性，并简化优化过程。这种方式定义的间隔是所有支持向量到超平面的最小距离，最大化这个距离帮助SVM提高分类器的泛化能力。_svm核心https://leo-la.blog.csdn.net/article/details/138164031

机器学习：深入解析SVM的核心概念【二、对偶问题】_svm对偶问题-CSDN博客文章浏览阅读1.7k次，点赞46次，收藏32次。这个优化问题是凸二次规划问题，因为它具备了凸规划问题所需的两个主要特性：一个凸的和凸的。目标函数 12∣∣ω∣∣2\frac{1}{2} ||\omega||^221∣∣ω∣∣2 是凸的：因为这个函数的二阶导数相对于 ω\omegaω 为正值，这保证了该函数是凸的，也就是说，它在任意方向上都是。约束条件是凸的：对于 SVM 的约束 yi(ωTxi+b)≥1y_i(\omega^T x_i + b) \geq 1yi(ωTxi+b)≥1，它们定义了一个。为了形成凸优化问题，约束条件本身也必须形成一个凸集_svm对偶问题https://leo-la.blog.csdn.net/article/details/138254287

机器学习：深入解析SVM的核心概念【三、核函数】_核函数机器学习-CSDN博客文章浏览阅读1.1k次，点赞24次，收藏28次。在实践中，选择合适的核函数对于构建有效的SVM模型至关重要。它不仅影响模型对数据的理解和分界线的构建，也影响模型的泛化能力。通过使用核函数，SVM可以在复杂的数据集上找到简洁的决策规则，即便在原始特征空间中数据是高度非线性的。问题四：半正定性理解半正定性是高维空间中的一个重要概念，我们可以用一个简化的类比来帮助理解。想象你有一座山，山顶是最高点。如果这座山的形状是凸的（像一个碗），那么无论你在山腰的哪个位置开始，都可以直接走最陡峭的路线到达山顶。在这座“凸山”上，无论你选择哪条路径，你总能达到山顶。_核函数机器学习https://leo-la.blog.csdn.net/article/details/138323547

机器学习：深入解析SVM的核心概念【四、软间隔与正则化】_软间隔svm原理-CSDN博客文章浏览阅读1.4k次，点赞12次，收藏23次。软间隔SVM是对传统的硬间隔SVM的扩展，它允许某些数据点违反最初的分类边界。这样做的目的是提高模型对噪声和异常值的，从而获得更好的泛化能力。在这个设置中，优化目标函数的推导过程是这样的：软间隔引入：为了应对现实世界数据中的噪声和不完全线性可分的情况，引入软间隔的概念。在硬间隔SVM中，所有数据点都严格满足 yi(wTxi+b)≥1y_i (w^T x_i + b) \geq 1yi(wTxi+b)≥1 的约束。在软间隔SVM中，我们允许某些点不满足这个条件，引入松弛变量 ξi\xi_iξi 来衡量每_软间隔svm原理https://leo-la.blog.csdn.net/article/details/138325130

14.bn层与卷积层参数融合

在cnn中，如果卷积层之后接Bn层，那么一般设置bias为0，因为bias会在下一层BN归一化时减去均值消掉，徒增计算，这也是为什么我们看到很多时候卷积层设置bias，有时候又不设置。

这里是model1

import numpy as np
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
 
class ConvWithBn(nn.Module):
    def __init__(self, ):
        super(ConvWithBn, self).__init__()
        self.conv1 = nn.Conv2d(3, 8, kernel_size=3, stride=1, padding=1, bias=False) 
        self.bn1 = nn.BatchNorm2d(8)
        self._initialize_weights()
 
    def forward(self, x):
        x = self.bn1(self.conv1(x))
        return x
    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.normal_(0, 1)
                m.bias.data.normal_(0, 1)
                m.running_mean.data.normal_(0, 1)
                m.running_var.data.uniform_(1, 2)

后面直接用模型1的权重加到模型3上面

这个是model3

class ConvWithBias(nn.Module):
    def __init__(self, ):
        super(ConvWithBias, self).__init__()
        self.conv1 = nn.Conv2d(3, 8, kernel_size=3, stride=1, padding=1, bias=True) 
    def forward(self, x):
        x = self.conv1(x)
        return x

合并的代码如下

Model3 = ConvWithBias()
# 提取模型1每一层参数
conv1w = model1_cpkt['conv1.weight']
bnw = model1_cpkt['bn1.weight']
bnb = model1_cpkt['bn1.bias']
bnmean = model1_cpkt['bn1.running_mean']
bnvar = model1_cpkt['bn1.running_var']
# 维度扩展
bnwexp = bnw.unsqueeze(1).unsqueeze(2).unsqueeze(3)
bnvarexp = bnvar.unsqueeze(1).unsqueeze(2).unsqueeze(3)
# 合并卷积BN层
new_conv1w = (bnwexp*conv1w)/(torch.sqrt(bnvarexp+1e-5))
new_conv2b = (bnb - bnw*bnmean/(torch.sqrt(bnvar+1e-5)))
merge_state_dict = {}
merge_state_dict['conv1.weight'] = new_conv1w
merge_state_dict['conv1.bias'] = new_conv2b
 
Model3.load_state_dict(merge_state_dict)
Model3.eval()
out3 = Model3(input)
print("Bias of merged ConvBn : ",torch.sum(out3 - out1))

15.FCN(全卷积神经网络)，ATSS，可形变transformer和可形变卷积，找论文看看

还有就是SSD，Yolo，FasterRCNN，deeplab，repvgg，yolof

16.手写batchnormal

import torch

class BatchNorm:
    def __init__(self, num_features, eps=1e-5, momentum=0.1):
        self.num_features = num_features
        self.eps = eps
        self.momentum = momentum
        # 可学习参数
        self.gamma = torch.ones(num_features)
        self.beta = torch.zeros(num_features)
        # 运行时的均值和方差
        self.running_mean = torch.zeros(num_features)
        self.running_var = torch.ones(num_features)

    def forward(self, x, training=True):
        if x.dim() != 4:
            raise ValueError("输入数据必须是4D张量：[batch_size, channels, height, width]")
        batch_size, channels, height, width = x.shape
        if training:
            # 计算均值和方差
            mean = x.mean(dim=(0, 2, 3), keepdim=True)  # [1, channels, 1, 1]
            var = x.var(dim=(0, 2, 3), keepdim=True)    # [1, channels, 1, 1]
            # 更新运行时的均值和方差
            self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * mean.squeeze()
            self.running_var = (1 - self.momentum) * self.running_var + self.momentum * var.squeeze()
        else:
            mean = self.running_mean.view(1, channels, 1, 1)
            var = self.running_var.view(1, channels, 1, 1)
        # 归一化
        x_hat = (x - mean) / torch.sqrt(var + self.eps)
        # 缩放和平移
        y = self.gamma.view(1, channels, 1, 1) * x_hat + self.beta.view(1, channels, 1, 1)
        return y

17.手写layernormal

18.Max Pooling：反向传播时，梯度仅通过前向传播时记录的最大值位置传递，其他位置的梯度为 0

Avg Pooling：反向传播时，梯度被均匀分配到池化窗口中的每个位置

19.进程和线程的区别

进程：进程是程序的一次执行实例，是操作系统进行资源分配和调度的基本单位。每个进程拥有独立的内存空间、代码、数据和系统资源,一个进程的崩溃不会直接影响其他进程,进程是操作系统调度的基本单位，进程间的切换开销较大,创建和销毁进程的开销较大

线程：线程是进程中的一个执行单元，是程序执行流的最小单位。一个进程可以包含多个线程，这些线程共享进程的资源,线程间的切换开销较小,创建和销毁线程的开销较小,若某个线程出错（如死锁、崩溃等），可能会影响到整个进程

20.深度可分离卷积的原理、参数量的计算

深度可分离卷积核心思想是将标准卷积分解为两个独立的步骤：深度卷积（Depthwise Convolution）和逐点卷积（Pointwise Convolution）。

标准卷积的参数量：Paramsstandard=k×k×Cin×Cout*H×W

深度可分离卷积的参数量：Paramsseparable=（k×k×Cin+Cin×Cout）*H×W

21.手写layernormal

import torch
import torch.nn as nn

class LayerNorm(nn.Module):
    def __init__(self, d_model, eps=1e-6):
        super(LayerNorm, self).__init__()
        # 可学习参数
        self.gamma = nn.Parameter(torch.ones(d_model))  # 缩放参数
        self.beta = nn.Parameter(torch.zeros(d_model))  # 平移参数
        self.eps = eps  # 防止分母为零的小常数

    def forward(self, x):
        # 计算均值和方差
        mean = x.mean(-1, keepdim=True)  # 在最后一个维度上计算均值
        std = x.std(-1, unbiased=False, keepdim=True)  # 在最后一个维度上计算标准差
        # 归一化并应用仿射变换
        return self.gamma * (x - mean) / (std + self.eps) + self.beta

22.Adam优化器的优势

自适应学习率：Adam通过计算每个参数的一阶矩（均值）和二阶矩（方差）来动态调整学习率，避免了手动调整学习率的复杂性

SGD优化器的优势

SGD的超参数较少，调参相对简单，计算量较小，内存占用少

Adam在某些情况下更容易发散，而SGD的发散风险较低，但需要仔细调整学习率

23.softmax手写

import torch
import torch.nn as nn
class softmax(nn.Module):
    def __init__(self,dim=None):
        super(softmax,self).__init__()
        self.dim=dim
    def forward(self,x):
        x=x-torch.max(x,dim=self.dim,keepdim=True).values
        exp=torch.exp(x)
        torch_sum=torch.sum(exp,dim=self.dim,keepdim=True)
        return exp/torch_sum
input_tensor = torch.tensor([[1.0, 2.0, 3.0], [1.0, 2.0, 3.0]])
softmax_layer = softmax(dim=1)
output_tensor = softmax_layer(input_tensor)
print(output_tensor)

24. ROC曲线

ROC曲线是一种图形化工具，用于展示分类模型在不同阈值下的性能。它通过绘制以下两个指标的关系来生成：

真正例率（True Positive Rate, TPR）：表示实际为正类的样本中被正确预测为正类的比例

假正例率（False Positive Rate, FPR）：表示实际为负类的样本中被错误预测为正类的比例

AUC

AUC是ROC曲线下的面积，用于量化模型的分类能力。AUC的取值范围在0到1之间

25.深拷贝和浅拷贝的区别

浅拷贝创建一个新对象，并将原对象的字段值复制到新对象中。对于基本数据类型，直接复制其值；对于引用类型字段，仅复制其引用（内存地址），而不是引用指向的实际对象。

深拷贝创建一个新对象，并递归地复制原对象的所有字段，包括引用类型字段指向的实际对象。新对象和原对象完全独立，不共享任何内存地址。

26.统计文件个数

ls -l | grep "^-" | wc -l

27.Inception结构详解(从V1到V4，再到xcpetion)

Inception结构详解(从V1到V4，再到xcpetion)_inception模型-CSDN博客文章浏览阅读1.2w次，点赞17次，收藏133次。详细讲了关于Inception结构的内容和原理(从Inception V1到Inception V4，再到xcpetion)，都做了详细的介绍_inception模型https://blog.csdn.net/ximu__l/article/details/129495171?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522a39039c32dddf6e6cfd00bac631e6d86%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=a39039c32dddf6e6cfd00bac631e6d86&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-129495171-null-null.142^v102^pc_search_result_base6&utm_term=Inception&spm=1018.2226.3001.4187

28.Pytorch 怎么实现多卡的Batch Normalization的同步

在 PyTorch 中，实现多卡训练时的 Batch Normalization（BN）同步可以通过 SyncBatchNorm（同步批量归一化）来实现。SyncBatchNorm 会跨多个 GPU 同步均值和方差，确保所有 GPU 使用相同的统计量进行归一化，从而提升模型训练的稳定性和效果。

29.手写MSA

import torch
import torch.nn as nn
import torch.nn.functional as F
class Multinalhead(nn.Module):
    def __init__(self,embed_dim,head):
        super(Multinalhead,self).__init__()
        self.embed_dim=embed_dim
        self.head=head
        self.head_dim=self.embed_dim//self.head
        self.query=nn.Linear(self.embed_dim,self.embed_dim)
        self.key=nn.Linear(self.embed_dim,self.embed_dim)
        self.value=nn.Linear(self.embed_dim,self.embed_dim)
        self.out=nn.Linear(self.embed_dim,self.embed_dim)
    def forward(self,q,k,v,mask=None):
        batch_size=q.size(0)
        Q = self.query(q)
        K = self.key(k)
        V = self.value(v)
        Q = Q.view(batch_size,-1,self.head,self.head_dim).transpose(1,2)
        K = K.view(batch_size, -1, self.head, self.head_dim).transpose(1, 2)
        V = V.view(batch_size, -1, self.head, self.head_dim).transpose(1, 2)
        score=torch.matmul(Q,K.transpose(-2,-1))/torch.sqrt(torch.tensor(self.head_dim,dtype=torch.float32))
        if mask:
            score=score.masked_fill(mask==0,-1e9)
        weight=F.softmax(score,dim=-1)
        context=torch.matmul(weight,V)
        context=context.transpose(1,2).contiguous().view(batch_size,-1,self.embed_dim)
        result=self.out(context)
        return result
import torch

# 定义模型参数
embed_dim = 64  # 输入和输出的维度
num_heads = 8   # 注意力头的数量

# 创建多头注意力层
multihead_attn = Multinalhead(embed_dim, num_heads)

# 创建模拟输入数据 (batch_size, sequence_length, embed_dim)
batch_size = 10
seq_length = 20
query = torch.randn(batch_size, seq_length, embed_dim)
key = torch.randn(batch_size, seq_length, embed_dim)
value = torch.randn(batch_size, seq_length, embed_dim)

# 计算多头注意力输出
output = multihead_attn(query, key, value)

print(output.shape)

30.手写FFN

import torch
import torch.nn as nn
class FeedForward(nn.Module):
    def __init__(self, embed_dim, ff_dim):
        super(FeedForward, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(embed_dim, ff_dim),
            nn.ReLU(),
            nn.Linear(ff_dim, embed_dim)
        )

    def forward(self, x):
        return self.net(x)
# 定义参数
embed_dim = 512  # 输入和输出的维度
ff_dim = 2048    # 中间层的维度

# 创建 FeedForward 实例
ffn = FeedForward(embed_dim, ff_dim)

# 创建模拟输入数据 (batch_size, seq_length, embed_dim)
batch_size = 10
seq_length = 20
x = torch.randn(batch_size, seq_length, embed_dim)

# 前向传播
output = ffn(x)

print(output.shape)

31.基础知识，深度学习之pytorch物体检测实战，讲的挺详细，董洪义那本，这两天看一下

还有opencv的那本，都得看

32.归一化方法：BN/LN/IN/GN/FN_instancenormalization bn-CSDN博客文章浏览阅读2.3w次，点赞52次，收藏188次。本文详细介绍了批量标准化(BN)、实例标准化(IN)、特征标准化(FN)及它们之间的区别。探讨了BN如何解决内部协变量偏移问题，以及BN、IN、LN、GN各自的应用场景。https://blog.csdn.net/mzpmzk/article/details/80043076?ops_request_misc=&request_id=&biz_id=102&utm_term=BN%E3%80%81LN%E3%80%81IN%E3%80%81GN&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-80043076.142^v102^pc_search_result_base6&spm=1018.2226.3001.4187

33.Dropout前传和后传的差异

在前向传播中，Dropout 会以概率 p 随机丢弃一部分神经元，并将保留的神经元的输出值缩放为 1/(1−p)，以保持期望值不变。

在反向传播中，Dropout 只对前向传播中保留的神经元进行梯度更新，被丢弃的神经元的梯度为 0。

训练阶段：在训练时，Dropout 会随机丢弃神经元，并对保留的神经元进行缩放。

测试阶段：在测试时，Dropout 会被关闭，所有神经元都参与计算，且不需要进行缩放。

当 BN（Batch Normalization）和 Dropout 一起使用时，可能会出现 方差偏移（Variance Shift） 的问题，导致模型性能下降，

Dropout 会通过保留率 p 缩放响应，改变神经元的方差。
BN 仍然使用训练时累计的滑动方差，导致测试时的方差与训练时的方差不匹配。
这种 方差不匹配 会导致数值不稳定，随着网络加深，预测偏差会累积，从而降低模型性能

34.attention机制的优势和劣势分别在哪里？

优点：Attention 机制能够同时捕捉全局和局部信息，避免了 RNN 对长期依赖的捕捉受序列长度限制的问题，与 RNN 不同，Attention 的每一步计算不依赖于上一步的结果，因此可以并行处理

缺点：Attention 机制本身无法直接捕捉序列中的位置信息，需要通过额外的手段（如位置编码）来补充，处理长序列时，Attention 的计算复杂度会显著增加，Attention 机制的效果依赖于大量数据，如果数据量不足，可能无法充分发挥其优势

35.1*1卷积核作用

1、实现跨通道的交互和信息整合

2、进行卷积核通道数的降维和升维

36.各种IOU【深度学习实战（49）】目标检测损失函数：IoU、GIoU、DIoU、CIoU、EIoU、alpha IoU、SIoU、WIoU原理及Pytorch实现_深度学习wiou-CSDN博客文章浏览阅读1.1k次，点赞17次，收藏24次。目标检测损失函数：IoU、GIoU、DIoU、CIoU、EIoU、alpha IoU、SIoU、WIoU原理及Pytorch实现_深度学习wiouhttps://blog.csdn.net/m0_51579041/article/details/140837130?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%90%84%E7%A7%8DIOU&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-5-140837130.142^v102^pc_search_result_base6&spm=1018.2226.3001.4187

37.Average Precision，是单个类别平均精确度，而mAP是所有类别的平均精确度

mAP@0.5：在 IoU 阈值为 0.5 时计算得到的 mAP，适用于评估模型能否大致定位目标。
mAP@0.5:0.95：在多个 IoU 阈值（从 0.5 到 0.95，步长为 0.05）下计算得到的平均 mAP，提供了更全面和严格的评估标准。

38.可变形卷积，看下面这个，挺详细

结合可变形注意力的视觉Transformer-CSDN博客文章浏览阅读5.1k次，点赞4次，收藏39次。首先要理解Q,K,VQ,K,VQ,K,V：Softmax(QKT)VSoftmax(QK^{T})VSoftmax(QKT)V假设window内的patch总数为3，则有：可以想象，对于3×33\times 33×3注意力分布，即QKTQK^{T}QKT，行代表query，列代表key，QKT[i,j]QK^{T}[i,j]QKT[i,j]为patch iii (query)和patch jjj (key)的相似度。对于SwinT中的相对位置偏置信息：Softmax(QKT+B)VSoftmax(QK^{_视觉transformerhttps://blog.csdn.net/qq_40943760/article/details/125091334?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522203c82e1708c6a7cbd6cbf8dfaab2d8b%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=203c82e1708c6a7cbd6cbf8dfaab2d8b&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-125091334-null-null.142^v102^pc_search_result_base6&utm_term=%E5%8F%AF%E5%8F%98%E5%BD%A2%E6%B3%A8%E6%84%8F%E5%8A%9BTransformer&spm=1018.2226.3001.4187

可变形transformer,看这个

可变形注意力DAttention-CSDN博客文章浏览阅读787次，点赞26次，收藏21次。论文题目：Vision Transformer with Deformable Attention现有的分层Vision Transformer，特别是PVT [36]和Swin Transformer [26]，试图解决过度关注的挑战。前者的下采样技术导致严重的信息丢失，而后者的shiftwindow注意力导致感受野的增长要慢得多，这限制了对大型物体建模的潜力。因此，需要数据相关的稀疏注意力来灵活地对相关特征进行建模，从而导致在DCN中首次提出的变形机制[9]。https://blog.csdn.net/2301_80086153/article/details/145657007?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%8F%AF%E5%8F%98%E5%BD%A2%E6%B3%A8%E6%84%8F%E5%8A%9BTransformer&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-4-145657007.142^v102^pc_search_result_base6&spm=1018.2226.3001.4187

39.IOU手写

def IoU(box1, box2):
    b1_x1, b1_y1, b1_x2, b1_y2 = box1
    b2_x1, b2_y1, b2_x2, b2_y2 = box2
    
    xx1 = np.maximum(b1_x1, b2_x1)
    yy1 = np.maximum(b1_y1, b2_y1)
    xx2 = np.minimum(b1_x2, b2_x2)
    yy2 = np.minimum(b1_y2, b2_y2)
    
    w = np.maximum(0.0, yy2 - yy1)
    h = np.maximum(0.0, xx2 - xx1)
 
    inter = w * h
    IoU = inter/((b1_x2-b1_x1)*(b1_y2-b1_y1) + (b2_x2-b2_x1)*(b2_y2-b2_y1) - inter)
    print("IoU: ", IoU)
 
 
if __name__ == "__main__":
    box1 = np.array([100, 100, 210, 210])
    box2 = np.array([150, 150, 230, 220])
    IoU(box1, box2)

40.Transformer的相关问题（小红书看看）

收藏！关于Transformer的20个常见面试问题，你知道多少？_transformer面试-CSDN博客文章浏览阅读1k次，点赞17次，收藏22次。此前，介绍了很多关于Transformer的内容，但都非常长，今天，就用简短的语言总结Transformer的20个常见面试问题，看看你了解多少？Transformer为何使用多头注意力机制？（为什么不使用一个头）使用单个注意力头的模型在处理复杂的输入时可能会受到限制，因为它只能关注输入序列中的某一方面信息。而多头注意力机制通过将输入特征分成多个子空间，使得每个头可以独立学习不同的特征表示。例如，在处理句子时，一个头可能专注于语法结构，而另一个头则可能关注语义关系。_transformer面试https://blog.csdn.net/m0_70486148/article/details/144715335?ops_request_misc=&request_id=&biz_id=102&utm_term=.Transformer%E7%9A%84%E7%9B%B8%E5%85%B3%E9%97%AE%E9%A2%98&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-144715335.142^v102^pc_search_result_base6&spm=1018.2226.3001.4187

41.空洞卷积输出大小

42.deeplab系列总结（感觉可以不用看，我同事做分割的没听过）

43.NMS手写

import numpy as np

def nms(boxes, scores, iou_threshold=0.5):
    """
    非极大值抑制(NMS)实现
    :param boxes: (N,4)格式的检测框，格式为[x1,y1,x2,y2]
    :param scores: (N,)对应的置信度分数
    :param iou_threshold: IOU重叠阈值
    :return: 保留的检测框索引
    """
    # 1. 获取按分数降序排列的索引
    order = scores.argsort()[::-1]
    
    keep = []  # 保留的结果索引
    
    while order.size > 0:
        # 2. 选取当前分数最高的框
        i = order[0]
        keep.append(i)
        
        # 3. 计算当前框与其他所有框的IOU
        xx1 = np.maximum(boxes[i, 0], boxes[order[1:], 0])
        yy1 = np.maximum(boxes[i, 1], boxes[order[1:], 1])
        xx2 = np.minimum(boxes[i, 2], boxes[order[1:], 2])
        yy2 = np.minimum(boxes[i, 3], boxes[order[1:], 3])
        
        w = np.maximum(0.0, xx2 - xx1)
        h = np.maximum(0.0, yy2 - yy1)
        intersection = w * h
        
        area_i = (boxes[i, 2] - boxes[i, 0]) * (boxes[i, 3] - boxes[i, 1])
        area_j = (boxes[order[1:], 2] - boxes[order[1:], 0]) * (boxes[order[1:], 3] - boxes[order[1:], 1])
        union = area_i + area_j - intersection
        
        iou = intersection / union
        
        # 4. 保留IOU小于阈值的框索引
        inds = np.where(iou <= iou_threshold)[0]
        order = order[inds + 1]  # 因为计算时跳过了第一个元素
        
    return keep

# 测试示例
if __name__ == "__main__":
    # 示例数据：每个框格式[x1,y1,x2,y2]
    boxes = np.array([
        [100, 100, 210, 210],
        [150, 150, 230, 220],
        [120, 80, 215, 205],
        [200, 200, 300, 300],
        [90, 90, 190, 190]
    ])
    
    # 对应的置信度分数
    scores = np.array([0.95, 0.9, 0.85, 0.7, 0.6])
    
    # 应用NMS
    keep = nms(boxes, scores, iou_threshold=0.5)
    
    print("保留的框索引:", keep)
    print("对应的框坐标:")
    print(boxes[keep])
    print("对应的分数:")
    print(scores[keep])

44.卷积层手写

import numpy as np

def conv2d(inputs, kernels, bias=None, stride=1, padding=0):
    """
    2D卷积操作
    :param inputs: 输入数据 [H, W, C_in]
    :param kernels: 卷积核 [K, K, C_in, C_out]
    :param bias: 偏置 [C_out]
    :param stride: 步长
    :param padding: 填充量
    :return: 输出特征图 [H_out, W_out, C_out]
    """
    # 添加padding
    if padding > 0:
        inputs = np.pad(inputs, ((padding, padding), (padding, padding), (0, 0)), mode='constant')
    
    H, W, C_in = inputs.shape
    K, _, C_in, C_out = kernels.shape
    
    # 计算输出尺寸
    H_out = (H - K) // stride + 1
    W_out = (W - K) // stride + 1
    
    output = np.zeros((H_out, W_out, C_out))
    
    # 滑动窗口卷积计算
    for i in range(H_out):
        for j in range(W_out):
            h_start = i * stride
            h_end = h_start + K
            w_start = j * stride
            w_end = w_start + K
            
            # 获取当前窗口 [K,K,C_in]
            window = inputs[h_start:h_end, w_start:w_end, :]
            
            # 与所有卷积核做点积 [K,K,C_in] x [K,K,C_in,C_out] -> [C_out]
            for c in range(C_out):
                output[i,j,c] = np.sum(window * kernels[:,:,:,c])
    
    # 添加偏置
    if bias is not None:
        output += bias
        
    return output

45.池化层手写

import numpy as np

def max_pool2d(inputs, pool_size=2, stride=2):
    """
    2D最大池化
    :param inputs: 输入数据 [H, W, C]
    :param pool_size: 池化窗口大小
    :param stride: 步长
    :return: 池化后的特征图
    """
    H, W, C = inputs.shape
    # 计算输出尺寸
    H_out = (H - pool_size) // stride + 1
    W_out = (W - pool_size) // stride + 1
    
    output = np.zeros((H_out, W_out, C))
    
    for i in range(H_out):
        for j in range(W_out):
            h_start = i * stride
            h_end = h_start + pool_size
            w_start = j * stride
            w_end = w_start + pool_size
            
            # 获取当前窗口并沿空间维度取最大值
            window = inputs[h_start:h_end, w_start:w_end, :]
            output[i, j, :] = np.max(window, axis=(0, 1))
    
    return output

46.激活函数优缺点

深度学习中的激活函数：理解与应用-CSDN博客文章浏览阅读2.9k次，点赞3次，收藏14次。激活函数对于人工神经网络模型去学习、理解非常复杂和非线性的函数来说具有十分重要的作用。它们将非线性特性引入到我们的网络中。_激活函数的优缺点https://blog.csdn.net/hollyprince/article/details/125900023?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522b6bb4f8382803d82a792aafd6d9ed400%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=b6bb4f8382803d82a792aafd6d9ed400&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-1-125900023-null-null.142^v102^pc_search_result_base6&utm_term=%E6%BF%80%E6%B4%BB%E5%87%BD%E6%95%B0%E6%9C%89%E5%93%AA%E4%BA%9B%EF%BC%9F%E4%BC%98%E7%BC%BA%E7%82%B9&spm=1018.2226.3001.4187

47.手写均值滤波

import numpy as np
def mean_filter(image, kernel_size=3):
    pad = kernel_size // 2
    padded = np.pad(image, ((pad, pad), (pad, pad)), mode='constant')
    output = np.zeros_like(image)
    for x in range(image.shape[0]):
        for y in range(image.shape[1]):
            window = padded[x:x + kernel_size, y:y + kernel_size]
            output[x, y] = np.mean(window)
    return output.astype(np.uint8)

48.手写高斯滤波

import numpy as np
def gaussian_kernel(kernel_size=3, sigma=1.0):
    m = (kernel_size - 1) // 2
    x = np.arange(-m, m + 1).reshape(kernel_size, 1)
    y = np.arange(-m, m + 1).reshape(1, kernel_size)
    kernel = np.exp(-(x ** 2 + y ** 2) / (2 * sigma ** 2))
    return kernel / kernel.sum()
def gaussian_filter(image, kernel_size=3, sigma=1.0):
    kernel = gaussian_kernel(kernel_size, sigma)
    pad = kernel_size // 2
    padded = np.pad(image, ((pad, pad), (pad, pad)), mode='reflect')
    output = np.zeros_like(image, dtype=np.float32)
    for x in range(image.shape[0]):
        for y in range(image.shape[1]):
            window = padded[x:x + kernel_size, y:y + kernel_size]
            output[x, y] = np.sum(window * kernel)
    return output.astype(np.uint8)

49.手写中值滤波

import numpy as np
def median_filter(image, kernel_size=3):
    pad = kernel_size // 2
    padded = np.pad(image, ((pad, pad), (pad, pad)), mode='reflect')
    output = np.zeros_like(image)
    for x in range(image.shape[0]):
        for y in range(image.shape[1]):
            window = padded[x:x + kernel_size, y:y + kernel_size]
            output[x, y] = np.median(window)
    return output.astype(np.uint8)

50.ATSS网络

https://arxiv.org/pdf/1912.02424https://arxiv.org/pdf/1912.0242451.RepVgg

https://arxiv.org/pdf/2101.03697https://arxiv.org/pdf/2101.0369752.ssd，yolo，fcos， atss等assign形式

SSD（Anchor-Based）

- 分配方式：基于固定IoU阈值（如0.5）的静态分配。
  - 每个GT（Ground Truth）与所有预设的Anchor计算IoU，IoU大于阈值的Anchor作为正样本。
  - 负样本通过难例挖掘（Hard Negative Mining）筛选。

YOLO系列（Anchor-Based/Free混合）

YOLOv1（Anchor-Free）：
- 将图像划分为网格，每个网格预测2个边界框，直接回归中心点和宽高。
YOLOv2/v3（Anchor-Based）：
- 引入Anchor机制，通过k-means聚类预设Anchor尺寸。
- 正样本分配：GT中心点所在的网格及其对应IoU最大的Anchor
YOLOv5改进：
- 动态扩展正样本：GT中心点附近的多个网格（最多3个）的Anchor均可能被分配为正样本，提升召回率
YOLOv7：
- 结合YOLOv5的扩展策略和YOLOX的SimOTA动态分配，通过Loss感知筛选高质量正样本

FCOS（Anchor-Free）

分配方式：
- 空间约束：GT框内的所有点均为正样本。
- 尺度约束：通过FPN层级限制，不同尺度的GT分配到不同特征层。
- 引入Centerness分支抑制低质量预测
特点：
- 无需Anchor，简化设计，但对密集目标易产生歧义（同一位置可能对应多个GT)

ATSS（自适应分配）

核心改进：
1. 候选集生成：对每个GT，在FPN各层选择中心距离最近的k个Anchor（默认k=9）。
2. 动态阈值：计算候选Anchor的IoU均值μ和标准差σ，阈值T=μ+σ。
3. 筛选：保留IoU > T且中心在GT内的Anchor作为正样本

53.VIT

Visual Transformer (ViT)模型详解-CSDN博客文章浏览阅读5.8w次，点赞141次，收藏469次。ViT是2020年Google团队提出的将Transformer应用在图像分类的模型，虽然不是第一篇将transformer应用在视觉任务的论文，但是因为其模型“简单”且效果好，可扩展性强（scalable，模型越大效果越好），成为了transformer在CV领域应用的里程碑著作，也引爆了后续相关研究。_vithttps://blog.csdn.net/lsb2002/article/details/135320751?ops_request_misc=%257B%2522request%255Fid%2522%253A%25222c8ec18e70e66b25595e2e7a3bdd8e8b%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=2c8ec18e70e66b25595e2e7a3bdd8e8b&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-2-135320751-null-null.142^v102^pc_search_result_base6&utm_term=VIT&spm=1018.2226.3001.418754.手写Dice

import torch
import torch.nn as nn

class DiceLoss(nn.Module):
    def __init__(self, smooth=1e-5):
        super(DiceLoss, self).__init__()
        self.smooth = smooth  # 防止分母为0

    def forward(self, pred, target):
        # 输入形状: pred [N, H, W], target [N, H, W]（需为浮点型）
        pred = pred.view(-1)  # 展平
        target = target.view(-1)
        intersection = (pred * target).sum()
        union = pred.sum() + target.sum()
        dice = (2. * intersection + self.smooth) / (union + self.smooth)
        return 1 - dice

55.PCA，经典的机器学习算法，包括SVM、决策树优缺点

PCA降维技术详解-CSDN博客文章浏览阅读9.1w次，点赞154次，收藏614次。本文主要介绍一种降维方法，PCA（Principal Component Analysis，主成分分析）。降维致力于解决三类问题。1. 降维可以缓解维度灾难问题；2. 降维可以在压缩数据的同时让信息损失最小化；3. 理解几百个维度的数据结构很困难，两三个维度的数据通过可视化更容易理解。。_pca降维https://blog.csdn.net/HLBoy_happy/article/details/77146012?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522d09fbe397af38a2bce86b837d3f0a962%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=d09fbe397af38a2bce86b837d3f0a962&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-77146012-null-null.142^v102^pc_search_result_base6&utm_term=PCA&spm=1018.2226.3001.4187集成学习算法：AdaBoost原理详解以及基于adaboost的图像二分类代码实现-CSDN博客文章浏览阅读1.1w次，点赞61次，收藏185次。本文从机器学习小白视角出发，介绍了AdaBoost算法。先阐述集成学习和AdaBoost概念，接着说明算法流程，包括初始化权值、迭代选弱分类器、更新权值等。还给出实例，分析优缺点。最后展示Python的scikit - learn库实现、手写算法、图像二分类及用朴素贝叶斯作弱分类器的代码。https://blog.csdn.net/Yaoyao2024/article/details/138467790?ops_request_misc=%257B%2522request%255Fid%2522%253A%252220d1982aaa17c13d98086d346b68f89f%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=20d1982aaa17c13d98086d346b68f89f&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-138467790-null-null.142^v102^pc_search_result_base6&utm_term=adaboost&spm=1018.2226.3001.4187机器学习之KNN最邻近分类算法_knn分类-CSDN博客文章浏览阅读10w+次，点赞647次，收藏4.2k次。KNN算法简介KNN（K-Nearest Neighbor）最邻近分类算法是数据挖掘分类（classification）技术中最简单的算法之一，其指导思想是”近朱者赤，近墨者黑“，即由你的邻居来推断出你的类别。KNN最邻近分类算法的实现原理：为了判断未知样本的类别，以所有已知类别的样本作为参照，计算未知样本与所有已知样本的距离，从中选取与未知样本距离最近的K个已知样本，根据少数服从多数..._knn分类https://blog.csdn.net/pengjunlee/article/details/82713047?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522276256550bbeedef862476fdccb65359%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=276256550bbeedef862476fdccb65359&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-82713047-null-null.142^v102^pc_search_result_base6&utm_term=KNN&spm=1018.2226.3001.4187机器学习算法系列（十八）-随机森林算法（Random Forest Algorithm）_随机森林算法流程图-CSDN博客文章浏览阅读10w+次，点赞567次，收藏3.2k次。机器学习算法系列（十八）-随机森林算法（Random Forest Algorithm）_随机森林算法流程图https://blog.csdn.net/sai_simon/article/details/123082619?ops_request_misc=%257B%2522request%255Fid%2522%253A%252289c8f4f66140b925cc2d299511a7edab%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=89c8f4f66140b925cc2d299511a7edab&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-123082619-null-null.142^v102^pc_search_result_base6&utm_term=%E9%9A%8F%E6%9C%BA%E6%A3%AE%E6%9E%97&spm=1018.2226.3001.4187【机器学习】决策树（理论）-CSDN博客文章浏览阅读4.5w次，点赞316次，收藏1.7k次。本文详细介绍了决策树的构建原理，包括熵的作用、信息增益、条件熵、信息增益率和基尼系数等关键概念，以及在实际应用中如何选择最优特征。此外，还讨论了决策树的预剪枝处理，如限制树的深度、叶子结点个数和信息增益，以防止过拟合。https://blog.csdn.net/the_ZED/article/details/129290733?ops_request_misc=&request_id=&biz_id=102&utm_term=%E5%86%B3%E7%AD%96%E6%A0%91&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-8-129290733.nonecase&spm=1018.2226.3001.418756.手推BP

57.RPN哪里也可以提升小目标检出率，为什么resnet101不适用于目标检测

调整Anchor尺寸：
- 小目标需要更小的Anchor尺寸（如8×8或16×16），确保小目标能被匹配到足够的正样本Anchor
- 过大的Anchor会导致小目标的IoU过低，无法被正确分类为前景。
动态采样与增强
FPN（特征金字塔网络）

下采样导致小目标信息丢失

计算冗余与效率问题

58.视觉注意力机制

视觉注意力机制——通道注意力、空间注意力、自注意力-CSDN博客文章浏览阅读10w+次，点赞231次，收藏1.5k次。本文深入探讨了计算机视觉中注意力机制的应用，包括通道注意力、空间注意力和自注意力。通道注意力通过学习通道的重要性来突出关键特征；空间注意力则通过捕捉图像中的重要区域；自注意力机制则用于获取全局上下文信息，增强模型的理解能力。文章以SENet、STN、CBAM等模型为例，阐述了这些机制的工作原理和计算过程。https://blog.csdn.net/qq_41204464/article/details/126881984?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522311cd8ee54c5171e460a2f666df83ce1%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=311cd8ee54c5171e460a2f666df83ce1&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-1-126881984-null-null.142^v102^pc_search_result_base6&utm_term=%E7%A9%BA%E9%97%B4%E6%B3%A8%E6%84%8F%E5%8A%9B%E5%92%8C%E9%80%9A%E9%81%93%E6%B3%A8%E6%84%8F%E5%8A%9B&spm=1018.2226.3001.4187SE、CBAM、ECA注意力机制（网络结构详解+详细注释代码+核心思想讲解+注意力机制优化神经网络方法）——pytorch实现_se注意力机制-CSDN博客文章浏览阅读4.9w次，点赞143次，收藏764次。这期博客我们来学习一下神秘已久的注意力机制，刚开始接触注意力机制的时候，感觉很有意思，事实上学会之后会发现比想象中的要简单，复杂的注意力机制后续会讲解，这期博客先讲解最常见的三种SE、CBAM、ECA注意力机制。_se注意力机制https://blog.csdn.net/qq_43215597/article/details/130634953?ops_request_misc=%257B%2522request%255Fid%2522%253A%25225384afef3761d46941580f7b0b7d268d%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=5384afef3761d46941580f7b0b7d268d&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-2-130634953-null-null.142^v102^pc_search_result_base6&utm_term=CBAM&spm=1018.2226.3001.418759.DetNet详解（很详细！！！一看就懂系列！！！！！！）-CSDN博客文章浏览阅读7.6k次，点赞4次，收藏26次。DetNet详解DetNet由旷视科技发表在ECCV2018的论文，出发点为现有的检测任务的backbone网络都是由分类任务衍生而来，因此作者想针对检测专用的backbone网络做一些讨论和研究而设计的DetNet。1.很多backbone网络在ImageNet大赛上做分类表现不错，才被人当作检测的主干特征提取网络（backbone），鲜有单独针对检测任务提出的backbone。检测和分类有明显的区别：（1）不仅需要分类，还需要精确的定位。（2）检测器都是类似FPN结构，在分类网络基础上额外多尺度特_detnethttps://blog.csdn.net/weixin_45074568/article/details/114596493?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522553790e26944b3933db3aa4f461cad8e%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=553790e26944b3933db3aa4f461cad8e&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-5-114596493-null-null.142^v102^pc_search_result_base6&utm_term=Detnet&spm=1018.2226.3001.4187

60.DETR

61.激活函数补充

常用的激活函数合集（详细版）-CSDN博客文章浏览阅读4.9w次，点赞286次，收藏2k次。从激活函数的公式及导函数、图像、优缺点或特点来描述了激活函数，以及总结了激活函数之间的优势，并且提供了pytorch的代码案例，以便于大家快速上手。_激活函数https://blog.csdn.net/caip12999203000/article/details/127067360?spm=1001.2014.3001.550662.贝叶斯估计与最大似然估计的区别

最大似然估计：
认为参数θ是固定但未知的常数，通过最大化似然函数L(θ∣D)寻找最优参数值，输出单一最优参数值θMLE，直接用于预测P(Xnew∣θMLE)

贝叶斯估计：
将参数θ视为随机变量，并假设其服从某个先验分布P(θ)。通过贝叶斯定理计算后验分布，输出参数的后验分布P(θ∣D)，预测时对所有可能的θ加权平均

63.F1分数（F1-Score）的贝塔值

β>1：更重视召回率（如医疗诊断，避免漏诊）。
β<1：更重视精确率（如垃圾邮件过滤，减少误判）。

64.SIFT

全网最详细SIFT算法原理实现-CSDN博客文章浏览阅读5.4w次，点赞250次，收藏1.3k次。本文深入探讨SIFT（尺度不变特征转换）算法，包括其原理、步骤和实际应用。SIFT算法由David G. Lowe提出，用于图像处理和计算机视觉中的特征匹配，具有尺度、旋转、亮度不变性。主要流程包括图像金字塔构建、关键点检测与定位、方向分配、描述子生成和关键点匹配。SIFT算法在全景拍摄等场景中发挥重要作用，其稳定性和高效性使其成为经典特征检测方法。https://blog.csdn.net/weixin_48167570/article/details/123704075?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522901f89d53ff0794cad3848a767c14c34%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=901f89d53ff0794cad3848a767c14c34&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-123704075-null-null.142^v102^pc_search_result_base8&utm_term=SIFT&spm=1018.2226.3001.4187

65.手写交叉自注意力

import torch
import torch.nn as nn
import torch.nn.functional as F

class CrossAttention(nn.Module):
    def __init__(self, dim_q, dim_kv, dim_out=None, num_heads=1):
        super().__init__()
        dim_out = dim_out or dim_q
        self.num_heads = num_heads
        self.scale = (dim_q // num_heads) ** -0.5

        # 投影层
        self.to_q = nn.Linear(dim_q, dim_q, bias=False)
        self.to_k = nn.Linear(dim_kv, dim_q, bias=False)
        self.to_v = nn.Linear(dim_kv, dim_out, bias=False)
        
    def forward(self, x_A, x_B):
        """
        x_A: (batch_size, len_A, dim_q)   → 生成Q
        x_B: (batch_size, len_B, dim_kv)  → 生成K, V
        """
        batch_size, len_A, len_B = x_A.shape[0], x_A.shape[1], x_B.shape[1]
        
        # 1. 投影到Q, K, V
        Q = self.to_q(x_A)  # (batch, len_A, dim_q)
        K = self.to_k(x_B)  # (batch, len_B, dim_q)
        V = self.to_v(x_B)  # (batch, len_B, dim_out)
        
        # 2. 多头拆分（可选）
        if self.num_heads > 1:
            dim_head_q = dim_q // self.num_heads
            dim_head_out = dim_out // self.num_heads
            Q = Q.view(batch_size, len_A, self.num_heads, dim_head_q).transpose(1, 2)
            K = K.view(batch_size, len_B, self.num_heads, dim_head_q).transpose(1, 2)
            V = V.view(batch_size, len_B, self.num_heads, dim_head_out).transpose(1, 2)
        
        # 3. 计算注意力分数
        scores = torch.matmul(Q, K.transpose(-2, -1)) * self.scale  # (batch, num_heads, len_A, len_B)
        attn_weights = F.softmax(scores, dim=-1)
        
        # 4. 加权求和
        output = torch.matmul(attn_weights, V)  # (batch, num_heads, len_A, dim_head_out)
        
        # 5. 合并多头（如果有多头）
        if self.num_heads > 1:
            output = output.transpose(1, 2).contiguous()
            output = output.view(batch_size, len_A, -1)  # (batch, len_A, dim_out)
        
        return output

# 测试
dim_q, dim_kv = 64, 128
model = CrossAttention(dim_q, dim_kv)
x_A = torch.randn(2, 10, dim_q)  # 序列A
x_B = torch.randn(2, 20, dim_kv) # 序列B
output = model(x_A, x_B)
print(output.shape)  # torch.Size([2, 10, 64])

66.ReLU函数在0处不可导，为什么还能用？
反馈神经网络正常工作需要的条件就是每一个点提供一个方向，即导数；0值不可微，本质上来说是因为这个地方可画多条切线，但我们需要的只是一条；由于这出现的0值的概率极低，任意选择一个子梯度就OK了，在0处的次微分集合是【0，1】；即选择其中一个就OK了；一般默认是0

67.为什么max pooling 要更常用？什么场景下 average pooling 比 max pooling 更合适？
作用：对输入的特征图进行压缩，一方面使特征图变小，简化网络计算复杂度；一方面进行特征压缩，提取主要特征。
通常来讲，max-pooling的效果更好，虽然max-pooling和average-pooling都对数据做了下采样，但是max-pooling感觉更像是做了特征选择，选出了分类辨识度更好的特征，提供了非线性。 pooling的主要作用一方面是去掉冗余信息，一方面要保留feature map的特征信息，在分类问题中，我们需要知道的是这张图像有什么object，而不大关心这个object位置在哪，在这种情况下显然max pooling比average pooling更合适。在网络比较深的地方，特征已经稀疏了，从一块区域里选出最大的，比起这片区域的平均值来，更能把稀疏的特征传递下去。
average-pooling更强调对整体特征信息进行一层下采样，在减少参数维度的贡献上更大一点，更多的体现在信息的完整传递这个维度上，在一个很大很有代表性的模型中，比如说- DenseNet中的模块之间的连接大多采用average-pooling，在减少维度的同时，更有利信息传递到下一个模块进行特征提取。
average-pooling在全局平均池化操作中应用也比较广，在ResNet和Inception结构中最后一层都使用了平均池化。有的时候在模型接近分类器的末端使用全局平均池化还可以代替Flatten操作，使输入数据变成一维向量

68.为什么在模型训练开始会有warm up？
warm up, 在刚刚开始训练时以很小的学习率进行训练，使得网络熟悉数据，随着训练的进行学习率慢慢变大，到了一定程度，以设置的初始学习率进行训练，接着过了一些inter后，学习率再慢慢变小；学习率变化：上升——平稳——下降。

有助于减缓模型在初始阶段对mini-batch的提前过拟合现象，保持分布的平稳；
有助于保持模型深层的稳定性

69.yolo5,6,8，9.10.11.12（这四个我觉得面试压根不会问，这才隔多久，12都出来了）

这些书上没看到额外补充，书推荐杨建华的yolo目标检测

YOLOv5网络模型的结构原理讲解（全）_yolov5网络结构详解-CSDN博客文章浏览阅读7.9w次，点赞215次，收藏1.5k次。YOLOv5有几种不同的架构，各网络模型算法性能分别如下：YOLOv5是一种目标检测算法，其模型结构主要包括以下组成部分：输入端：YOLOv5的Head网络由3个不同的输出层组成，分别负责检测大中小尺度的目标。Backbone网络：YOLOv5使用CSPDarknet53作为其主干网络，其具有较强的特征提取能力和计算效率。Neck网络：YOLOv5使用的是FPN(FPN网络能够在不同的特征图层次上进行检测，可以提高目标检测的性能)网络，可以融合来自不同特征图层次的信息。输出端：损失函数，YOLOv5使用的_yolov5网络结构详解https://blog.csdn.net/weixin_47872288/article/details/130368368?ops_request_misc=%257B%2522request%255Fid%2522%253A%252216382d7cb3ca340726fe306a4160e7f3%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=16382d7cb3ca340726fe306a4160e7f3&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-5-130368368-null-null.142^v102^pc_search_result_base8&utm_term=Yolov5&spm=1018.2226.3001.4187yolov6算法及其改进-CSDN博客文章浏览阅读1.3k次，点赞23次，收藏23次。网络架构设计：对于Backbone和Neck，延续了YOLOv4和YOLOv5的PAN架构思想并使用了重参思想进行了改进；关于Head部分，作者Decoupled Head进行了简化并将其命名为Efficient Decouple Head；标签匹配：对TaskAlign、SimOTA、ObjectBox以及ATSS等进行了评估，最终确认TaskAlign更为有效且训练友好；损失函数：损失函数一般包含cls loss、box-regression loss以及object loss。_yolov6https://blog.csdn.net/m0_38113054/article/details/144781934?ops_request_misc=&request_id=&biz_id=102&utm_term=Yolov6&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-144781934.142^v102^pc_search_result_base8&spm=1018.2226.3001.4187

目标检测算法——YOLOV8——算法详解-CSDN博客文章浏览阅读8.2w次，点赞259次，收藏1.4k次。本文梳理Yolo v8 的改进点，并针对一些较难理解的点进行重点阐述，主要有如下几方面：backbone 使用C2f模块，检测头使用了anchor-free + Decoupled-head，损失函数使用了分类BCE、回归CIOU + VFL（新增项目）的组合，框匹配策略由静态匹配改为了Task-Aligned Assigner匹配方式、最后 10 个 epoch 关闭 Mosaic 的操作、训练总 epoch 数从 300 提升到了 500。_yolov8https://blog.csdn.net/u012863603/article/details/128816715?ops_request_misc=&request_id=&biz_id=102&utm_term=Yolov8&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-2-128816715.142^v102^pc_search_result_base8&spm=1018.2226.3001.4187

70.C++八股完全没准备，看人要不要为难我吧

71.smooth L1损失函数

smooth L1完美的避开了L1和L2损失的缺点：

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

72.训练过程中类别不平衡怎么办？怎么解决的？

1. 从采样的策略上：通过采样方法将不平衡的数据集变为平衡的数据集，优点是简单方便。具体分为过采样和欠采样。
过采样：将小份的样本复制多份。
这样可能会造成训练出的模型有一定过拟合。

欠采样：将大份的样本中筛选一部分作为数据集，等于丢弃部分训练集的数据，也可能会造成过拟合。
可以采用3个方法减少欠采样带来的损失。
1.1 EasyEnsemble ：利用模型融合的方法，多次欠采样产生多个数据集，从而训练多个模型，综合多个模型的结果作为最终的结果
1.2 BalanceCascade：利用增量训练的思想，先利用欠采样产生的训练集训练一个分类器，然后对分类正确的样本从总训练集中筛除，再次在剩余的数据集利用欠采样训练第二个分类器，最终结合所有的分类器结果作为最终结果。
1.3 NearMiss：利用KNN试图挑选那些最具代表性的大众样本。

2. 图像增强：通过某种手段，利用已有的样本人工合成少数类样本，从而达到类别平衡的目的。

常规的图像增强方法有：缩放，旋转，翻转，偏移等。
还有根据场景化定制的一些图像增强方法：增加噪声，滤波操作（模糊），调节亮度/对比度

3. 加权操作：通过加权的方式解决数据不平衡的问题，在设计损失函数时，为少数类样本赋予更大的权值，为多数类样本赋予更小的权值。
例如： focal loss

4. 调整输出阈值：当类别不平衡时，采用默认的分类阈值可能会导致输出全部为反例，产生虚高的准确度，导致分类失败。因此，可以选择调整阈值，使得模型对于较少的类别更为敏感。

73.手写一维卷积

import numpy as np
def conv1d_manual(input_signal, kernel, stride=1, padding=0):
    batch_size, in_channels, input_length = input_signal.shape
    out_channels, _, kernel_size = kernel.shape

    # 计算输出长度
    output_length = ((input_length + 2 * padding - kernel_size) // stride) + 1

    # 添加padding
    if padding > 0:
        padded_input = np.zeros((batch_size, in_channels, input_length + 2 * padding))
        padded_input[:, :, padding:-padding] = input_signal
    else:
        padded_input = input_signal

    # 初始化输出
    output = np.zeros((batch_size, out_channels, output_length))

    # 执行卷积运算
    for b in range(batch_size):
        for oc in range(out_channels):
            for i in range(0, output_length):
                start = i * stride
                end = start + kernel_size
                # 提取当前窗口
                window = padded_input[b, :, start:end]
                # 计算点积
                output[b, oc, i] = np.sum(window * kernel[oc, :, :])

    return output

74.周一跟老板提离职