예제 #1
0
    def __init__(self, in_channels, out_channels, num_classes):
        super(RCCAModule, self).__init__()
        inter_channels = in_channels // 4
        self.conva = nn.Sequential(
            nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
            InPlaceABNSync(inter_channels))
        self.cca = CrissCrossAttention(inter_channels)
        self.convb = nn.Sequential(
            nn.Conv2d(inter_channels, inter_channels, 3, padding=1,
                      bias=False), InPlaceABNSync(inter_channels))

        self.bottleneck = nn.Sequential(
            nn.Conv2d(in_channels + inter_channels,
                      out_channels,
                      kernel_size=3,
                      padding=1,
                      dilation=1,
                      bias=False), InPlaceABNSync(out_channels),
            nn.Dropout2d(0.1),
            nn.Conv2d(512,
                      num_classes,
                      kernel_size=1,
                      stride=1,
                      padding=0,
                      bias=True))
예제 #2
0
 def __init__(self, in_channels, out_channels):
     super(RCCAModule, self).__init__()
     inter_channels = in_channels // 4
     self.conva = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False),
                                nn.BatchNorm2d(inter_channels))
     self.cca = CrissCrossAttention(inter_channels)
     self.convb = nn.Sequential(nn.Conv2d(inter_channels, out_channels, 3, padding=1, bias=False),
                                nn.BatchNorm2d(out_channels))
예제 #3
0
    def __init__(self, num_classes, n_bands, chanel):
        super(SSCDNonLModel, self).__init__()
        #self.num_Node=num_Node
        self.bands = n_bands
        chanel = chanel
        kernel = 5
        CCChannel = 25

        self.b1 = nn.BatchNorm2d(self.bands)
        self.con1 = nn.Conv2d(self.bands, chanel, 1, padding=0, bias=True)
        self.s1 = nn.Sigmoid()
        self.cond1 = nn.Conv2d(chanel,
                               chanel,
                               kernel,
                               padding=2,
                               groups=chanel,
                               bias=True)
        self.sd1 = nn.Sigmoid()

        self.b2 = nn.BatchNorm2d(self.bands + chanel)
        #self.nlcon1=NonLocalBlock(300, 300, True)
        #self.gcn1=GCNtrans(300,1000)
        #self.bcat=nn.BatchNorm2d(300+300)
        self.con2 = nn.Conv2d(self.bands + chanel,
                              chanel,
                              1,
                              padding=0,
                              bias=True)
        self.s2 = nn.Sigmoid()
        self.cond2 = nn.Conv2d(chanel,
                               CCChannel,
                               kernel,
                               padding=2,
                               groups=25,
                               bias=True)
        self.sd2 = nn.Sigmoid()

        self.b4 = nn.BatchNorm2d(CCChannel)
        self.nlcon2 = CrissCrossAttention(CCChannel)
        self.nlcon3 = CrissCrossAttention(CCChannel)
        self.bcat = nn.BatchNorm2d(CCChannel + CCChannel)
        self.con4 = nn.Conv2d(CCChannel + CCChannel,
                              chanel,
                              1,
                              padding=0,
                              bias=True)
        self.s4 = nn.Sigmoid()
        self.cond4 = nn.Conv2d(chanel,
                               chanel,
                               kernel,
                               padding=2,
                               groups=chanel,
                               bias=True)
        self.sd4 = nn.Sigmoid()

        self.b5 = nn.BatchNorm2d(CCChannel + chanel)
        self.con5 = nn.Conv2d(CCChannel + chanel,
                              chanel,
                              1,
                              padding=0,
                              bias=True)
        self.s5 = nn.Sigmoid()
        self.cond5 = nn.Conv2d(chanel,
                               chanel,
                               kernel,
                               padding=2,
                               groups=chanel,
                               bias=True)
        self.sd5 = nn.Sigmoid()

        #self.b6=nn.BatchNorm2d(300+300)
        self.con6 = nn.Conv2d(chanel + CCChannel,
                              num_classes + 1,
                              1,
                              padding=0,
                              bias=True)