paper cvpr2020

code 评估

blog

ResNet

resnet-残留块blog 2 3

ResNet 模型中的一个残差块的定义。在这个残差块中，根据条件选择了两种不同的快捷连接方式：投影连接和身份连接。

如果 stride 不等于 1 或者 in_channels 不等于 out_channels，则使用投影连接（ShortcutProjection）。投影连接通过一个卷积层将输入 x 的维度从 in_channels 转换为 out_channels，以匹配残差块的输出维度。这样做是为了处理输入和输出通道数不匹配或者步幅不为 1 的情况。

如果 stride 等于 1 并且 in_channels 等于 out_channels，则使用身份连接（nn.Identity()）。身份连接直接将输入 x 作为残差块的输出，不进行任何维度转换。

在残差块中，经过卷积操作和激活函数后，快捷连接和残差路径的输出将被相加，并通过第二个激活函数（ReLU）进行激活，得到最终的输出。

这种设计可以使得 ResNet 模型能够有效地处理不同通道数和步幅的情况，并引入了跳跃连接来缓解梯度消失问题，提高模型的训练效果和表示能力。

通过快捷连接和残差路径的相加操作，可以保留更多的信息和梯度流动，有助于提高模型的性能和训练效果。

in_channels 和 out_channels 是两个整数参数，用于指定残差块的输入通道数和输出通道数。在卷积神经网络中，通道数指的是特征图的深度或通道的数量。

Bottleneck Residual Block（瓶颈残差块）是 ResNet 中的一种特殊类型的残差块，它在 ResNet 的深层网络中起到了重要的作用。 ResNet 的主要思想是通过跳跃连接（shortcut connection）和残差学习（residual learning）来解决梯度消失问题，使得网络能够更深地进行训练。而 Bottleneck Residual Block 是对传统的残差块的改进，旨在进一步减少模型的参数量和计算复杂度。 Bottleneck Residual Block 的设计主要包含三个关键部分： 1. 瓶颈结构（Bottleneck）：它通过引入一个较小的瓶颈层，将输入特征图的维度显著降低，然后再将其扩展回原始维度。这样的设计可以减少计算量，并提高网络的表达能力。 2. 1x1 卷积层：瓶颈结构中的第一个卷积层采用 1x1 的卷积核，用于降低输入特征图的维度。这样可以减少计算量和参数数量。 3. 维度扩展：在瓶颈结构中，经过 1x1 卷积层降维后的特征图，会经过一个 3x3 卷积层进行特征提取，然后再通过另一个 1x1 卷积层将维度扩展回原始维度。这样的设计可以在保持网络性能的同时减少计算量。 通过引入瓶颈结构和适当的维度变换，Bottleneck Residual Block 在减少参数量的同时保持了网络的表达能力。这种设计使得 ResNet 能够构建更深的网络，同时保持较低的计算复杂度，更适合处理复杂的视觉任务。

ResNet（Residual Network）是一种深度卷积神经网络结构，通过残差学习（residual learning）和跳跃连接（shortcut connection）解决了深层网络中的梯度消失问题，使得网络能够更深地进行训练。ResNet 的主要结构特点是在网络中引入了残差块（Residual Block），并通过跳跃连接将输入直接添加到输出中，实现了信息的直接传递。 下面是 ResNet 的经典网络结构，以 ResNet-50 为例： 1. 输入层：接受输入图像或特征图。 2. 卷积层和池化层：一系列的卷积层和池化层用于提取特征和减小特征图的尺寸。 3. 残差块：由多个残差块组成，每个残差块由多个卷积层和跳跃连接组成。其中，常用的残差块包括基本残差块（Basic Residual Block）和瓶颈残差块（Bottleneck Residual Block）。 4. 全局平均池化层：对最后一个残差块的输出进行全局平均池化，将特征图的高度和宽度降为1。 5. 全连接层：将全局平均池化后的特征图连接到全连接层，用于分类或回归任务。 6. 输出层：根据任务需求，输出相应的结果，如分类标签或回归值。 经典的 ResNet 结构包括了不同深度的变种，如 ResNet-18、ResNet-34、ResNet-50、ResNet-101 和 ResNet-152 等。这些网络结构的主要区别在于残差块的堆叠方式和网络的深度。较深的网络通常能够提取更复杂的特征，但也会增加训练和推理的计算成本。 ResNet 的设计思想和网络结构的灵活性使其成为计算机视觉领域中广泛应用的模型，用于图像分类、目标检测、语义分割等任务。

以下是 ResNet-50 的网络结构图示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

Input  
  |  
Conv1 (7x7, 64, stride 2)  
  |  
BatchNorm  
  |  
ReLU  
  |  
MaxPool (3x3, stride 2)  
  |  
Residual Block 1  
  |\  
  | Conv2 (1x1, 64)  
  | BatchNorm  
  | ReLU  
  | Conv3 (3x3, 64)  
  | BatchNorm  
  | ReLU  
  | Conv4 (1x1, 256)  
  | BatchNorm  
  | Shortcut Connection  
  | ReLU  
  |  
Residual Block 2  
  |\  
  | Conv5 (1x1, 128)  
  | BatchNorm  
  | ReLU  
  | Conv6 (3x3, 128)  
  | BatchNorm  
  | ReLU  
  | Conv7 (1x1, 512)  
  | BatchNorm  
  | Shortcut Connection  
  | ReLU  
  |  
Residual Block 3  
  |\  
  | Conv8 (1x1, 256)  
  | BatchNorm  
  | ReLU  
  | Conv9 (3x3, 256)  
  | BatchNorm  
  | ReLU  
  | Conv10 (1x1, 1024)  
  | BatchNorm  
  | Shortcut Connection  
  | ReLU  
  |  
Residual Block 4  
  |\  
  | Conv11 (1x1, 512)  
  | BatchNorm  
  | ReLU  
  | Conv12 (3x3, 512)  
  | BatchNorm  
  | ReLU  
  | Conv13 (1x1, 2048)  
  | BatchNorm  
  | Shortcut Connection  
  | ReLU  
  |  
Global Average Pooling  
  |  
Fully Connected Layer (Output)

上述结构中，Conv1 是一个 7x7 的卷积层，接着是 Batch Normalization 和 ReLU 激活函数。MaxPool 是一个最大池化层，其后是四个残差块（Residual Block）。每个残差块由多个卷积层和跳跃连接（Shortcut Connection）组成。最后经过全局平均池化（Global Average Pooling）后连接到全连接层，最终输出结果。 请注意，上述结构只是 ResNet-50 的一个示例，实际上，不同深度的 ResNet（如 ResNet-18、ResNet-34、ResNet-101 等）具有不同的层数和残差块的堆叠方式。

以下是对于给定参数的解释： - n_blocks: 一个整数列表，表示每个阶段（stage）中的残差块数量。例如，n_blocks = [3, 4, 6, 3] 表示 ResNet 中有四个阶段，每个阶段分别有 3、4、6、3 个残差块。 - n_channels: 一个整数列表，表示每个阶段中每个残差块的输出通道数。列表的长度应与 n_blocks 相同。例如，n_channels = [64, 128, 256, 512] 表示第一个阶段的每个残差块输出通道数为 64，第二个阶段为 128，以此类推。 - bottlenecks（可选）: 一个整数列表，表示每个阶段中是否使用瓶颈残差块（Bottleneck Residual Block）。如果没有指定该参数，则默认为 None，表示使用基本残差块（Basic Residual Block）。列表的长度应与 n_blocks 相同。例如，bottlenecks = [True, True, False, False] 表示第一个和第二个阶段使用瓶颈残差块，而第三个和第四个阶段使用基本残差块。 - img_channels: 输入图像的通道数，默认为 3，表示彩色图像的三个通道（红、绿、蓝）。 - first_kernel_size: 第一个卷积层的内核大小，默认为 7，表示一个 7x7 的卷积核。 这些参数用于初始化 ResNet 网络的构造函数，以定义网络的结构和特征图的通道数。具体的网络结构和层数取决于这些参数的配置。

dilation

在深度学习中，dilation（扩张率）是一种用于卷积操作的参数，用于控制卷积核在输入上的采样间隔。 在传统的卷积操作中，卷积核按照固定的步幅（stride）在输入上滑动，每次移动一个固定的距离进行采样。而使用 dilation 参数可以使卷积核在输入上以更大的间隔进行采样，从而扩大了感受野（receptive field）。 dilation 的值决定了卷积核在输入上的采样间隔。具体地，如果 dilation 为 1，则表示使用常规的卷积操作，卷积核之间没有间隔。如果 dilation 大于 1，则表示在输入上进行稀疏采样，卷积核之间有一定的间隔。较大的 dilation 值可以增加卷积核感受野的大小，从而捕捉更广阔的上下文信息。 使用 dilation 参数的卷积操作被称为 dilated convolution 或 atrous convolution。它在许多计算机视觉任务中被广泛应用，例如图像分割、语义分割和目标检测等，以便有效地捕捉图像中的全局和局部信息。

resnet代码分析

机器学习模型训练全流程 2

利用resnet1 2 3 4

？提取的特征是什么？卷积

ResNet（残差网络）是一种深度卷积神经网络结构，用于图像分类和特征提取任务。在 ResNet 中，最后一个全连接层之前的卷积层通常被视为特征提取器。 具体而言，ResNet 提取的特征是在网络的最后一个卷积层之前的输出。这个输出是一个具有固定维度的特征向量，其维度取决于所使用的 ResNet 模型的具体配置。 以 ResNet-50 为例，它的最后一个卷积层的输出是一个 2048 维的特征向量。这个特征向量可以被视为输入图像的高级表示，其中包含了图像的语义信息。这些特征可以用于图像分类、目标检测、图像检索等各种计算机视觉任务。 因此，ResNet 提取的特征是一个具有固定维度的向量，其中包含了输入图像的高级语义信息。具体的维度取决于所使用的 ResNet 模型的配置。

ResNet-50 是一个深度残差网络模型，用于图像分类和特征提取任务。当使用 ResNet-50 模型进行特征提取时，它会提取输入图像的高级语义特征。 具体来说，ResNet-50 模型通过一系列的卷积层、池化层和全连接层组成。在前向传播过程中，输入图像会经过一系列的卷积和池化操作，以提取图像中的低级特征，例如边缘和纹理。然后，这些低级特征会被传递到残差块（residual blocks）中，其中每个残差块包含多个卷积层，用于进一步提取图像中的高级语义特征。这些高级特征具有更丰富的语义信息，可以用于图像分类、目标检测、图像分割等任务。 因此，当使用 ResNet-50 模型进行特征提取时，提取到的特征是经过多层卷积和池化操作后得到的高级语义特征。这些特征通常被用作输入图像的紧凑表示，可以用于许多计算机视觉任务。

五个特征是什么？结构图

COD

blog 2 3

对于输入图像（大小为H×W×3），通过ResNet-50后，5个特征大小分别为 (H/K,W/K) （K=4，4，8，16，32）。

bcwh：(batchsize,chanel,weight,height)

浅层特征保留了构造对象边界的空间细节，深层特征保留了用于定位对象的语义信息。我们将提取的特征分为低级{X0，X1}，中级{X2}，高级{X3，X4}，并通过串联，上采样进行组合 以及下采样操作。 SINet利用密集连接的来保存来自不同层的更多信息，然后使用RF组件来扩大感受野。

RF结构如图所示，分为5个分支，图中的“C”为拼接操作（concatenation），前4个分支进行了拼接操作后，进行1×1卷积降维后与第5个分支相加

具体过程为：首先将低级特征X0，X1进行拼接操作后，连续进行两次下采样，再通过RF组件得到 rf_4S ；对X3，X4分别进行两次和四次的上采样后与X2一起进行拼接操作，通过RF组件得到rf_3S；对X4进行两次上采样后与X3进行拼接操作，通过RF组件得到 rf_2S ；X4通过RF组件得到 rf_1S 。

从先前的搜索模块sa中获得候选特征后，在识别模块中，我们需要精确地检测出被伪装的物体，文章里的方法扩展了具有密集连接功能的部分解码器组件（PDC） 更具体地说，PDC集成了SM的四个功能级别。其中的“×”表示multiplication操作，“C”表示concatenation操作。

从先前的搜索模块中获得候选特征后，在识别模块中，我们需要精确地检测出被伪装的物体。 文章里的方法扩展了具有密集连接功能的部分解码器组件（PDC） 更具体地说，PDC集成了SM的四个功能级别。

由于注意力机制可以有效地消除无关特征的干扰。 本文又引入了搜索注意（SA）模块来增强X2的中层特征并获得增强的伪装图

将前面得到的 rfs_i（i=1，2，3，4）通过PDC组件后得到 Cs,分为两步，一步将 Cs 进行八次上采样操作后得到 Ccsm ，另一步是将 Cs 经过Sigmoid激活函数后与X2一起进入SA模块（其实就是突出显示Cs初始伪装区域的最大函数），得到 Cℎ 。将 Cℎ 与X3-1与X4-1一起通过PDC模块，在进行八次上采样得到 Ccim 。使用交叉熵作为损失函数，公式如下：

L = L s CE(Ccsm, G) + L i CE(Ccim, G)

–

可以看到，网络整体的架构还是属于encoder-decoder的建构的，不同在于，结尾输出的loss有两个。而这两个loss也将整个网络划分成了两个功能块——Search Module (SM)和 Identification Module (IM)，而两个loss的计算逻辑都是将两个模块解码器最终的特征图上采样，再与原图伪装物体的显著图做交叉熵得到的。

第一个loss是用来衡量原图中有没有伪装物的，第二个loss是用来衡量模型预测的伪装物的位置准不准的。

在SM模块中，在5层卷积的基础上，将[X0,X1]，[X2,X3,X4]，[X3,X4]以及[X4]送入四个RF模块，最后做一个PDC，也就是一个解码器。

此处所谓的RF(reception field)和Google的Inception v3系列网络很像，都是通过1x1卷积与双串联式的架构来减少网络参数，从而达到瓶颈训练的效果，同时也是增大感受野的一种方式，而在COD或者其他的一些显著物检测上，增大感受野是提高预测精度的一种常用方式。

做完四个RF，如何将四个RF得到的特征图融合就是decoder干的事情了，此处的decoder，也就是PDC，大致逻辑也很简单，就是先将后面三个RF得到的特征图上采样到和第一个RF得到的特征图一样的尺寸，然后根据论文中一个elementwise的乘法，将最终decoder得到的四个特征图做拼接，就可以得到PDC的输出了,而第一个PDC的输出也就是第一个模块——SM模块的输出内容了。

关于第二个模块IM，根据文章之前的说法，猎人在得知有猎物存在后，需要知道猎物的大致位置，因此，与SM模块相比，IM模块更加需要关于伪装物轮廓边缘信息。

DCNN的底层输出的特征图多是关于物体边缘轮廓信息的，中层是关于空间位置信息的，而高层多是关于语义信息的。

所以IM在SM原本CNN encoder的基础上，取第三层卷积输出的特征图X2，因为底层能够保留更多的轮廓信息，并将X2与SM的输出结果来做一个简单的fusion，不过原文中是将这个fusion称为一种attention机制。个人认为这么做的目的就是在确保SM模块的输入有较多的边缘轮廓信息的前提下利用全局信息消除无关特征

SA :Ch= fmax(g(x2,σ,λ),Cs)，目的是为了强调原本的伪装物区域。Cs是SM模块的输出结果，g(.)则是一个简单的高斯滤波器

之后的IM主体就是一个简单的encoder-decoder架构了，decoder采用的PDC和之前一样，输出的结果便是IM的输出了。

最终将IM和SM的输出结果分别上采样到和原图的GT一样大，分别做交叉熵得到 ls 和 ld ，加起来就是最终的loss了。

代码

这段代码实现了一个名为 SA 的自定义模块，用于执行全局注意力机制。 首先，代码中定义了一个 _get_kernel 函数，用于生成一个二维高斯核。该函数接受两个参数：kernlen（核的长度，默认为 16）和 nsig（高斯标准差，默认为 3）。它通过计算标准正态分布在给定范围内的概率密度函数，生成一个二维的高斯核。这个高斯核用于后续的卷积操作。 接下来，代码定义了一个 min_max_norm 函数，用于执行归一化操作。该函数接受一个输入张量 in_，并执行以下步骤： - 计算输入张量在第 3 和第 2 维度上的最大值和最小值，并扩展为与输入张量相同的形状。 - 将输入张量减去最小值。 - 将结果除以最大值与最小值之差，加上一个很小的常数（1e-8）以避免除以零。 接下来，定义了一个名为 SA 的自定义模块（nn.Module 的子类），用于执行全局注意力机制。 在 __init__ 函数中，定义了一个 gaussian_kernel 参数，它是通过调用 _get_kernel 函数生成的高斯核，并将其转换为 torch.Tensor 类型的参数。 在前向传播函数 forward 中，输入参数 attention 和 x 分别表示注意力图和特征图。代码使用 F.conv2d 函数对注意力图进行卷积操作，使用之前定义的高斯核进行卷积，并进行边缘填充（padding）操作。然后，通过调用 min_max_norm 函数对卷积结果进行归一化操作。最后，将特征图 x 与归一化后的注意力图相乘，得到最终的输出。 这个 SA 模块可以用于在神经网络中引入全局注意力机制，以增强对特定区域的关注和重要性。

–

通过在 __init__ 函数中进行初始化操作，可以在创建 SINet 类的实例时，为实例的属性赋予初始值。这样，在实例被创建后，就可以直接使用这些属性，并在其他方法中进行操作。

总体而言，该 forward 方法实现了一个残差块的前向传播过程，通过将输入特征与中间特征相加，以及进行卷积和批归一化操作，生成最终的输出特征。

resnet

该网络是一个基于 ResNet50 的修改版，包含了两个分支。下面是各个层的功能：

  • conv1：一个 7x7 的卷积层，输入通道数为 3，输出通道数为 64。
  • bn1：一个批归一化层，对 conv1 的输出进行归一化。
  • relu：一个 ReLU 激活函数，对 bn1 的输出进行非线性激活。
  • maxpool：一个最大池化层，对特征图进行下采样。
  • layer1：第一个残差层，包含 3 个 Bottleneck 残差块。
  • layer2：第二个残差层，包含 4 个 Bottleneck 残差块。
  • layer3_1：第三个残差层的第一个分支，包含 6 个 Bottleneck 残差块。
  • layer4_1：第四个残差层的第一个分支，包含 3 个 Bottleneck 残差块。
  • layer3_2：第三个残差层的第二个分支，包含 6 个 Bottleneck 残差块。
  • layer4_2：第四个残差层的第二个分支，包含 3 个 Bottleneck 残差块。
  • output：网络的输出，包括两个分支的输出。

常规resnet网络由以下几个主要组件组成：

  • conv1：一个 7x7 的卷积层，输入通道数为 3，输出通道数为 64。
  • bn1：一个批归一化层，对 conv1 的输出进行归一化。
  • relu：一个 ReLU 激活函数，对 bn1 的输出进行非线性激活。
  • maxpool：一个最大池化层，对特征图进行下采样。
  • layer1：第一个残差层，包含 3 个 Bottleneck 残差块。
  • layer2：第二个残差层，包含 4 个 Bottleneck 残差块。
  • layer3：第三个残差层，包含 6 个 Bottleneck 残差块。
  • layer4：第四个残差层，包含 3 个 Bottleneck 残差块。
  • avgpool：一个平均池化层，对特征图进行全局平均池化。
  • fc：一个全连接层，将特征图映射到输出类别的维度。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

import torch  
import torch.nn as nn  
  
# 定义 Bottleneck 残差块  
class Bottleneck(nn.Module):  
    def __init__(self, in_channels, out_channels, stride=1, downsample=None):  
        super(Bottleneck, self).__init__()  
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)  
        self.bn1 = nn.BatchNorm2d(out_channels)  
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)  
        self.bn2 = nn.BatchNorm2d(out_channels)  
        self.conv3 = nn.Conv2d(out_channels, out_channels * 4, kernel_size=1, bias=False)  
        self.bn3 = nn.BatchNorm2d(out_channels * 4)  
        self.relu = nn.ReLU(inplace=True)  
        self.downsample = downsample  
        self.stride = stride  
  
    def forward(self, x):  
        identity = x  
  
        out = self.conv1(x)  
        out = self.bn1(out)  
        out = self.relu(out)  
  
        out = self.conv2(out)  
        out = self.bn2(out)  
        out = self.relu(out)  
  
        out = self.conv3(out)  
        out = self.bn3(out)  
  
        if self.downsample is not None:  
            identity = self.downsample(x)  
  
        out += identity  
        out = self.relu(out)  
  
        return out  
  
# 定义 ResNet50 网络  
class ResNet50(nn.Module):  
    def __init__(self, num_classes=1000):  
        super(ResNet50, self).__init__()  
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)  
        self.bn1 = nn.BatchNorm2d(64)  
        self.relu = nn.ReLU(inplace=True)  
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)  
        self.layer1 = self._make_layer(Bottleneck, 64, 3)  
        self.layer2 = self._make_layer(Bottleneck, 128, 4, stride=2)  
        self.layer3 = self._make_layer(Bottleneck, 256, 6, stride=2)  
        self.layer4 = self._make_layer(Bottleneck, 512, 3, stride=2)  
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  
        self.fc = nn.Linear(512 * 4, num_classes)  
  
    def _make_layer(self, block, channels, blocks, stride=1):  
        downsample = None  
        if stride != 1 or channels != 64 * 4:  
            downsample = nn.Sequential(  
                nn.Conv2d(channels, 64 * 4, kernel_size=1, stride=stride, bias=False),  
                nn.BatchNorm2d(64 * 4)  
            )  
  
        layers = []  
        layers.append(block(channels, 64, stride, downsample))  
        for _ in range(1, blocks):  
            layers.append(block(64 * 4, 64))  
  
        return nn.Sequential(*layers)  
  
    def forward(self, x):  
        x = self.conv1(x)  
        x = self.bn1(x)  
        x = self.relu(x)  
        x = self.maxpool(x)  
  
        x = self.layer1(x)  
        x = self.layer2(x)  
        x = self.layer3(x)  
        x = self.layer4(x)  
  
        x = self.avgpool(x)  
        x = x.view(x.size(0), -1)  
        x = self.fc(x)  
  
        return x  
  
# 创建 ResNet50 模型实例  
model = ResNet50()  
  
# 打印模型结构  
print(model)

修改输出类别

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	model = models.resnet50(pretrained=True)
    print(model)
    # (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
    #   (fc): Linear(in_features=2048, out_features=1000, bias=True)
    fc_inputs = model.fc.in_features
    print(fc_inputs)
    model.fc = nn.Linear(fc_inputs, num_classes)
    print(model.fc)
    # 2048
    # Linear(in_features=2048, out_features=214, bias=True)
    model = model.cuda()

forward方法实现了网络的前向传播过程。输入 x 经过一系列的卷积、批归一化、激活函数和池化层后，分别经过 layer1、layer2、layer3_1 和 layer4_1，得到输出特征 x1。同时，输入 x 经过 layer3_2 和 layer4_2，得到输出特征 x2。

因此，x1 和 x2 是两个不同分支的输出特征。它们在网络结构中具有不同的路径，经过不同的残差块和卷积操作。这种设计可以用于多任务学习、特征融合或其他需要多个分支的场景。具体应用中，可以根据需要使用 x1 和 x2 进行后续处理、特征融合或用于不同的任务。

SA

这段代码定义了一个名为SA的PyTorch模型类。它实现了一个holistic attention机制。 在__init__方法中，代码通过_get_kernel函数生成了一个大小为31x31的高斯卷积核，并将其转换为PyTorch的Parameter类型。这个高斯卷积核将用于后续的卷积操作。 在forward方法中，代码接收两个输入参数：attention和x。其中，attention表示注意力图，x表示输入的特征图。代码首先将attention图与高斯卷积核进行卷积操作，并进行填充(padding)以保持输入输出的尺寸一致。然后，通过min-max归一化函数进行归一化处理。接下来，将x与attention图的最大值相乘，实现了特征图x的加权操作。最后，返回加权后的特征图x。 这段代码的作用是对输入的特征图x进行holistic attention操作，根据注意力图attention对特征图进行加权，以增强重要的特征。

–

这段代码对应的是一个名为SINet_ResNet50的网络模型，它基于ResNet50的编码器-解码器结构。

网络结构如下：

  • 特征抽象部分：
    • 头部（head）：通过卷积、批归一化和ReLU激活函数进行特征提取。
    • 低级特征（low-level features）：通过最大池化层和ResNet的第一个layer进行特征提取。
    • 第二层（layer2）：通过ResNet的第二个layer进行特征提取。
      -Stage-1: Search Module (SM)：
    • 将低级特征和第一层特征进行拼接，然后经过下采样和RF模块进行特征提取。
    • 第二层特征经过RF模块进行特征提取。
    • 第三层特征经过RF模块进行特征提取。
    • 第四层特征经过RF模块进行特征提取。
    • 使用PDC_SM模块将提取的特征进行处理得到camouflage_map_sm。
  • Switcher: Search Attention (SA)：
    • 使用SA模块对camouflage_map_sm和第二层特征进行处理得到x2_sa。
  • Stage-2: Identification Module (IM)：
    • 第三层特征经过第二个layer进行特征提取。
    • 第四层特征经过第二个layer进行特征提取。
    • 第二层特征经过RF模块进行特征提取。
    • 第三层特征经过RF模块进行特征提取。
    • 第四层特征经过RF模块进行特征提取。
    • 使用PDC_IM模块将提取的特征进行处理得到camouflage_map_im。
  • 输出：
    • 返回经过上采样的camouflage_map_sm和camouflage_map_im。 这个网络模型主要用于图像隐写分析任务。

–

scipy1.2.2 imsave 2

1
2
3
4
5
6

 pip3 install --upgrade pip
# https://www.cnblogs.com/peixu/p/14614013.html#:~:text=1%E3%80%81git%20clone%20git%40github.com%3ANVIDIA%2Fapex.git,2%E3%80%81%E5%BC%80cmd%E5%91%BD%E4%BB%A4%E7%AA%97%E5%8F%A3%EF%BC%8C%E5%88%87%E6%8D%A2%E5%88%B0apex%E6%89%80%E5%9C%A8%E7%9A%84%E6%96%87%E4%BB%B6%E5%A4%B9%203%E3%80%81python%20setup.py%20install
python setup.py install
conda install -c conda-forge nvidia-apex



1
2
3
4

# paper
{'Smeasure': 0.7762281331568003, 'wFmeasure': 0.6310046513108765, 'MAE': 0.042614733798974784, 'adpEm': 0.86695971862112, 'meanEm': 0.8635102776241943, 'maxEm': 0.8746242151987729, 'adpFm': 0.6670583855153248, 'meanFm': 0.6791200438546587, 'maxFm': 0.6908318653815608}
# test
{'Smeasure': 0.757855827894297, 'wFmeasure': 0.5506477369940896, 'MAE': 0.05048519826051167, 'adpEm': 0.798543892694507, 'meanEm': 0.7831408148773497, 'maxEm': 0.854691225152544, 'adpFm': 0.5912450146637638, 'meanFm': 0.6132905844614, 'maxFm': 0.6561096578776877}

基于像素与层级双对比的语义分割

语义分割实现了图像像素级的分类。它能够将一张图片或者视频，按照类别的异同，将图像分为多个块。

语义分割数据集的图像中往往含有多个目标对象，且它们之间存在相互作用的关系[9]。所以如何有效地获取图像内的上下文信息成为提升语义分割性能的关键。

经过对比学习训练的网络在部分下游任务中甚至强过传统的神经网络[14–16]。传统的对比学习在执行下游语义分割任务往往分两步：首先，训练一个基于对比学习的主干网络；然后，针对语义分割任务对训练好的主干网络进行微调得到一个语义分割网络。但是，由于这两阶段相互独立，且现有的主干网络在对比学习过程中并没有很好的建模语义信息，导致模型在训练时产生割裂，使得通过对比学习学到的良好特征不能有效融入到语义分割网络。

现有方法一般将对比学习作用于主干网络之后分割头之前（Before）的特征[17]，或者将对比学习作用于分类头之前分割头之后（After）的特征[18]。另外，语义分割网络的主干网络与分割头之间一般通过降维（卷积）操作，得到适合分割的分割特征（Intra）。因此，为充分利用对比学习提升语义分割性能，本文对对比学习位置进行了深入分析与实验验证，重点分析了在Intra处引入对比学习的端到端的语义分割网络。

不同大小和形状的符号分别表示不同尺寸和类别的特征，左侧为原特征空间，右侧为经过对比学习训练得到的嵌入式特征空间。可以发现在嵌入式特征空间中不同类别的特征被更好的区分。但是，由于没有考虑到语义分割模型对多尺度目标的检测需求，一些不同尺度的物体仍然没有得到有效区分，从而造成不同类别间的边界模糊。

为解决这个问题，本文设计了多尺度嵌入式映射模块(Multi-scale Embedded Projector, MEP)，采用空洞卷积生成三个不同尺度的嵌入式特征空间，针对不同尺度的特征进行对比学习，获得多尺度特征信息

另外，为了更好的利用获取的多尺度特征信息，不仅不同层级特征内部进行像素级对比学习，不同层级之间也进行了层级对比学习。最后，在像素与层级双对比（Double Contrast, DC）的作用下，不同特征在嵌入式特征空间中得到的了更好的划分。

在对比学习中，与正样本高度相似的负样本和与正样本高度区分的正样本统称为难样本。尽管难样本会诱导分类错误，损害分割精度，但是Kalantidis等人[19]发现难样本会带来更大的梯度贡献，在训练后期为模型提供更大的帮助。基于此，本文提出了激励式样本采样策略(Excitation Sampling，ES），把一幅图片中的同一类别的难样本和简单样本通过一定的采集策略组织成一个样本，并通过动态调整样本中的难样本和简单样本的权重为模型提供优质样本。