示例#1
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 128, 1)

        self.conv256_0 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv256_1 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv256_2 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv256_3 = nn.Conv2d(128, 128, 3, padding=1)

        self.conv128_0 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_1 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_2 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_3 = nn.Conv2d(128, 128, 3, padding=1)

        self.conv_down_256_32 = nn.Conv2d(128, 128, 8, 8)
        self.conv_down_128_32 = nn.Conv2d(128, 128, 4, 4)
        self.conv_down_64_32 = nn.Conv2d(128, 128, 2, 2)

        self.gdn_down_256_32 = pytorch_gdn.GDN(128)
        self.gdn_down_128_32 = pytorch_gdn.GDN(128)
        self.gdn_down_64_32 = pytorch_gdn.GDN(128)

        self.conv_down_256_128 = nn.Conv2d(128, 128, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(128, 128, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(128)
        self.gdn_down_128_64 = pytorch_gdn.GDN(128)
示例#2
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(128, 1, 1)

        self.tconv256_0 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv256_1 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv256_2 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv256_3 = nn.ConvTranspose2d(128, 128, 3, padding=1)

        self.tconv128_0 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_1 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_2 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_3 = nn.ConvTranspose2d(128, 128, 3, padding=1)

        self.tconv_up_32_256 = nn.ConvTranspose2d(128, 128, 8, 8)
        self.tconv_up_32_128 = nn.ConvTranspose2d(128, 128, 4, 4)
        self.tconv_up_32_64 = nn.ConvTranspose2d(128, 128, 2, 2)

        self.igdn_up_32_256 = pytorch_gdn.GDN(128, True)
        self.igdn_up_32_128 = pytorch_gdn.GDN(128, True)
        self.igdn_up_32_64 = pytorch_gdn.GDN(128, True)

        self.tconv_up_64_128 = nn.ConvTranspose2d(128, 128, 2, 2)
        self.tconv_up_128_256 = nn.ConvTranspose2d(128, 128, 2, 2)

        self.igdn_up_64_128 = pytorch_gdn.GDN(128, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(128, True)
示例#3
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(64, 1, 1)

        self.tconv_up_16_256 = nn.ConvTranspose2d(64, 64, 16, 16)
        self.tconv_up_16_128 = nn.ConvTranspose2d(64, 64, 8, 8)
        self.tconv_up_16_64 = nn.ConvTranspose2d(64, 64, 4, 4)
        self.tconv_up_16_32 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_up_16_256 = pytorch_gdn.GDN(64, True)
        self.igdn_up_16_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_16_64 = pytorch_gdn.GDN(64, True)
        self.igdn_up_16_32 = pytorch_gdn.GDN(64, True)

        self.tconv_up_32_64 = nn.ConvTranspose2d(64, 64, 2, 2)
        self.tconv_up_64_128 = nn.ConvTranspose2d(64, 64, 2, 2)
        self.tconv_up_128_256 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_up_32_64 = pytorch_gdn.GDN(64, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(64, True)

        self.tconv_up_32_256 = nn.ConvTranspose2d(64, 64, 8, 8)
        self.tconv_up_32_128 = nn.ConvTranspose2d(64, 64, 4, 4)
        self.tconv_up_64_256 = nn.ConvTranspose2d(64, 64, 4, 4)
        self.igdn_up_32_256 = pytorch_gdn.GDN(64, True)
        self.igdn_up_32_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_64_256 = pytorch_gdn.GDN(64, True)
示例#4
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 128, 1)

        self.conv1_0 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv1_1 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv1_2 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv1_3 = nn.Conv2d(128, 128, 3, padding=1)

        self.conv2_0 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv2_1 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv2_2 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv2_3 = nn.Conv2d(128, 128, 3, padding=1)

        self.conv_g1 = nn.Conv2d(128, 128, 8, 8)
        self.conv_g2 = nn.Conv2d(128, 128, 4, 4)
        self.conv_g3 = nn.Conv2d(128, 128, 2, 2)

        self.gdn_g1 = pytorch_gdn.GDN(128)
        self.gdn_g2 = pytorch_gdn.GDN(128)
        self.gdn_g3 = pytorch_gdn.GDN(128)

        self.conv_f1 = nn.Conv2d(128, 128, 2, 2)
        self.conv_f2 = nn.Conv2d(128, 128, 2, 2)

        self.gdn_f1 = pytorch_gdn.GDN(128)
        self.gdn_f2 = pytorch_gdn.GDN(128)
示例#5
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(128, 1, 1)

        self.tconv1_0 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv1_1 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv1_2 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv1_3 = nn.ConvTranspose2d(128, 128, 3, padding=1)

        self.tconv2_0 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv2_1 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv2_2 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv2_3 = nn.ConvTranspose2d(128, 128, 3, padding=1)

        self.tconv_g1 = nn.ConvTranspose2d(128, 128, 8, 8)
        self.tconv_g2 = nn.ConvTranspose2d(128, 128, 4, 4)
        self.tconv_g3 = nn.ConvTranspose2d(128, 128, 2, 2)

        self.igdn_g1 = pytorch_gdn.GDN(128, True)
        self.igdn_g2 = pytorch_gdn.GDN(128, True)
        self.igdn_g3 = pytorch_gdn.GDN(128, True)

        self.tconv_f1 = nn.ConvTranspose2d(128, 128, 2, 2)
        self.tconv_f2 = nn.ConvTranspose2d(128, 128, 2, 2)

        self.igdn_f1 = pytorch_gdn.GDN(128, True)
        self.igdn_f2 = pytorch_gdn.GDN(128, True)
示例#6
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 128, 1)

        self.conv_down_256_8 = nn.Conv2d(128, 128, 32, 32)
        self.conv_down_128_8 = nn.Conv2d(128, 128, 16, 16)
        self.conv_down_64_8 = nn.Conv2d(128, 128, 8, 8)
        self.conv_down_32_8 = nn.Conv2d(128, 128, 4, 4)
        self.conv_down_16_8 = nn.Conv2d(128, 128, 2, 2)

        self.gdn_down_256_8 = pytorch_gdn.GDN(128)
        self.gdn_down_128_8 = pytorch_gdn.GDN(128)
        self.gdn_down_64_8 = pytorch_gdn.GDN(128)
        self.gdn_down_32_8 = pytorch_gdn.GDN(128)
        self.gdn_down_16_8 = pytorch_gdn.GDN(128)

        self.conv_down_256_128 = nn.Conv2d(128, 128, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(128, 128, 2, 2)
        self.conv_down_64_32 = nn.Conv2d(128, 128, 2, 2)
        self.conv_down_32_16 = nn.Conv2d(128, 128, 2, 2)
        self.conv_down_16_8 = nn.Conv2d(128, 128, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(128)
        self.gdn_down_128_64 = pytorch_gdn.GDN(128)
        self.gdn_down_64_32 = pytorch_gdn.GDN(128)
        self.gdn_down_32_16 = pytorch_gdn.GDN(128)
        self.gdn_down_16_8 = pytorch_gdn.GDN(128)
示例#7
0
    def __init__(self,
                 downSample,
                 in_channels,
                 out_channels,
                 device,
                 kernel_size=2,
                 stride=2,
                 padding=0,
                 groups=1,
                 step=2):
        super(SampleNet, self).__init__()
        self.downSample = downSample
        self.step = step
        middle_channels = (in_channels + out_channels) // 2
        if (self.downSample == True):
            if (self.step == 2):
                self.convDownX = nn.Conv2d(in_channels,
                                           middle_channels, (kernel_size, 1),
                                           (stride, 1),
                                           groups=groups)

                self.convDownY = nn.Conv2d(middle_channels,
                                           out_channels, (1, kernel_size),
                                           (1, stride),
                                           groups=groups)
            elif (self.step == 1):
                self.convDown = nn.Conv2d(in_channels,
                                          out_channels,
                                          kernel_size,
                                          stride,
                                          groups=groups)

            self.gdn = pytorch_gdn.GDN(out_channels,
                                       device=device,
                                       inverse=False)

        elif (self.downSample == False):

            self.igdn = pytorch_gdn.GDN(in_channels,
                                        device=device,
                                        inverse=True)
            if (self.step == 2):
                self.tconvUpY = nn.ConvTranspose2d(in_channels,
                                                   middle_channels,
                                                   (1, kernel_size),
                                                   (1, stride),
                                                   groups=groups)
                self.tconvUpX = nn.ConvTranspose2d(middle_channels,
                                                   out_channels,
                                                   (kernel_size, 1),
                                                   (stride, 1),
                                                   groups=groups)
            elif (self.step == 1):
                self.tconvUp = nn.ConvTranspose2d(in_channels,
                                                  out_channels,
                                                  kernel_size,
                                                  stride,
                                                  groups=groups)
示例#8
0
    def __init__(self):
        super(DecodeNet2, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(128, 1, 1)

        self.tconv_up_64_128 = nn.ConvTranspose2d(128, 128, 2, 2)
        self.tconv_up_128_256 = nn.ConvTranspose2d(128, 128, 2, 2)

        self.igdn_up_64_128 = pytorch_gdn.GDN(128, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(128, True)
示例#9
0
    def __init__(self):
        super(EncodeNet2, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 128, 1)

        self.conv_down_256_128 = nn.Conv2d(128, 128, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(128, 128, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(128)
        self.gdn_down_128_64 = pytorch_gdn.GDN(128)
示例#10
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 64, 1)

        self.conv_down_256_16 = nn.Conv2d(64, 64, 16, 16)
        self.conv_down_128_16 = nn.Conv2d(64, 64, 8, 8)
        self.conv_down_64_16 = nn.Conv2d(64, 64, 4, 4)
        self.conv_down_32_16 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_down_256_16 = pytorch_gdn.GDN(64)
        self.gdn_down_128_16 = pytorch_gdn.GDN(64)
        self.gdn_down_64_16 = pytorch_gdn.GDN(64)
        self.gdn_down_32_16 = pytorch_gdn.GDN(64)

        self.conv_down_256_128 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_64_32 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_32_16 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(64)
        self.gdn_down_128_64 = pytorch_gdn.GDN(64)
        self.gdn_down_64_32 = pytorch_gdn.GDN(64)
        self.gdn_down_32_16 = pytorch_gdn.GDN(64)

        self.conv_down_16_8 = nn.Conv2d(64, 64, 2, 2)
        self.gdn_down_16_8 = pytorch_gdn.GDN(64)
        self.tconv_up_8_16 = nn.ConvTranspose2d(64, 64, 2, 2)
示例#11
0
    def __init__(self):
        super(DecodeNet1, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(32, 1, 1)

        self.tconv_up_16_32 = nn.ConvTranspose2d(32, 32, 2, 2)
        self.tconv_up_32_64 = nn.ConvTranspose2d(32, 32, 2, 2)
        self.tconv_up_64_128 = nn.ConvTranspose2d(32, 32, 2, 2)
        self.tconv_up_128_256 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.igdn_up_16_32 = pytorch_gdn.GDN(32, True)
        self.igdn_up_32_64 = pytorch_gdn.GDN(32, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(32, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(32, True)
示例#12
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 64, 1)

        self.conv_down_256_16 = nn.Conv2d(64, 64, 16, 16)
        self.conv_down_128_16 = nn.Conv2d(64, 64, 8, 8)
        self.conv_down_64_16 = nn.Conv2d(64, 64, 4, 4)
        self.conv_down_32_16 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_down_256_16 = pytorch_gdn.GDN(64)
        self.gdn_down_128_16 = pytorch_gdn.GDN(64)
        self.gdn_down_64_16 = pytorch_gdn.GDN(64)
        self.gdn_down_32_16 = pytorch_gdn.GDN(64)

        self.conv_down_256_128 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_64_32 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_32_16 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(64)
        self.gdn_down_128_64 = pytorch_gdn.GDN(64)
        self.gdn_down_64_32 = pytorch_gdn.GDN(64)
        self.gdn_down_32_16 = pytorch_gdn.GDN(64)
        self.k1_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k1_2 = nn.Parameter(torch.FloatTensor([1]))
        self.k1_3 = nn.Parameter(torch.FloatTensor([1]))
        self.k2_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k2_2 = nn.Parameter(torch.FloatTensor([1]))
        self.k2_3 = nn.Parameter(torch.FloatTensor([1]))
        self.k3_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k3_2 = nn.Parameter(torch.FloatTensor([1]))
        self.k3_3 = nn.Parameter(torch.FloatTensor([1]))
        self.k4_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k4_3 = nn.Parameter(torch.FloatTensor([1]))
示例#13
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 32, 3, padding=1)
        self.conv1 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv3 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv4 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv5 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv6 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv7 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv8 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv9 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv10 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv11 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv12 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv13 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv14 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv15 = nn.Conv2d(32, 32, 3, padding=1)
        self.conv16 = nn.Conv2d(32, 32, 3, padding=1)

        self.bn1 = nn.BatchNorm2d(32)
        self.bn2 = nn.BatchNorm2d(32)
        self.bn3 = nn.BatchNorm2d(32)
        self.bn4 = nn.BatchNorm2d(32)
        self.bn5 = nn.BatchNorm2d(32)
        self.bn6 = nn.BatchNorm2d(32)
        self.bn7 = nn.BatchNorm2d(32)
        self.bn8 = nn.BatchNorm2d(32)
        self.bn9 = nn.BatchNorm2d(32)
        self.bn10 = nn.BatchNorm2d(32)
        self.bn11 = nn.BatchNorm2d(32)
        self.bn12 = nn.BatchNorm2d(32)
        self.bn13 = nn.BatchNorm2d(32)
        self.bn14 = nn.BatchNorm2d(32)
        self.bn15 = nn.BatchNorm2d(32)
        self.bn16 = nn.BatchNorm2d(32)

        self.conv_down_256_128 = nn.Conv2d(32, 32, 2, 2)

        self.conv_down_128_64 = nn.Conv2d(32, 32, 2, 2)

        self.conv_down_64_32 = nn.Conv2d(32, 32, 2, 2)

        self.conv_down_32_16 = nn.Conv2d(32, 32, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(32)
        self.gdn_down_128_64 = pytorch_gdn.GDN(32)
        self.gdn_down_64_32 = pytorch_gdn.GDN(32)
        self.gdn_down_32_16 = pytorch_gdn.GDN(32)
示例#14
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 64, 1)

        self.conv_down_256_128 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_64_32 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_32_16 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(64)
        self.gdn_down_128_64 = pytorch_gdn.GDN(64)
        self.gdn_down_64_32 = pytorch_gdn.GDN(64)
        self.gdn_down_32_16 = pytorch_gdn.GDN(64)
示例#15
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(32, 1, 5, padding=2)
        self.tconv1 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv2 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv3 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv4 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv5 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv6 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv7 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv8 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv9 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv10 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv11 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv12 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv13 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv14 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv15 = nn.ConvTranspose2d(32, 32, 3, padding=1)
        self.tconv16 = nn.ConvTranspose2d(32, 32, 3, padding=1)

        self.bn1 = nn.BatchNorm2d(32)
        self.bn2 = nn.BatchNorm2d(32)
        self.bn3 = nn.BatchNorm2d(32)
        self.bn4 = nn.BatchNorm2d(32)
        self.bn5 = nn.BatchNorm2d(32)
        self.bn6 = nn.BatchNorm2d(32)
        self.bn7 = nn.BatchNorm2d(32)
        self.bn8 = nn.BatchNorm2d(32)
        self.bn9 = nn.BatchNorm2d(32)
        self.bn10 = nn.BatchNorm2d(32)
        self.bn11 = nn.BatchNorm2d(32)
        self.bn12 = nn.BatchNorm2d(32)
        self.bn13 = nn.BatchNorm2d(32)
        self.bn14 = nn.BatchNorm2d(32)
        self.bn15 = nn.BatchNorm2d(32)
        self.bn16 = nn.BatchNorm2d(32)

        self.tconv_up_16_32 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.tconv_up_32_64 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.tconv_up_64_128 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.tconv_up_128_256 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.igdn_up_16_32 = pytorch_gdn.GDN(32, True)
        self.igdn_up_32_64 = pytorch_gdn.GDN(32, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(32, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(32, True)
示例#16
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 64, 1)

        self.conv_down_256_16 = nn.Conv2d(64, 64, 16, 16)
        self.conv_down_128_16 = nn.Conv2d(64, 64, 8, 8)
        self.conv_down_64_16 = nn.Conv2d(64, 64, 4, 4)
        self.conv_down_32_16 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_down_256_16 = pytorch_gdn.GDN(64)
        self.gdn_down_128_16 = pytorch_gdn.GDN(64)
        self.gdn_down_64_16 = pytorch_gdn.GDN(64)
        self.gdn_down_32_16 = pytorch_gdn.GDN(64)

        self.conv_down_256_128 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_64_32 = nn.Conv2d(64, 64, 2, 2)
        self.conv_down_32_16 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(64)
        self.gdn_down_128_64 = pytorch_gdn.GDN(64)
        self.gdn_down_64_32 = pytorch_gdn.GDN(64)
        self.gdn_down_32_16 = pytorch_gdn.GDN(64)

        self.fc = nn.Linear(64*16*16, 64*16*16)
        nn.init.zeros_(self.fc.weight)
示例#17
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up1 = nn.Conv2d(1, 32, 1)
        self.conv_channels_up2 = nn.Conv2d(1, 32, 2, 2)
        self.conv_channels_up3 = nn.Conv2d(1, 32, 4, 4)
        self.conv_channels_up4 = nn.Conv2d(1, 32, 8, 8)

        self.conv_down_256_16 = nn.Conv2d(32, 32, 16, 16)
        self.conv_down_128_16 = nn.Conv2d(32, 32, 8, 8)
        self.conv_down_64_16 = nn.Conv2d(32, 32, 4, 4)
        self.conv_down_32_16 = nn.Conv2d(32, 32, 2, 2)

        self.gdn_down_256_16 = pytorch_gdn.GDN(32)
        self.gdn_down_128_16 = pytorch_gdn.GDN(32)
        self.gdn_down_64_16 = pytorch_gdn.GDN(32)
        self.gdn_down_32_16 = pytorch_gdn.GDN(32)

        self.conv_down_256_128 = nn.Conv2d(32, 32, 2, 2)
        self.conv_down_128_64 = nn.Conv2d(32, 32, 2, 2)
        self.conv_down_64_32 = nn.Conv2d(32, 32, 2, 2)
        self.conv_down_32_16 = nn.Conv2d(32, 32, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(32)
        self.gdn_down_128_64 = pytorch_gdn.GDN(32)
        self.gdn_down_64_32 = pytorch_gdn.GDN(32)
        self.gdn_down_32_16 = pytorch_gdn.GDN(32)
示例#18
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 256, 5, padding=2)

        self.conv_down_256_128 = nn.Conv2d(256, 128, 2, 2)

        self.conv_down_128_64 = nn.Conv2d(128, 64, 2, 2)

        self.conv_down_64_32 = nn.Conv2d(64, 32, 2, 2)

        self.conv_down_32_16 = nn.Conv2d(32, 16, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(128)
        self.gdn_down_128_64 = pytorch_gdn.GDN(64)
        self.gdn_down_64_32 = pytorch_gdn.GDN(32)
        self.gdn_down_32_16 = pytorch_gdn.GDN(16)
示例#19
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(256, 1, 5, padding=2)

        self.tconv_up_16_32 = nn.ConvTranspose2d(16, 32, 2, 2)

        self.tconv_up_32_64 = nn.ConvTranspose2d(32, 64, 2, 2)

        self.tconv_up_64_128 = nn.ConvTranspose2d(64, 128, 2, 2)

        self.tconv_up_128_256 = nn.ConvTranspose2d(128, 256, 2, 2)

        self.igdn_up_16_32 = pytorch_gdn.GDN(16, True)
        self.igdn_up_32_64 = pytorch_gdn.GDN(32, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(128, True)
示例#20
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(64, 1, 1)

        self.tconv_up_16_256 = nn.ConvTranspose2d(64, 64, 16, 16)
        self.tconv_up_16_128 = nn.ConvTranspose2d(64, 64, 8, 8)
        self.tconv_up_16_64 = nn.ConvTranspose2d(64, 64, 4, 4)
        self.tconv_up_16_32 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_up_16_256 = pytorch_gdn.GDN(64, True)
        self.igdn_up_16_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_16_64 = pytorch_gdn.GDN(64, True)
        self.igdn_up_16_32 = pytorch_gdn.GDN(64, True)

        self.tconv_up_32_64 = nn.ConvTranspose2d(64, 64, 2, 2)
        self.tconv_up_64_128 = nn.ConvTranspose2d(64, 64, 2, 2)
        self.tconv_up_128_256 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_up_32_64 = pytorch_gdn.GDN(64, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(64, True)

        self.k1_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k1_2 = nn.Parameter(torch.FloatTensor([1]))
        self.k1_3 = nn.Parameter(torch.FloatTensor([1]))
        self.k2_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k2_2 = nn.Parameter(torch.FloatTensor([1]))
        self.k2_3 = nn.Parameter(torch.FloatTensor([1]))
        self.k3_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k3_2 = nn.Parameter(torch.FloatTensor([1]))
        self.k3_3 = nn.Parameter(torch.FloatTensor([1]))
        self.k4_1 = nn.Parameter(torch.FloatTensor([1]))
        self.k4_3 = nn.Parameter(torch.FloatTensor([1]))
示例#21
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(64, 1, 1)

        self.tconv_g1 = nn.ConvTranspose2d(64, 64, 8, 8)
        self.tconv_g2 = nn.ConvTranspose2d(64, 64, 4, 4)
        self.tconv_g3 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_g1 = pytorch_gdn.GDN(64, True)
        self.igdn_g2 = pytorch_gdn.GDN(64, True)
        self.igdn_g3 = pytorch_gdn.GDN(64, True)

        self.tconv_f1 = nn.ConvTranspose2d(64, 64, 2, 2)
        self.tconv_f2 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_f1 = pytorch_gdn.GDN(64, True)
        self.igdn_f2 = pytorch_gdn.GDN(64, True)
示例#22
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 64, 1)

        self.conv_g1 = nn.Conv2d(64, 64, 8, 8)
        self.conv_g2 = nn.Conv2d(64, 64, 4, 4)
        self.conv_g3 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_g1 = pytorch_gdn.GDN(64)
        self.gdn_g2 = pytorch_gdn.GDN(64)
        self.gdn_g3 = pytorch_gdn.GDN(64)

        self.conv_f1 = nn.Conv2d(64, 64, 2, 2)
        self.conv_f2 = nn.Conv2d(64, 64, 2, 2)

        self.gdn_f1 = pytorch_gdn.GDN(64)
        self.gdn_f2 = pytorch_gdn.GDN(64)
示例#23
0
    def __init__(self):
        super(DecodeNet, self).__init__()
        self.tconv_channels_down_1 = nn.ConvTranspose2d(32, 1, 1)
        self.tconv_channels_down_3 = nn.ConvTranspose2d(32, 1, 3, padding=1)
        self.tconv_channels_down_5 = nn.ConvTranspose2d(32, 1, 5, padding=2)
        self.tconv_channels_down_7 = nn.ConvTranspose2d(32, 1, 7, padding=3)
        self.tconv_channels_down_9 = nn.ConvTranspose2d(32, 1, 9, padding=4)

        self.tconv_up_16_32 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.tconv_up_32_64 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.tconv_up_64_128 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.tconv_up_128_256 = nn.ConvTranspose2d(32, 32, 2, 2)

        self.igdn_up_16_32 = pytorch_gdn.GDN(32, True)
        self.igdn_up_32_64 = pytorch_gdn.GDN(32, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(32, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(32, True)
示例#24
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv0 = nn.ConvTranspose2d(128, 1, 9, padding=4)

        self.tconv_up_0 = nn.ConvTranspose2d(128, 128, 4, 4)  # 升采样

        self.igdn128_0 = pytorch_gdn.GDN(128, True)

        self.tconv1 = nn.ConvTranspose2d(128, 128, 5, padding=2)

        self.tconv_up_1 = nn.ConvTranspose2d(128, 128, 2, 2)  # 升采样

        self.igdn128_1 = pytorch_gdn.GDN(128, True)

        self.tconv2 = nn.ConvTranspose2d(128, 128, 5, padding=2)

        self.tconv_up_2 = nn.ConvTranspose2d(128, 128, 2, 2)  # 升采样

        self.igdn128_2 = pytorch_gdn.GDN(128, True)
示例#25
0
    def __init__(self):
        super(EncodeNet, self).__init__()

        self.conv0 = nn.Conv2d(1, 128, 9, padding=4)

        self.conv_down_0 = nn.Conv2d(128, 128, 4, 4)  # 降采样

        self.gdn128_0 = pytorch_gdn.GDN(128)

        self.conv1 = nn.Conv2d(128, 128, 5, padding=2)

        self.conv_down_1 = nn.Conv2d(128, 128, 2, 2)  # 降采样

        self.gdn128_1 = pytorch_gdn.GDN(128)

        self.conv2 = nn.Conv2d(128, 128, 5, padding=2)

        self.conv_down_2 = nn.Conv2d(128, 128, 2, 2)  # 降采样

        self.gdn128_2 = pytorch_gdn.GDN(128)
示例#26
0
    def __init__(self):
        super(EncodeNet, self).__init__()
        self.conv_channels_up_1 = nn.Conv2d(1, 32, 1)
        self.conv_channels_up_3 = nn.Conv2d(1, 32, 3, padding=1)
        self.conv_channels_up_5 = nn.Conv2d(1, 32, 5, padding=2)
        self.conv_channels_up_7 = nn.Conv2d(1, 32, 7, padding=3)
        self.conv_channels_up_9 = nn.Conv2d(1, 32, 9, padding=4)

        self.conv_down_256_128 = nn.Conv2d(32, 32, 2, 2)

        self.conv_down_128_64 = nn.Conv2d(32, 32, 2, 2)

        self.conv_down_64_32 = nn.Conv2d(32, 32, 2, 2)

        self.conv_down_32_16 = nn.Conv2d(32, 32, 2, 2)

        self.gdn_down_256_128 = pytorch_gdn.GDN(32)
        self.gdn_down_128_64 = pytorch_gdn.GDN(32)
        self.gdn_down_64_32 = pytorch_gdn.GDN(32)
        self.gdn_down_32_16 = pytorch_gdn.GDN(32)
示例#27
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(64, 1, 1)

        self.tconv3_16 = nn.ConvTranspose2d(64, 64, 3, 1, padding=1)
        self.tconv_up_16_32 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.tconv3_32 = nn.ConvTranspose2d(64, 64, 3, 1, padding=1)
        self.tconv_up_32_64 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.tconv3_64 = nn.ConvTranspose2d(64, 64, 3, 1, padding=1)
        self.tconv_up_64_128 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.tconv3_128 = nn.ConvTranspose2d(64, 64, 3, 1, padding=1)
        self.tconv_up_128_256 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_up_16_32 = pytorch_gdn.GDN(64, True)
        self.igdn_up_32_64 = pytorch_gdn.GDN(64, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(64, True)
示例#28
0
    def __init__(self):
        super(DecodeNet, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(64, 1, 1)

        self.dropout16 = nn.Dropout2d(0.5)
        self.tconv_up_16_32 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.dropout32 = nn.Dropout2d(0.5)
        self.tconv_up_32_64 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.dropout64 = nn.Dropout2d(0.5)
        self.tconv_up_64_128 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.dropout128 = nn.Dropout2d(0.5)
        self.tconv_up_128_256 = nn.ConvTranspose2d(64, 64, 2, 2)

        self.igdn_up_16_32 = pytorch_gdn.GDN(64, True)
        self.igdn_up_32_64 = pytorch_gdn.GDN(64, True)
        self.igdn_up_64_128 = pytorch_gdn.GDN(64, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(64, True)
示例#29
0
    def __init__(self):
        super(EncodeNet2, self).__init__()

        self.conv_channels_up = nn.Conv2d(1, 128, 1)

        self.conv_down_256_128 = nn.Conv2d(128, 128, 2, 2)

        self.conv128_1 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_2 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_3 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_4 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_5 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv128_6 = nn.Conv2d(128, 128, 3, padding=1)
        self.bn128_1 = nn.BatchNorm2d(128)
        self.bn128_2 = nn.BatchNorm2d(128)
        self.bn128_3 = nn.BatchNorm2d(128)
        self.bn128_4 = nn.BatchNorm2d(128)
        self.bn128_5 = nn.BatchNorm2d(128)
        self.bn128_6 = nn.BatchNorm2d(128)

        self.conv_down_128_64 = nn.Conv2d(128, 128, 2, 2)

        self.conv64_1 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv64_2 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv64_3 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv64_4 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv64_5 = nn.Conv2d(128, 128, 3, padding=1)
        self.conv64_6 = nn.Conv2d(128, 128, 3, padding=1)
        self.bn64_1 = nn.BatchNorm2d(128)
        self.bn64_2 = nn.BatchNorm2d(128)
        self.bn64_3 = nn.BatchNorm2d(128)
        self.bn64_4 = nn.BatchNorm2d(128)
        self.bn64_5 = nn.BatchNorm2d(128)
        self.bn64_6 = nn.BatchNorm2d(128)

        self.gdn_down_256_128 = pytorch_gdn.GDN(128)
        self.gdn_down_128_64 = pytorch_gdn.GDN(128)
示例#30
0
    def __init__(self):
        super(DecodeNet2, self).__init__()

        self.tconv_channels_down = nn.ConvTranspose2d(128, 1, 1)

        self.tconv64_1 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv64_2 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv64_3 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv64_4 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv64_5 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv64_6 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.bn64_1 = nn.BatchNorm2d(128)
        self.bn64_2 = nn.BatchNorm2d(128)
        self.bn64_3 = nn.BatchNorm2d(128)
        self.bn64_4 = nn.BatchNorm2d(128)
        self.bn64_5 = nn.BatchNorm2d(128)
        self.bn64_6 = nn.BatchNorm2d(128)

        self.tconv_up_64_128 = nn.ConvTranspose2d(128, 128, 2, 2)
        self.tconv128_1 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_2 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_3 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_4 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_5 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.tconv128_6 = nn.ConvTranspose2d(128, 128, 3, padding=1)
        self.bn128_1 = nn.BatchNorm2d(128)
        self.bn128_2 = nn.BatchNorm2d(128)
        self.bn128_3 = nn.BatchNorm2d(128)
        self.bn128_4 = nn.BatchNorm2d(128)
        self.bn128_5 = nn.BatchNorm2d(128)
        self.bn128_6 = nn.BatchNorm2d(128)

        self.tconv_up_128_256 = nn.ConvTranspose2d(128, 128, 2, 2)

        self.igdn_up_64_128 = pytorch_gdn.GDN(128, True)
        self.igdn_up_128_256 = pytorch_gdn.GDN(128, True)