예제 #1
0
파일: idcgan.py 프로젝트: jay9z/GAN-pp
 def __init__(self):
     super(Generator,self).__init__()
     self.fc1 = Linear(input_dim=64,output_dim=1024)
     self.bn1 = BatchNorm(num_channels=256,act='relu')
     self.conv2 = Conv2DTranspose(num_channels=256,num_filters=192,filter_size=3,padding=1,output_size=4,stride=2)
     self.bn2 = BatchNorm(num_channels=192,act='relu')
     self.conv3 = Conv2DTranspose(num_channels=192,num_filters=128,filter_size=3,padding=1,output_size=8,stride=2)
     self.bn3 = BatchNorm(num_channels=128,act='relu')
     self.conv4 = Conv2DTranspose(num_channels=128,num_filters=64,filter_size=3,padding=1,output_size=16,stride=2)
     self.bn4 = BatchNorm(num_channels=64,act='relu')
     self.conv5 = Conv2DTranspose(num_channels=64,num_filters=1,filter_size=3,padding=1,output_size=32,stride=2,act='tanh')
예제 #2
0
파일: unet.py 프로젝트: sherillL/seghome
    def __init__(self, num_channels, num_filters):
        super(Decoder, self).__init__()
        # TODO: decoder contains:
        #       1 2x2 transpose conv (makes feature map 2x larger)
        #       1 3x3 conv + 1bn + 1relu +
        #       1 3x3 conv + 1bn + 1relu

        self.up = Conv2DTranspose(num_channels=num_channels,
                                  num_filters=num_filters,
                                  filter_size=2,
                                  stride=2)

        self.conv1 = Conv2D(num_channels,
                            num_filters,
                            filter_size=3,
                            stride=1,
                            padding=1)
        self.bn1 = BatchNorm(num_filters, act='relu')

        self.conv2 = Conv2D(num_filters,
                            num_filters,
                            filter_size=3,
                            stride=1,
                            padding=1)
        self.bn2 = BatchNorm(num_filters, act='relu')
예제 #3
0
파일: fcn8s.py 프로젝트: sherillL/seghome
    def __init__(self, num_classes=59):
        super(FCN8s, self).__init__()
        backbone = VGG16BN(pretrained=False)

        self.layer1 = backbone.layer1
        self.layer1[0].conv._padding = [100, 100]
        self.pool1 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer2 = backbone.layer2
        self.pool2 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer3 = backbone.layer3
        self.pool3 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer4 = backbone.layer4
        self.pool4 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer5 = backbone.layer5
        self.pool5 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)

        self.fc6 = Conv2D(512, 4096, 7, act='relu')
        self.fc7 = Conv2D(4096, 4096, 1, act='relu')
        self.drop6 = Dropout()
        self.drop7 = Dropout()

        self.score = Conv2D(4096, num_classes, 1)
        self.score_pool3 = Conv2D(256, num_classes, 1)
        self.score_pool4 = Conv2D(512, num_classes, 1)

        self.up_output = Conv2DTranspose(num_channels=num_classes,
                                        num_filters=num_classes,
                                        filter_size=4,
                                        stride=2,
                                        bias_attr=False)

        self.up_pool4 = Conv2DTranspose(num_channels=num_classes,
                                        num_filters=num_classes,
                                        filter_size=4,
                                        stride=2,
                                        bias_attr=False)

        self.up_final = Conv2DTranspose(num_channels=num_classes,
                                        num_filters=num_classes,
                                        filter_size=16,
                                        stride=8,
                                        bias_attr=False)                                
예제 #4
0
    def __init__(self,num_classes=59):
        super(FCN8s,self).__init__()
        vgg16bn = VGG16BN()
        self.layer1 = vgg16bn.layer1
        self.layer1[0].conv._padding = [100,100]
        self.layer2 = vgg16bn.layer2
        self.layer3 = vgg16bn.layer3
        self.layer4 = vgg16bn.layer4
        self.layer5 = vgg16bn.layer5

        # self.conv1_1 = Conv2D(3,64,3,padding=1)
        # self.conv1_2 = Conv2D(64,64,3,padding=1)
        self.pool1 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True)
        # self.conv2_1 = Conv2D(64,128,3,padding=1)
        # self.conv2_2 = Conv2D(128,128,3,padding=1)
        self.pool2 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True)
        # self.conv3_1 = Conv2D(128,256,3,padding=1)
        # self.conv3_2 = Conv2D(256,256,3,padding=1)
        # self.conv3_3 = Conv2D(256,256,3,padding=1)
        self.pool3 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True)
        # self.conv4_1 = Conv2D(256,512,3,padding=1)
        # self.conv4_2 = Conv2D(512,512,3,padding=1)
        # self.conv4_3 = Conv2D(512,512,3,padding=1)
        self.pool4 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True)
        # self.conv5_1 = Conv2D(512,512,3,padding=1)
        # self.conv5_2 = Conv2D(512,512,3,padding=1)
        # self.conv5_3 = Conv2D(512,512,3,padding=1)
        self.pool5 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True)
        self.conv6 = Conv2D(512,4096,1,act='relu')
        self.conv7 = Conv2D(4096,4096,1,act='relu')
        self.drop6 = Dropout()
        self.drop7 = Dropout()

        self.score = Conv2D(4096,num_classes,1)
        self.score_pool3 = Conv2D(256,num_classes,1)
        self.score_pool4 = Conv2D(512,num_classes,1,)
        self.upsample1 = Conv2DTranspose(num_classes,num_classes,filter_size=4,stride=2,padding=2,bias_attr=False)
        self.upsample2 = Conv2DTranspose(num_classes,num_classes,filter_size=4,stride=2,padding=2,bias_attr=False)
        self.upsample3 = Conv2DTranspose(num_classes,num_classes,filter_size=16,stride=8,padding=1,bias_attr=False)
    def __init__(self, name_scope, md=4):
        super(PWCDCNet, self).__init__(name_scope)
        self.param_attr = fluid.ParamAttr(
            name='conv_weights',
            regularizer=fluid.regularizer.L2DecayRegularizer(
                regularization_coeff=0.0004),
            initializer=fluid.initializer.MSRAInitializer(uniform=True,
                                                          fan_in=None,
                                                          seed=0))
        self.md = md
        self.conv1a = Conv2D("conv1a",
                             16,
                             filter_size=3,
                             stride=2,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv1aa = Conv2D("conv1aa",
                              16,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv1b = Conv2D("conv1b",
                             16,
                             filter_size=3,
                             stride=1,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv2a = Conv2D("conv2a",
                             32,
                             filter_size=3,
                             stride=2,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv2aa = Conv2D("conv2aa",
                              32,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv2b = Conv2D("conv2b",
                             32,
                             filter_size=3,
                             stride=1,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv3a = Conv2D("conv3a",
                             64,
                             filter_size=3,
                             stride=2,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv3aa = Conv2D("conv3aa",
                              64,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv3b = Conv2D("conv3b",
                             64,
                             filter_size=3,
                             stride=1,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv4a = Conv2D("conv4a",
                             96,
                             filter_size=3,
                             stride=2,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv4aa = Conv2D("conv4aa",
                              96,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv4b = Conv2D("conv4b",
                             96,
                             filter_size=3,
                             stride=1,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv5a = Conv2D("conv5a",
                             128,
                             filter_size=3,
                             stride=2,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv5aa = Conv2D("conv5aa",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv5b = Conv2D("conv5b",
                             128,
                             filter_size=3,
                             stride=1,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv6aa = Conv2D("conv6aa",
                              196,
                              filter_size=3,
                              stride=2,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv6a = Conv2D("conv6a",
                             196,
                             filter_size=3,
                             stride=1,
                             padding=1,
                             param_attr=self.param_attr)
        self.conv6b = Conv2D("conv6b",
                             196,
                             filter_size=3,
                             stride=1,
                             padding=1,
                             param_attr=self.param_attr)

        self.conv6_0 = Conv2D("conv6_0",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv6_1 = Conv2D("conv6_1",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv6_2 = Conv2D("conv6_2",
                              96,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv6_3 = Conv2D("conv6_3",
                              64,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv6_4 = Conv2D("conv6_4",
                              32,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.predict_flow6 = Conv2D("predict_flow6",
                                    2,
                                    filter_size=3,
                                    stride=1,
                                    padding=1,
                                    param_attr=self.param_attr)
        self.deconv6 = Conv2DTranspose("deconv6",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat6 = Conv2DTranspose("upfeat6",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        self.conv5_0 = Conv2D("conv5_0",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv5_1 = Conv2D("conv5_1",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv5_2 = Conv2D("conv5_2",
                              96,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv5_3 = Conv2D("conv5_3",
                              64,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv5_4 = Conv2D("conv5_4",
                              32,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.predict_flow5 = Conv2D("predict_flow5",
                                    2,
                                    filter_size=3,
                                    stride=1,
                                    padding=1,
                                    param_attr=self.param_attr)
        self.deconv5 = Conv2DTranspose("deconv5",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat5 = Conv2DTranspose("upfeat5",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        self.conv4_0 = Conv2D("conv4_0",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv4_1 = Conv2D("conv4_1",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv4_2 = Conv2D("conv4_2",
                              96,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv4_3 = Conv2D("conv4_3",
                              64,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv4_4 = Conv2D("conv4_4",
                              32,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.predict_flow4 = Conv2D("predict_flow4",
                                    2,
                                    filter_size=3,
                                    stride=1,
                                    padding=1,
                                    param_attr=self.param_attr)
        self.deconv4 = Conv2DTranspose("deconv4",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat4 = Conv2DTranspose("upfeat4",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        self.conv3_0 = Conv2D("conv3_0",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv3_1 = Conv2D("conv3_1",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv3_2 = Conv2D("conv3_2",
                              96,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv3_3 = Conv2D("conv3_3",
                              64,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv3_4 = Conv2D("conv3_4",
                              32,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.predict_flow3 = Conv2D("predict_flow3",
                                    2,
                                    filter_size=3,
                                    stride=1,
                                    padding=1,
                                    param_attr=self.param_attr)
        self.deconv3 = Conv2DTranspose("deconv3",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat3 = Conv2DTranspose("upfeat3",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        self.conv2_0 = Conv2D("conv2_0",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv2_1 = Conv2D("conv2_1",
                              128,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv2_2 = Conv2D("conv2_2",
                              96,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv2_3 = Conv2D("conv2_3",
                              64,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.conv2_4 = Conv2D("conv2_4",
                              32,
                              filter_size=3,
                              stride=1,
                              padding=1,
                              param_attr=self.param_attr)
        self.predict_flow2 = Conv2D("predict_flow2",
                                    2,
                                    filter_size=3,
                                    stride=1,
                                    padding=1,
                                    param_attr=self.param_attr)
        self.deconv2 = Conv2DTranspose("deconv2",
                                       2,
                                       filter_size=4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        self.dc_conv1 = Conv2D("dc_conv1",
                               128,
                               filter_size=3,
                               stride=1,
                               padding=1,
                               dilation=1,
                               param_attr=self.param_attr)
        self.dc_conv2 = Conv2D("dc_conv2",
                               128,
                               filter_size=3,
                               stride=1,
                               padding=2,
                               dilation=2,
                               param_attr=self.param_attr)
        self.dc_conv3 = Conv2D("dc_conv3",
                               128,
                               filter_size=3,
                               stride=1,
                               padding=4,
                               dilation=4,
                               param_attr=self.param_attr)
        self.dc_conv4 = Conv2D("dc_conv4",
                               96,
                               filter_size=3,
                               stride=1,
                               padding=8,
                               dilation=8,
                               param_attr=self.param_attr)
        self.dc_conv5 = Conv2D("dc_conv5",
                               64,
                               filter_size=3,
                               stride=1,
                               padding=16,
                               dilation=16,
                               param_attr=self.param_attr)
        self.dc_conv6 = Conv2D("dc_conv6",
                               32,
                               filter_size=3,
                               stride=1,
                               padding=1,
                               dilation=1,
                               param_attr=self.param_attr)
        self.dc_conv7 = Conv2D("dc_conv7",
                               2,
                               filter_size=3,
                               stride=1,
                               padding=1,
                               param_attr=self.param_attr)
예제 #6
0
    def __init__(self, input_channels=1):
        '''
        :功能                  :类初始化函数
        :参数 input_channels   :int,输入数据的通道数,1或3或4
        :返回                  :None
        '''
        super(GGCNN, self).__init__()

        #网络结构定义,直接照搬GGCNN 三层卷积三层反卷积
        self.conv1 = Conv2D(input_channels,
                            filter_sizes[0],
                            kernel_sizes[0],
                            stride=strides[0],
                            padding=3,
                            act='relu',
                            param_attr=fluid.initializer.Xavier(uniform=False))
        self.conv2 = Conv2D(filter_sizes[0],
                            filter_sizes[1],
                            kernel_sizes[1],
                            stride=strides[1],
                            padding=2,
                            act='relu',
                            param_attr=fluid.initializer.Xavier(uniform=False))
        self.conv3 = Conv2D(filter_sizes[1],
                            filter_sizes[2],
                            kernel_sizes[2],
                            stride=strides[2],
                            padding=1,
                            act='relu',
                            param_attr=fluid.initializer.Xavier(uniform=False))

        self.convt1 = Conv2DTranspose(
            filter_sizes[2],
            filter_sizes[3],
            kernel_sizes[3],
            stride=strides[3],
            act='relu',
            output_size=50,
            padding=1,
            param_attr=fluid.initializer.Xavier(
                uniform=False))  #这里本来有个output_padding参数,但paddle没有,故删了
        self.convt2 = Conv2DTranspose(
            filter_sizes[3],
            filter_sizes[4],
            kernel_sizes[4],
            stride=strides[4],
            act='relu',
            output_size=100,
            padding=2,
            param_attr=fluid.initializer.Xavier(uniform=False))
        self.convt3 = Conv2DTranspose(
            filter_sizes[4],
            filter_sizes[5],
            kernel_sizes[5],
            stride=strides[5],
            act='relu',
            output_size=301,
            padding=3,
            param_attr=fluid.initializer.Xavier(uniform=False))

        self.pos_output = Conv2D(
            filter_sizes[5],
            1,
            filter_size=2,
            param_attr=fluid.initializer.Xavier(uniform=False))
        self.cos_output = Conv2D(
            filter_sizes[5],
            1,
            filter_size=2,
            param_attr=fluid.initializer.Xavier(uniform=False))
        self.sin_output = Conv2D(
            filter_sizes[5],
            1,
            filter_size=2,
            param_attr=fluid.initializer.Xavier(uniform=False))
        self.width_output = Conv2D(
            filter_sizes[5],
            1,
            filter_size=2,
            param_attr=fluid.initializer.Xavier(uniform=False))
예제 #7
0
파일: pwcnet.py 프로젝트: tty33/PaddleGAN
    def __init__(self, md=4):
        super(PWCDCNet, self).__init__()
        self.md = md
        self.param_attr = fluid.ParamAttr(
            regularizer=fluid.regularizer.L2DecayRegularizer(
                regularization_coeff=0.0004),
            initializer=fluid.initializer.MSRAInitializer(uniform=True,
                                                          fan_in=None,
                                                          seed=0))
        self.conv1a = Conv2D(3, 16, 3, 2, 1, param_attr=self.param_attr)
        self.conv1aa = Conv2D(16, 16, 3, 1, 1, param_attr=self.param_attr)
        self.conv1b = Conv2D(16, 16, 3, 1, 1, param_attr=self.param_attr)
        self.conv2a = Conv2D(16, 32, 3, 2, 1, param_attr=self.param_attr)
        self.conv2aa = Conv2D(32, 32, 3, 1, 1, param_attr=self.param_attr)
        self.conv2b = Conv2D(32, 32, 3, 1, 1, param_attr=self.param_attr)
        self.conv3a = Conv2D(32, 64, 3, 2, 1, param_attr=self.param_attr)
        self.conv3aa = Conv2D(64, 64, 3, 1, 1, param_attr=self.param_attr)
        self.conv3b = Conv2D(64, 64, 3, 1, 1, param_attr=self.param_attr)
        self.conv4a = Conv2D(64, 96, 3, 2, 1, param_attr=self.param_attr)
        self.conv4aa = Conv2D(96, 96, 3, 1, 1, param_attr=self.param_attr)
        self.conv4b = Conv2D(96, 96, 3, 1, 1, param_attr=self.param_attr)
        self.conv5a = Conv2D(96, 128, 3, 2, 1, param_attr=self.param_attr)
        self.conv5aa = Conv2D(128, 128, 3, 1, 1, param_attr=self.param_attr)
        self.conv5b = Conv2D(128, 128, 3, 1, 1, param_attr=self.param_attr)
        self.conv6aa = Conv2D(128, 196, 3, 2, 1, param_attr=self.param_attr)
        self.conv6a = Conv2D(196, 196, 3, 1, 1, param_attr=self.param_attr)
        self.conv6b = Conv2D(196, 196, 3, 1, 1, param_attr=self.param_attr)

        nd = (2 * self.md + 1)**2
        dd = np.cumsum([128, 128, 96, 64, 32], dtype=np.int32).astype(np.int)
        dd = [int(d) for d in dd]
        od = nd
        self.conv6_0 = Conv2D(od, 128, 3, 1, 1, param_attr=self.param_attr)
        self.conv6_1 = Conv2D(od + dd[0],
                              128,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv6_2 = Conv2D(od + dd[1],
                              96,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv6_3 = Conv2D(od + dd[2],
                              64,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv6_4 = Conv2D(od + dd[3],
                              32,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.predict_flow6 = Conv2D(od + dd[4],
                                    2,
                                    3,
                                    1,
                                    1,
                                    param_attr=self.param_attr)
        self.deconv6 = Conv2DTranspose(2,
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat6 = Conv2DTranspose(od + dd[4],
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        od = nd + 128 + 4
        self.conv5_0 = Conv2D(od, 128, 3, 1, 1, param_attr=self.param_attr)
        self.conv5_1 = Conv2D(od + dd[0],
                              128,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv5_2 = Conv2D(od + dd[1],
                              96,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv5_3 = Conv2D(od + dd[2],
                              64,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv5_4 = Conv2D(od + dd[3],
                              32,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.predict_flow5 = Conv2D(od + dd[4],
                                    2,
                                    3,
                                    1,
                                    1,
                                    param_attr=self.param_attr)
        self.deconv5 = Conv2DTranspose(2,
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat5 = Conv2DTranspose(od + dd[4],
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        od = nd + 96 + 4
        self.conv4_0 = Conv2D(od, 128, 3, 1, 1, param_attr=self.param_attr)
        self.conv4_1 = Conv2D(od + dd[0],
                              128,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv4_2 = Conv2D(od + dd[1],
                              96,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv4_3 = Conv2D(od + dd[2],
                              64,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv4_4 = Conv2D(od + dd[3],
                              32,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.predict_flow4 = Conv2D(od + dd[4],
                                    2,
                                    3,
                                    1,
                                    1,
                                    param_attr=self.param_attr)
        self.deconv4 = Conv2DTranspose(2,
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat4 = Conv2DTranspose(od + dd[4],
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        od = nd + 64 + 4
        self.conv3_0 = Conv2D(od, 128, 3, 1, 1, param_attr=self.param_attr)
        self.conv3_1 = Conv2D(od + dd[0],
                              128,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv3_2 = Conv2D(od + dd[1],
                              96,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv3_3 = Conv2D(od + dd[2],
                              64,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv3_4 = Conv2D(od + dd[3],
                              32,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.predict_flow3 = Conv2D(od + dd[4],
                                    2,
                                    3,
                                    1,
                                    1,
                                    param_attr=self.param_attr)
        self.deconv3 = Conv2DTranspose(2,
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)
        self.upfeat3 = Conv2DTranspose(od + dd[4],
                                       2,
                                       4,
                                       stride=2,
                                       padding=1,
                                       param_attr=self.param_attr)

        od = nd + 32 + 4
        self.conv2_0 = Conv2D(od, 128, 3, 1, 1, param_attr=self.param_attr)
        self.conv2_1 = Conv2D(od + dd[0],
                              128,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv2_2 = Conv2D(od + dd[1],
                              96,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv2_3 = Conv2D(od + dd[2],
                              64,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.conv2_4 = Conv2D(od + dd[3],
                              32,
                              3,
                              1,
                              1,
                              param_attr=self.param_attr)
        self.predict_flow2 = Conv2D(od + dd[4],
                                    2,
                                    3,
                                    1,
                                    1,
                                    param_attr=self.param_attr)
        #        self.deconv2 = Conv2DTranspose(2, 2, 4, stride=2, padding=1, param_attr=self.param_attr)

        self.dc_conv1 = Conv2D(od + dd[4],
                               128,
                               3,
                               1,
                               1,
                               dilation=1,
                               param_attr=self.param_attr)
        self.dc_conv2 = Conv2D(128,
                               128,
                               3,
                               1,
                               2,
                               dilation=2,
                               param_attr=self.param_attr)
        self.dc_conv3 = Conv2D(128,
                               128,
                               3,
                               1,
                               4,
                               dilation=4,
                               param_attr=self.param_attr)
        self.dc_conv4 = Conv2D(128,
                               96,
                               3,
                               1,
                               8,
                               dilation=8,
                               param_attr=self.param_attr)
        self.dc_conv5 = Conv2D(96,
                               64,
                               3,
                               1,
                               16,
                               dilation=16,
                               param_attr=self.param_attr)
        self.dc_conv6 = Conv2D(64,
                               32,
                               3,
                               1,
                               1,
                               dilation=1,
                               param_attr=self.param_attr)
        self.dc_conv7 = Conv2D(32, 2, 3, 1, 1, param_attr=self.param_attr)