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

CANet代码：

作者：Monodyee | 2024-04-05 16:52:39

赞

踩

canet

函数

 CANet由三部分组成，encoder，co-attention fusion module,decoder。首先看最重要的部分co-attention fusion module代码，该module由PCAM和CCAM模块组成：

 

  1. class PCAM_Module(Module):
  2.     """ Position attention module"""
  3.     #Ref from SAGAN
  4.     def __init__(self, in_dim):
  5.         super(PCAM_Module, self).__init__()
  6.         self.chanel_in = in_dim
  7.         self.query_conv = Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
  8.         self.key_conv = Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)
  9.         self.value_conv = Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)
  10.         self.gamma = Parameter(torch.zeros(1))
  11.  
  12.         self.softmax = Softmax(dim=-1)
  13.     def forward(self, x, y):
  14.         """
  15.             inputs :
  16.                 x : input feature maps( B X C X H X W)
  17.             returns :
  18.                 out : attention value + input feature
  19.                 attention: B X (HxW) X (HxW)
  20.         """
  21.         m_batchsize, C, height, width = x.size()
  22.         # # 生成Q，尺寸变换为(b,c,h,w)->(b,c,w*h)->(b,w*h,c/8)
  23.         proj_query = self.query_conv(x).view(m_batchsize, -1, width*height).permute(0, 2, 1)
  24.         # 生成K，尺寸变换为(b,c,h,w)->(b,c/8,w*h)
  25.         proj_key = self.key_conv(y).view(m_batchsize, -1, width*height)
  26.         # q*k，维度变换为(b,w*h,c/8) * (b,c/8,w*h) = (b,w*h,w*h)
  27.         energy = torch.bmm(proj_query, proj_key)
  28.         # 经过softmax生成注意力图,(b,w*h,w*h)
  29.         attention = self.softmax(energy)
  30.         # 生成V，维度变换为(b,c,h,w)->(b,c,h*w)
  31.         proj_value = self.value_conv(y).view(m_batchsize, -1, width*height)
  32.         # attention * V = (b,c,h*w) * (b,w*h,w*h) = (b,c,w*h)
  33.         out = torch.bmm(proj_value, attention.permute(0, 2, 1))
  34.         # (b,c,w*h)->(b,c,h,w)
  35.         out = out.view(m_batchsize, C, height, width)
  36.         out = self.gamma*out + x
  37.         return out
  38.  
  39. class CCAM_Module(Module):
  40.     """ Channel attention module"""
  41.     def __init__(self, in_dim):
  42.         super(CCAM_Module, self).__init__()
  43.         self.chanel_in = in_dim
  44.  
  45.  
  46.         self.gamma = Parameter(torch.zeros(1))
  47.         self.softmax = Softmax(dim=-1)
  48.     def forward(self, x, y):
  49.         """
  50.             inputs :
  51.                 x : input feature maps( B X C X H X W)
  52.             returns :
  53.                 out : attention value + input feature
  54.                 attention: B X C X C
  55.         """
  56.         m_batchsize, C, height, width = x.size()
  57.         # 生成q,(b,c,h,w)->(b,c,n)
  58.         proj_query = x.view(m_batchsize, C, -1)
  59.         # 生成k,(b,c,h,w)->(b,c,n)->(b,n,c)
  60.         proj_key = y.view(m_batchsize, C, -1).permute(0, 2, 1)
  61.         # 矩阵相乘，(b,c,n) * (b,n,c) = (b,c,c)
  62.         energy = torch.bmm(proj_query, proj_key)
  63.         # 生成energy每一行最大的值，以及对应的索引。这里只取值，将其扩充到energy维度减去energy
  64.         energy_new = torch.max(energy, -1, keepdim=True)[0].expand_as(energy)-energy
  65.         # 输出注意力map，(b,c,c)
  66.         attention = self.softmax(energy_new)
  67.         # 生成V，维度为(b,c,h*w)
  68.         proj_value = y.view(m_batchsize, C, -1)
  69.         # (b,c,c)*(b,c,h*w) = (b,c,h*w)
  70.         out = torch.bmm(attention, proj_value)
  71.         # (b,c,h*w)->(b,c,h,w)
  72.         out = out.view(m_batchsize, C, height, width)
  73.         out = self.gamma*out + x
  74.         return out

最后输出的两个特征图和卷积输出的特征图共同输入到fusion layer：

  1. class FusionLayer(Module):
  2.     def __init__(self, in_channels, groups=1, radix=2, reduction_factor=4, norm_layer=None):
  3.         super(FusionLayer, self).__init__()
  4.         inter_channels = max(in_channels//reduction_factor, 32) # (256或者32)
  5.         self.radix = radix # 2
  6.         self.cardinality = groups
  7.         self.use_bn = norm_layer is not None
  8.         self.relu = ReLU(inplace=True)
  9.         self.fc1_p = Conv2d(in_channels, inter_channels, 1, groups=self.cardinality)  # 1024 -> 256
  10.         self.fc1_c = Conv2d(in_channels, inter_channels, 1, groups=self.cardinality)  # 1024 -> 256
  11.         if self.use_bn:
  12.             self.bn1_p = norm_layer(inter_channels)
  13.             self.bn1_c = norm_layer(inter_channels)
  14.         self.fc2_p = Conv2d(inter_channels, in_channels*radix, 1, groups=self.cardinality)  # 256 -> 1024
  15.         self.fc2_c = Conv2d(inter_channels, in_channels*radix, 1, groups=self.cardinality)  # 256 -> 1024
  16.  
  17.         self.rsoftmax = rSoftMax(radix, groups)
  18.  
  19.     def forward(self, x, y, z):
  20.         """
  22.         :param x: convolution fusion features,(b,2048,h,w)
  23.         :param y: position attention features,(b,1024,h,w)
  24.         :param z: channel attention features,(b,1024,h,w)
  25.         :return:
  26.         """
  27.  
  28.         assert self.radix == 2, "Error radix size!"
  29.         # (b,2048,h,w)
  30.         batch, rchannel = x.shape[:2] # n, 2048
  31.         if self.radix > 1:
  32.             splited = torch.split(x, rchannel//self.radix, dim=1) # 两个，维度分别为(b,1024,h,w)
  33.             gap_1 = splited[0]  # (b,1024,h,w)
  34.             gap_2 = splited[1]  # (b,1024,h,w)
  35.         else:
  36.             gap_1 = x
  37.             gap_2 = x
  38.  
  39.         assert gap_1.shape[1] == y.shape[1], "Error!"
  40.         assert gap_2.shape[1] == z.shape[1], "Error!"
  41.  
  42.         gap_p = sum([gap_1, y])
  43.         gap_c = sum([gap_2, z])
  44.  
  45.         gap_p = F.adaptive_avg_pool2d(gap_p, 1)  # n, 1024, h, w -> n, 1024, 1, 1
  46.         gap_c = F.adaptive_avg_pool2d(gap_c, 1)  # n, 1024, h, w -> n, 1024, 1, 1
  47.  
  48.         gap_p = self.fc1_p(gap_p) # n,256,1,1
  49.         gap_c = self.fc1_c(gap_c) # n,256,1,1
  50.  
  51.         if self.use_bn:
  52.             gap_p = self.bn1_p(gap_p)
  53.             gap_c = self.bn1_c(gap_c)
  54.  
  55.         gap_p = self.relu(gap_p)
  56.         gap_c = self.relu(gap_c)
  57.  
  58.         atten_p = self.fc2_p(gap_p)  # n, 256, 1, 1 -> n, 2048, 1, 1
  59.         atten_c = self.fc2_c(gap_c)  # n, 256, 1, 1 -> n, 2048, 1, 1
  60.  
  61.         atten_p = self.rsoftmax(atten_p).view(batch, -1, 1, 1)  # (n, 2048) -> (n, 2048, 1, 1)
  62.         atten_c = self.rsoftmax(atten_c).view(batch, -1, 1, 1)  # (n, 2048) -> (n, 2048, 1, 1)
  63.  
  64.         if self.radix > 1:
  65.             attens_p = torch.split(atten_p, rchannel//self.radix, dim=1)  # 2(n, 1024, 1, 1) tuple
  66.             attens_c = torch.split(atten_c, rchannel//self.radix, dim=1)  # 2(n, 1024, 1, 1) tuple
  67.  
  68.             splited_p = (gap_1, y)  # （(n, 1024, h, w)，(n, 1024, h, w)）
  69.             splited_c = (gap_1, y)  # （(n, 1024, h, w)，(n, 1024, h, w)）
  70.  
  71.             out_p = sum([att * split for (att, split) in zip(attens_p, splited_p)]) # (n, 1024, h, w)
  72.             out_c = sum([att * split for (att, split) in zip(attens_c, splited_c)]) # (n, 1024, h, w)
  73.         else:
  74.             out_p = atten_p * y
  75.             out_c = atten_c * z
  76.  
  77.         if self.radix > 1:
  78.             out = torch.cat([out_p, out_c], 1) # (n, 2048, h, w)
  79.         else:
  80.             out = sum([out_p, out_c])
  81.  
  82.         return out.contiguous()

CANet整体模块，首先需要明确的几点：

1：backbone采用resnet50

2：在decoder采用的TransBasicBlock进行上采样

首先定义一些基本函数，然后对RGB和depth分别进行特征提取：

  1. class ACNet(nn.Module):
  2.     def __init__(self, num_class=37, backbone='ResNet-101', pretrained=False, pcca5=False):
  3.         super(ACNet, self).__init__()
  4.  
  5.         self.pcca5 = pcca5
  6.         self.backbone = backbone
  7.  
  8.         if self.backbone == 'ResNet-50':
  9.             layers = [3, 4, 6, 3]
  10.         else:
  11.             layers = [3, 4, 23, 3]
  12.  
  13.         block = Bottleneck
  14.         transblock = TransBasicBlock
  15.         # RGB image branch
  16.         self.inplanes = 64
  17.         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
  18.                                bias=False)
  19.         self.bn1 = nn.BatchNorm2d(64)
  20.         self.relu = nn.ReLU(inplace=True)
  21.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  22.         self.layer1 = self._make_layer(block, 64, layers[0])
  23.         self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
  24.         self.layer3 = self._make_layer(block, 256, layers[2], stride=2) # use PSPNet extractors
  25.         self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
  26.  
  27.         # depth image branch
  28.         self.inplanes = 64
  29.         self.conv1_d = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3,
  30.                                bias=False)
  31.         self.bn1_d = nn.BatchNorm2d(64)
  32.         self.relu_d = nn.ReLU(inplace=True)
  33.         self.maxpool_d = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  34.         self.layer1_d = self._make_layer(block, 64, layers[0])
  35.         self.layer2_d = self._make_layer(block, 128, layers[1], stride=2)
  36.         self.layer3_d = self._make_layer(block, 256, layers[2], stride=2)
  37.         self.layer4_d = self._make_layer(block, 512, layers[3], stride=2)
  38.  
  39.         """
  40.         # merge branch
  41.         self.atten_rgb_0 = self.channel_attention(64)
  42.         self.atten_depth_0 = self.channel_attention(64)
  43.         self.maxpool_m = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  44.         self.atten_rgb_1 = self.channel_attention(64*4)
  45.         self.atten_depth_1 = self.channel_attention(64*4)
  46.         # self.conv_2 = nn.Conv2d(64*4, 64*4, kernel_size=1) #todo 用cat和conv降回通道数
  47.         self.atten_rgb_2 = self.channel_attention(128*4)
  48.         self.atten_depth_2 = self.channel_attention(128*4)
  49.         self.atten_rgb_3 = self.channel_attention(256*4)
  50.         self.atten_depth_3 = self.channel_attention(256*4)
  51.         self.atten_rgb_4 = self.channel_attention(512*4)
  52.         self.atten_depth_4 = self.channel_attention(512*4)
  53.         """
  54.  
  55.         self.inplanes = 64
  56.         self.layer1_m = self._make_layer(block, 64, layers[0])
  57.         self.layer2_m = self._make_layer(block, 128, layers[1], stride=2)
  58.         self.layer3_m = self._make_layer(block, 256, layers[2], stride=2)
  59.         self.layer4_m = self._make_layer(block, 512, layers[3], stride=2)
  60.  
  61.         # agant module
  62.         self.agant0 = self._make_agant_layer(64, 64)
  63.         self.agant1 = self._make_agant_layer(64*4, 64)
  64.         self.agant2 = self._make_agant_layer(128*4, 128)
  65.         self.agant3 = self._make_agant_layer(256*4, 256)
  66.         self.agant4 = self._make_agant_layer(512*4, 512)
  67.  
  68.         #transpose layer
  69.         self.inplanes = 512
  70.         self.deconv1 = self._make_transpose(transblock, 256, 6, stride=2)
  71.         self.deconv2 = self._make_transpose(transblock, 128, 4, stride=2)
  72.         self.deconv3 = self._make_transpose(transblock, 64, 3, stride=2)
  73.         self.deconv4 = self._make_transpose(transblock, 64, 3, stride=2)
  74.  
  75.         # final blcok
  76.         self.inplanes = 64
  77.         self.final_conv = self._make_transpose(transblock, 64, 3)
  78.  
  79.         self.final_deconv = nn.ConvTranspose2d(self.inplanes, num_class, kernel_size=2,
  80.                                                stride=2, padding=0, bias=True)
  81.  
  82.         self.out5_conv = nn.Conv2d(256, num_class, kernel_size=1, stride=1, bias=True)
  83.         self.out4_conv = nn.Conv2d(128, num_class, kernel_size=1, stride=1, bias=True)
  84.         self.out3_conv = nn.Conv2d(64, num_class, kernel_size=1, stride=1, bias=True)
  85.         self.out2_conv = nn.Conv2d(64, num_class, kernel_size=1, stride=1, bias=True)
  86.  
  87.         if self.pcca5:
  88.  
  89.             self.conv_5a = nn.Sequential(nn.Conv2d(2048, 512, kernel_size=3, stride=1, padding=1, bias=False),
  90.                                      nn.BatchNorm2d(512),
  91.                                      nn.ReLU())
  92.             self.conv_5c = nn.Sequential(nn.Conv2d(2048, 512, kernel_size=3, stride=1, padding=1, bias=False),
  93.                                      nn.BatchNorm2d(512),
  94.                                      nn.ReLU())
  95.             self.pca_5 = PCAM_Module(512)
  96.             self.cca_5 = CCAM_Module(512)
  97.             """
  98.             self.pconv_5 = nn.Sequential(nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
  99.                                      BatchNorm2d(512),
  100.                                      nn.ReLU())
  101.             self.cconv_5 = nn.Sequential(nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False),
  102.                                      BatchNorm2d(512),
  103.                                      nn.ReLU())
  104.             self.pconv_out = nn.Sequential(nn.Conv2d(512, 2048, kernel_size=3, stride=1, padding=1, bias=False),
  105.                                      BatchNorm2d(2048),
  106.                                      nn.ReLU(),
  107.                                      nn.Dropout2d(0.1, False))
  108.             self.cconv_out = nn.Sequential(nn.Conv2d(512, 2048, kernel_size=3, stride=1, padding=1, bias=False),
  109.                                      BatchNorm2d(2048),
  110.                                      nn.ReLU(),
  111.                                      nn.Dropout2d(0.1, False))
  112.             self.alpha = Parameter(torch.ones(1))
  113.             self.beta = Parameter(torch.ones(1))
  114.             """
  115.             self.pconv_5 = nn.Sequential(nn.Conv2d(512, 1024, kernel_size=1, stride=1, padding=0, bias=False),
  116.                                      nn.BatchNorm2d(1024),
  117.                                      nn.ReLU())
  118.             self.cconv_5 = nn.Sequential(nn.Conv2d(512, 1024, kernel_size=1, stride=1, padding=0, bias=False),
  119.                                      nn.BatchNorm2d(1024),
  120.                                      nn.ReLU())
  121.             self.split_conv = FusionLayer(in_channels=1024, groups=1,radix=2, reduction_factor=4, norm_layer=nn.BatchNorm2d)
  122.  
  123.         # weight initial
  124.         for m in self.modules():
  125.             if isinstance(m, nn.Conv2d):
  126.                 n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
  127.                 m.weight.data.normal_(0, math.sqrt(2. / n))
  128.             elif isinstance(m, nn.BatchNorm2d):
  129.                 m.weight.data.fill_(1)
  130.                 m.bias.data.zero_()
  131.  
  132.         if pretrained:
  133.             self._load_resnet_pretrained()

其中分别调用了_make_layer函数，block函数，_make_agant_layer函数，_make_transpose函数。

1：_make_layer函数，将输入维度，输出维度，步长，上采样输入到block函数，返回的是一个列表，里面是block个layer。

  1.     def _make_layer(self, block, planes, blocks, stride=1, dilation=1):
  2.         downsample = None
  3.         if stride != 1 or self.inplanes != planes * block.expansion:
  4.             downsample = nn.Sequential(
  5.                 nn.Conv2d(self.inplanes, planes * block.expansion,
  6.                           kernel_size=1, stride=stride, bias=False),
  7.                 nn.BatchNorm2d(planes * block.expansion),
  8.             )
  9.  
  10.         layers = []
  11.         layers.append(block(self.inplanes, planes, stride, downsample))
  12.         self.inplanes = planes * block.expansion
  13.         for i in range(1, blocks):
  14.             layers.append(block(self.inplanes, planes, dilation=dilation))
  15.  
  16.         return nn.Sequential(*layers)

2：block函数，就是一个普通的残差网络，维度由输入的inplane，到输出的inplane*4。

  1. class Bottleneck(nn.Module):
  2.     expansion = 4
  3.  
  4.     def __init__(self, inplanes, planes, stride=1, downsample=None, dilation=1):
  5.         super(Bottleneck, self).__init__()
  6.         self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
  7.         self.bn1 = nn.BatchNorm2d(planes)
  8.         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, dilation=dilation,
  9.                                padding=dilation, bias=False)
  10.         self.bn2 = nn.BatchNorm2d(planes)
  11.         self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
  12.         self.bn3 = nn.BatchNorm2d(planes * 4)
  13.         self.relu = nn.ReLU(inplace=True)
  14.         self.downsample = downsample
  15.         self.stride = stride
  16.  
  17.     def forward(self, x):
  18.         residual = x
  19.  
  20.         out = self.conv1(x)
  21.         out = self.bn1(out)
  22.         out = self.relu(out)
  23.  
  24.         out = self.conv2(out)
  25.         out = self.bn2(out)
  26.         out = self.relu(out)
  27.  
  28.         out = self.conv3(out)
  29.         out = self.bn3(out)
  30.  
  31.         if self.downsample is not None:
  32.             residual = self.downsample(x)
  33.  
  34.         out += residual
  35.         out = self.relu(out)
  36.  
  37.         return out

3：_make_agant_layer函数，将刚才四倍输出变为原来的维度。

  1.    def _make_agant_layer(self, inplanes, planes):
  2.         layers = nn.Sequential(
  3.             nn.Conv2d(inplanes, planes, kernel_size=1,
  4.                       stride=1, padding=0, bias=False),
  5.             nn.BatchNorm2d(planes),
  6.             nn.ReLU(inplace=True)
  7.         )
  8.         return layers

4：_make_transpose函数。使用nn.ConvTranspose2d进行上采样，将layer放在一起，生成序列。这里的block是TransBasicBlock。

  1.     def _make_transpose(self, block, planes, blocks, stride=1):
  2.         upsample = None
  3.         if stride != 1:
  4.             upsample = nn.Sequential(
  5.                 nn.ConvTranspose2d(self.inplanes, planes,
  6.                                    kernel_size=2, stride=stride,
  7.                                    padding=0, bias=False),
  8.                 nn.BatchNorm2d(planes),
  9.             )
  10.         elif self.inplanes != planes:
  11.             upsample = nn.Sequential(
  12.                 nn.Conv2d(self.inplanes, planes,
  13.                           kernel_size=1, stride=stride, bias=False),
  14.                 nn.BatchNorm2d(planes),
  15.             )
  16.  
  17.         layers = []
  18.  
  19.         for i in range(1, blocks):
  20.             layers.append(block(self.inplanes, self.inplanes))
  21.  
  22.         layers.append(block(self.inplanes, planes, stride, upsample))
  23.         self.inplanes = planes
  24.  
  25.         return nn.Sequential(*layers)
  26.

接着对rgb和depth进行提取：

  1.  def encoder(self, rgb, depth):
  2.         rgb = self.conv1(rgb)
  3.         rgb = self.bn1(rgb)
  4.         rgb = self.relu(rgb)
  5.         depth = self.conv1_d(depth)
  6.         depth = self.bn1_d(depth)
  7.         depth = self.relu_d(depth)
  8.  
  9.         m0 = rgb + depth
  10.  
  11.         rgb = self.maxpool(rgb)
  12.         depth = self.maxpool_d(depth)
  13.         m = self.maxpool(m0)
  14.  
  15.         # block 1
  16.         rgb = self.layer1(rgb)
  17.         depth = self.layer1_d(depth)
  18.         m = self.layer1_m(m)
  19.  
  20.         m1 = m + rgb + depth
  21.  
  22.         # block 2
  23.         rgb = self.layer2(rgb)
  24.         depth = self.layer2_d(depth)
  25.         m = self.layer2_m(m1)
  26.  
  27.         m2 = m + rgb + depth
  28.  
  29.         # block 3
  30.         rgb = self.layer3(rgb)
  31.         depth = self.layer3_d(depth)
  32.         m = self.layer3_m(m2)
  33.  
  34.         m3 = m + rgb + depth
  35.  
  36.         # block 4
  37.         rgb = self.layer4(rgb)
  38.         depth = self.layer4_d(depth)
  39.         m = self.layer4_m(m3)
  40.  
  41.         if self.pcca5:
  42.             rgb_down = self.conv_5a(rgb)
  43.             depth_down = self.conv_5c(depth)
  44.             attention_position = self.pca_5(rgb_down, depth_down)
  45.             attention_channel = self.cca_5(rgb_down, depth_down)
  46.             p_out = self.pconv_5(attention_position)
  47.             c_out = self.cconv_5(attention_channel)
  48.             m4 = self.split_conv(m, p_out, c_out)
  49.  
  50.             """
  51.             smooth_p = self.pconv_5(attention_position)
  52.             smooth_c = self.cconv_5(attention_channel)
  53.             p_out = self.pconv_out(smooth_p)
  54.             c_out = self.cconv_out(smooth_c)
  55.             m4 = m + self.alpha * p_out + self.beta * c_out
  56.             """
  57.         else:
  58.             m4 = m + rgb + depth
  59.  
  60.         return m0, m1, m2, m3, m4  # channel of m is 2048

最后输入进decoder：

  1.     def decoder(self, fuse0, fuse1, fuse2, fuse3, fuse4):
  2.         agant4 = self.agant4(fuse4)
  3.         # upsample 1
  4.         x = self.deconv1(agant4)
  5.         if self.training:
  6.             out5 = self.out5_conv(x)
  7.         x = x + self.agant3(fuse3)
  8.         # upsample 2
  9.         x = self.deconv2(x)
  10.         if self.training:
  11.             out4 = self.out4_conv(x)
  12.         x = x + self.agant2(fuse2)
  13.         # upsample 3
  14.         x = self.deconv3(x)
  15.         if self.training:
  16.             out3 = self.out3_conv(x)
  17.         x = x + self.agant1(fuse1)
  18.         # upsample 4
  19.         x = self.deconv4(x)
  20.         if self.training:
  21.             out2 = self.out2_conv(x)
  22.         x = x + self.agant0(fuse0)
  23.         # final
  24.         x = self.final_conv(x)
  25.         out = self.final_deconv(x)
  26.  
  27.         if self.training:
  28.             return out, out2, out3, out4, out5
  29.  
  30.         return out

将encoder输出作为decoder输入，整个模型就搭建完毕了。

  1.     def forward(self, rgb, depth, phase_checkpoint=False):
  2.         fuses = self.encoder(rgb, depth)
  3.         m = self.decoder(*fuses)
  4.         return m

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

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

  

闽ICP备14008679号