def cyclegan_discriminator(h):
    with C.layers.default_options(init=C.normal(0.02), pad=True, bias=False):
        h = C.leaky_relu(Convolution2D((3, 3), 64, strides=2, bias=True)(h), alpha=0.2)

        h = C.leaky_relu(InstanceNormalization((128, 1, 1)))(Convolution2D((3, 3), 128, strides=2)(h)), alpha=0.2)
        h = C.leaky_relu(InstanceNormalization((256, 1, 1)))(Convolution2D((3, 3), 256, strides=2)(h)), alpha=0.2)
        h = C.leaky_relu(InstanceNormalization((512, 1, 1)))(Convolution2D((3, 3), 512, strides=2)(h)), alpha=0.2)

        h = Convolution2D((1, 1), 1, activation=None, bias=True)(h)

        return h
Beispiel #2
0
def cgan_discriminator(x, y):
    with C.layers.default_options(init=C.normal(scale=0.02), map_rank=1, use_cntk_engine=True):
        hx = C.reshape(x, (1, 28, 28))
        hy = C.ones_like(hx) * C.reshape(y, (label_dim, 1, 1))
        h = C.splice(hx, hy, axis=0)

        h = C.leaky_relu((Convolution2D((5, 5), 1, strides=(2, 2))(h)), alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Convolution2D((5, 5), 64, strides=(2, 2))(h)), alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Dense(1024)(h)), alpha=0.2)

        h = Dense(1, activation=C.sigmoid)(h)

    return h
Beispiel #3
0
def pix2pix_discriminator(y, x):
    with C.layers.default_options(init=C.normal(0.02), pad=True, bias=False, map_rank=1, use_cntk_engine=True):
        x = C.leaky_relu(Convolution2D((3, 3), 32, strides=2, bias=True)(x), alpha=0.2)
        y = C.leaky_relu(Convolution2D((3, 3), 32, strides=2, bias=True)(y), alpha=0.2)

        h = C.splice(x, y, axis=0)

        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3), 128, strides=2)(h)), alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3), 256, strides=2)(h)), alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3), 512, strides=2)(h)), alpha=0.2)

        h = Convolution2D((1, 1), 1, activation=None, bias=True)(h)

        return h
Beispiel #4
0
def pix2pix_generator(h):
    with C.layers.default_options(init=C.normal(0.02), pad=True, bias=False, map_rank=1, use_cntk_engine=True):
        h_enc1 = C.leaky_relu(Convolution2D((4, 4), 64, strides=2, bias=True)(h), alpha=0.2)
        h_enc2 = C.leaky_relu(BatchNormalization()(Convolution2D((4, 4), 128, strides=2)(h_enc1)), alpha=0.2)
        h_enc3 = C.leaky_relu(BatchNormalization()(Convolution2D((4, 4), 256, strides=2)(h_enc2)), alpha=0.2)
        h_enc4 = C.leaky_relu(BatchNormalization()(Convolution2D((4, 4), 512, strides=2)(h_enc3)), alpha=0.2)
        h_enc5 = C.leaky_relu(BatchNormalization()(Convolution2D((4, 4), 512, strides=2)(h_enc4)), alpha=0.2)
        h_enc6 = C.leaky_relu(BatchNormalization()(Convolution2D((4, 4), 512, strides=2)(h_enc5)), alpha=0.2)
        h_enc7 = C.leaky_relu(BatchNormalization()(Convolution2D((4, 4), 512, strides=1)(h_enc6)), alpha=0.2)
        h_enc8 = C.leaky_relu(BatchNormalization()(Convolution2D((4, 4), 512, strides=1)(h_enc7)), alpha=0.2)

        h_dec8 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 512, strides=1, pad=True, output_shape=(img_height // 64, img_width // 64))(h_enc8)))
        h_dec8 = C.splice(h_dec8, h_enc8, axis=0)
        h_dec8 = C.relu(h_dec8)

        h_dec7 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 512, strides=1, pad=True, output_shape=(img_height // 64, img_width // 64))(h_dec8)))
        h_dec7 = C.splice(h_dec7, h_enc7, axis=0)
        h_dec7 = C.relu(h_dec7)

        h_dec6 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 512, strides=1, pad=True, output_shape=(img_height // 64, img_width // 64))(h_dec7)))
        h_dec6 = C.splice(h_dec6, h_enc6, axis=0)
        h_dec6 = C.relu(h_dec6)

        h_dec5 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 512, strides=2, pad=True, output_shape=(img_height // 32, img_width // 32))(h_dec6)))
        h_dec5 = C.splice(h_dec5, h_enc5, axis=0)
        h_dec5 = C.relu(h_dec5)

        h_dec4 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 512, strides=2, pad=True, output_shape=(img_height // 16, img_width // 16))(h_dec5)))
        h_dec4 = C.splice(h_dec4, h_enc4, axis=0)
        h_dec4 = C.relu(h_dec4)

        h_dec3 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 256, strides=2, pad=True, output_shape=(img_height // 8, img_width // 8))(h_dec4)))
        h_dec3 = C.splice(h_dec3, h_enc3, axis=0)
        h_dec3 = C.relu(h_dec3)

        h_dec2 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 128, strides=2, pad=True, output_shape=(img_height // 4, img_width // 4))(h_dec3)))
        h_dec2 = C.splice(h_dec2, h_enc2, axis=0)
        h_dec2 = C.relu(h_dec2)

        h_dec1 = Dropout(0.5)(BatchNormalization()(ConvolutionTranspose2D(
            (4, 4), 64, strides=2, pad=True, output_shape=(img_height // 2, img_width // 2))(h_dec2)))
        h_dec1 = C.splice(h_dec1, h_enc1, axis=0)
        h_dec1 = C.relu(h_dec1)

        h = ConvolutionTranspose2D((4, 4), 3, activation=C.tanh, strides=2, pad=True, bias=True,
                                   output_shape=(img_height, img_width))(h_dec1)

        return h
def wgan_critic(h):
    with C.layers.default_options(init=C.normal(0.02), pad=True, bias=False):
        h = C.leaky_relu(Convolution2D((3, 3), 32, strides=2, bias=True)(h),
                         alpha=0.2)

        h = C.leaky_relu(LayerNormalization()(Convolution2D((3, 3),
                                                            64,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(LayerNormalization()(Convolution2D((3, 3),
                                                            128,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(LayerNormalization()(Convolution2D((3, 3),
                                                            256,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(LayerNormalization()(Convolution2D((3, 3),
                                                            512,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(LayerNormalization()(Convolution2D((3, 3),
                                                            1024,
                                                            strides=2)(h)),
                         alpha=0.2)

        h = Convolution2D((4, 4), 1, pad=False, strides=1, bias=True)(h)
        return h
Beispiel #6
0
def dcgan_discriminator(h):
    with C.layers.default_options(init=C.normal(0.02),
                                  pad=True,
                                  bias=False,
                                  map_rank=1,
                                  use_cntk_engine=True):
        h = C.leaky_relu(Convolution2D((3, 3), 32, strides=2, bias=True)(h),
                         alpha=0.2)

        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3),
                                                            64,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3),
                                                            128,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3),
                                                            256,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3),
                                                            512,
                                                            strides=2)(h)),
                         alpha=0.2)
        h = C.leaky_relu(BatchNormalization()(Convolution2D((3, 3),
                                                            1024,
                                                            strides=2)(h)),
                         alpha=0.2)

        h = Convolution2D((4, 4),
                          1,
                          activation=C.sigmoid,
                          pad=False,
                          bias=True,
                          strides=1)(h)

        return h
Beispiel #7
0
def test_LeakyRelu(tmpdir):
    data = np.asarray([[-1, -0.5, 0, 1, 2]], dtype=np.float32)
    model = C.leaky_relu(data)
    verify_no_input(model, tmpdir, 'LeakyRelu_0')
Beispiel #8
0
def test_LeakyRelu(tmpdir, dtype):
    with C.default_options(dtype=dtype):
        data = np.asarray([[-1, -0.5, 0, 1, 2]], dtype=dtype)
        model = C.leaky_relu(data)
        verify_no_input(model, tmpdir, 'LeakyRelu_0')
Beispiel #9
0
def test_LeakyRelu(tmpdir, dtype):
    with C.default_options(dtype = dtype):
        data = np.asarray([[-1, -0.5, 0, 1, 2]], dtype=dtype)
        model = C.leaky_relu(data)
        verify_no_input(model, tmpdir, 'LeakyRelu_0')
Beispiel #10
0
def test_LeakyRelu(tmpdir):
    data = np.asarray([[-1, -0.5, 0, 1, 2]], dtype=np.float32)
    model = C.leaky_relu(data)
    verify_no_input(model, tmpdir, 'LeakyRelu_0')