一边记录一边看，这段实习跑路之前运行完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聚类
python
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，看下面的四个链接，讲的挺详细，组会当时是我同门讲的，哥们划水
14.bn层与卷积层参数融合
在cnn中，如果卷积层之后接Bn层，那么一般设置bias为0，因为bias会在下一层BN归一化时减去均值消掉，徒增计算，这也是为什么我们看到很多时候卷积层设置bias，有时候又不设置。
这里是model1
python
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
python
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合并的代码如下
python
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
python
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 y17.手写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
python
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.beta22.Adam优化器的优势
自适应学习率：Adam通过计算每个参数的一阶矩（均值）和二阶矩（方差）来动态调整学习 率，避免了手动调整学习率的复杂性
SGD优化器的优势
SGD的超参数较少，调参相对简单，计算量较小，内存占用少
Adam在某些情况下更容易发散，而SGD的发散风险较低，但需要仔细调整学习率
23.softmax手写
python
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)- ROC曲线
ROC曲线是一种图形化工具，用于展示分类模型在不同阈值下的性能。它通过绘制以下两个指 标的关系来生成：
真正例率（True Positive Rate, TPR）：表示实际为正类的样本中被正确预测为正类的比例
假正例率（False Positive Rate, FPR）：表示实际为负类的样本中被错误预测为正类的比例
AUC
AUC是ROC曲线下的面积，用于量化模型的分类能力。AUC的取值范围在0到1之间
25.深拷贝和浅拷贝的区别
浅拷贝创建一个新对象，并将原对象的字段值复制到新对象中。对于基本数据类型，直接复制 其值；对于引用类型字段，仅复制其引用（内存地址），而不是引用指向的实际对象。
深拷贝创建一个新对象，并递归地复制原对象的所有字段，包括引用类型字段指向的实际对 象。新对象和原对象完全独立，不共享任何内存地址。
26.统计文件个数
bash
ls -l | grep "^-" | wc -l27.Inception结构详解(从V1到V4，再到xcpetion)
28.Pytorch 怎么实现多卡的Batch Normalization的同步
在 PyTorch 中，实现多卡训练时的 Batch Normalization（BN）同步可以通过 SyncBatchNorm（同步批量归一化）来实现。SyncBatchNorm 会跨多个 GPU 同步均值和方 差，确保所有 GPU 使用相同的统计量进行归一化，从而提升模型训练的稳定性和效果。
29.手写MSA
python
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
python
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的那本，都得看
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、进行卷积核通道数的降维和升维
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,看这个
39.IOU手写
python
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的相关问题（小红书看看）
41.空洞卷积输出大小
42.deeplab系列总结（感觉可以不用看，我同事做分割的没听过）
43.NMS手写
python
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.卷积层手写
python
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 output45.池化层手写
python
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 output46.激活函数优缺点
47.手写均值滤波
python
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.手写高斯滤波
python
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.手写中值滤波
python
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.02424
https://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）筛选。
- 分配方式 ：基于固定IoU阈值（如0.5）的静态分配。
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（自适应分配）
- 核心改进 ：
- 候选集生成：对每个GT，在FPN各层选择中心距离最近的k个Anchor（默认k=9）。
- 动态阈值：计算候选Anchor的IoU均值μ和标准差σ，阈值T=μ+σ。
- 筛选：保留IoU > T且中心在GT内的Anchor作为正样本
53.VIT
python
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 - dice55.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结构，在分类网络基础上额外多尺度特_detnet
https://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.激活函数补充
最大似然估计 ：
认为参数θ是固定但未知的常数，通过最大化似然函数L(θ∣D)寻找最优参数值，输出单一最优参数值θMLE，直接用于预测P(Xnew∣θMLE)
贝叶斯估计 ：
将参数θ视为随机变量 ，并假设其服从某个先验分布 P(θ)。通过贝叶斯定理计算后验分布，输出参数的后验分布P(θ∣D)，预测时对所有可能的θ加权平均
63.F1分数（F1-Score）的贝塔值
- β>1：更重视召回率（如医疗诊断，避免漏诊）。
- β<1：更重视精确率（如垃圾邮件过滤，减少误判）。
64.SIFT
65.手写交叉自注意力
python
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。_yolov6
https://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
70.C++八股完全没准备，看人要不要为难我吧
71.smooth L1损失函数
smooth L1完美的避开了L1和L2损失的缺点：
在[-1,1]之间就是L2损失，解决L1在0处有折点
在[-1， 1]区间以外就是L1损失，解决离群点梯度爆炸问题
当预测值与真实值误差过大时，梯度值不至于过大
当预测值与真实值误差很小时，梯度值足够小
72.训练过程中类别不平衡怎么办？怎么解决的？
- 从采样的策略上： 通过采样方法将不平衡的数据集变为平衡的数据集，优点是简单方便。具体分为过采样和欠采样。
过采样 ：将小份的样本复制多份。
这样可能会造成训练出的模型有一定过拟合。
欠采样：将大份的样本中筛选一部分作为数据集，等于丢弃部分训练集的数据，也可能会造成过拟合。
可以采用3个方法减少欠采样带来的损失。
1.1 EasyEnsemble ：利用模型融合的方法，多次欠采样产生多个数据集，从而训练多个模型，综合多个模型的结果作为最终的结果
1.2 BalanceCascade： 利用增量训练的思想，先利用欠采样产生的训练集训练一个分类器，然后对分类正确的样本从总训练集中筛除，再次在剩余的数据集利用欠采样训练第二个分类器，最终结合所有的分类器结果作为最终结果。
1.3 NearMiss：利用KNN试图挑选那些最具代表性的大众样本。
- 图像增强：通过某种手段，利用已有的样本人工合成少数类样本，从而达到类别平衡的目的。
常规的图像增强方法有： 缩放，旋转，翻转，偏移等。
还有根据场景化定制的一些图像增强方法：增加噪声，滤波操作（模糊），调节亮度/对比度
- 加权操作：通过加权的方式解决数据不平衡的问题，在设计损失函数时，为少数类样本赋予更大的权值，为多数类样本赋予更小的权值。
例如： focal loss
- 调整输出阈值：当类别不平衡时，采用默认的分类阈值可能会导致输出全部为反例，产生虚高的准确度，导致分类失败。因此，可以选择调整阈值，使得模型对于较少的类别更为敏感。
73.手写一维卷积
python
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 output74.周一跟老板提离职