def create_generation_evaluator_model(base_embedding_layer, gen_units,
embedding_dim, seq_len, vocab_size):
input_y = Input(shape=(seq_len, ))
embedding_layer = Embedding(input_dim=vocab_size, output_dim=embedding_dim)
x = embedding_layer(input_y) # (batch, seq_len, embedding_dim)
x = Bidirectional(
GRU(
gen_units, # dropout=0.5, recurrent_dropout=0.5,
return_sequences=True,
recurrent_initializer='glorot_uniform'))(x)
x = Bidirectional(
GRU(
gen_units, # dropout=0.25, recurrent_dropout=0.0,
recurrent_initializer='glorot_uniform'))(x)
x = Dense(gen_units)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Dense(1)(x)
model = Model(inputs=input_y, outputs=x)
embedding_weights = [var.numpy() for var in base_embedding_layer.weights]
embedding_layer.set_weights(embedding_weights)
embedding_layer.trainable = False
return model
def define_generator(latent_dim, n_classes=3):
print("********** ENTERED generator *****************")
##### foundation for labels
in_label = Input(shape=(1, ))
embedding_layer = Embedding(n_classes, 8)
embedding_layer.trainable = True
li = embedding_layer(in_label)
n_nodes = 5 * 5
li = Dense(n_nodes)(li)
li = Reshape((5, 5, 1))(li)
print("generator... n_nodes, li.shape: ", n_nodes, li.shape)
##### foundation for 5x5 image
in_lat = Input(shape=(latent_dim, ))
n_nodes = 128 * 5 * 5
genX = Dense(n_nodes)(in_lat)
genX = LeakyReLU(alpha=0.2)(genX)
genX = Reshape((5, 5, 128))(genX)
dropout = 0.1
print("genX.shape: ", genX.shape)
##### merge image gen and label input
merge = Concatenate()([genX, li])
print("merge.shape: ", merge.shape)
##### create merged model
# upsample to 10x10
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(merge)
print("gen after CV2DT.shape: ", gen.shape)
gen = LeakyReLU(alpha=0.2)(gen)
gen = Dropout(dropout)(gen)
print("gen.shape: ", gen.shape)
# upsample to 20x20
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(gen)
gen = LeakyReLU(alpha=0.2)(gen)
print("gen.shape: ", gen.shape)
# upsample to 40x40
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(gen)
gen = LeakyReLU(alpha=0.2)(gen)
print("gen.shape: ", gen.shape)
# upsample to 80x80
gen = Conv2DTranspose(128, (4, 4), strides=(2, 2), padding='same')(gen)
gen = LeakyReLU(alpha=0.2)(gen)
print("gen.shape: ", gen.shape)
# output layer 80x80x3
out_layer = Conv2D(3, (5, 5), activation='tanh', padding='same')(gen)
print("out_layer.shape: ", out_layer.shape)
# define model
model = Model(inputs=[in_lat, in_label], outputs=out_layer)
opt = Adamax(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=10e-8)
model.compile(loss=['binary_crossentropy'], optimizer=opt)
print("\nembedding_layer.get_weights(): \n", embedding_layer.get_weights())
model.summary()
plot_model(model, to_file='cgan/generator_model.png')
return model
def tranferModel(nmt_base_model,
en_len,
fr_len,
MAX_VOCAB,
ENC_EMB_DIM,
DEC_EMB_DIM,
HID_DIM,
EMB_TRAIN=True,
GRU_LAYER=True,
is_trainable=False):
fr_vocab = en_vocab = MAX_VOCAB
en_inputs = Input(shape=(en_len, ), name='en_inputs')
tr_en_emb_layer = Embedding(en_vocab + 1,
ENC_EMB_DIM,
input_length=en_len,
trainable=EMB_TRAIN,
name='en_emb')
tr_en_emb = tr_en_emb_layer(en_inputs)
tr_en_emb_masked = Masking(name='en_emb_mask')(tr_en_emb) ###
if GRU_LAYER:
tr_en_gru = GRU(HID_DIM, return_state=True, dropout=0.5, name='en_gru')
en_out, en_state = tr_en_gru(tr_en_emb_masked)
else:
tr_en_gru = LSTM(HID_DIM,
return_state=True,
dropout=0.5,
name='en_lstm')
en_out, en_state, en_carry = tr_en_gru(tr_en_emb_masked)
if not is_trainable:
tr_en_emb_layer.trainable = False
tr_en_gru.trainable = False
de_inputs = Input(shape=(fr_len - 1, ), name='de_inputs')
tr_de_emb_layer = Embedding(fr_vocab + 1,
DEC_EMB_DIM,
input_length=fr_len - 1,
trainable=EMB_TRAIN,
name='de_emb')
tr_de_emb = tr_de_emb_layer(de_inputs)
tr_de_emb_masked = Masking(name='de_emb_mask')(tr_de_emb) ###
if GRU_LAYER:
tr_de_gru = GRU(HID_DIM,
return_sequences=True,
return_state=True,
dropout=0.5,
name='de_gru')
de_out, _ = tr_de_gru(tr_de_emb_masked, initial_state=en_state)
else:
tr_de_gru = LSTM(HID_DIM,
return_sequences=True,
return_state=True,
dropout=0.5,
name='de_lstm')
de_out, _, _ = tr_de_gru(tr_de_emb_masked,
initial_state=[en_state, en_carry])
tr_de_dense_0 = TimeDistributed(Dense(HID_DIM,
activation='relu',
name='de_dense_0'),
name='de_timedense_0') # fr_vocab
tr_de_dense_0_output = tr_de_dense_0(de_out) ###
tr_de_dense_1 = Dense(fr_vocab, activation='softmax',
name='de_dense_1') # trainable
de_pred = TimeDistributed(tr_de_dense_1,
name='de_timedense_1')(tr_de_dense_0_output)
if not is_trainable:
tr_de_emb_layer.trainable = False
tr_de_gru.trainable = False
tr_de_dense_0.trainable = False
# Define the new transfer learning model which accepts encoder/decoder inputs and outputs predictions
nmt_emb = Model(inputs=[en_inputs, de_inputs],
outputs=de_pred,
name='transfer_learning_model')
return nmt_emb, en_inputs, tr_en_emb_layer, tr_en_gru, en_state, \
de_inputs, tr_de_emb_layer, tr_de_gru, tr_de_dense_0, tr_de_dense_1