devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

senet模型代码解读_senet代码

作者：我家自动化 | 2024-04-05 02:27:38

赞

踩

senet代码

网络架构图：

准备模型：

  1. model_name = 'se_resnext101_32x4d'
  2. model = MODEL( num_classes= 500 , senet154_weight = WEIGHT_PATH, multi_scale = True, learn_region=True)
  3. model = torch.nn.DataParallel(model)
  4. vgg16 = model
  5. vgg16.load_state_dict(torch.load('./model/ISIAfood500.pth'))

 Senet模型代码：

  1. """这段代码定义了一个名为senet154的函数，它使用SENet模型来进行图像分类。
  2. """
  3.  
  4. def senet154(num_classes=1000, pretrained='imagenet'):
  5.     model = SENet(SEBottleneck, [3, 8, 36, 3], groups=64, reduction=16,
  6.                   dropout_p=0.2, num_classes=num_classes)
  7.     if pretrained is not None:
  8.         settings = pretrained_settings['senet154'][pretrained]
  9.         initialize_pretrained_model(model, num_classes, settings)
  10.     return model
  11.  
  12.     
  13. """SENet是一种卷积神经网络，它使用SEBottleneck块来增强特征表示。这个函数
  14. 使用了一个包含四个元素的列表来定义SENet的结构，其中每个元素表示一个阶段，
  15. 每个阶段包含多个SEBottleneck块。groups参数指定了SEBottleneck块中的卷积分组数，
  16. reduction参数指定了SE块中的通道缩减比例。如果pretrained参数不为None，则会使用
  17. 预训练的权重来初始化模型。预训练的权重存储在pretrainedsettings字典中，
  18. 可以通过指定pretrained参数来选择不同的预训练权重。最后，函数返回SENet模型。"""
  19.  
  20. class SENet(nn.Module):
  21.  
  22.     def __init__(self, block, layers, groups, reduction, dropout_p=0.2,
  23.                  inplanes=128, input_3x3=True, downsample_kernel_size=3,
  24.        
  25.         super(SENet, self).__init__()
  26.         self.inplanes = inplanes
  27.         if input_3x3:
  28.             layer0_modules = [
  29.                 ('conv1', nn.Conv2d(3, 64, 3, stride=2, padding=1,
  30.                                     bias=False)),
  31.                 ('bn1', nn.BatchNorm2d(64)),
  32.                 ('relu1', nn.ReLU(inplace=True)),                     # 从这  224 -> 112  stride =2                  
  33.                 ('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1,
  34.                                     bias=False)),
  35.                 ('bn2', nn.BatchNorm2d(64)),
  36.                 ('relu2', nn.ReLU(inplace=True)),
  37.                 ('conv3', nn.Conv2d(64, inplanes, 3, stride=1, padding=1,
  38.                                     bias=False)),
  39.                 ('bn3', nn.BatchNorm2d(inplanes)),
  40.                 ('relu3', nn.ReLU(inplace=True)),            # 输出的是 128 * 112* 112
  41.             ] 
  42.         else:
  43.             layer0_modules = [
  44.                 ('conv1', nn.Conv2d(3, inplanes, kernel_size=7, stride=2,
  45.                                     padding=3, bias=False)),
  46.                 ('bn1', nn.BatchNorm2d(inplanes)),
  47.                 ('relu1', nn.ReLU(inplace=True)),
  48.             ]
  49.         # To preserve compatibility with Caffe weights `ceil_mode=True`
  50.         # is used instead of `padding=1`.
  51.         layer0_modules.append(('pool', nn.MaxPool2d(3, stride=2,
  52.                                                     ceil_mode=True)))    #  这个 就 变成了  112 -> 56
  53.         self.layer0 = nn.Sequential(OrderedDict(layer0_modules))   # output 128 * 56 * 56
  54.         self.layer1 = self._make_layer(
  55.             block,
  56.             planes=64,
  57.             blocks=layers[0],
  58.             groups=groups,
  59.             reduction=reduction,
  60.             downsample_kernel_size=1,
  61.             downsample_padding=0                 # layer 1 不会降尺寸。 但是会改变通道。 所以输出是256 * 56 *56
  62.         )
  63.         self.layer2 = self._make_layer(
  64.             block,
  65.             planes=128,
  66.             blocks=layers[1],
  67.             stride=2,
  68.             groups=groups,
  69.             reduction=reduction,
  70.             downsample_kernel_size=downsample_kernel_size,
  71.             downsample_padding=downsample_padding          # layer 2  降尺寸。  因为stride =2 要进行降采样。 输出就是 512 * 28 * 28
  72.         ) 
  73.         self.layer3 = self._make_layer(
  74.             block,
  75.             planes=256,
  76.             blocks=layers[2],
  77.             stride=2,
  78.             groups=groups,
  79.             reduction=reduction,
  80.             downsample_kernel_size=downsample_kernel_size,
  81.             downsample_padding=downsample_padding  # layer 3  降尺寸。  因为stride =2 要进行降采样。 输出就是 1024 * 14 * 14
  82.         )
  83.         self.layer4 = self._make_layer(
  84.             block,
  85.             planes=512,
  86.             blocks=layers[3],
  87.             stride=2,
  88.             groups=groups,
  89.             reduction=reduction,
  90.             downsample_kernel_size=downsample_kernel_size,  # layer 4  降尺寸。  因为stride =2 要进行降采样。 输出就是 2048 * 7 * 7
  91.             downsample_padding=downsample_padding
  92.         )
  93.         self.avg_pool = nn.AvgPool2d(7, stride=1)
  94.         self.dropout = nn.Dropout(dropout_p) if dropout_p is not None else None
  95.         self.last_linear = nn.Linear(512 * block.expansion, num_classes)
  97.     def _make_layer(self, block, planes, blocks, groups, reduction, stride=1,
  98.                     downsample_kernel_size=1, downsample_padding=0):
  99.         downsample = None
  100.         if stride != 1 or self.inplanes != planes * block.expansion:
  101.             downsample = nn.Sequential(
  102.                 nn.Conv2d(self.inplanes, planes * block.expansion,
  103.                           kernel_size=downsample_kernel_size, stride=stride,
  104.                           padding=downsample_padding, bias=False),
  105.                 nn.BatchNorm2d(planes * block.expansion),
  106.             )
  108.         layers = []
  109.         layers.append(block(self.inplanes, planes, groups, reduction, stride,
  110.                             downsample))
  111.         self.inplanes = planes * block.expansion
  112.         for i in range(1, blocks):
  113.             layers.append(block(self.inplanes, planes, groups, reduction))
  115.         return nn.Sequential(*layers)
  117.     def features(self, x):
  118.         x = self.layer0(x)
  119.         x = self.layer1(x)
  120.         x = self.layer2(x)
  121.         x = self.layer3(x)
  122.         x = self.layer4(x)
  123.         return x
  125.     def logits(self, x):
  126.         x = self.avg_pool(x)
  127.         if self.dropout is not None:
  128.             x = self.dropout(x)
  129.         x = x.view(x.size(0), -1)
  130.         x = self.last_linear(x)
  131.         return x
  133.     def forward(self, x):
  134.         x = self.features(x)
  135.         x = self.logits(x)
  136.         return x

模型构建代码：

  1. class ConvBlock(nn.Module):
  2.     """基本卷积块。
  4.     卷积 + 批量归一化 + relu。
  5.     Args:
  6.         in_c (int): 输入通道数。
  7.         out_c (int): 输出通道数。
  8.         k (int or tuple): 卷积核大小。
  9.         s (int or tuple): 步长。
  10.         p (int or tuple): 填充。
  11.     """
  12.     def __init__(self, in_c, out_c, k, s=1, p=0):
  13.         super(ConvBlock, self).__init__()
  14.         self.conv = nn.Conv2d(in_c, out_c, k, stride=s, padding=p)
  15.         self.bn = nn.BatchNorm2d(out_c)
  16.  
  17.     def forward(self, x):
  18.         return F.relu(self.bn(self.conv(x)))
  19.  
  20.  
  21. # 定义InceptionA模块
  22. class InceptionA(nn.Module):
  23.  
  24.     def __init__(self, in_channels, out_channels):
  25.         super(InceptionA, self).__init__()
  26.         mid_channels = out_channels // 4
  27.  
  28.         # 第一个分支
  29.         self.stream1 = nn.Sequential(
  30.             ConvBlock(in_channels, mid_channels, 1), # 1x1卷积
  31.             ConvBlock(mid_channels, mid_channels, 3, p=1), # 3x3卷积
  32.         )
  33.         # 第二个分支
  34.         self.stream2 = nn.Sequential(
  35.             ConvBlock(in_channels, mid_channels, 1), # 1x1卷积
  36.             ConvBlock(mid_channels, mid_channels, 3, p=1), # 3x3卷积
  37.         )
  38.         # 第三个分支
  39.         self.stream3 = nn.Sequential(
  40.             ConvBlock(in_channels, mid_channels, 1), # 1x1卷积
  41.             ConvBlock(mid_channels, mid_channels, 3, p=1), # 3x3卷积
  42.         )
  43.         # 第四个分支
  44.         self.stream4 = nn.Sequential(
  45.             nn.AvgPool2d(3, stride=1, padding=1), # 平均池化
  46.             ConvBlock(in_channels, mid_channels, 1), # 1x1卷积
  47.         )
  48.  
  49.     def forward(self, x):
  50.         # 将四个分支的输出拼接在一起
  51.         s1 = self.stream1(x)
  52.         s2 = self.stream2(x)
  53.         s3 = self.stream3(x)
  54.         s4 = self.stream4(x)
  55.         y = torch.cat([s1, s2, s3, s4], dim=1)
  56.         return y
  57.  
  58. # 定义InceptionB模块
  59. class InceptionB(nn.Module):
  60.  
  61.     def __init__(self, in_channels, out_channels):
  62.         super(InceptionB, self).__init__()
  63.         mid_channels = out_channels // 4
  64.  
  65.         # 第一个分支
  66.         self.stream1 = nn.Sequential(
  67.             ConvBlock(in_channels, mid_channels, 1), # 1x1卷积
  68.             ConvBlock(mid_channels, mid_channels, 3, s=2, p=1), # 3x3卷积
  69.         )
  70.         # 第二个分支
  71.         self.stream2 = nn.Sequential(
  72.             ConvBlock(in_channels, mid_channels, 1), # 1x1卷积
  73.             ConvBlock(mid_channels, mid_channels, 3, p=1), # 3x3卷积
  74.             ConvBlock(mid_channels, mid_channels, 3, s=2, p=1), # 3x3卷积
  75.         )
  76.         # 第三个分支
  77.         self.stream3 = nn.Sequential(
  78.             nn.MaxPool2d(3, stride=2, padding=1), # 最大池化
  79.             ConvBlock(in_channels, mid_channels*2, 1), # 1x1卷积
  80.         )
  81.  
  82.     def forward(self, x):
  83.         # 分别对三个分支进行计算
  84.         s1 = self.stream1(x)
  85.         s2 = self.stream2(x)
  86.         s3 = self.stream3(x)
  87.         # 将三个分支的结果进行拼接
  88.         y = torch.cat([s1, s2, s3], dim=1)
  89.         return y
  90.  
  91.  
  92.  
  93. class SpatialAttn(nn.Module):
  94.     """Spatial Attention (Sec. 3.1.I.1)"""
  95.     
  96.     def __init__(self):
  97.         super(SpatialAttn, self).__init__()
  98.         self.conv1 = ConvBlock(1, 1, 3, s=2, p=1)
  99.         self.conv2 = ConvBlock(1, 1, 1)
  100.  
  101.     def forward(self, x):
  102.         # global cross-channel averaging
  103.         x = x.mean(1, keepdim=True) # 由hwc 变为 hw1
  104.         # 3-by-3 conv
  105.         h = x.size(2)
  106.         x = self.conv1(x)
  107.         # bilinear resizing
  108.         x = F.upsample(x, (h,h), mode='bilinear', align_corners=True)
  109.         # scaling conv
  110.         x = self.conv2(x)
  111.         return x  
  112.         ## 返回的是h*w*1 的 soft map
  113.  
  114. class ChannelAttn(nn.Module):
  115.  
  116.     """通道注意力机制"""
  117.  
  118.     def __init__(self, in_channels, reduction_rate=16):
  119.  
  120.         super(ChannelAttn, self).__init__()
  121.  
  122.         assert in_channels%reduction_rate == 0
  123.  
  124.         self.conv1 = ConvBlock(in_channels, in_channels // reduction_rate, 1)
  125.  
  126.         self.conv2 = ConvBlock(in_channels // reduction_rate, in_channels, 1)
  127.  
  128.  
  129.     def forward(self, x):
  130.  
  131.         # 压缩操作（全局平均池化）
  132.         x = F.avg_pool2d(x, x.size()[2:]) 
  133.  
  134.         # 激励操作（2个卷积层）
  135.         x = self.conv1(x)
  136.         x = self.conv2(x)
  137.  
  138.         return x
  139.  
  140. '''
  141. 空间和通道上的attention 融合
  142. 就是空间和通道上的attention做一个矩阵乘法
  143. '''
  144.  
  145. class SoftAttn(nn.Module):
  146.     """Soft Attention (Sec. 3.1.I)
  147.     
  148.     Aim: Spatial Attention + Channel Attention
  149.     
  150.     Output: attention maps with shape identical to input.
  151.     """
  152.     
  153.     def __init__(self, in_channels):
  154.         super(SoftAttn, self).__init__()
  155.         self.spatial_attn = SpatialAttn()
  156.         self.channel_attn = ChannelAttn(in_channels)
  157.         self.conv = ConvBlock(in_channels, in_channels, 1)
  158.  
  159.  
  160.     def forward(self, x):
  161.  
  162.         y_spatial = self.spatial_attn(x) # 空间注意力输出
  163.         y_channel = self.channel_attn(x) # 通道注意力输出
  164.         y = y_spatial * y_channel # 空间注意力和通道注意力相乘
  165.         y = torch.sigmoid(self.conv(y)) # 卷积块输出
  166.         return y
  167.  
  168. '''
  169. 输出的是STN 需要的theta
  170. '''
  171. class HardAttn(nn.Module):
  172.     """Hard Attention (Sec. 3.1.II)"""
  173.     
  174.     def __init__(self, in_channels):
  175.         super(HardAttn, self).__init__()
  176.         self.fc = nn.Linear(in_channels, 4*2)
  177.         self.init_params()
  178.  
  179.     def init_params(self):
  180.         self.fc.weight.data.zero_()
  181.         # 初始化 参数
  182.         # if x_t = 0  the performance is very low
  183.         self.fc.bias.data.copy_(torch.tensor([0.3, -0.3, 0.3, 0.3, -0.3, 0.3, -0.3, -0.3], dtype=torch.float))
  184.  
  185.     def forward(self, x):
  186.         # squeeze operation (global average pooling)
  187.         x = F.avg_pool2d(x, x.size()[2:]).view(x.size(0), x.size(1))
  188.         # predict transformation parameters
  189.         theta = torch.tanh(self.fc(x))
  190.         theta = theta.view(-1, 4, 2)
  191.         return theta
  192.          #  返回的是 2T  T为区域数量。 因为尺度会固定。 所以只要学位移的值
  193.  
  194. class HarmAttn(nn.Module):
  195.  
  196.     """Harmonious Attention (Sec. 3.1)"""
  197.     # 定义一个名为HarmAttn的类，继承自nn.Module类，表示这是一个神经网络模型
  198.  
  199.     def __init__(self, in_channels):
  200.  
  201.         super(HarmAttn, self).__init__()
  202.         # 调用父类的构造函数，初始化神经网络模型
  203.         self.soft_attn = SoftAttn(in_channels)
  204.         # 定义一个名为soft_attn的属性，其值为SoftAttn(in_channels)，表示该属性是一个软注意力机制
  205.  
  206.         self.hard_attn = HardAttn(in_channels)
  207.         # 定义一个名为hard_attn的属性，其值为HardAttn(in_channels)，表示该属性是一个硬注意力机制
  208.  
  209.     def forward(self, x):
  210.  
  211.         # 定义一个名为forward的函数，表示前向传播过程
  212.         y_soft_attn = self.soft_attn(x)
  213.         # 定义一个名为y_soft_attn的变量，其值为self.soft_attn(x)，表示使用软注意力机制对输入x进行处理
  214.         theta = self.hard_attn(x)
  215.         # 定义一个名为theta的变量，其值为self.hard_attn(x)，表示使用硬注意力机制对输入x进行处理
  216.  
  217.         return y_soft_attn, theta
  218.  
  219.  
  220. class MODEL(nn.Module):
  221.  
  222.     '''
  223.     cvper2020的主模型
  224.     '''
  225.  
  226.     def __init__(self, num_classes, senet154_weight, nchannels=[256,512,1024,2048], multi_scale = False ,learn_region=True, use_gpu=True):
  227.  
  228.         super(MODEL,self).__init__()
  229.         self.learn_region=learn_region
  230.         self.use_gpu = use_gpu
  231.         self.conv = ConvBlock(3, 32, 3, s=2, p=1)
  232.         self.senet154_weight = senet154_weight
  233.         self.multi_scale = multi_scale
  234.         self.num_classes = num_classes
  235.  
  236.  
  237.         # 构建SEnet154 
  238.  
  239.         senet154_ = senet154(num_classes=1000, pretrained=None)
  240.         senet154_.load_state_dict(torch.load(self.senet154_weight))
  241.  
  242.         self.extract_feature = senet154_.layer0
  243.  
  244.         #全局backbone
  245.         self.global_layer1 = senet154_.layer1
  246.         self.global_layer2 = senet154_.layer2
  247.         self.global_layer3 = senet154_.layer3
  248.         self.global_layer4 = senet154_.layer4
  249.  
  250.         self.classifier_global =nn.Sequential(
  251.                                 nn.Linear(2048*2, 2048), # 将4个区域 融合成一个 需要加上batchnorma1d, 和 relu
  252.                                 nn.BatchNorm1d(2048),
  253.                                 nn.ReLU(),
  254.                                 nn.Dropout(0.2),
  255.                                 nn.Linear(2048, num_classes),
  256.                                 )
  257.  
  258.         if self.multi_scale:
  259.             self.global_fc = nn.Sequential(
  260.                                 nn.Linear(2048+512+1024, 2048), # 将4个区域 融合成一个 需要加上batchnorma1d, 和 relu
  261.                                 nn.BatchNorm1d(2048),
  262.                                 nn.ReLU(),
  263.                                 )
  264.  
  265.             self.global_out = nn.Linear(2048,num_classes)  # global 分类
  266.  
  267.         else:
  268.             self.global_out = nn.Linear(2048,num_classes)  # global 分类
  269.         self.ha2  = HarmAttn(nchannels[1])
  270.         self.ha3  = HarmAttn(nchannels[2])
  271.         self.ha4  = HarmAttn(nchannels[3])
  272.  
  273.         self.dropout = nn.Dropout(0.2)  #  分类层之前使用dropout
  274.  
  275.         if self.learn_region:
  276.  
  277.             self.init_scale_factors()
  278.             self.local_conv1 = InceptionB(nchannels[1], nchannels[1])
  279.             self.local_conv2 = InceptionB(nchannels[2], nchannels[2])
  280.             self.local_conv3 = InceptionB(nchannels[3], nchannels[3])    
  281.             self.local_fc = nn.Sequential(
  282.  
  283.                                 nn.Linear(2048+512+1024, 2048), # 将4个区域 融合成一个 需要加上batchnorma1d, 和 relu
  284.                                 nn.BatchNorm1d(2048),
  285.                                 nn.ReLU(),
  286.                                 )
  287.  
  288.             self.classifier_local = nn.Linear(2048,num_classes)
  289.  
  290.  
  291.     def init_scale_factors(self):
  292.  
  293.         # 初始化四个区域的缩放因子（s_w，s_h）
  294.         # s_w和s_h是固定的。
  295.         self.scale_factors = []
  296.  
  297.         self.scale_factors.append(torch.tensor([[0.5, 0], [0, 0.5]], dtype=torch.float))
  298.         self.scale_factors.append(torch.tensor([[0.5, 0], [0, 0.5]], dtype=torch.float))
  299.         self.scale_factors.append(torch.tensor([[0.5, 0], [0, 0.5]], dtype=torch.float))
  300.         self.scale_factors.append(torch.tensor([[0.5, 0], [0, 0.5]], dtype=torch.float))
  301.  
  302.      
  303.  
  304.     def stn(self, x, theta):
  305.  
  306.         """执行空间变换
  307.         x: (batch, channel, height, width)
  309.         theta: (batch, 2, 3)
  311.         """
  312.  
  313.         grid = F.affine_grid(theta, x.size())
  314.         x = F.grid_sample(x, grid)
  315.         return x
  316.  
  317.     def transform_theta(self, theta_i, region_idx):
  318.  
  319.         """将theta转换为包括（s_w，s_h）的形式，结果为（batch，2，3）"""
  320.         scale_factors = self.scale_factors[region_idx]
  321.         theta = torch.zeros(theta_i.size(0), 2, 3)
  322.         theta[:,:,:2] = scale_factors
  323.         theta[:,:,-1] = theta_i
  324.         if self.use_gpu: theta = theta.cuda()
  325.  
  326.         return theta
  327.  
  328.  
  329.  
  330.     def forward(self, x):
  331.  
  332.         batch_size = x.size()[0]  # 获取批量大小
  333.         x = self.extract_feature(x)  # 输出形状为128 * 56 *56  senet154第0层layer 提取特征
  334.         #  =================layer 1 ===============
  335.         # 全局分支
  336.         x1 = self.global_layer1(x)  # 输出形状为256*56*56
  337.  
  338.         #============layer 2================
  339.         #全局分支
  340.  
  341.         x2 = self.global_layer2(x1)  # x2是512*28*28
  342.         x2_attn, x2_theta = self.ha2(x2)
  343.         x2_out = x2 * x2_attn
  344.  
  345.         if self.multi_scale:
  346.             #  attention global layer1  avg pooling 
  347.             x2_avg = F
  348.             x2_avg = F.adaptive_avg_pool2d(x2_out, (1, 1)).view(x2_out.size(0), -1)  #512 向量
  349.  
  350.         # local branch
  351.         if self.learn_region:
  352.             x2_local_list = []
  353.  
  354.             for region_idx in range(4):
  355.                 x2_theta_i = x2_theta[:,region_idx,:]
  356.                 x2_theta_i = self.transform_theta(x2_theta_i, region_idx)
  357.                 x2_trans_i = self.stn(x2, x2_theta_i)  #256*56*26
  358.                 x2_trans_i = F.upsample(x2_trans_i, (56, 56), mode='bilinear', align_corners=True)
  359.                 x2_local_i = x2_trans_i 
  360.                 x2_local_i = self.local_conv1(x2_local_i) # 512*28*28
  361.                 x2_local_list.append(x2_local_i)
  362.  
  363.         #============layer 3================
  364.         #global branch
  365.  
  366.         x3 = self.global_layer3(x2_out)  # x3 is 1024*14*14
  367.         # print('layer3 output')
  368.         # print(x3.size())
  369.         x3_attn, x3_theta = self.ha3(x3)
  370.         x3_out = x3 * x3_attn
  371.     
  372.         if self.multi_scale:
  373.                 #  attention global layer1  avg pooling 
  374.             x3_avg = F.adaptive_avg_pool2d(x3_out, (1, 1)).view(x3_out.size(0), -1)  #1024 向量
  375.         
  376.         # local branch
  377.         if self.learn_region:
  378.             x3_local_list = []
  379.             for region_idx in range(4):
  380.                 x3_theta_i = x3_theta[:,region_idx,:]
  381.                 x3_theta_i = self.transform_theta(x3_theta_i, region_idx)
  382.                 x3_trans_i = self.stn(x3, x3_theta_i) #512*28*28
  383.                 x3_trans_i = F.upsample(x3_trans_i, (28, 28), mode='bilinear', align_corners=True)
  384.                 x3_local_i = x3_trans_i 
  385.                 x3_local_i = self.local_conv2(x3_local_i) # 1024*14*14
  386.                 x3_local_list.append(x3_local_i)
  387.  
  388.         #============layer 4================
  389.         #global branch
  390.         x4 = self.global_layer4(x3_out)  # 2048*7*7
  391.         x4_attn, x4_theta = self.ha4(x4)
  392.         x4_out = x4 * x4_attn
  393.         
  394.  
  395.         # local branch
  396.         if self.learn_region:
  397.             x4_local_list = []
  398.             for region_idx in range(4):
  399.                 x4_theta_i = x4_theta[:,region_idx,:]
  400.                 x4_theta_i = self.transform_theta(x4_theta_i, region_idx)
  401.                 x4_trans_i = self.stn(x4, x4_theta_i) #1024*14*14
  402.                 x4_trans_i = F.upsample(x4_trans_i, (14,14), mode='bilinear', align_corners=True)
  403.                 x4_local_i = x4_trans_i 
  404.                 x4_local_i = self.local_conv3(x4_local_i) # 2048*7*7
  405.                 x4_local_list.append(x4_local_i)
  406.         # ============== Feature generation ==============
  407.         # global branch
  408.         x4_avg = F.avg_pool2d(x4_out, x4_out.size()[2:]).view(x4_out.size(0),  -1) #全局pooling 2048 之前已经relu过了
  409.         
  410.         if self.multi_scale:
  411.             multi_scale_feature = torch.cat([x2_avg, x3_avg, x4_avg],1)
  412.             global_fc = self.global_fc(multi_scale_feature)
  413.             global_out = self.global_out(self.dropout(global_fc))
  414.  
  415.         else:
  416.             global_out = self.global_out(x4_avg)  # 2048 -> num_classes
  417.  
  418.         if self.learn_region:
  419.             x_local_list = []
  420.  
  421.             local_512 = torch.randn(batch_size, 4, 512).cuda()
  422.             local_1024 = torch.randn(batch_size, 4, 1024).cuda()
  423.             local_2048 = torch.randn(batch_size, 4, 2048).cuda()
  424.  
  425.             for region_idx in range(4):
  426.  
  427.                 x2_local_i = x2_local_list[region_idx]
  428.                 x2_local_i = F.avg_pool2d(x2_local_i, x2_local_i.size()[2:]).view(x2_local_i.size(0), -1) #每个local 都全局pooling
  429.                 local_512[:,region_idx] = x2_local_i
  430.  
  431.                 x3_local_i = x3_local_list[region_idx]
  432.                 x3_local_i = F.avg_pool2d(x3_local_i, x3_local_i.size()[2:]).view(x3_local_i.size(0), -1) #每个local 都全局pooling
  433.                 local_1024[:,region_idx] = x3_local_i
  434.  
  435.  
  436.                 x4_local_i = x4_local_list[region_idx]
  437.                 x4_local_i = F.avg_pool2d(x4_local_i, x4_local_i.size()[2:]).view(x4_local_i.size(0), -1) #每个local 都全局pooling
  438.                 local_2048[:,region_idx] = x4_local_i
  439.  
  440.             local_512_maxpooing = local_512.max(1)[0]
  441.             local_1024_maxpooing = local_1024.max(1)[0]
  442.             local_2048_maxpooing = local_2048.max(1)[0]
  443.             local_concate = torch.cat([local_512_maxpooing, local_1024_maxpooing, local_2048_maxpooing], 1)
  444.             local_fc = self.local_fc(local_concate)
  445.             local_out = self.classifier_local(self.dropout(local_fc))
  446.  
  447.         if self.multi_scale:
  448.             out = torch.cat([global_fc,local_fc],1)
  449.         else:        
  450.             out = torch.cat([x4_avg, local_512_maxpooing, local_1024_maxpooing, local_2048_maxpooing], 1) # global  和  local 一起做拼接 2048*2
  451.  
  452.         out = self.classifier_global(out)
  453.         
  454.         if self.learn_region:
  455.             return out, global_out,local_out
  456.         else:
  457.             return global_out
  458.           
  459.  
  460.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/362724?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号