深度学习面试题目

深度学习面试题目

batchb​​​​​​batch size设置技巧_batch size怎么设置_汀、人工智能的博客-CSDN博客=%257B%2522request%255Fid%2522%253A%2522170072622816800213083453%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=170072622816800213083453&biz_id=0&utm_medium=distribute.pc_-task-blog-2~all~top_positive~default-1-125624973-null-null.142%5Ev96%5Epc_search_result_base7&utm_term=batchsize%E5%8F%96%E5%A4%9A%E5%B0%91%E4%B8%BA%E5%A5%BD&spm=1018.2226.3001.4187

性能指标（模型评估）之mAP_map 准确率-CSDN博客

        1 bs

小：batch数太小，而类别又比较多的时候，真的可能会导致loss函数震荡而不收敛

大：局部最小值，处理相同的数据量的速度越快，Batch_Size 增大到某个时候，达到时间上的最优

2 BN层

1. 加快网络的训练和收敛的速度
2. 控制梯度爆炸防止梯度消失
3. 防止过拟合

当然，如果是小批量输入数据，即每次输入原数据的一部分时，经过多轮epoch迭代，BN最终也将累计记录到整体均值和方差。

对照这个就可以了。

我们可以清楚的看到，BN层对更加复杂模型的优化效果更好。换而言之，越复杂的模型对于梯度不平稳的问题就越明显，因此BN层在解决该问题后模型效果提升就越明显。

3 w的初始化和激活函数作用

Pytorch权重初始化方法——Kaiming、Xavier_kaiming初始化_劳塔罗爆射破门的博客-CSDN博客

Mish激活函数主要有一下四个特点：无上界、无下界、光滑、非单调。这四个特性提高了函数的性能。无上限：它可以防止网络饱和，即梯度消失。有下界：提高网络的正则化效果。平滑：首先，与ReLU相比，在0值点连续可以减少一些不可预测的问题。其次，它可以使网络更容易优化，提高泛化性能，一些较小的负输入可以保留为负输出，以提高网络的可解释性和梯度流。 

pytorch没有现成的包装
 

sigmoid——梯度消失（w=0)——Xavier有意义+BN算法

tanh—— 梯度爆炸（w>0)——w>1;  方法：xavier有意义+BN算法

relu ——死点问题 ，x<0为0 （降低学习率，Kaiming方法）——学习率更小，Kaiming 方法

4 学习率调节

5 conv2d

CV【2】：卷积与Conv2d_conv2d卷积核_zzzyzh的博客-CSDN博客

公式

边缘检测是卷积操作的一个常见应用，我们所使用的权重矩阵其实是纵向的索贝尔算子（Sobel
Operator），用于检测纵向的边缘，我们也可以使用横向的索贝尔算子，以及拉普拉斯算子来检测边缘。在OpenCV当中我们可以很容易地实现这个操作：

K的大小

卷积核一般都是奇数3*3/5*5/7*7 cv卷积核一般比较小，

stride  

通常是1-3

特征图的尺寸大小

特征图的尺寸非常重要，它既不能太小，也不能太大。如果特征图太小，
就可能缺乏可以提取的信息，进一步缩小的可能性就更低，网络深度就会受限制。如果特征图太大，每个卷积核需要扫描的次数就越多，所需要的卷积操作就会越多，影响整体计算

padding

还有vaild直接不填充了

 maxpool+avgpool

注意是步长可能相似不意味着卷积核

池化层不随着算法进行进步

6 Dropout2d与BatchNorm2d

7 LeNet5 ——定义框架

不能改变特征尺寸，容易报错大

2个卷积和平均池化+1个fc+softmax ，加入得是tanh，除此以外没有别的relu，BN

（conv+tanh+avg）*2 +（fc+tanh）+softmax

8 AlexNet——小卷积核

经验：

1 卷积核很小的情况 会增大特征。（卷积核不适应可以换）
2 步长很大，会让特征变少。但速度很快。
3 增加通道数目 会让特征变多。
思路
1 (小卷积（会让特征图下降更慢，可以用不同网络提取信息），核搭配大通道) 小而深——小卷积，多通道，大步长。
2 大尺寸先变成小尺寸（227*227-32*32） 加深深度，（减少尺寸，增大深度）
3 relu函数
4 加入BN层
5 增强数据集
6 训练使用GPU

网络结构

(conv+relu+pool)x2+(conv+relu)x3+pool+(fc+relu) x2 +softmax

该有的都有的，此外加入一个

9 VGG16——加深层数

引言:如何减小特征图尺寸呢？ 1、padding+stride进行的缩短2/4个  2 特征图不变 maxpool缩小

思想：使用多个连续且保持尺寸不变的卷积核，卷积层加大深度，maxpool进行将尺寸减半

共同点：conv 和fc 后面都有relu

补充知识点

感受野与加层

为什么加深层可以效果更好：更大感受野+复杂的非线性函数（池化层放大感受野的

感受野：1 聚焦于中间位置的图像 2 深度越大，感受野越大，放大感受野的效率更高

如何提高感受野：1 加大深度 2利用池化 3 膨胀卷积

平移不变性

大部分神经网络具有一定的平移不变性。

1、CNN的平移不变性只能够应对“微小的平移”，当物体横向或纵向平移的像素过多时，CNN的平移不变性会衰减
2、卷积+池化层的叠加可以增强CNN的平移不变性（更深的网络拥有更强的平移不变性），同时增强模型的鲁棒性

参数量影响

卷积层

目标：相同的预测效果下，参数量越小越好

参数量大小：（卷积核高*宽*输入通道数）*输出通道数+输出通道数

大尺寸卷积核vs小尺寸卷积核

1*1卷积核：然而，由于1x1卷积核可以在不增加也不减少信息的情况下维持特征图的尺寸，加深度

分组卷积

深度卷积：

全连接层

作用：1分类器，进行分类2 作为整合信息的工具，将特征图中的信息进行整合

全卷积层1*1代替线性层

解放了输入层对图像尺寸的限制 实际就是fc由于maxpool替换了

10 NIN----全卷积网络部署连接层

主要原因看一下补充知识点

1 全连接层 2通道是先增大后来一点点减小

11 GoogleLeNet——并联机构

GoogLenet网络详解-CSDN博客

加深网络的结构的inception块

1 采用了多种卷积核确保各种类型和层次得信息提取出来

2 并联效率更高，使得连接层得效率更高

3 大量使用1*1 卷积，加层，扩大感受野。

多层次的读取信息——辅助信息

网络图：

12 Resnet

残差块：残差单元，残差网络中，我们将众多残差单元与普通卷积层串联——在浅层网络后堆叠某种结构以加深度。

残差单元的比较

1 残差单元实现了0负担增加深度，不复杂

2 残差快容易训练保持必要精度

几个问题：

1 padding ：例如每一层的padding和stride。幸运的是，我们只有1x1和3x3两种卷积核，为了保持特征图的尺寸不变，1x1卷积核搭配的padding都为0，3x3卷积核搭配的padding都为1。

2 stride ：这说明5次降维任务中的其他4次都是由步长为2的卷积层来完成的

3 跳跃连接上的卷积层 ：因此，每当卷积层缩小特征图尺寸时，也需要在跳跃连接上加入核为1x1、步长为2的卷积层用于缩小原始特征图的尺寸。特别的，我们使用虚线来表示含有1x1卷积层的跳跃连接。

4 BN与relu位置：主题是conv+BN+RELU 残差值得是加一起后relu。对于两种块而言，最后一个卷积层后能够作用BN层

5 参数初始化在哪里实现

初始化：是令残差单元或瓶颈架构尽量与恒等函数相似

对于第一层来说残差支流不需要进行卷积

middle指的是中间得一块，128，输入in指的是256 输出的是512

13 优化算法

1 adaGrad

定义：使用每个维度上权重梯度的大小来自适应调整学习，避免学习率难以适应所有的维度问题

公式：

缺陷：

2 RMSprop

借鉴了BN层得动量法

3 Adama

14 Gan网络介绍

1 GAN

定义

交叉熵

生成图像越准确说明越好。此事判别器loss不就越大

# 两个线性层改变1进入1输出求出概率
class Discriminator(nn.Module):def __init__(self,in_features):"""in_features : 真实数据的维度、同时也是生成的假数据的维度，对于普通神经网络而言就是特征数量"""super().__init__()self.disc = nn.Sequential(nn.Linear(in_features,128)#,nn.BatchNorm1d(128),nn.LeakyReLU(0.1) #由于生成对抗网络的损失非常容易梯度消失，因此使用LeakyReLU,nn.Linear(128,1),nn.Sigmoid())def forward(self,data):"""输入的data可以是真实数据时，Disc输出dx。输入的data是gz时，Disc输出dgz"""return self.disc(data)# 两个线性层  
class Generator(nn.Module):def __init__(self,in_features,out_features):"""in_features:生成器的in_features，一般输入z的维度z_dim，该值可自定义out_features:生成器的out_features，需要与真实数据的维度一致"""super().__init__() = nn.Sequential(nn.Linear(in_features,256)#,nn.BatchNorm1d(256),nn.LeakyReLU(0.1),nn.Linear(256,out_features) # 得出out_feaure 函数,nn.Tanh() #用于归一化数据 tanh对抗函数里面这个)def forward(self,z):gz = (z)return gz

#检测生成器、判别器能否顺利跑通
#假设真实数据结构为28*28*1 = 784(真实数据是784特征）
#输入噪声z = s((10,64))       
gen = Generator(64,784)
gen(z).shape #生成数据

 torch.Size([10, 784])

disc = Discriminator(784)
disc(gen(z)).shape #输出唯一值概率看输入的是什么值

torch.Size([10, 1])

损失函数

for epoch in range(num_epochs):# x特征矩阵，y（label不使用）for batch_idx, (x,_) in enumerate(dataloader):# 放到设备上去cpu（gpu）x = x.view(-1,784).to(device)batch_size = x.shape[0]############################# (1) 判别器的反向传播：最小化 -[logD(x) + log(1 - D(G(z)))]############################# -logdx# 生成需要输入ceriterion 的真实标签1与预测概率dx = disc(x).view(-1)#放入判别器loss_real = criterion(s_like(dx))loss_real.backward()# 计算所有真实数据的损失均值D_x = dx.mean().item()# -log(1-dgz)# 生成需要输入ceriterion 的真实标签0与预测概率# 因此噪声z的样本量必须与真实数据一样——batch_size，z_dim指的是每个样本噪音的个数noise = torch.randn((batch_size,z_dim)).to(device)gz = gen(noise)dgz1 = disc(gz.detach())# 计算所有的加上数据上的损失函数loss_fake = criterion(s_like(dgz1))loss_fake.backward()D_G_z1 = an().item()#计算errorDerrorD = (loss_real + loss_fake)/2#分别进行迭代 判别器迭代，不设计原始和生成器optim_disc.step()_grad()############################# (2) 生成器的反向传播：最小化 -log(D(G(z)))#############################生成需要输入criterion的真实标签1与预测概率gdz#注意，由于在此时判别器上的权重已经被更新过了，所以dgz的值会变化，需要重新生成# 判别器通过虚线进行反向传播dgz2 = disc(gz)#计算errorGerrorG = criterion(s_like(dgz2))errorG.backward() #反向传播optim_gen.step() #更新生成器上的权重_grad() #清零生成器更新后梯度D_G_z2 = an().item()#监控训练进度if batch_idx % 500 == 0 or batch_idx == 0:print('[%d/%d][%d/%d]tLoss_D: %.4ftLoss_G: %.4ftD(x): %.4ftD(G(z)): %.4f / %.4f' %(epoch+1, num_epochs, batch_idx, len(dataloader),errorD.item(), errorG.item(), D_x, D_G_z1, D_G_z2))#保存errorG和errorD，以便后续绘图用G_losses.append(errorG.item())D_real_loss.append(loss_real.item())D_fake_loss.append(loss_fake.item())D_losses.append(errorD.item())#将固定噪音fixed_noise输入生成器，查看输出的结果变化if (iters % 500 == 0) or ((epoch == num_epochs-1) and (batch_idx == len(dataloader)-1)):_grad():fake = gen(fixed_noise).cpu().detach()print("fake data saved")img_list.append(fake.view(-1,1,28,28))iters += 1

损失函数三个：

判别器：loss_real = criterion(s_like(dx))  + loss_fake 

loss_fake=criterion(s_like(dgz1)) dgz1指的是生成的假

生成器： errorG = criterion(s_like(dgz2))

2 DCGan

反卷积与转置卷积

卷积运算的逆运算被称为反卷积（Deconvolution），反卷积是一种能够将某一卷积核的缩小效果完全逆转的运算，这种完全逆转可以将被卷积之前的图像像素极大程度地复原、甚至生成超越原始图像的图像，因此反卷积常被用于提升图像像素、为影像上色等实践领域。

相比之下，转置卷积只能够将图像恢复到被卷积之前的尺寸（即恢复空间信息），但不能复原被卷积之前的图像像素信息、甚至还会打乱图像中不同维度的信息、让通道信息混杂在一起，这就非常适合被用于从无到有生成数据。

相当于把基本Gan网络换成了DCGan

#实现DCGAN中的discriminator  3的卷积def BasicConv2d(in_channels,out_channels,ks,s,p):return nn.Sequential(nn.Conv2d(in_channels,out_channels,ks,s,p,bias=False),nn.BatchNorm2d(out_channels),nn.LeakyReLU(0.2,inplace=True))class DCDisc(nn.Module):def __init__(self):super(DCDisc,self).__init__()self.main = nn.Sequential(BasicConv2d(3,128,3,2,1),BasicConv2d(128,256,3,2,1),BasicConv2d(256,512,3,2,1),BasicConv2d(512,1024,3,2,1),nn.Conv2d(1024,1,3,2,0)  # 320 可以按照以前的结构改,nn.Sigmoid()  # 二分类，多分类的话就是softmax)def forward(self,gz):return self.main(gz)

# 转置卷积层 
def BasicTransConv2d(in_channels,out_channels,ks,s,p):return nn.Sequential(nn.ConvTranspose2d(in_channels,out_channels,ks,s,p,bias=False),nn.BatchNorm2d(out_channels),nn.ReLU(True))#实现DCGAN中的GENERATOR  4的卷积class DCGen(nn.Module):def __init__(self):super(DCGen, self).__init__()self.main = nn.Sequential(BasicTransConv2d(100,1024,4,1,0),BasicTransConv2d(1024,512,4,2,1),BasicTransConv2d(512,256,4,2,1),BasicTransConv2d(256,128,4,2,1),nn.ConvTranspose2d(128,3,4,2,1),nn.Tanh())def forward(self,z):return self.main(z)

3 cGan 条件Gan网络

CGAN理论讲解及代码实现_cgan代码_无咎.lsy的博客-CSDN博客

代码原理：

代码解析：

#cGAN中的生成器
class cGAN_gen(nn.Module):def __init__(self):super().__init__()self.label_upsample = nn.Sequential(nn.Embedding(10, 50),nn.Linear(50,49),nn.ReLU(inplace=True))ise_upsample = nn.Sequential(nn.Linear(100,6272),nn.LeakyReLU(0.2,True))self.main = nn.Sequential(nn.ConvTranspose2d(129,128,4,2,1) #这里使用的是能够使,nn.LeakyReLU(0.2,True),nn.ConvTranspose2d(128,128,4,2,1),nn.LeakyReLU(0.2,True),nn.Conv2d(128,1,3,1,1) #卷积层作为最后的结尾层，最后输出图像尺寸为28x28)def forward(self,label,noise): #标签在前，噪音在后noise = ise_upsample(noise)noise = noise.view(-1,128,7,7)label = self.label_upsample(label)label = label.view(-1,1,7,7)inputs = torch.cat((noise,label),dim=1)fakedata = self.main(inputs)return fakedata

判别器

#DCGAN中的判别器
class cGAN_disc(nn.Module):def __init__(self):super().__init__()self.label_embedding = nn.Sequential(nn.Embedding(10,50),nn.Linear(50,784),nn.ReLU(inplace=True) #在架构图上这里没有激活函数) self.main = nn.Sequential(nn.Conv2d(2,128,3,2,1),nn.LeakyReLU(0.2,inplace=True),nn.Conv2d(128,128,3,2,1),nn.LeakyReLU(0.2,inplace=True)) #由于Fashion-MNIST图像较小，因此在这里使用的卷积层也很少self.output_ = nn.Sequential(nn.Dropout(0.2),nn.Linear(128*7*7,1))def forward(self,label,realdata): #标签在前，数据在后label = self.label_embedding(label)label = label.view(-1,1,28,28)inputs = torch.cat((realdata,label),dim=1)features = self.main(inputs)features = features.view(-1,128*7*7)outputs = self.output_(features)return outputs

4 infoGan

InfoGAN详细介绍及特征解耦图像生成_javastart的博客-CSDN博客=&request_id=&biz_id=102&utm_term=infogan%E4%B8%8Egan&utm_medium=distribute.pc_-task-blog-2~all~sobaiduweb~default-0-128709689.142%5Ev96%5Epc_search_result_base7&spm=1018.2226.3001.4187

5 BIGGan

6 自编码器

1 稀疏自编码器

会舍弃一些的信息神经元

2 变分自动编码器

具体步骤

15 Transformer

1 NLP里面得Transformer

自注意力机制(Self-Attention)_Michael_Lzy的博客-CSDN博客

全网最通俗易懂的 Self-Attention自注意力机制 讲解_self attention机制-CSDN博客

史上最小白之Transformer详解_transformer最小白-CSDN博客

transform 词向量编码——onehot word2vec

位置编码——正余弦位置编码，正弦余弦函数生成

transformer位置信息：Transformer使用的是正余弦位置编码。位置编码通过使用不同频率的正弦、余弦函数生成，然后和对应的位置的词向量相加，位置向量维度必须和词向量的维度一致

只能进行相加，拼接的情况会使得数据量过大

mask：

1.padding mask：因为每个批次输入序列长度是不一样的也就是说，我们要对输入序列进行对齐。具体来说，就是给在较短的序列后面填充 0。但是如果输入的序列太长，则是截取左边的内容，把多余的直接舍弃

2 sequence mask

sequence mask 是为了使得 decoder 不能看见未来的信息。这在训练的时候有效，因为训练的时候每次我们是将target数据完整输入进decoder中，预测时不需要，预测的时候我们只能得到前一时刻预测出的输出

为什么会存在两层mutitransformers

跟我一样的牛角尖型选手可能又要发问啦，为啥Decoder中要搞两个Multi-Head Attention呢？
我个人理解是第一个Masked Multi-Head Attention是为了得到之前已经预测输出的信息，相当于记录当前时刻的输入之间的信息的意思。第二个Multi-Head Attention是为了通过当前输入的信息得到下一时刻的信息，也就是输出的信息，是为了表示当前的输入与经过encoder提取过的特征向量之间的关系来预测输出。

2 VIT

ViT (Visual Transformer)--CSDN博客

VIT 简单理解_vit位置编码-CSDN博客

TNT

输入图像

总体上Dropout(下面） 到最后的LayerNorm  里面的是LayerNorm 到Dropout，里面是multi-head/MLP

3 Swin Transformer

Swin-Transformer详解_swin transformer-CSDN博客

为什么引入swin

1 双模太差异太大了 密集程度什么的

2 图像是高分辨率图像，不能进行识别；

整体框架

【深度学习】详解 Swin Transformer (SwinT)-CSDN博客

patch partion 指的是conv原图像输入进去经过卷积得到[B, C, H, W]，然后 flatten: [B, C, H, W] -> [B, C, HW] 

linear embing——Layernorm 指的是直接就是LN

对于SWIN

class SwinTransformerBlock(nn.Module):r""" Swin Transformer Block.Args:dim (int): Number of input channels.num_heads (int): Number of attention heads.window_size (int): Window size.shift_size (int): Shift size for SW-MSA.mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: Truedrop (float, optional): Dropout rate. Default: 0.0attn_drop (float, optional): Attention dropout rate. Default: 0.0drop_path (float, optional): Stochastic depth rate. Default: 0.0act_layer (nn.Module, optional): Activation layer. Default: nn.GELUnorm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm"""# 与Vit的block结构是相同的def __init__(self, dim, num_heads, window_size=7, shift_size=0,mlp_ratio=4., qkv_bias=True, drop=0., attn_drop=0., drop_path=0.,act_layer=nn.GELU, norm_layer=nn.LayerNorm):super().__init__()self.dim = dimself.num_heads = num_headsself.window_size = window_sizeself.shift_size = shift_sizeself.mlp_ratio = mlp_ratioassert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size
 = norm_layer(dim)self.attn = WindowAttention(dim, window_size=(self.window_size, self.window_size), num_heads=num_heads, qkv_bias=qkv_bias,attn_drop=attn_drop, proj_drop=drop)self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()2 = norm_layer(dim)mlp_hidden_dim = int(dim * mlp_ratio)self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)def forward(self, x, attn_mask):# x(B,L,C)，因此需要记录h和wH, W = self.H, self.WB, L, C = x.shapeassert L == H * W, "input feature has wrong size"# 残差网络shortcut = xx = 1(x)x = x.view(B, H, W, C)#图像填充(B, H, W, C)微调尺寸# pad feature maps to multiples of window size# 把feature map给pad到window size的整数倍pad_l = pad_t = 0pad_r = (self.window_size - W % self.window_size) % self.window_sizepad_b = (self.window_size - H % self.window_size) % self.window_sizex = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))_, Hp, Wp, _ = x.shape# cyclic shiftif self.shift_size > 0:# 对窗口进行移位。从上向下移，从左往右移，因此是负的shifted_x = ll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))else:shifted_x = xattn_mask = None# 划分窗口 windowsx_windows = window_partition(shifted_x, self.window_size)  # [nW*B, Mh, Mw, C]# # [nW*B, Mh*Mw]输入进行# [nW*B, Mh*Mw, C]attentionx_windows = x_windows.view(-1, self.window_size * self.window_size, C)# W-MSA/SW-MSAattn_windows = self.attn(x_windows, mask=attn_mask)  # [nW*B, Mh*Mw, C]# 窗口还原attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)  # [nW*B, Mh, Mw, C]shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp)  # [B, H', W', C]# shift还原，如果没有shifted就不用还原if self.shift_size > 0:x = ll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))else:x = shifted_xif pad_r > 0 or pad_b > 0:# 把前面pad的数据移除掉x = x[:, :H, :W, :].contiguous()x = x.view(B, H * W, C)# FFN MLP[不改变维度的]# 改编为度是mergex = shortcut + self.drop_path(x)x = x + self.drop_path(self.2(x)))return x

接下来是MERGE

class PatchMerging(nn.Module):r""" Patch Merging Layer.Args:dim (int): Number of _layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm"""def __init__(self, dim, norm_layer=nn.LayerNorm):super().__init__()self.dim =  = norm_layer(4 * duction = nn.Linear(4 * dim, 2 * dim, bias=False)  # 将通道数由4倍变为2倍def forward(self, x, H, W):"""x: B, H*W（L）, C，并不知道H和W，所以需要单独传参"""# 1222222222B, L, C = x.shapeassert L == H * W, "input feature has wrong size"x = x.view(B, H, W, C)# padding# 因为是下采样两倍，如果输入feature map的H，W不是2的整数倍，需要进行paddingpad_input = (H % 2 == 1) or (W % 2 == 1)if pad_input:# 此时（B,H,W,C)依然是从后向前# (C_front, C_back, W_left, W_right, H_top, H_bottom)# 注意这里的Tensor通道是[B, H, W, C]，所以会和官方文档有些不同x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2))x0 = x[:, 0::2, 0::2, :]  # [B, H/2, W/2, C]x1 = x[:, 1::2, 0::2, :]  # [B, H/2, W/2, C]x2 = x[:, 0::2, 1::2, :]  # [B, H/2, W/2, C]x3 = x[:, 1::2, 1::2, :]  # [B, H/2, W/2, C]x = torch.cat([x0, x1, x2, x3], -1)  # [B, H/2, W/2, 4*C],这里的-1就是在C的维度上拼接x = x.view(B, -1, 4 * C)  # [B, H/2*W/2, 4*C]x = (x)x = duction(x)  # [B, H/2*W/2, 2*C]return x

patch merging

第一个先进行 H/4*W/4*48 48维度得 第一个48——C——2C——4C——8C 每一个模块经过了2268

注意力机制讲解

先进行编码排列。H/4*W/4*48 先补全7*7得倍数窗口（补0）对于每一个图片

W-MAS不考虑窗口移动 

先是窗口设置(H*W/49,7*7,*C)

经过MLP(H*W/49,7*7,3C)

(3,H*W/49,3,7*7,C/3)   第一个三指的是qkv三个矩阵  第二个三头数 进行自适应计算

计算完后就是原来图像形况

12.1 Swin-Transformer网络结构详解_哔哩哔哩_bilibili

SW-MSA层我们需要考虑窗口移动与自注意编码

16 RNN与LSTM

如何从RNN起步，一步一步通俗理解LSTM_rnn lstm-CSDN博客

1 RNN

为了解决文字语言的：序列形的数据就不太好用原始的神经网络处理了，引入了隐状态h（hidden state）的概念，隐状态h可以对序列形的数据提取特征，接着再转换为输出。

2 LSTM

本质：

σ表示的Sigmoid 激活函数与 tanh 函数类似，不同之处在于 sigmoid 是把值压缩到0~1 之间而不是 -1~1 之间。这样的设置有助于更新或忘记信息：

因为任何数乘以 0 都得 0，这部分信息就会剔除掉；
同样的，任何数乘以 1 都得到它本身，这部分信息就会完美地保存下来。

LSTM核心

忘记门

输入门

细胞状态

输出门

17 姿态估计

1 openpose

一文openpose姿态估计-CSDN博客

openpose原理以及各种细节的介绍_openpose介绍_QTreeY123的博客-CSDN博客

热图原理：在实际打标签的时候就需要把标签做成热度图，而且在实际肩膀的位置是1，如果你打的点远离肩膀，那就是0.9，0.8，0.7，每一个点都要进行高斯分布形成一个热度图

以前的姿态估计不可以，以前的事先检测后进行姿态估计，为了在追求效率我们直接检测关键点，然后进行拼接

标签制作

我认为指的是一个标签变成了一个区域的意思，这个区域内的点进行计算 ：限定区域得到的是不同地方的区域计算，别的一个给定的是向量标签问题

计算比较

得到的是每个点的任意向量进行投影计算，得到计算值，求积分。

如何一个个匹配？

a就与b匹配其他不考虑一个个解决再说 匈牙利算法

整体框架：

2 匈牙利算法

理解匈牙利算法_hungarian linear sum minimization-CSDN博客

匈牙利算法相关介绍_花花少年的博客-CSDN博客

sklearn 来计算

18 图像融合

注意：融合是没有标签的，和gan一样，自编码器也是一样的

定义：图像融合是指将多幅图像的信息融合在一起，生成一幅新的图像，使得新图像能够包含原始图像的所有关键信息和特征

原理：特征融合，该方法将多幅图像的特征进行提取和匹配，然后根据匹配结果进行融合。常用的特征包括边缘、纹理、颜色等

分类：

红外与可见光图像融合：将红外图像和可见光图像进行融合，可以提高目标检测和识别的性能

摇杆图像：将多源的遥感图像进行融合，可以提高地物的识别和分析能力

方法：见微信

评价指标

一文读懂信息熵、交叉熵和相对熵（KL散度） - 知乎 (zhihu)

图像融合质量评价方法SSIM、PSNR、EN、MSE与NRMSE（一）-CSDN博客

信息熵  标准差 结构相似度  均方误差 MSE（越小越好，其他都是越大越好）均方根误差

损失函数

loss=loss_int+loss_grad+loss_SSIM

其他方式：gan网络指的是两个鉴别器   自编码器指的是两个阶段的网络

19 目标检测

1 yolo1检测

YOLO系列详解：YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5、YOLOv6、YOLOv7_AI追随者的博客-CSDN博客YOLO系列详解：YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5、YOLOv6、YOLOv7_AI追随者的博客-CSDN博客YOLO系列详解：YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5、YOLOv6、YOLOv7_AI追随者的博客-CSDN博客

置信度：

高置信度会结果很全面但是不精确，低的相反。

AP：均值计算

流程：

本质的流程

图片输入进去，得到7*7*30 7*7 指的是分的图像的部分总共7*7个 30个维度如下图所示：

• 每个bounding box要预测(x, y, w, h)和confidence共5个值，每个网格还要预测一个类别信息，记为C类。则SxS个网格，每个网格要预测B个bounding box还要预测C个categories。输出就是S x S x (5*B+C)的一个tensor。
• class信息是针对每个网格的，confidence信息是针对每个bounding box的。

损失函数

损失函数有两个地方：

1 不同的损失函数权重不一样的，位置误差更大一点

2 如果没有物体的也需要损失函数

非极大值抑制：选取最大的最好的那个置信度

问题

小问题一般化

2 yolo2检测

 Draknet19

深度学习目标检测_YOLOV2超详细解读_yolov2结构图-CSDN博客

此外预测方式也发生了改变

第一个：为什么输入是416？为什么是400+，不是224呢，因为这样可以让图片分辨率更好

因为2^5可以把416整除这样的话。此外因为：

第二个 网络图很像VGG16所以，而且没有线性层，最后一层conv很特殊

第三个先验框的提取 聚类的方法，采用的iou面积来计算的

通过计算选取不同的先验框来计算原先是9个

有一个问题？为什么可以取

第四个怎么预测的？

V2中没有使用偏移量，而是选择相对gride cell 的偏移量。

把每一个格子看成1来计算的，且看的是相对于左上角的

第五个问题？如何训练的

3 yolo3 检测

网络：

输出信息类别

所谓的多尺度就是来自这3条预测之路，y1,y2和y3的深度都是255，边长的规律是13:26:52。YOLOv3设定的是每个网格单元预测3个box，所以每个box需要有(x, y, w, h, confidence)五个基本参数，然后还要有80个类别的概率。所以3×(5 + 80) = 255，这个255就是这么来的。

softmax的改进

相当于每一个类别进行sigomid的运用

4 yolo4 检测

数据增强小技巧

YOLOv4中的tricks概念总结——Bag of freebies_Clichong的博客-CSDN博客

随机设置补丁，label Smoothing——改变标签

IOU计算

IOU_Loss：主要考虑检测框和目标框重叠面积。

GIOU_Loss：在IOU的基础上，解决边界框不重合时的问题。——引入差集

DIOU_Loss：在IOU和GIOU的基础上，考虑边界框中心点距离的信息。——引入中心距离

CIOU_Loss：在DIOU的基础上，考虑边界框宽高比的尺度信息。——衡量长宽比一致性的参数

YOLOv4中采用了CIOU_Loss的回归方式，使得预测框回归的速度和精度更高一些。

DIOU-NMS 

降低重叠的图像

归一化操作

【YOLO v4 相关理论】Normalization: BN、CBN、CmBN_yolov4中的batchnormalization网络-CSDN博客

BN每一个mini batch进行运算 CBN前几个mini batch进行运算 CmBN一个整个的batch进行计算

网络结构

对于backbone

CV 经典主干网络 (Backbone) 系列: CSPNet_cv里面backbone-CSDN博客

SPP

YOLO系列详解：YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5、YOLOv6、YOLOv7_AI追随者的博客-CSDN博客

SPP（Spatial Pyramid Pooling）解读_spp结构-CSDN博客

FAN

1 加一起变成拼接

好处：

引入了自底向上的路径，使得底层信息更容易传到顶部
并且还是一个捷径，红色的没准走个100层(Resnet)，绿色的几层就到了

总结：

backbone改变了

conv的一部分用mish改变

下采样采用了SPP

消除敏感度

提出了空间注意力机制

5 yolo5 检测

1+2+1+2 1csp在neck存在   2 两个残差快 1 focus  2 自适应模块

YOLO系列梳理（三）YOLOv5_yolov5自适应锚框_CV技术指南(公众号)的博客-CSDN博客

不同之处：

1 相比于V4 CSP不仅在backbone存在，在neck里面也存在的

2 CSP结构-YOLOv4网络结构中，借鉴了CSPNet的设计思路，仅仅在主干网络中设计了CSP结构。而YOLOv5中设计了两种CSP结构，以YOLOv5s网络为例，CSP1_X结构应用于Backbone主干网络中，另一种CSP2_X结构则应用于Neck网络中

Focus 操作

自适应框选

自适应图片缩放

YOLOv5 提出一种方法能够自适应的添加最少的黑边到缩放之后的图片

focus

残差网络有两种

YOLOv5网络模型的结构原理讲解（全）_yolov5网络结构详解-CSDN博客

6 yolo6 检测

1+1+1

YOLO v6：一个硬件友好的目标检测算法_解耦检测头-CSDN博客

YOLO系列详解：YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5、YOLOv6、YOLOv7-CSDN博客

YOLOv6 主要在 Backbone、Neck、Head 以及训练策略等方面进行了诸多的改进：

统一设计了更高效的 Backbone 和 Neck ：受到硬件感知神经网络设计思想的启发，基于 RepVGG style设计了可重参数化、更高效的骨干网络 EfficientRep Backbone 和 Rep-PAN Neck。

优化设计了更简洁有效的 Efficient Decoupled Head，在维持精度的同时，进一步降低了一般解耦头带来的额外延时开销。

Anchor-free 无锚范式，SimOTA标签分配策略以及 SIoU边界框回归损失来进一步提高检测精度。

backbone

具体图

结合图差不多的。主要有一个SimSPPF

空间金字塔池化改进 SPP / SPPF / SimSPPF / ASPP / RFB / SPPCSPC / SPPFCSPC_金字塔池化模块-CSDN博客

neck

FAN里面的csp变成rep

检测头部

基于yolox改进得到的

在 YOLOv6 中，我们采用了解耦检测头（Decoupled Head）结构，并对其进行了精简设计。原始 YOLOv5 的检测头是通过分类和回归分支融合共享的方式来实现的，而 YOLOX 的检测头则是将分类和回归分支进行解耦，同时新增了两个额外的 3x3 的卷积层，虽然提升了检测精度，但一定程度上增加了网络延时。

因此，我们对解耦头进行了精简设计，同时综合考虑到相关算子表征能力和硬件上计算开销这两者的平衡，采用 Hybrid Channels 策略重新设计了一个更高效的解耦头结构，在维持精度的同时降低了延时，缓解了解耦头中 3x3 卷积带来的额外延时开销。通过在 nano 尺寸模型上进行消融实验，对比相同通道数的解耦头结构，精度提升 0.2% AP 的同时，速度提升6.8%。
 

SIOU损失函数

目标检测--边框回归损失函数SIoU原理详解及代码实现_边框损失函数-CSDN博客

simOTA 细节学习

目标检测标签分配之 OTA 和 SimOTA 细节学习-CSDN博客

首先是3*1000 3个物体 1000个候选框 

选取前十个进行当成正样本

正样本加一起得到一个值 文中里面的是 343

然后进行选取最大的当成正样本

速度快，但是效果低了

7 yolo7 检测

给一个结构图看吧 up不写了太累了

补充知识点：检测指标知识点

目标检测评价指标-CSDN博客【语义分割】评价指标：PA、CPA、MPA、IoU、MIoU详细总结和代码实现_语义分割mpa计算公式-CSDN博客目标检测评价指标-CSDN博客

8 EifficientNet网络

9 RGB-T检测

20 分割任务

1 Unet解读

分割focal loss

深度学习分割任务——Unet++分割网络代码详细解读（文末附带作者所用code）-CSDN博客

【语义分割】评价指标：PA、CPA、MPA、IoU、MIoU详细总结和代码实现_语义分割mpa计算公式-CSDN博客

class Unet(nn.Module):def __init__(self):super().__init__()der_conv = nn.Sequential(DoubleConv2d(1,64),DoubleConv2d(64,128),DoubleConv2d(128,256),DoubleConv2d(256,512))der_down = nn.MaxPool2d(2)self.decoder_up = nn.Sequential(nn.ConvTranspose2d(1024,512,4,2,1),nn.ConvTranspose2d(512,256,4,2,1),nn.ConvTranspose2d(256,128,4,2,1),nn.ConvTranspose2d(128,64,4,2,1))self.decoder_conv = nn.Sequential(DoubleConv2d(1024,512),DoubleConv2d(512,256),DoubleConv2d(256,128),DoubleConv2d(128,64))self.bottleneck = DoubleConv2d(512,1024)self.output = nn.Conv2d(64,2,3,1,1)def forward(self,x):#encoder：保存每一个DoubleConv的结果为跳跃链接做准备，同时输出codesskip_connection = []for idx in range(4):x = der_conv[idx](x)skip_connection.append(x)x = der_down(x)x = self.bottleneck(x)#调换顺序skip_connection = skip_connection[::-1]#decoder：codes每经过一个转置卷积，就需要与跳跃链接中的值合并#合并后的值进入DoubleConvfor idx in range(4):x = self.decoder_up[idx](x)#转换尺寸skip_connection[idx] = size(skip_connection[idx],size=x.shape[-2:])x = torch.cat((skip_connection[idx],x),dim=1)x = self.decoder_conv[idx](x)x = self.output(x)return x

这个里面指的是cat 通道数进行相加得到的

2 U-net++

从denseNet弄来的

【语义分割】U-Net++_u-net++缺陷-CSDN博客

为什么这么做：

作者认为：当 Encoder 和 Decoder 网络的特征映射在语义上相似时，优化器能更好的处理学习任务。因此，设计了一系列nested (嵌套的)，dense (密集的) skip pathways (跳跃路径)，将高分辨率特征图从 Encoder 网络逐渐地和 Decoder 网络中相应语义的特征图优先进行融合，通过叠加的方式整合，以此来获取不同层次的特征。此外，该网络还加入了更浅的U-Net，使得融合的特征图尺度差异更小，更能高效地捕获前景对象的深层 ( fine-grained ) 细节
 

图像增强工具 albumentations学习总结 - hou永胜 - 博客园 (cnblogs)数据增强

深度学习100问-15：什么是深监督(Deep Supervision)？-CSDN博客

相当于一个辅助分类器

3 U2-net

U2Net网络简介_duts数据集-CSDN博客

和Unet感觉差不多，大的讨一个小的

RSU-7结构

RSU-4F结构

其中En_1和De_1采用的是RSU-7，En_2和De_2采用的是RSU-6，En_3和De_3采用的是RSU-5，En_4和De_4采用的是RSU-4，最后还剩下En_5、En_6和De_5三个模块。这三个模块采用的是RSU-4F

在RSU-4F中并没有进行下采样或上采样，而是将采样层全部替换成了膨胀卷积。作者在论文3.2章节中的解释是到En_5时，特征图的分辨率已经很低了，如果接着下采样会丢失很多上下文信息，所以在RSU-4F中就不再进行下采样了。下图是我绘制的RSU-4F，其中带参数d的卷积层全部是膨胀卷积，d为膨胀系数。

3 deeplab

Deeplabv3+网络结构详解与模型的搭建_如何更改deeplabv3+的主干网络-CSDN博客

deeplab V3

pytorch 官网给的

v3把atrous换成普通的卷积而已

backbone 指的是resnet50

v3+

相当于把conv换成了深度可分离卷积

源码解析

deeplab v3+ 源码详解_deeplabv3代码-CSDN博客

def get_argparser():parser = argparse.ArgumentParser()# Datset Options# 数据参数parser.add_argument("--data_root", type=str, default='./datasets/data',help="path to Dataset")#数据集类型parser.add_argument("--dataset", type=str, default='voc',choices=['voc', 'cityscapes'], help='Name of dataset')parser.add_argument("--num_classes", type=int, default=None,help="num classes (default: None)")# 网络模型parser.add_argument("--model", type=str, default='deeplabv3plus_mobilenet',choices=['deeplabv3_resnet50',  'deeplabv3plus_resnet50','deeplabv3_resnet101', 'deeplabv3plus_resnet101','deeplabv3_mobilenet', 'deeplabv3plus_mobilenet'], help='model name')# 裁剪parser.add_argument("--separable_conv", action='store_true', default=False,help="apply separable conv to decoder and aspp")parser.add_argument("--output_stride", type=int, default=16, choices=[8, 16])# 训练过程parser.add_argument("--test_only", action='store_true', default=False)#parser.add_argument("--save_val_results", action='store_true', default=False,help="save segmentation results to "./results"")# 总的次数parser.add_argument("--total_itrs", type=int, default=30e3,help="epoch number (default: 30k)")# 学习率parser.add_argument("--lr", type=float, default=0.01,help="learning rate (default: 0.01)")# 学习率衰减parser.add_argument("--lr_policy", type=str, default='poly', choices=['poly', 'step'],help="learning rate scheduler policy")#迭代的次数parser.add_argument("--step_size", type=int, default=10000)#验证集要不要裁剪parser.add_argument("--crop_val", action='store_true', default=False,help='crop validation (default: False)')# 样本量parser.add_argument("--batch_size", type=int, default=16,help='batch size (default: 16)')parser.add_argument("--val_batch_size", type=int, default=4,help='batch size for validation (default: 4)')#输入输入大小parser.add_argument("--crop_size", type=int, default=513)parser.add_argument("--ckpt", default=None, type=str,help="restore from checkpoint")parser.add_argument("--continue_training", action='store_true', default=False)parser.add_argument("--loss_type", type=str, default='cross_entropy',choices=['cross_entropy', 'focal_loss'], help="loss type (default: False)")parser.add_argument("--gpu_id", type=str, default='0',help="GPU ID")parser.add_argument("--weight_decay", type=float, default=1e-4,help='weight decay (default: 1e-4)')parser.add_argument("--random_seed", type=int, default=1,help="random seed (default: 1)")# 打印几次每隔几次parser.add_argument("--print_interval", type=int, default=10,help="print interval of loss (default: 10)")# 验证机打印parser.add_argument("--val_interval", type=int, default=100,help="epoch interval for eval (default: 100)")#是否加载预训练模型parser.add_argument("--download", action='store_true', default=False,help="download datasets")# 选择版本parser.add_argument("--year", type=str, default='2012',choices=['2012_aug', '2012', '2011', '2009', '2008', '2007'], help='year of VOC')# 要不要进行展示parser.add_argument("--enable_vis", action='store_true', default=False,help="use visdom for visualization")parser.add_argument("--vis_port", type=str, default='13570',help='port for visdom')parser.add_argument("--vis_env", type=str, default='main',help='env for visdom')parser.add_argument("--vis_num_samples", type=int, default=8,help='number of samples for visualization (default: 8)')return parser

模型：

deeplab v3+ 源码详解_deeplabv3代码-CSDN博客DeepLabV3使用及源码讲解_deeplabv3代码-CSDN博客

21 时序任务

就是一种思想

22 注意力机制

1 CBMA

通道有一个线性层计算

class ChannelAttention(nn.Module):"""CBAM混合注意力机制的通道注意力"""def __init__(self, in_channels, ratio=16):super(ChannelAttention, self).__init__()self.avg_pool = nn.AdaptiveAvgPool2d(1)self.max_pool = nn.AdaptiveMaxPool2d(1)self.fc = nn.Sequential(# 全连接层# nn.Linear(in_planes, in_planes // ratio, bias=False),# nn.ReLU(),# nn.Linear(in_planes // ratio, in_planes, bias=False)# 利用1x1卷积代替全连接，避免输入必须尺度固定的问题，并减小计算量nn.Conv2d(in_channels, in_channels // ratio, 1, bias=False),nn.ReLU(inplace=True),nn.Conv2d(in_channels // ratio, in_channels, 1, bias=False))self.sigmoid = nn.Sigmoid()def forward(self, x):avg_out = self.fc(self.avg_pool(x))max_out = self.fc(self.max_pool(x))out = avg_out + max_outout = self.sigmoid(out)return out * x

class SpatialAttention(nn.Module):"""CBAM混合注意力机制的空间注意力"""def __init__(self, kernel_size=7):super(SpatialAttention, self).__init__()assert kernel_size in (3, 7), 'kernel size must be 3 or 7'padding = 3 if kernel_size == 7 v1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)self.sigmoid = nn.Sigmoid()def forward(self, x):avg_out = an(x, dim=1, keepdim=True)max_out, _ = torch.max(x, dim=1, keepdim=True)out = torch.cat([avg_out, max_out], dim=1)out = self.v1(out))return out * x

2 SE 注意力机制

附加一些小问题

面试经验1 

list如何删选不重复元素？

numpy如何解决

如何把数据输入到cpu上训练

torch.detach什么意思？有什么作用？

如何冻结torch的层

BN层训练和测试时候有什么区别？

# 10 是原来特征  20是后来的特征 2 是头数 头数必须和feature的channel一样才可以。
# 流程主要是先进行 线性层+拆开特征数+进行操作
# (32, 20, 10)——（MLP)(32,20,20)——(32,20,2,10)——(attn)(32,2,20,20)——(32,20,2,10)——(32,20,20)

import torch
import numpy as np
 as nn
import math
functional as Fclass selfAttention(nn.Module) :def __init__(self, num_attention_heads, input_size, hidden_size):super(selfAttention, self).__init__()if hidden_size % num_attention_heads != 0 :raise ValueError("the hidden size %d is not a multiple of the number of attention heads""%d" % (hidden_size, num_attention_heads))self.num_attention_heads = num_attention_headsself.attention_head_size = int(hidden_size / num_attention_heads)self.all_head_size = hidden_sizeself.key_layer = nn.Linear(input_size, hidden_size)self.query_layer = nn.Linear(input_size, hidden_size)self.value_layer = nn.Linear(input_size, hidden_size)def trans_to_multiple_heads(self, x):new_size = x.size()[ : -1] + (self.num_attention_heads, self.attention_head_size)x = x.view(new_size)return x.permute(0, 2, 1, 3)def forward(self, x):key = self.key_layer(x)query = self.query_layer(x)value = self.value_layer(x)key_heads = ans_to_multiple_heads(key)query_heads = ans_to_multiple_heads(query)value_heads = ans_to_multiple_heads(value)attention_scores = torch.matmul(query_heads, key_heads.permute(0, 1, 3, 2))attention_scores = attention_scores / math.sqrt(self.attention_head_size)attention_probs = F.softmax(attention_scores, dim = -1)context = torch.matmul(attention_probs, value_heads)context = context.permute(0, 2, 1, 3).contiguous()new_size = context.size()[ : -2] + (self.all_head_size , )context = context.view(*new_size)return context# 32是批次 20是词向量 10是特征features = torch.rand((32, 20, 10))
# 10 是原来特征  20是后来的特征 2 是头数 头数必须和feature的channel一样才可以。
# 流程主要是先进行 线性层+拆开特征数+进行操作
attention = selfAttention(2, 10, 20)
result = attention.forward(features)
print(result.shape)

import math
from collections import OrderedDict
from functools import partialimport numpy as np
import torch
 as nn
functional as F# --------------------------------------#
#   Gelu激活函数的实现
#   利用近似的数学公式
# --------------------------------------#
class GELU(nn.Module):def __init__(self):super(GELU, self).__init__()def forward(self, x):return 0.5 * x * (1 + torch.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * torch.pow(x, 3))))def drop_path(x, drop_prob: float = 0., training: bool = False):if drop_prob == 0. or not training:return xkeep_prob = 1 - drop_probshape = (x.shape[0],) + (1,) * (x.ndim - 1)random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)random_tensor.floor_()output = x.div(keep_prob) * random_tensorreturn outputclass DropPath(nn.Module):def __init__(self, drop_prob=None):super(DropPath, self).__init__()self.drop_prob = drop_probdef forward(self, x):return drop_path(x, self.drop_prob, aining)class PatchEmbed(nn.Module):def __init__(self, input_shape=[480, 480], patch_size=16, in_chans=3, num_features=768, norm_layer=None,flatten=True):super().__init__()self.num_patches = (input_shape[0] // patch_size) * (input_shape[1] // patch_size)self.flatten = flattenself.proj = nn.Conv2d(in_chans, num_features, kernel_size=patch_size, stride=patch_ = norm_layer(num_features) if norm_layer else nn.Identity()def forward(self, x):# 1*3*480*480x = self.proj(x)# 1*768*30*30if self.flatten:x = x.flatten(2).transpose(1, 2)  # BCHW -> BNCx = (x)return x# --------------------------------------------------------------------------------------------------------------------#
#   Attention机制
#   将输入的特征qkv特征进行划分，首先生成query, key, value。query是查询向量、key是键向量、v是值向量。
#   然后利用 查询向量query 点乘 转置后的键向量key，这一步可以通俗的理解为，利用查询向量去查询序列的特征，获得序列每个部分的重要程度score。
#   然后利用 score 点乘 value，这一步可以通俗的理解为，将序列每个部分的重要程度重新施加到序列的值上去。
# --------------------------------------------------------------------------------------------------------------------#
class Attention(nn.Module):def __init__(self, dim, num_heads=12, qkv_bias=False, attn_drop=0., proj_drop=0.):super().__init__()self.num_heads = num_headsself.scale = (dim // num_heads) ** -0.5self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)self.attn_drop = nn.Dropout(attn_drop)self.proj = nn.Linear(dim, dim)self.proj_drop = nn.Dropout(proj_drop)def forward(self, x):B, N, C = x.shapeqkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)q, k, v = qkv[0], qkv[1], qkv[2]attn = (q @ k.transpose(-2, -1)) * self.scaleattn = attn.softmax(dim=-1)attn = self.attn_drop(attn)x = (attn @ v).transpose(1, 2).reshape(B, N, C)x = self.proj(x)x = self.proj_drop(x)return x# 1*3*480*480——1*768*30*30——1*768*900——1*900*3*12*64(3个qkv 12个头 64特征)qkv指的是900*12*64——(attn(1*12*900*900)里面就是注意力,reshape进行操作）接下来就是(1*900*768)
# MLP里面就是1*768*900 变成1*768*3072 变成1*768*900
class Mlp(nn.Module):""" MLP as used in Vision Transformer, MLP-Mixer and related networks"""def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=GELU, drop=0.):super().__init__()out_features = out_features or in_featureshidden_features = hidden_features or in_featuresdrop_probs = (drop, drop)self.fc1 = nn.Linear(in_features, hidden_features)self.act = act_layer()self.drop1 = nn.Dropout(drop_probs[0])self.fc2 = nn.Linear(hidden_features, out_features)self.drop2 = nn.Dropout(drop_probs[1])def forward(self, x):x = self.fc1(x)x = self.act(x)x = self.drop1(x)x = self.fc2(x)x = self.drop2(x)return xclass Block(nn.Module):def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, drop=0., attn_drop=0.,drop_path=0., act_layer=GELU, norm_layer=nn.LayerNorm):super().__init__()1 = norm_layer(dim)self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=2 = norm_layer(dim)self.mlp = Mlp(in_features=dim, hidden_features=int(dim * mlp_ratio), act_layer=act_layer, drop=drop)self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()def forward(self, x):x = x + self.drop_path(self.1(x)))x = x + self.drop_path(self.2(x)))return xclass Conv2dReLU(nn.Sequential):def __init__(self,in_channels,out_channels,kernel_size,padding=0,stride=1,use_batchnorm=True,):conv = nn.Conv2d(in_channels,out_channels,kernel_size,stride=stride,padding=padding,bias=not (use_batchnorm),)relu = nn.ReLU(inplace=True)bn = nn.BatchNorm2d(out_channels)super(Conv2dReLU, self).__init__(conv, bn, relu)class VisionTransformer(nn.Module):def __init__(# patchsize指的是16*16 16个self, input_shape=[480, 480], patch_size=16, in_chans=3, num_classes=2, num_features=768,depth=12, num_heads=12, mlp_ratio=4., qkv_bias=True, drop_rate=0.1, attn_drop_rate=0.1, drop_path_rate=0.1,norm_layer=partial(nn.LayerNorm, eps=1e-6), act_layer=GELU):super().__init__()# -----------------------------------------------##   480, 480, 3 -> 196, 768# -----------------------------------------------#self.patch_embed = PatchEmbed(input_shape=input_shape, patch_size=patch_size, in_chans=in_chans,num_features=num_features)# 一个图像的尺寸是多少 900 30*30num_patches = (480 // patch_size) * (480 // patch_size)# 一个图像的特征是768self.num_features = w_feature_shape = [int(input_shape[0] // patch_size), int(input_shape[1] // patch_size)]self.old_feature_shape = [int(480 // patch_size), int(480 // patch_size)]# --------------------------------------------------------------------------------------------------------------------##   classtoken部分是transformer的分类特征。用于堆叠到序列化后的图片特征中，作为一个单位的序列特征进行特征提取。##   在利用步长为16x16的卷积将输入图片划分成14x14的部分后，将14x14部分的特征平铺，一幅图片会存在序列长度为196的特征。#   此时生成一个classtoken，将classtoken堆叠到序列长度为196的特征上，获得一个序列长度为197的特征。#   在特征提取的过程中，classtoken会与图片特征进行特征的交互。最终分类时，我们取出classtoken的特征，利用全连接分类。# --------------------------------------------------------------------------------------------------------------------##   196, 768 -> 197, 768# cls_token=1*1*768self.cls_token = nn.s(1, 1, num_features))# --------------------------------------------------------------------------------------------------------------------##   为网络提取到的特征添加上位置信息。#   以输入图片为480, 480, 3为例，我们获得的序列化后的图片特征为196, 768。加上classtoken后就是197, 768#   此时生成的pos_Embedding的shape也为197, 768，代表每一个特征的位置信息。# --------------------------------------------------------------------------------------------------------------------##   197, 768 -> 197, 768self.pos_embed = nn.s(1, num_patches, num_features))self.pos_drop = nn.Dropout(p=drop_rate)# -----------------------------------------------##   197, 768 -> 197, 768  12次# -----------------------------------------------#dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]self.blocks = nn.Sequential(*[Block(dim=num_features,num_heads=num_heads,mlp_ratio=mlp_ratio,qkv_bias=qkv_bias,drop=drop_rate,attn_drop=attn_drop_rate,drop_path=dpr[i],norm_layer=norm_layer,act_layer=act_layer) for i in range(depth)]) = norm_layer(num_features)self.head = nn.Linear(num_features, num_classes) if num_classes > 0 else nn.Identity()n_patches = (480 // 16) * (480 // 16)self.position_embeddings = nn.s(1, n_patches, 768))v_more = Conv2dReLU(768,2048,kernel_size=3,padding=1,use_batchnorm=True,)def forward_features(self, x):x = self.patch_embed(x)# cls_token = self.pand(x.shape[0], -1, -1)# x = torch.cat((cls_token, x), dim=1)## cls_token_pe = self.pos_embed[:, 0:1, :]# img_token_pe = self.pos_embed[:, 1: , :]# print(img_token_pe.shape)## img_token_pe = img_token_pe.view(1, *self.old_feature_shape, -1).permute(0, 3, 1, 2)# print(img_token_pe.shape)# img_token_pe = F.interpolate(img_token_pe, size&#w_feature_shape, mode='bicubic', align_corners=False)# print(img_token_pe.shape)# img_token_pe = img_token_pe.permute(0, 2, 3, 1).flatten(2)# print(img_token_pe.shape)# pos_embed = torch.cat([cls_token_pe, img_token_pe], dim=1)# x = x.flatten(2)# x = x.transpose(-1, -2)x = x + self.position_embeddingsx = self.pos_drop(x)x = self.blocks(x)x = (x)return xdef forward1(self, hidden_states):B, n_patch, hidden = hidden_states.size()  # reshape from (B, n_patch, hidden) to (B, h, w, hidden)h, w = int(np.sqrt(n_patch)), int(np.sqrt(n_patch))x = hidden_states.permute(0, 2, 1)x = x.contiguous().view(B, hidden, h, w)x = v_more(x)return xdef forward(self, x):x = self.forward_features(x)x = self.forward1(x)# print(x.shape)return xdef freeze_backbone(self):backbone = [self.patch_embed, self.cls_token, self.pos_embed, self.pos_drop, self.blocks[:8]]for module in backbone:try:for param in module.parameters():quires_grad = quires_grad = Falsedef Unfreeze_backbone(self):backbone = [self.patch_embed, self.cls_token, self.pos_embed, self.pos_drop, self.blocks[:8]]for module in backbone:try:for param in module.parameters():quires_grad = quires_grad = Truedef vit(input_shape=[480, 480], pretrained=False, num_classes=2):model = VisionTransformer(input_shape)if pretrained:model.load_state_dict(torch.load("model_data/vit-patch_16.pth"))if num_classes != 1000:model.head = nn.Linear(model.num_features, num_classes)return modelimport torch# Create a random input tensor with the shape (batch_size, channels, height, width)
input_data = torch.randn((1, 3, 480, 480))# Instantiate the Vision Transformer model
vit_model = vit(input_shape=[480, 480], num_classes=2)# Forward pass through the model
output = vit_model(input_data)# Print the shape of the output
print("Output shape:", output.shape)

import numpy as npdef non_max_sppse(pre_box, threshold=0.2):for object_name, bbox in pre_box.items():bbox_array = np.array(bbox, np.float32)# 计算所有框的面积x1, y1, x2, y2, source = bbox_array[:, 0], bbox_array[:, 1], bbox_array[:, 2], bbox_array[:, 3], bbox_array[:, 4]areas = (x2 - x1 + 1) * (y2 - y1 + 1)# 对置信度进行排序order = source.argsort()[::-1]keep = []while order.size>0:i = order[0]keep.append(i)xx1 = np.maximum(x1[i], x1[order[1:]])yy1 = np.maximum(y1[i], y1[order[1:]])xx2 = np.minimum(x2[i], x2[order[1:]])yy2 = np.minimum(y2[i], y2[order[1:]])inter = np.maximum(0, (xx2 - xx1 + 1)) * np.maximum(0, (yy2 - yy1 + 1))iou = inter / (areas[i] + areas[order[1:]] - inter)indexs = np.where(iou < threshold)[0] + 1order = order[indexs]bbox = bbox_array[keep]pre_box[object_name] = list()pre_box = pre_boxreturn pre_boxpre_box = {"dog": [[2, 8, 4, 15, 0.5], [3, 12, 5, 17, 0.1], [3, 9, 4, 15, 0.3], [3, 10, 5, 18, 0.6], [2, 15, 4, 23, 0.8]]}
a = non_max_sppse(pre_box, 0.2)
print(a)

import numpy as npdef conv2d(inputs, kernels, bias, stride, padding):""""inputs: c, h, wkernels: out_ch , in_ch, kh, kw; in_ch == cbias: out_ch"""c, h, w = inputs.shapeout_ch, in_ch, kh, kw = kernels.shapeh_out = 1 + (h + 2 * padding - kh) // stridew_out = 1 + (h + 2 * padding - kh) // strideoutputs = np.zeros((out_ch, h_out, w_out))inputs_pad = np.pad(inputs, ((0, 0), (padding, padding), (padding, padding)))for i in range(h_out):for j in range(w_out):area = inputs_pad[:, i * stride:i * stride + kh, j * stride:j * stride + kw]  # in_ch, k, koutputs[:, i, j] = np.sum(area[None, :] * kernels, axis=(1, 2, 3)) + biasreturn outputsimage = np.random.rand(3,8, 8).astype(np.float32)
kernels = np.random.rand(6,3,1, 1).astype(np.float32)
result = conv2d(inputs=image, kernels=kernels, bias=0, stride=2, padding=0)# 打印结果
print("卷积结果:n", result.shape)

import numpy as npimport torch
functional as F
from torch import nn
import math# 在计算自注意力的时候，首先计算每个元素的 Query 和所有其他元素的 Key 之间的相似度（通常用点积来计算），
# 然后对相似度进行, softmax(行方向上)操作得到权重，最后将这个权重应用到每个元素的 Value 上，再将所有元素的加权 Value 求和
# 就得到了当前元素的输出。
class SimpleAttention(nn.Module):def __init__(self, dim, num_heads):super().__init__()self.num_heads = num_headsself.dim = dim  # dim是特征长度self.head_dim = dim // num_headsdef forward(self, query, key, value, mask=None):B, _, N = query.size()  # N是序列长度# 将输入的Q、K、V拆分为多头。 num_heads多头、 head_dim每个头的特征维度、 N是序列长度query = query.view(B, self.num_heads, self.head_dim, N)key = key.view(B, self.num_heads, self.head_dim, N)value = value.view(B, self.num_heads, self.head_dim, N)# 计算注意力分数。计算query和key的点积（dot product）。点积是相似性度量方法，# 我们使用点积来衡量query和每个key之间的相似性，相似性越高，对应的value在最终的注意力输出中的权重就越大。# sqrt这部分是在对点积的结果进行缩放（scaling），用于防止点积的结果过大，导致softmax函数的梯度过小，从而影响模型的训练。attn_scores = torch.matmul(query, anspose(-2, -1)) / math.sqrt(self.head_dim)# 如果提供了mask，将其应用到注意力分数上if mask is not None:attn_scores = attn_scores.masked_fill(mask == 0, float('-inf'))# 计算注意力权重attn_weights = F.softmax(attn_scores, dim=-1)# 计算加权的Voutput = torch.matmul(attn_weights, value)# 合并多头output = iguous().view(B, -1, N)return output# 创建一个示例的多通道二维图片数据（4x4 像素，3个通道）
query = np.random.rand(3, 12, 12).astype(np.float32)
key = np.random.rand(3, 12, 12).astype(np.float32)
value = np.random.rand(3, 12, 12).astype(np.float32)# 执行池化操作
SimpleAttention2 = SimpleAttention(dim=64, num_heads=8)
results = SimpleAttention2(query, key, value)# 打印卷积结果
print(results.shape)

import numpy as npdef max_pooling(inputs, pool_size, stride):"""最大池化操作inputs: 输入数据，形状为 (C, H, W)pool_size: 池化核的大小stride: 步长"""C, H, W = inputs.shape# 初始化输出数据H_out = (H - pool_size) // stride + 1W_out = (W - pool_size) // stride + 1outputs = np.zeros((C, H_out, W_out))# 进行最大池化操作for i in range(H_out):for j in range(W_out):inputs_slice = inputs[:, i*stride:i*stride+pool_size, j*stride:j*stride+pool_size]outputs[:, i, j] = np.max(inputs_slice, axis=(1, 2))         # 最大池化# outputs[:, i, j] = np.mean(inputs_slice, axis=(1, 2))        # 平均池化return outputs# 创建一个示例的多通道二维图片数据（4x4 像素，3个通道）
image = np.random.rand(3, 12, 12).astype(np.float32)# 定义 池化核大小
pool_size = 2# 执行池化操作
result = max_pooling(image, pool_size, stride=2)# 打印卷积结果
print(result.shape)

import numpy as npdef IoU_cal(box1, box2):x1 = max(box1[0], box2[0])y1 = max(box1[1], box2[1])x2 = min(box1[2], box2[2])y2 = min(box1[3], box2[3])inter = max(0, x2 - x1) * max(0, y2 - y1)areas1 = (box1[2] - box1[0]) * (box1[3] - box1[1])areas2 = (box2[2] - box2[0]) * (box2[3] - box2[1])iou = inter / (areas1 + areas2 - inter)return ioupre_box1 = [2, 9, 4, 15, 0.5]
pre_box2 = [3, 7, 6, 10, 0.5]a = IoU_cal(pre_box1, pre_box2)
print(a)

import numpy as npdef batch_norm(inputs, gamma, beta, eps):"""批量归一化操作。N, C, H, W样本数可以看做N*H*W，CNN中，BN通常在每个通道上独立进行inputs: 输入数据，形状为 (N, C, H, W)gamma: 缩放因子，形状为 (C,)beta: 偏移因子，形状为 (C,)eps: 防止除0的小数值"""N, C, H, W = inputs.shape# 在N、H和W的维度上计算每个通道的均值和方差mean = np.mean(inputs, axis=(0, 2, 3), keepdims=True)  # (1,C,1,1)var = np.var(inputs, axis=(0, 2, 3), keepdims=True)# 计算归一化的输入。eps防止除0inputs_norm = (inputs - mean) / np.sqrt(var + eps)# 缩放和偏移outputs = gamma * inputs_norm + betareturn outputs# 举例
inputs = np.random.rand(64, 3, 128, 128)  # 64 samples, 3 channels, 128x128 feature mapsgamma = 0.5
beta = 0.2
eps = 2e-12outputs = batch_norm(inputs, gamma, beta, eps)
print('输出：', outputs.shape)

#导入相关模块
from torch.utils.data import DataLoader,Dataset
from skimage import io,transform
import matplotlib.pyplot as plt
import os
import torch
from torchvision import transforms
import numpy as npclass AnimalData(Dataset): #继承Datasetdef __init__(self, root_dir, transform=None): #__init__是初始化该类的一些基础参数_dir = root_dir   #文件目录ansform = transform #变换self.images = os._dir)#目录里的所有文件def __len__(self):#返回整个数据集的大小return len(self.images)def __getitem__(self,index):#根据索引index返回dataset[index]image_index = self.images[index]#根据索引index获取该图片img_path = os.path._dir, image_index)#获取索引为index的图片的路径名img = io.imread(img_path)# 读取该图片label = img_path.split('\')[-1].split('.')[0]# 根据该图片的路径名获取该图片的label，具体根据路径名进行分割。我这里是"E:\Python Project\Pytorch\dogs-vs-cats\train\cat.0.jpg"，所以先用"\"分割，选取最后一个为['cat.0.jpg']，然后使用"."分割，选取[cat]作为该图片的标签sample = {'image':img,'label':label}#根据图片和标签创建字典ansform:sample = ansform(sample)#对样本进行变换return sample #返回该样本