def mask_generator(x): mask = sequential([ Dense(16), Reshape((1, 4, 4)), UpSampling2D((16, 16)) ])(x) depth_map = sequential([ Dense(16), Reshape((1, 4, 4)), UpSampling2D((4, 4)) ])(x) return mask, depth_map
def get_offset_back(inputs, nb_units): n = nb_units input = concat(inputs) back_feature_map = sequential([ UpSampling2D(), # 64x64 conv(n, 3, 3), conv(n, 3, 3), ], ns='offset.back')(input) return back_feature_map, sequential([ Convolution2D(1, 3, 3, border_mode='same'), LinearInBounds(-1, 1, clip=True), ], ns='offset.back_out')(back_feature_map)
def get_decoder_model( input, nb_units, nb_output=NUM_MIDDLE_CELLS + NUM_CONFIGS, depth=1, dense=[]): def dense_bn(n): return [ Dense(n), BatchNormalization(), Activation('relu') ] n = nb_units d = depth return sequential([ conv(n, depth=d), MaxPooling2D(), # 32x32 conv(2*n, depth=d), MaxPooling2D(), # 16x16 conv(4*n, depth=d), MaxPooling2D(), # 8x8 conv(8*n, depth=d), MaxPooling2D(), # 4x4 conv(16*n, depth=d), Flatten(), [dense_bn(d) for d in dense], Dense(nb_output) ])(input)
def mask_generator(input, nb_units=64, dense_factor=3, nb_dense_layers=2, trainable=True): n = nb_units def conv(n): return [ Convolution2D(n, 3, 3, border_mode='same', init='he_normal'), Activation('relu'), ] dense_layers = [ Dense(dense_factor*nb_units, activation='relu') for _ in range(nb_dense_layers)] return sequential(dense_layers + [ Dense(8*n*4*4), Activation('relu'), Reshape((8*n, 4, 4,)), UpSampling2D(), # 8x8 conv(4*n), conv(4*n), UpSampling2D(), # 16x16 conv(2*n), conv(2*n), UpSampling2D(), # 32x32 conv(n), UpSampling2D(), # 64x64 conv(n), Convolution2D(1, 3, 3, border_mode='same', init='he_normal'), Activation('linear'), ], ns='mask_gen', trainable=trainable)(input)
def mask_blending_discriminator(x, n=32, conv_repeat=1, dense=[], out_activation='sigmoid'): def conv(n): layers = [ Convolution2D(n, 3, 3, subsample=(2, 2), border_mode='same'), BatchNormalization(axis=1), LeakyReLU(0.2), ] return layers + [[ Convolution2D(n, 3, 3, border_mode='same'), BatchNormalization(axis=1), LeakyReLU(0.2), ] for _ in range(conv_repeat-1)] def get_dense(nb): return [ Dense(nb), BatchNormalization(axis=1), LeakyReLU(0.2), ] return sequential([ Convolution2D(n, 5, 5, subsample=(2, 2), border_mode='same'), LeakyReLU(0.2), conv(2*n), conv(4*n), conv(8*n), Flatten(), [get_dense(nb) for nb in dense], Dense(1, activation=out_activation) ], ns='dis')(concat(x, axis=0, name='concat_fake_real'))
def test_sequential_flatten(): x = Input(shape=(20, )) seq = sequential([Dense(20), [Dense(10)], [[Dense(1)], Dense(1)]]) out = seq(x) model = Model([x], [out]) model.compile('adam', 'mse') model.predict_on_batch(np.random.sample((64, 20)))
def get_offset_back(inputs, nb_units): n = nb_units input = concat(inputs) back_feature_map = sequential( [ UpSampling2D(), # 64x64 conv(n, 3, 3), conv(n, 3, 3), ], ns='offset.back')(input) return back_feature_map, sequential([ Convolution2D(1, 3, 3, border_mode='same'), LinearInBounds(-1, 1, clip=True), ], ns='offset.back_out')(back_feature_map)
def get_mask_postprocess(inputs, nb_units): n = nb_units return sequential([ conv(n, 3, 3), conv(n, 3, 3), Convolution2D(1, 5, 5, border_mode='same', init='normal'), ], ns='mask_post')(concat(inputs))
def get_mask_weight_blending(inputs, min=0, max=2): input = concat(inputs) return sequential([ Convolution2D(1, 3, 3), Flatten(), Dense(1), LinearInBounds(min, max, clip=True), ], ns='mask_weight_blending')(input)
def get_mask_postprocess(inputs, nb_units): n = nb_units return sequential([ conv(n, 3, 3), conv(n, 3, 3), Deconvolution2D(1, 5, 5, border_mode=(2, 2)), LinearInBounds(-1, 1, clip=True), ], ns='mask_post')(concat(inputs))
def d(): x = Input(shape=(input_size + output_size, nb_chars)) d_realness = sequential([ LSTM(100), Dense(1, activation='sigmoid'), ])(x) d = Model([x], [d_realness]) return d
def d(): x = Input(shape=(input_size + output_size, nb_chars)) d_realness = sequential([ LSTM(100), Dense(1, activation='sigmoid'), ])(x) d = Model([x], [d_realness]) return d
def get_offset_middle(inputs, nb_units): n = nb_units input = concat(inputs) return sequential([ UpSampling2D(), # 32x32 conv(2*n, 3, 3), conv(2*n, 3, 3), conv(2*n, 3, 3), ], ns='offset.middle')(input)
def simple_gan(): z = Input(batch_shape=simple_gan_z_shape, name='z') generator = sequential([ Dense(simple_gan_nb_z, activation='relu', name='g1'), Dense(simple_gan_nb_z, activation='relu', name='g2'), Dense(simple_gan_nb_out, activation='sigmoid', name='g3'), ])(z) fake = Input(batch_shape=simple_gan_real_shape, name='fake') real = Input(batch_shape=simple_gan_real_shape, name='real') discriminator = sequential([ Dense(20, activation='relu', input_dim=2, name='d1'), Dense(1, activation='sigmoid', name='d2') ])(concat([fake, real], axis=0)) return GAN(Container(z, generator), Container([fake, real], gan_outputs(discriminator)), simple_gan_z_shape[1:], simple_gan_real_shape[1:])
def m(): x = Input(shape=(input_size + output_size, nb_chars)) m_realness = sequential([ LSTM(14), Dense(1, activation='sigmoid'), ])(x) m = Model([x], [m_realness]) m.compile(Adam(), 'mse') return m
def m(): x = Input(shape=(input_size + output_size, nb_chars)) m_realness = sequential([ LSTM(14), Dense(1, activation='sigmoid'), ])(x) m = Model([x], [m_realness]) m.compile(Adam(), 'mse') return m
def get_mask_postprocess(inputs, nb_units): n = nb_units return sequential([ conv(n, 3, 3), conv(n, 3, 3), Deconvolution2D(1, 5, 5, border_mode=(2, 2)), LinearInBounds(-1, 1, clip=True), ], ns='mask_post')(concat(inputs))
def get_mask_weight_blending(inputs, min=0, max=2): input = concat(inputs) return sequential([ Convolution2D(1, 3, 3), Flatten(), Dense(1), LinearInBounds(K.variable(min), K.variable(2), clip=True), ], ns='mask_weight_blending')(input)
def mask_generator(input, nb_units=64, dense_factor=3, nb_dense_layers=2, depth=2, nb_output_channels=1, trainable=True): n = nb_units def conv(n, repeats=1): return [ [ Convolution2D(n, 3, 3, border_mode='same', init='he_normal'), Activation('relu') ] for _ in range(repeats) ] dense_layers = [ Dense(dense_factor*nb_units, activation='relu') for _ in range(nb_dense_layers)] base = sequential(dense_layers + [ Dense(8*n*4*4), Activation('relu'), Reshape((8*n, 4, 4,)), conv(8*n), UpSampling2D(), # 8x8 conv(4*n, depth), UpSampling2D(), # 16x16 conv(2*n), ], ns='mask_gen.base', trainable=trainable)(input) mask = sequential([ conv(2*n, depth), UpSampling2D(), # 32x32 conv(n, 2), UpSampling2D(), # 64x64 conv(n, 1), Convolution2D(1, 3, 3, border_mode='same', init='he_normal'), ], ns='mask_gen.mask', trainable=trainable)(base) depth_map = sequential([ conv(n // 2, depth - 1), Convolution2D(1, 3, 3, border_mode='same', init='he_normal'), ], ns='mask_gen.depth_map', trainable=trainable)(base) return mask, depth_map
def mask_generator_extra(input, nb_units=64, nb_dense=[256, 1024], depth=2, project_factor=1, filter_size=3): n = nb_units def conv(n, repeats=1): return [ [ Convolution2D(n, filter_size, filter_size, border_mode='same', init='he_normal'), Activation('relu') ] for _ in range(repeats) ] dense_layers = [] for nb in nb_dense: dense_layers.append( Dense(nb, init='he_normal', activation='relu') ) base = sequential(dense_layers + [ Dense(8*n*4*4*project_factor), Activation('relu'), Reshape((8*n*project_factor, 4, 4,)), conv(8*n, depth), UpSampling2D(), # 8x8 conv(4*n, depth), UpSampling2D(), # 16x16 conv(2*n), ], ns='mask_gen.base')(input) mask = sequential([ conv(2*n, depth), UpSampling2D(), # 32x32 conv(n, depth), UpSampling2D(), # 64x64 conv(n, depth - 1), Convolution2D(1, 5, 5, border_mode='same', init='he_normal'), ], ns='mask_gen.mask')(base) depth_map = sequential([ conv(n // 2, depth - 1), Convolution2D(1, 3, 3, border_mode='same', init='he_normal'), ], ns='mask_gen.depth_map')(base) return mask, depth_map
def get_offset_middle(inputs, nb_units): n = nb_units input = concat(inputs) return sequential( [ UpSampling2D(), # 32x32 conv(2 * n, 3, 3), conv(2 * n, 3, 3), conv(2 * n, 3, 3), ], ns='offset.middle')(input)
def test_sequential(): x = Input(shape=(20,)) seq = sequential([ Dense(20), Dense(10), Dense(1), ]) out = seq(x) model = Model([x], [out]) model.compile('adam', 'mse') model.predict_on_batch(np.random.sample((64, 20)))
def mask_generator_all_conv(input, nb_units=64, depth=2, filter_size=3): n = nb_units def conv(n, repeats=1, f=None): if f is None: f = filter_size return [ [ Convolution2D(n, f, f, border_mode='same', init='he_normal'), Activation('relu') ] for _ in range(repeats) ] base = sequential([ Reshape((22, 1, 1,)), conv(8*n, depth, f=1), UpSampling2D(), # 2x2 conv(8*n, depth, f=2), UpSampling2D(), # 4x4 conv(8*n, depth), UpSampling2D(), # 8x8 conv(4*n, depth), UpSampling2D(), # 16x16 conv(2*n), ], ns='mask_gen.base')(input) mask = sequential([ conv(2*n, depth), UpSampling2D(), # 32x32 conv(n, depth), UpSampling2D(), # 64x64 conv(n, depth - 1), Convolution2D(1, 3, 3, border_mode='same', init='he_normal'), ], ns='mask_gen.mask')(base) depth_map = sequential([ conv(n // 2, depth - 1), Convolution2D(1, 3, 3, border_mode='same', init='he_normal'), ], ns='mask_gen.depth_map')(base) return mask, depth_map
def test_sequential_namespace(): x = Input(shape=(20, )) dense1 = Dense(20) dense2 = Dense(10) dense3 = Dense(1) seq = sequential([ dense1, dense2, dense3, ], ns='hello') seq(x) assert dense1.name.startswith('hello.') assert dense2.name.startswith('hello.') assert dense3.name.startswith('hello.')
def test_sequential_enumerate(): x = Input(shape=(20, )) dense1 = Dense(20) dense2 = Dense(10) dense3 = Dense(1) seq = sequential([ dense1, dense2, dense3, ], ns='hello') seq(x) assert dense1.name.endswith('hello.00_dense') assert dense2.name.endswith('hello.01_dense') assert dense3.name.endswith('hello.02_dense')
def g(): seq = Input(shape=(input_size, nb_chars)) z = Input(shape=(z_size,)) z_rep = RepeatVector(input_size)(z) seq_and_z = merge([seq, z_rep], mode='concat', concat_axis=-1) fake_prob = sequential([ LSTM(8), RepeatVector(output_size), LSTM(8, return_sequences=True), TimeDistributed(Dense(nb_chars, activation='softmax')), ])(seq_and_z) g = Model([z, seq], [fake_prob]) return g
def test_sequential_trainable(): x = Input(shape=(20,)) dense1 = Dense(20) dense2 = Dense(10) dense3 = Dense(1) seq = sequential([ dense1, dense2, dense3, ], trainable=False) seq(x) assert collect_trainable_weights(dense1) == [] assert collect_trainable_weights(dense2) == [] assert collect_trainable_weights(dense3) == []
def test_sequential_namespace(): x = Input(shape=(20,)) dense1 = Dense(20) dense2 = Dense(10) dense3 = Dense(1) seq = sequential([ dense1, dense2, dense3, ], ns='hello') seq(x) assert dense1.name.startswith('hello.') assert dense2.name.startswith('hello.') assert dense3.name.startswith('hello.')
def test_sequential_enumerate(): x = Input(shape=(20,)) dense1 = Dense(20) dense2 = Dense(10) dense3 = Dense(1) seq = sequential([ dense1, dense2, dense3, ], ns='hello') seq(x) assert dense1.name.endswith('hello.00_dense') assert dense2.name.endswith('hello.01_dense') assert dense3.name.endswith('hello.02_dense')
def test_sequential_trainable(): x = Input(shape=(20, )) dense1 = Dense(20) dense2 = Dense(10) dense3 = Dense(1) seq = sequential([ dense1, dense2, dense3, ], trainable=False) seq(x) assert collect_trainable_weights(dense1) == [] assert collect_trainable_weights(dense2) == [] assert collect_trainable_weights(dense3) == []
def g(): seq = Input(shape=(input_size, nb_chars)) z = Input(shape=(z_size, )) z_rep = RepeatVector(input_size)(z) seq_and_z = merge([seq, z_rep], mode='concat', concat_axis=-1) fake_prob = sequential([ LSTM(8), RepeatVector(output_size), LSTM(8, return_sequences=True), TimeDistributed(Dense(nb_chars, activation='softmax')), ])(seq_and_z) g = Model([z, seq], [fake_prob]) return g
def get_offset_front(inputs, nb_units): n = nb_units input = concat(inputs) return sequential([ Dense(8*n*4*4), BatchNormalization(), Activation('relu'), Reshape((8*n, 4, 4)), UpSampling2D(), # 8x8 conv(4*n, 3, 3), conv(4*n, 3, 3), UpSampling2D(), # 16x16 conv(2*n, 3, 3), conv(2*n, 3, 3), ], ns='offset.front')(input)
def get_mask_driver(x, nb_units, nb_output_units): n = nb_units driver = sequential([ Dense(n), BatchNormalization(), Dropout(0.25), Activation('relu'), Dense(n), BatchNormalization(), Dropout(0.25), Activation('relu'), Dense(nb_output_units), BatchNormalization(gamma_init=constant_init(0.25)), LinearInBounds(-1, 1, clip=True), ], ns='driver') return driver(x)
def mask_blending_discriminator(x, n=32, out_activation='sigmoid'): def conv(n): return [ Convolution2D(n, 5, 5, subsample=(2, 2), border_mode='same'), BatchNormalization(), LeakyReLU(0.2), ] return sequential([ Convolution2D(n, 5, 5, subsample=(2, 2), border_mode='same'), LeakyReLU(0.2), conv(2*n), conv(4*n), conv(8*n), Flatten(), Dense(1, activation=out_activation) ], ns='dis')(concat(x, axis=0, name='concat_fake_real'))
def get_mask_driver(x, nb_units, nb_output_units): n = nb_units driver = sequential([ Dense(n), BatchNormalization(), Dropout(0.25), Activation('relu'), Dense(n), BatchNormalization(), Dropout(0.25), Activation('relu'), Dense(nb_output_units), BatchNormalization(), LinearInBounds(-1, 1), ], ns='driver') return driver(x)
def get_offset_front(inputs, nb_units): n = nb_units input = concat(inputs) return sequential( [ Dense(8 * n * 4 * 4), BatchNormalization(), Activation('relu'), Reshape((8 * n, 4, 4)), UpSampling2D(), # 8x8 conv(4 * n, 3, 3), conv(4 * n, 3, 3), UpSampling2D(), # 16x16 conv(2 * n, 3, 3), conv(2 * n, 3, 3), ], ns='offset.front')(input)
def mask_blending_discriminator(x, n=32, out_activation='sigmoid'): def conv(n): return [ Convolution2D(n, 5, 5, subsample=(2, 2), border_mode='same'), BatchNormalization(), LeakyReLU(0.2), ] return sequential([ Convolution2D(n, 5, 5, subsample=(2, 2), border_mode='same'), LeakyReLU(0.2), conv(2 * n), conv(4 * n), conv(8 * n), Flatten(), Dense(1, activation=out_activation) ], ns='dis')(concat(x, axis=0, name='concat_fake_real'))
def get_offset_merge_mask(input, nb_units, nb_conv_layers, poolings=None, ns=None): def conv_layers(units, pooling): layers = [Convolution2D(units, 3, 3, border_mode='same')] if pooling: layers.append(MaxPooling2D()) layers.extend([ BatchNormalization(axis=1), Activation('relu'), ]) return layers if poolings is None: poolings = [False] * nb_conv_layers if type(nb_units) == int: nb_units = [nb_units] * nb_conv_layers layers = [] for i, (units, pooling) in enumerate(zip(nb_units, poolings)): layers.extend(conv_layers(units, pooling)) return sequential(layers, ns=ns)(input)
def get_lighting_generator(inputs, nb_units): n = nb_units input = concat(inputs) light_conv = sequential([ conv(n, 5, 5), conv(n, 5, 5), conv(n, 3, 3), UpSampling2D(), # 32x32 conv(n, 5, 5), Convolution2D(2, 1, 1, border_mode='same'), UpSampling2D(), # 64x64 LinearInBounds(-1, 1, clip=True), GaussianBlur(sigma=4), ], ns='lighting')(input) shift = Split(0, 1, axis=1)(light_conv) scale = Split(1, 2, axis=1)(light_conv) return shift, scale
def mask_generator(input, nb_units=64, dense_factor=3, nb_dense_layers=2, trainable=True): n = nb_units def conv(n): return [ Convolution2D(n, 3, 3, border_mode='same', init='he_normal'), Activation('relu'), ] dense_layers = [ Dense(dense_factor * nb_units, activation='relu') for _ in range(nb_dense_layers) ] return sequential( dense_layers + [ Dense(8 * n * 4 * 4), Activation('relu'), Reshape(( 8 * n, 4, 4, )), UpSampling2D(), # 8x8 conv(4 * n), conv(4 * n), UpSampling2D(), # 16x16 conv(2 * n), conv(2 * n), UpSampling2D(), # 32x32 conv(n), UpSampling2D(), # 64x64 conv(n), Convolution2D(1, 3, 3, border_mode='same', init='he_normal'), Activation('linear'), ], ns='mask_gen', trainable=trainable)(input)
def get_lighting_generator(inputs, nb_units): n = nb_units input = concat(inputs) light_conv = sequential( [ conv(n, 5, 5), conv(n, 5, 5), conv(n, 3, 3), UpSampling2D(), # 32x32 conv(n, 5, 5), Convolution2D(2, 1, 1, border_mode='same'), UpSampling2D(), # 64x64 LinearInBounds(-1, 1, clip=True), GaussianBlur(sigma=4), ], ns='lighting')(input) shift = Split(0, 1, axis=1)(light_conv) scale = Split(1, 2, axis=1)(light_conv) return shift, scale
def get_offset_merge_mask(input, nb_units, nb_conv_layers, poolings=None, ns=None): def conv_layers(units, pooling): layers = [Convolution2D(units, 3, 3, border_mode='same')] if pooling: layers.append(MaxPooling2D()) layers.extend([ BatchNormalization(axis=1), Activation('relu'), ]) return layers if poolings is None: poolings = [False] * nb_conv_layers if type(nb_units) == int: nb_units = [nb_units] * nb_conv_layers layers = [] for i, (units, pooling) in enumerate(zip(nb_units, poolings)): layers.extend(conv_layers(units, pooling)) return sequential(layers, ns=ns)(input)
def discriminator_fn(x): return gan_outputs(sequential([ Flatten(), Dense(1), ])(concat(x)), fake_for_gen=(0, 10), fake_for_dis=(0, 10), real=(10, 20))
def offset_front(x): return sequential([ Dense(16), Reshape((1, 4, 4)), UpSampling2D((4, 4)) ])(concat(x))
def offset_back(x): feature_map = sequential([ UpSampling2D(), ])(concat(x)) return feature_map, Convolution2D(1, 3, 3, border_mode='same')(feature_map)
def mask_post(x): return sequential([ Convolution2D(1, 3, 3, border_mode='same') ])(concat(x))
def mask_weight_blending(x): return sequential([ Flatten(), Dense(1), ])(x)