def __init__(self, hidden_dim, **kwargs):
        super().__init__()

        # conv feature
        self.conv = nn.Sequential(
            nn.Conv2d(COLOR_CHANNELS * 2,
                      NUM_CHANNELS_2 // 2,
                      kernel_size=4,
                      stride=2,
                      padding=1), nn.LeakyReLU(LEAKY), nn.Dropout2d(DROPOUT),
            BasicBlocks.block_conv_k3s2p1_BN_RELU(NUM_CHANNELS_2 // 2,
                                                  NUM_CHANNELS_1 // 2,
                                                  leaky=LEAKY),
            nn.Dropout2d(DROPOUT),
            BasicBlocks.block_conv_k3s2p1_BN_RELU(NUM_CHANNELS_1 // 2,
                                                  NUM_CHANNELS_1 // 2 * 2,
                                                  leaky=LEAKY),
            nn.Dropout2d(DROPOUT))

        self.fc = BasicBlocks.block_linear_BN_RELU(NUM_CHANNELS_1 // 2 * 2 *
                                                   4 * 4,
                                                   NUM_HIDDEN_1,
                                                   leaky=LEAKY)

        self.last_layer = nn.Linear(NUM_HIDDEN_1, hidden_dim)
    def __init__(self, hidden_dim, **kwargs):
        super(Discriminator, self).__init__()

        num_channels = list(map(lambda x: x // 2, NUM_CHANNELS))

        # b * NUM_CHANNELS[0] * 32 * 32
        self.first_layer = nn.Sequential(
            nn.Conv2d(COLOUR_CHANNELS * 2,
                      num_channels[0],
                      kernel_size=3,
                      stride=2,
                      padding=1), nn.LeakyReLU(LEAKY, inplace=True))

        # b * NUM_CHANNELS[-1] * 4 * 4
        list_layers = [
            BasicBlocks.block_conv_k3s2p1_BN_RELU(num_channels[i0],
                                                  num_channels[i0 + 1],
                                                  leaky=LEAKY)
            for i0 in range(len(num_channels) - 1)
        ]
        self.intermediate_layer = nn.Sequential(*list_layers)

        # b * hidden_dim * 1 * 1
        self.last_layer = nn.Conv2d(num_channels[-1],
                                    hidden_dim,
                                    kernel_size=4,
                                    stride=1,
                                    padding=0)
    def __init__(self, num_PAC=1, **kwargs):
        super(Discriminator, self).__init__()

        # conv feature
        self.conv = nn.Sequential(
            nn.Conv2d(COLOR_CHANNELS * num_PAC,
                      NUM_CHANNELS_2,
                      kernel_size=4,
                      stride=2,
                      padding=1), nn.LeakyReLU(LEAKY),
            BasicBlocks.block_conv_k3s2p1_BN_RELU(NUM_CHANNELS_2,
                                                  NUM_CHANNELS_1,
                                                  leaky=LEAKY),
            BasicBlocks.block_conv_k3s2p1_BN_RELU(NUM_CHANNELS_1,
                                                  NUM_CHANNELS_1 * 2,
                                                  leaky=LEAKY))

        self.fc = BasicBlocks.block_linear_BN_RELU(NUM_CHANNELS_1 * 2 * 4 * 4,
                                                   NUM_HIDDEN_1,
                                                   leaky=LEAKY)

        self.last_layer = nn.Linear(NUM_HIDDEN_1, 1)