コード例 #1
0
ファイル: networks.py プロジェクト: EvaBr/MorphNonlins
    def __init__(self, nin, nout, nG=64):
        super().__init__()
        self.name = "UNet"

        self.conv0 = nn.Sequential(convBatch(nin, nG),
                                   convBatch(nG, nG))
        self.conv1 = nn.Sequential(convBatch(nG * 1, nG * 2, stride=2),
                                   convBatch(nG * 2, nG * 2))
        self.conv2 = nn.Sequential(convBatch(nG * 2, nG * 4, stride=2),
                                   convBatch(nG * 4, nG * 4))

        self.bridge = nn.Sequential(convBatch(nG * 4, nG * 8, stride=2),
                                    residualConv(nG * 8, nG * 8),
                                    convBatch(nG * 8, nG * 8))

        self.deconv1 = upSampleConv(nG * 8, nG * 8)
        self.conv5 = nn.Sequential(convBatch(nG * 12, nG * 4),
                                   convBatch(nG * 4, nG * 4))
        self.deconv2 = upSampleConv(nG * 4, nG * 4)
        self.conv6 = nn.Sequential(convBatch(nG * 6, nG * 2),
                                   convBatch(nG * 2, nG * 2))
        self.deconv3 = upSampleConv(nG * 2, nG * 2)
        self.conv7 = nn.Sequential(convBatch(nG * 3, nG * 1),
                                   convBatch(nG * 1, nG * 1))
        self.final = nn.Conv2d(nG, nout, kernel_size=1)
コード例 #2
0
ファイル: networks.py プロジェクト: mathilde-b/SRDA
    def __init__(self, nin, nout, nG=32): # m changed the default from 64 to 32
        super().__init__()

        self.conv0 = nn.Sequential(convBatch(nin, nG),
                                   convBatch(nG, nG))
        self.conv1 = nn.Sequential(convBatch(nG * 1, nG * 2, stride=2),
                                   convBatch(nG * 2, nG * 2))
        self.conv2 = nn.Sequential(convBatch(nG * 2, nG * 4, stride=2),
                                   convBatch(nG * 4, nG * 4))

        self.bridge = nn.Sequential(convBatch(nG * 4, nG * 8, stride=2),
                                    residualConv(nG * 8, nG * 8),
                                    convBatch(nG * 8, nG * 8))

        self.deconv1 = upSampleConv(nG * 8, nG * 8)
        self.conv5 = nn.Sequential(convBatch(nG * 12, nG * 4),
                                   convBatch(nG * 4, nG * 4))
        self.deconv2 = upSampleConv(nG * 4, nG * 4)
        self.conv6 = nn.Sequential(convBatch(nG * 6, nG * 2),
                                   convBatch(nG * 2, nG * 2))
        self.deconv3 = upSampleConv(nG * 2, nG * 2)
        self.conv7 = nn.Sequential(convBatch(nG * 3, nG * 1),
                                   convBatch(nG * 1, nG * 1))
        self.final = nn.Conv2d(nG, nout, kernel_size=1)
コード例 #3
0
    def __init__(self, nin, nout):
        super().__init__()
        self.projecting_factor = 4
        self.n_kernels = 16

        # Initial
        self.conv0 = nn.Conv2d(nin, 15, kernel_size=3, stride=2, padding=1)
        self.maxpool0 = nn.MaxPool2d(2, return_indices=True)

        # First group
        self.bottleNeck1_0 = BottleNeckDownSampling(self.n_kernels,
                                                    self.projecting_factor,
                                                    self.n_kernels * 4)
        self.bottleNeck1_1 = BottleNeckNormal(self.n_kernels * 4,
                                              self.n_kernels * 4,
                                              self.projecting_factor, 0.01)
        self.bottleNeck1_2 = BottleNeckNormal(self.n_kernels * 4,
                                              self.n_kernels * 4,
                                              self.projecting_factor, 0.01)
        self.bottleNeck1_3 = BottleNeckNormal(self.n_kernels * 4,
                                              self.n_kernels * 4,
                                              self.projecting_factor, 0.01)
        self.bottleNeck1_4 = BottleNeckNormal(self.n_kernels * 4,
                                              self.n_kernels * 4,
                                              self.projecting_factor, 0.01)

        # Second group
        self.bottleNeck2_0 = BottleNeckDownSampling(self.n_kernels * 4,
                                                    self.projecting_factor,
                                                    self.n_kernels * 8)
        self.bottleNeck2_1 = BottleNeckNormal(self.n_kernels * 8,
                                              self.n_kernels * 8,
                                              self.projecting_factor, 0.1)
        self.bottleNeck2_2 = BottleNeckDownSamplingDilatedConv(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 8, 2)
        self.bottleNeck2_3 = BottleNeckNormal_Asym(self.n_kernels * 8,
                                                   self.n_kernels * 8,
                                                   self.projecting_factor, 0.1)
        self.bottleNeck2_4 = BottleNeckDownSamplingDilatedConv(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 8, 4)
        self.bottleNeck2_5 = BottleNeckNormal(self.n_kernels * 8,
                                              self.n_kernels * 8,
                                              self.projecting_factor, 0.1)
        self.bottleNeck2_6 = BottleNeckDownSamplingDilatedConv(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 8, 8)
        self.bottleNeck2_7 = BottleNeckNormal_Asym(self.n_kernels * 8,
                                                   self.n_kernels * 8,
                                                   self.projecting_factor, 0.1)
        self.bottleNeck2_8 = BottleNeckDownSamplingDilatedConv(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 8, 16)

        # Third group
        self.bottleNeck3_1 = BottleNeckNormal(self.n_kernels * 8,
                                              self.n_kernels * 8,
                                              self.projecting_factor, 0.1)
        self.bottleNeck3_2 = BottleNeckDownSamplingDilatedConv(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 8, 2)
        self.bottleNeck3_3 = BottleNeckNormal_Asym(self.n_kernels * 8,
                                                   self.n_kernels * 8,
                                                   self.projecting_factor, 0.1)
        self.bottleNeck3_4 = BottleNeckDownSamplingDilatedConv(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 8, 4)
        self.bottleNeck3_5 = BottleNeckNormal(self.n_kernels * 8,
                                              self.n_kernels * 8,
                                              self.projecting_factor, 0.1)
        self.bottleNeck3_6 = BottleNeckDownSamplingDilatedConv(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 8, 8)
        self.bottleNeck3_7 = BottleNeckNormal_Asym(self.n_kernels * 8,
                                                   self.n_kernels * 8,
                                                   self.projecting_factor, 0.1)
        self.bottleNeck3_8 = BottleNeckDownSamplingDilatedConvLast(
            self.n_kernels * 8, self.projecting_factor, self.n_kernels * 4, 16)

        # ### Decoding path ####
        # Unpooling 1
        self.unpool_0 = nn.MaxUnpool2d(2)

        self.bottleNeck_Up_1_0 = BottleNeckUpSampling(self.n_kernels * 8,
                                                      self.projecting_factor,
                                                      self.n_kernels * 4)
        self.PReLU_Up_1 = nn.PReLU()

        self.bottleNeck_Up_1_1 = BottleNeckNormal(self.n_kernels * 4,
                                                  self.n_kernels * 4,
                                                  self.projecting_factor, 0.1)
        self.bottleNeck_Up_1_2 = BottleNeckNormal(self.n_kernels * 4,
                                                  self.n_kernels,
                                                  self.projecting_factor, 0.1)

        # Unpooling 2
        self.unpool_1 = nn.MaxUnpool2d(2)
        self.bottleNeck_Up_2_1 = BottleNeckUpSampling(self.n_kernels * 2,
                                                      self.projecting_factor,
                                                      self.n_kernels)
        self.bottleNeck_Up_2_2 = BottleNeckNormal(self.n_kernels,
                                                  self.n_kernels,
                                                  self.projecting_factor, 0.1)
        self.PReLU_Up_2 = nn.PReLU()

        # Unpooling Last
        self.deconv3 = upSampleConv(self.n_kernels, self.n_kernels)

        self.out_025 = nn.Conv2d(self.n_kernels * 8,
                                 nout,
                                 kernel_size=3,
                                 stride=1,
                                 padding=1)
        self.out_05 = nn.Conv2d(self.n_kernels,
                                nout,
                                kernel_size=3,
                                stride=1,
                                padding=1)
        self.final = nn.Conv2d(self.n_kernels, nout, kernel_size=1)