def build_model(dist: Union[Distribution, PixelCNN], input_shape: tuple = None, filepath: str = None) \
-> Tuple[tf.keras.Model, Union[Distribution, PixelCNN]]:
"""
Create tf.keras.Model from TF distribution.
Parameters
----------
dist
TensorFlow distribution.
input_shape
Input shape of the model.
filepath
File to load model weights from.
Returns
-------
TensorFlow model.
"""
x_in = Input(shape=input_shape)
log_prob = dist.log_prob(x_in)
model = Model(inputs=x_in, outputs=log_prob)
model.add_loss(-tf.reduce_mean(log_prob))
if isinstance(filepath, str):
model.load_weights(filepath)
return model, dist
def _build_model(self):
sequence_source_id = Input([900], name='source_id', dtype=tf.int32)
sequence_target_id = Input([200], name='target_id', dtype=tf.int32)
sequence_target_mask = Input([200], name='target_mask', dtype=tf.int32)
self.encoder = Encoder(self.vocab_size, self.emb_dim,
self.dropout_keep, self.encode_dim,
self.n_agents, self.encoder_layers_num,
self.batch_size)
self.decode = Decoder(self.mode, self.attention_units, self.encode_dim,
self.decode_len, self.vocab_size, self.emb_dim,
self.batch_size, self.word2id)
self.softmax = Softmax(axis=-1)
encoder_outputs = self.encoder(sequence_source_id)
# encoder_outputs = Concatenate(encoder_outputs, axis=1)
decoder_output = self.decode(sequence_target_id, encoder_outputs)
print('##########', encoder_outputs)
print('##########', decoder_output.shape)
# decoder_output = Lambda(lambda x:tf.unstack(x))(decoder_output)
vocab_dists = self.softmax(decoder_output)
self.loss = Seq2SeqLoss(sequence_target_mask, self.batch_size)
model = Model([sequence_source_id, sequence_target_id], vocab_dists)
loss = losses(self.decode_len, sequence_target_mask, self.batch_size,
vocab_dists, sequence_target_id)
model.add_loss(loss)
model.compile(Adam(self.learning_rate))
return model
def compile(self):
x = Input(shape=(self.input_dim, ), name="input")
latent_dim = self.layer_sizes[-1]
encoder = self.make_encoder()
decoder = self.make_decoder()
sampling_layer = Lambda(sampling_func,
output_shape=(latent_dim, ),
name="sampling_layer")
z_mean, z_log_var = encoder(x)
z = sampling_layer([z_mean, z_log_var])
x_decoded_mean = decoder(z)
model = Model(inputs=x, outputs=x_decoded_mean)
if self.recons_type == "xent":
recons_loss = self.input_dim * metrics.binary_crossentropy(
Flatten()(x),
Flatten()(x_decoded_mean))
elif self.recons_type == "mse":
recons_loss = metrics.mse(x, x_decoded_mean)
kl_loss = -0.5 * tf.reduce_sum(
1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=-1)
vae_loss = tf.reduce_mean(recons_loss + self.beta * kl_loss)
model.add_loss(vae_loss)
adam = Adam(learning_rate=self.learning_rate)
model.compile(optimizer=adam)
self.model = model
self.encoder = encoder
self.decoder = decoder
def build_model(hp):
params = hp.copy()
params['e_dim'] = params['dim']
params['r_dim'] = params['dim']
params['name'] = 'embedding_model'
embedding_model = models[params['embedding_model']]
embedding_model = embedding_model(**params)
triple = Input((3, ))
ftriple = Input((3, ))
inputs = [triple, ftriple]
score = embedding_model(triple)
fscore = embedding_model(ftriple)
loss_function = loss_function_lookup(params['loss_function'])
loss = loss_function(score, fscore, params['margin'] or 1, 1)
model = Model(inputs=inputs, outputs=loss)
model.add_loss(loss)
model.compile(optimizer='adam', loss=None)
return model
def get_model(feature_extractor, rpn_model, anchors, hyper_params, mode="training"):
"""Generating rpn model for given backbone base model and hyper params.
inputs:
feature_extractor = feature extractor layer from the base model
rpn_model = tf.keras.model generated rpn model
anchors = (total_anchors, [y1, x1, y2, x2])
these values in normalized format between [0, 1]
hyper_params = dictionary
mode = "training" or "inference"
outputs:
frcnn_model = tf.keras.model
"""
input_img = rpn_model.input
rpn_reg_predictions, rpn_cls_predictions = rpn_model.output
#
roi_bboxes = RoIBBox(anchors, mode, hyper_params, name="roi_bboxes")([rpn_reg_predictions, rpn_cls_predictions])
#
roi_pooled = RoIPooling(hyper_params, name="roi_pooling")([feature_extractor.output, roi_bboxes])
#
output = TimeDistributed(Flatten(), name="frcnn_flatten")(roi_pooled)
output = TimeDistributed(Dense(4096, activation="relu"), name="frcnn_fc1")(output)
output = TimeDistributed(Dropout(0.5), name="frcnn_dropout1")(output)
output = TimeDistributed(Dense(4096, activation="relu"), name="frcnn_fc2")(output)
output = TimeDistributed(Dropout(0.5), name="frcnn_dropout2")(output)
frcnn_cls_predictions = TimeDistributed(Dense(hyper_params["total_labels"], activation="softmax"), name="frcnn_cls")(output)
frcnn_reg_predictions = TimeDistributed(Dense(hyper_params["total_labels"] * 4, activation="linear"), name="frcnn_reg")(output)
#
if mode == "training":
input_gt_boxes = Input(shape=(None, 4), name="input_gt_boxes", dtype=tf.float32)
input_gt_labels = Input(shape=(None, ), name="input_gt_labels", dtype=tf.int32)
rpn_cls_actuals = Input(shape=(None, None, hyper_params["anchor_count"]), name="input_rpn_cls_actuals", dtype=tf.float32)
rpn_reg_actuals = Input(shape=(None, 4), name="input_rpn_reg_actuals", dtype=tf.float32)
frcnn_reg_actuals, frcnn_cls_actuals = RoIDelta(hyper_params, name="roi_deltas")(
[roi_bboxes, input_gt_boxes, input_gt_labels])
#
loss_names = ["rpn_reg_loss", "rpn_cls_loss", "frcnn_reg_loss", "frcnn_cls_loss"]
rpn_reg_loss_layer = Lambda(train_utils.reg_loss, name=loss_names[0])([rpn_reg_actuals, rpn_reg_predictions])
rpn_cls_loss_layer = Lambda(train_utils.rpn_cls_loss, name=loss_names[1])([rpn_cls_actuals, rpn_cls_predictions])
frcnn_reg_loss_layer = Lambda(train_utils.reg_loss, name=loss_names[2])([frcnn_reg_actuals, frcnn_reg_predictions])
frcnn_cls_loss_layer = Lambda(train_utils.frcnn_cls_loss, name=loss_names[3])([frcnn_cls_actuals, frcnn_cls_predictions])
#
frcnn_model = Model(inputs=[input_img, input_gt_boxes, input_gt_labels,
rpn_reg_actuals, rpn_cls_actuals],
outputs=[roi_bboxes, rpn_reg_predictions, rpn_cls_predictions,
frcnn_reg_predictions, frcnn_cls_predictions,
rpn_reg_loss_layer, rpn_cls_loss_layer,
frcnn_reg_loss_layer, frcnn_cls_loss_layer])
#
for layer_name in loss_names:
layer = frcnn_model.get_layer(layer_name)
frcnn_model.add_loss(layer.output)
frcnn_model.add_metric(layer.output, name=layer_name, aggregation="mean")
#
else:
bboxes, labels, scores = Decoder(hyper_params["variances"], hyper_params["total_labels"], name="faster_rcnn_decoder")(
[roi_bboxes, frcnn_reg_predictions, frcnn_cls_predictions])
frcnn_model = Model(inputs=input_img, outputs=[bboxes, labels, scores])
#
return frcnn_model
def get_model(self):
"""create triplet model
Use pretrained model, MobileNetV2
Returns: tupple
embedding model and model with triplet loss function
"""
base_model = MobileNetV2(input_shape=(224, 224, 3),
weights='imagenet',
include_top=False,
pooling='max')
for layer in base_model.layers:
layer.trainable = False
x = base_model.output
x = Dropout(0.6)(x)
x = Dense(EMBEDDING_DIM)(x)
x = Lambda(lambda x: K.l2_normalize(x, axis=1))(x)
embedding_model = Model(base_model.input, x, name='embedding')
input_shape = (IMAGE_SIZE, IMAGE_SIZE, 3)
anchor_input = Input(input_shape, name='anchor_input')
positive_input = Input(input_shape, name='positive_input')
negative_input = Input(input_shape, name='negative_input')
anchor_embedding = embedding_model(anchor_input)
positive_embedding = embedding_model(positive_input)
negative_embedding = embedding_model(negative_input)
inputs = [anchor_input, positive_input, negative_input]
outputs = [anchor_embedding, positive_embedding, negative_embedding]
triplet_model = Model(inputs, outputs)
triplet_model.add_loss(K.mean(self.triplet_loss(outputs)))
return embedding_model, triplet_model
def make_model(n_features, n_outputs, n_nodes=100, dropout_reg=1e-5, wd=0):
losses = []
inp = Input(shape=(n_features,))
x = inp
x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'),
weight_regularizer=wd, dropout_regularizer=dropout_reg)(x)
losses.append(loss)
x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'),
weight_regularizer=wd, dropout_regularizer=dropout_reg)(x)
losses.append(loss)
x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'),
weight_regularizer=wd, dropout_regularizer=dropout_reg)(x)
losses.append(loss)
mean, loss = ConcreteDropout(Dense(n_outputs), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x)
losses.append(loss)
log_var, loss = ConcreteDropout(Dense(n_outputs), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x)
losses.append(loss)
out = concatenate([mean, log_var])
model = Model(inp, out)
for loss in losses:
model.add_loss(loss)
model.compile(optimizer=optimizers.Adam(), loss=heteroscedastic_loss, metrics=[mse_loss])
assert len(model.layers[1].trainable_weights) == 3 # kernel, bias, and dropout prob
assert len(model.losses) == 5, f'{len(model.losses)} is not 5' # a loss for each Concrete Dropout layer
return model
class valiationalAutoencoder:
def __init__(self, input_dim, output_dim, batch_size, epochs):
self.batch_size = batch_size
self.input_dim = input_dim
self.output_dim = output_dim
self.epochs = epochs
inputs = Input(shape=(self.input_dim,), name='encoder_input')
x = Dense(1024, activation='relu')(inputs)
x = BatchNormalization()(x)
x = Dropout(0.3)(x)
x = Dense(512, activation='relu')(x)
x = BatchNormalization()(x)
x = Dropout(0.3)(x)
x = Dense(256, activation='relu')(x)
x = BatchNormalization()(x)
x = Dropout(0.3)(x)
z_mean = Dense(128, name='z_mean')(x)
z_log_var = Dense(128, name='z_log_var')(x)
z = Lambda(sampling, output_shape=(128,), name='z')([z_mean, z_log_var])
self.encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
# print(self.encoder.summary())
latent_inputs = Input(shape=(128,), name='z_sampling')
x = Dense(256, activation='relu')(latent_inputs)
x = BatchNormalization()(x)
x = Dropout(0.3)(x)
x = Dense(512, activation='relu')(x)
x = BatchNormalization()(x)
x = Dropout(0.3)(x)
x = Dense(1024, activation='relu')(x)
outputs = Dense(self.input_dim, activation='sigmoid')(x)
self.decoder = Model(latent_inputs, outputs, name='decoder')
# print(self.decoder.summary())
outputs = self.decoder(self.encoder(inputs)[2])
self.vae = Model(inputs, outputs, name='vae_mlp')
reconstruction_loss = mse(inputs, outputs)
reconstruction_loss *= self.input_dim
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
# kl_loss = K.sum(kl_loss, axis=-1)
kl_loss = K.mean(kl_loss, axis=-1)
# kl_loss *= -0.5
kl_loss *= -5e-4
vae_loss = K.mean(reconstruction_loss + kl_loss)
self.vae.add_loss(vae_loss)
self.vae.compile(optimizer='adam')
# print(self.vae.summary())
def train(self, X_train, model):
tb_hist = tensorflow.keras.callbacks.TensorBoard(log_dir='./graph_' + model, histogram_freq=1, write_graph=True, write_images=True)
model_path = './' + model + '.h5'#'{epoch:02d}-{val_loss:.4f}.h5'
cb_checkpoint = ModelCheckpoint(filepath=model_path, monitor='val_loss', verbose=1, save_best_only=True, save_format='tf')
history = self.vae.fit(X_train, batch_size=self.batch_size, epochs=self.epochs, verbose=1, shuffle=True, validation_split=0.2, callbacks=[tb_hist, cb_checkpoint])
return history
def gaussian_blindspot_network(input_shape, mode, reg_weight=0):
""" Create a variant of the Gaussian blindspot newtork.
input_shape: Shape of input image
mode: mse, uncalib, global, perpixel, poisson
mse -- regress to expected value using mean squared error loss
uncalib -- model prior and noise together with single Gaussian at each pixel
gaussian -- Gaussian noise
poisson -- Poisson noise
poissongaussian -- Poisson-Gaussian noise
reg_weight: strength of regularization on prior std. dev.
"""
# create input layer
inputs = Input(input_shape)
# run blindspot network
x = blindspot_network(inputs)
# get prior parameters
loc = Conv2D(1, 1, kernel_initializer='he_normal', name='loc')(x)
if mode != 'mse':
std = Conv2D(1, 1, kernel_initializer='he_normal', name='std')(x)
# get noise variance
if mode == 'mse':
pass
elif mode == 'uncalib':
pass
elif mode == 'gaussian':
noise_std = GaussianLayer()([])
elif mode == 'poisson':
noise_std = PoissonLayer()(loc)
elif mode == 'poissongaussian':
noise_std = PoissonGaussianLayer()(loc)
else:
raise ValueError('unknown mode %s' % mode)
# get outputs
if mode == 'mse':
outputs = loc
elif mode == 'uncalib':
outputs = [loc, std]
else:
outputs = Lambda(lambda x: gaussian_posterior_mean(*x))(
[inputs, loc, std, noise_std])
# create model
model = Model(inputs=inputs, outputs=outputs)
# create loss function
# input is evaluated against output distribution
if mode == 'mse':
loss = mse_loss(inputs, loc)
elif mode == 'uncalib':
loss = uncalib_gaussian_loss(inputs, loc, std)
else:
loss = gaussian_loss(inputs, loc, std, noise_std, reg_weight)
model.add_loss(loss)
return model
def construct_model(embedding_dim,
initial_model=None,
learning_rate=None,
margin=None):
inputs = Input(shape=(data.H, data.W, 3), name='inputs')
conv = Conv2D(filters=16,
kernel_size=5,
strides=2,
padding='same',
activation='elu')(inputs)
conv = Conv2D(filters=32,
kernel_size=3,
strides=2,
padding='same',
activation='elu')(conv)
conv = Conv2D(filters=32,
kernel_size=3,
strides=2,
padding='same',
activation='elu')(conv)
conv = Conv2D(filters=32,
kernel_size=3,
strides=2,
padding='same',
activation='elu')(conv)
mlp = Flatten()(conv)
mlp = Dropout(rate=0.5)(mlp)
mlp = Dense(units=64, activation='elu')(mlp)
embeddings = Dense(units=embedding_dim, activation=None,
name='embedding')(mlp)
embeddings = NormaliseLayer()(embeddings)
model = Model(inputs=inputs, outputs=embeddings)
print(model.summary())
if initial_model is not None:
model.load_weights(initial_model)
# use setting of learning_rate (and margin) to denote if
# we should compile also
if learning_rate is None:
# inference only
return model
else:
assert margin is not None
# use custom loss function since we have no y_true
# (wrap it in an object as a cleaner way of tracking the internal ops we'll probe)
loss_fn = TripletLoss(embeddings, embedding_dim, margin)
model.add_loss(loss_fn.triplet_loss())
model.compile(optimizer=optimizers.Adam(lr=learning_rate), loss=None)
# for the training model we'll use the model as well as the inputs
# & the loss_fn so we can feed directly from inputs -> elements
# in loss for summaries.
return model, inputs, loss_fn
def build_cvae(z_dim = 8,
inter_dim = 256,
seq_length = 128,
n_features = 13):
inputs = Input(shape=(seq_length,n_features))
x_encoded = Conv1D(inter_dim, 3, padding='same', activation='relu')(inputs)
x_encoded = MaxPooling1D(pool_size=2, padding='same')(x_encoded)
x_encoded = Dropout(0.5)(x_encoded)
x_encoded = Conv1D(inter_dim, 3, padding='same', activation='relu')(x_encoded)
x_encoded = MaxPooling1D(pool_size=2, padding='same')(x_encoded)
x_encoded = BatchNormalization()(x_encoded)
x_encoded = Conv1D(inter_dim, 3, padding='same', activation='relu')(x_encoded)
x_encoded = MaxPooling1D(pool_size=2, padding='same')(x_encoded)
x_encoded = Dropout(0.5)(x_encoded)
x_encoded = Flatten()(x_encoded)
x_encoded = Dense(500, activation='relu')(x_encoded)
x_encoded = Dropout(0.5)(x_encoded)
x_encoded = Dense(25, activation='relu')(x_encoded)
mu = Dense(z_dim, activation='linear')(x_encoded)
log_var = Dense(z_dim, activation='linear')(x_encoded)
z = Lambda(sampling, output_shape=(z_dim,))([mu, log_var])
encoder = Model(inputs, [mu, log_var, z], name='encoder')
latent_inputs = Input(shape=(z_dim,))
z_decoder = Dense(z_dim, activation='relu')(latent_inputs)
z_decoder = Dense(25, activation='relu')(z_decoder)
z_decoder = Dense(500, activation='relu')(z_decoder)
z_decoder = Dense(int(seq_length/8)*inter_dim, activation='relu')(z_decoder)
z_decoder = Reshape((int(seq_length/8), inter_dim))(z_decoder)
z_decoder = UpSampling1D(2)(z_decoder)
z_decoder = Conv1D(inter_dim,3,padding='same', activation='relu')(z_decoder)
z_decoder = UpSampling1D(2)(z_decoder)
z_decoder = Conv1D(inter_dim,3,padding='same', activation='relu')(z_decoder)
z_decoder = UpSampling1D(2)(z_decoder)
z_decoder = Conv1D(inter_dim,3,padding='same', activation='relu')(z_decoder)
# No activation
decoder_output = Dense(n_features, activation='relu')(z_decoder)
decoder = Model(latent_inputs, decoder_output, name='decoder')
outputs = decoder(encoder(inputs)[2])
# build model
cvae = Model(inputs, outputs)
# loss
reconstruction_loss = tf.reduce_mean(binary_crossentropy(inputs, outputs)) * (seq_length*n_features)
kl_loss = 1 + log_var - tf.square(mu) - tf.exp(log_var)
kl_loss = tf.reduce_mean(kl_loss)
kl_loss *= -0.5
total_loss = reconstruction_loss + kl_loss
# build model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.0005)
cvae.add_loss(total_loss)
cvae.compile(optimizer='rmsprop')
return encoder, decoder, cvae
def build_vae(input_shape):
'''
Arguments:
input_shape(tuple): the shape of input images (H, W, C)
Returns:
encoder, decoder, autoencoder models
'''
def build_encoder(input_shape, latent_dim):
inputs = Input(input_shape)
x = Conv2D(256, 4, strides=2, padding='same', activation='relu')(inputs)
x = Conv2D(128, 4, strides=2, padding='same', activation='relu')(x)
x = Conv2D(64, 4, strides=2, padding='same', activation='relu')(x)
# x = Conv2D(64, 4, strides=2, padding='same', activation='relu')(x)
x = Flatten()(x)
mean = Dense(latent_dim)(x)
logvar = Dense(latent_dim)(x)
epsilon = K.random_normal(K.shape(mean))
z = mean + K.exp(0.5 * logvar) * epsilon
encoder = Model(inputs, [z, mean, logvar], name='encoder')
return encoder
def build_decoder(latent_dim):
decoder = Sequential([
Dense(4* 4* 64, activation='relu', input_shape=(latent_dim,)),
Reshape((4, 4, 64)),
# Conv2DTranspose(128, 4, strides=2, padding='same', activation='relu'),
Conv2DTranspose(64, 4, strides=2, padding='same', activation='relu'),
Conv2DTranspose(32, 4, strides=2, padding='same', activation='relu'),
Conv2DTranspose(3, 4, strides=2, padding='same', activation='sigmoid')
], name='decoder')
return decoder
latent_dim = 512
encoder = build_encoder(input_shape, latent_dim)
# encoder.summary()
decoder = build_decoder(latent_dim)
# decoder.summary()
inputs = Input(input_shape)
z, mean, logvar = encoder(inputs)
decoder_out = decoder(z)
autoencoder = Model(inputs, decoder_out)
bce_loss = K.sum(binary_crossentropy(inputs, decoder_out), axis=[1, 2])
kl_loss = -0.5 * K.sum(1 + logvar - K.square(mean) - K.exp(logvar), axis=-1)
vae_loss = K.mean(bce_loss + kl_loss)
autoencoder.add_loss(vae_loss)
autoencoder.add_metric(tf.reduce_mean(bce_loss), name='bce_sum', aggregation='mean')
autoencoder.add_metric(tf.reduce_mean(bce_loss) / input_shape[0] / input_shape[1], name='bce', aggregation='mean')
autoencoder.add_metric(tf.reduce_mean(kl_loss), name='KL', aggregation='mean')
autoencoder.compile(Adam(1e-3, decay=5e-4))
return encoder, decoder, autoencoder
def createVAE(decoder, encoder):
# We are saying that the decoder takes the last output of the encoder as the input
dec_out = decoder(encoder.outputs[2])
# Defining an end-to-end model with encoder inputs and decoder outputs
vae = Model(inputs=encoder.inputs, outputs=dec_out)
vae.summary()
# VAE loss comprises both crossentropy and KL divergence loss
vae.compile(loss='binary_crossentropy', optimizer='rmsprop')
vae.add_loss(kl_loss(encoder.outputs[0], encoder.outputs[1]))
return vae
def task_5_model(x_train, filters=16, n_latent=5, kernel_size=3):
inputs = Input(shape=x_train.shape[1:])
x = inputs
for i in range(2):
filters *= 2
x = Conv2D(filters,
kernel_size,
activation="relu",
strides=2,
padding="same")(x)
shape = K.int_shape(x)
x = Flatten()(x)
x = Dense(filters, activation="relu")(x)
z_mean = Dense(n_latent)(x)
z_log_var = Dense(n_latent)(x)
z = Lambda(sampling)([z_mean, z_log_var])
encoder = Model(inputs, [z_mean, z_log_var, z], name="encoder")
latent_inputs = Input(shape=(n_latent, ))
x = Dense(shape[1] * shape[2] * shape[3], activation="relu")(latent_inputs)
x = Reshape((shape[1], shape[2], shape[3]))(x)
for i in range(2):
x = Conv2DTranspose(filters,
kernel_size,
activation="relu",
strides=2,
padding="same")(x)
filters //= 2
outputs = Conv2DTranspose(filters=1,
kernel_size=kernel_size,
activation="sigmoid",
padding="same")(x)
decoder = Model(latent_inputs, outputs, name="decoder")
outputs = decoder(encoder(inputs)[2])
vae = Model(inputs, outputs)
reconstruction_loss = mse(K.flatten(inputs), K.flatten(outputs))
reconstruction_loss *= np.prod(x_train.shape[1:3])
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
vae_loss = K.mean(reconstruction_loss + kl_loss)
vae.add_loss(vae_loss)
return vae
class policy_model:
#input (state, state, state, state, action)
def __init__(self, innput_size, policy_lr, policy_clip=5):
ACTI = 'relu'
policy_lr = policy_lr
policy_clip = policy_clip
inputes = Input(shape=(innput_size * 4, ))
actions_true = Input(shape=[innput_size], name='actions_true')
advantages = Input(shape=[1], name='advantages')
_ = Dense(128, activation=ACTI)(inputes) #512
#_ = Dense(32, activation=ACTI)(_)
#_ = Dropout(0.1)(_)
#_ = Dense(256, activation=ACTI)(_)
#_ = Dropout(0.1)(_)
#_ = Dense(128, activation=ACTI)(_)
out_1 = Dense(innput_size, activation='softmax')(_)
#@tf.function
def custom_loss_old(y_true, y_pred, adv):
log_lik = K.log(y_true * (y_true - y_pred) + (1 - y_true) *
(y_true + y_pred))
#loss = 1 / (-K.mean(log_lik * adv, keepdims=True))
return K.mean(log_lik * adv, keepdims=True)
def custom_loss(y_true, y_pred, adv):
log_lik = K.log(y_true * (y_true - y_pred) + (1 - y_true) *
(y_true + y_pred))
loss = 1 / (-K.mean(log_lik * adv, keepdims=True))
return K.clip(loss, -0.5, 0.5)
#return loss
#self.policy.compile(optimizer=Adam(lr=1e-2), loss=custom_loss)
self.policy = Model(inputs=[inputes, actions_true, advantages],
outputs=[out_1])
self.policy.add_loss(custom_loss(actions_true, out_1, advantages))
self.policy.compile(optimizer=Adam(
lr=policy_lr)) # -3, -2 give NaN if value is -4, 8e-3
#self.policy.compile(optimizer=Adam(lr=1e-2), loss='mean_squared_error')
#self.policy.compile(optimizer=Adam(lr=1e-1), loss='mean_squared_error')
self.prediction = Model(inputs=inputes, outputs=[out_1])
#trro vi bruke monte carlo, kjor en heil episode foor trening
def partial_fit(self, x):
return self.policy.train_on_batch(x)
def partial_fit_two(self, x, y, adv):
adv = np.array(adv)
return self.policy.train_on_batch([x], y, sample_weight=adv)
def predict(self, x):
#print(f'x shape: {x.shape}')
return self.prediction.predict(
x=x)[0] #Why only take firse of 8 output :P
def build_vae(intermediate_dim=512, latent_dim=2):
"""
Build VAE
:param intermediate_dim: size of hidden layers of the encoder/decoder
:param latent_dim: latent space size
:returns tuple: the encoder, the decoder, and the full vae
"""
# encoder first
inputs = Input(shape=(image_size, ), name='encoder_input')
x = Dense(intermediate_dim, activation='relu')(inputs)
# latent mean and variance
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
# Reparameterization trick for random sampling
# Note the use of the Lambda layer
# At runtime, it will call the sampling function
z = Lambda(sampling, output_shape=(latent_dim, ),
name='z')([z_mean, z_log_var])
# full encoder encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
encoder.summary()
# decoder
latent_inputs = Input(shape=(latent_dim, ), name='z_sampling')
x = Dense(intermediate_dim, activation='relu')(latent_inputs)
outputs = Dense(image_size, activation='sigmoid')(x)
# full decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
# VAE model
outputs = decoder(encoder(inputs)[2])
vae = Model(inputs, outputs, name='vae')
# Loss function
# we start wit the reconstruction loss
reconstruction_loss = binary_crossentropy(inputs, outputs) * image_size
# next is the KL divergence
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = tf.keras.backend.sum(kl_loss, axis=-1)
kl_loss *= -0.5
# we combine them in a total loss
vae_loss = K.mean(reconstruction_loss + kl_loss)
vae.add_loss(vae_loss)
return encoder, decoder, vae
def make_model(loss_type,
n_features,
n_outputs,
n_nodes=400,
dropout_reg=1e-5,
wd=1e-3):
losses = []
inp = Input(shape=(n_features, ))
x = inp
x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'),
weight_regularizer=wd,
dropout_regularizer=dropout_reg)(x)
losses.append(loss)
x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'),
weight_regularizer=wd,
dropout_regularizer=dropout_reg)(x)
losses.append(loss)
x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'),
weight_regularizer=wd,
dropout_regularizer=dropout_reg)(x)
losses.append(loss)
if loss_type == MSE:
mean = Dense(100, activation='relu')(x)
final_mean = Dense(n_outputs, activation='linear')(mean)
model = Model(inp, final_mean)
learning_rate_fn = tf.keras.optimizers.schedules.PolynomialDecay(
1e-3, 500, 1e-5, power=0.5)
model.compile(
optimizer=optimizers.Adam(learning_rate=learning_rate_fn),
loss=mse_loss)
if loss_type == HETEROSCEDASTIC:
mean = Dense(100, activation='relu')(x)
final_mean = Dense(n_outputs, activation='linear')(mean)
log_var = Dense(100, activation='relu')(x)
final_log_var = Dense(n_outputs, activation='linear')(log_var)
out = concatenate([final_mean, final_log_var])
model = Model(inp, out)
for loss in losses:
model.add_loss(loss)
learning_rate_fn = tf.keras.optimizers.schedules.PolynomialDecay(
1e-3, 500, 1e-5, power=0.5)
model.compile(
optimizer=optimizers.Adam(learning_rate=learning_rate_fn),
loss=heteroscedastic_loss,
metrics=[mse_loss])
return model
def build_actor_con(self):
b_model = robot_khop_model()
#b_model.load_weights('gnn_khop_env3_share.h5', by_name=True)
advantage = Input(shape=(1, ))
old_prediction = Input(shape=(NUM_ACTIONS, ))
y_true = Input(shape=(NUM_ACTIONS, ))
model = Model(
inputs=[b_model.input, advantage, old_prediction, y_true],
outputs=[b_model.output])
model.add_loss(
proximal_policy_optimization_loss_con(advantage, old_prediction,
y_true, b_model.output))
model.compile(optimizer=Adam(learning_rate=Learning_rate))
return model
def _build_model(self):
"""Build VAE = encoder + decoder + vae_loss"""
# Build Encoder
inputs = Input(shape=(self.n_features_,))
# Input layer
layer = Dense(self.n_features_, activation=self.hidden_activation)(
inputs)
# Hidden layers
for neurons in self.encoder_neurons:
layer = Dense(neurons, activation=self.hidden_activation,
activity_regularizer=l2(self.l2_regularizer))(layer)
layer = Dropout(self.dropout_rate)(layer)
# Create mu and sigma of latent variables
z_mean = Dense(self.latent_dim)(layer)
z_log = Dense(self.latent_dim)(layer)
# Use parametrisation sampling
z = Lambda(self.sampling, output_shape=(self.latent_dim,))(
[z_mean, z_log])
# Instantiate encoder
encoder = Model(inputs, [z_mean, z_log, z])
if self.verbosity >= 1:
encoder.summary()
# Build Decoder
latent_inputs = Input(shape=(self.latent_dim,))
# Latent input layer
layer = Dense(self.latent_dim, activation=self.hidden_activation)(
latent_inputs)
# Hidden layers
for neurons in self.decoder_neurons:
layer = Dense(neurons, activation=self.hidden_activation)(layer)
layer = Dropout(self.dropout_rate)(layer)
# Output layer
outputs = Dense(self.n_features_, activation=self.output_activation)(
layer)
# Instatiate decoder
decoder = Model(latent_inputs, outputs)
if self.verbosity >= 1:
decoder.summary()
# Generate outputs
outputs = decoder(encoder(inputs)[2])
# Instantiate VAE
vae = Model(inputs, outputs)
vae.add_loss(self.vae_loss(inputs, outputs, z_mean, z_log))
vae.compile(optimizer=self.optimizer)
if self.verbosity >= 1:
vae.summary()
return vae, encoder, decoder
def create_implExModel(num_nodes,
num_edges,
embed_size=50,
n3_reg=1e-3,
learning_rate=5e-1,
num_negs=50,
alpha=1.,
beta=1.):
# Build complEx Model
sub_inputs = Input(shape=(), name='subject')
obj_inputs = Input(shape=(), name='object')
rel_inputs = Input(shape=(), name='relation')
cnt_inputs = Input(shape=(), name='count')
y_true_inputs = Input(shape=(), name='label')
inputs = {
"subject": sub_inputs,
"object": obj_inputs,
"relation": rel_inputs,
"count": cnt_inputs,
"label": y_true_inputs
}
node_layer = Embedding(input_dim=num_nodes,
output_dim=embed_size,
embeddings_initializer=GlorotUniform(),
name='node_embedding')
edge_layer = Embedding(input_dim=num_edges,
output_dim=embed_size,
embeddings_initializer=GlorotUniform(),
name='edge_embedding')
sub_embed = node_layer(sub_inputs)
rel_embed = edge_layer(rel_inputs)
obj_embed = node_layer(obj_inputs)
outputs = ComplExDotScore(n3_reg)([sub_embed, rel_embed, obj_embed])
model = Model(inputs, outputs, name='implEx')
# Compile implEx Model
wbce_loss = tf.nn.weighted_cross_entropy_with_logits(
y_true_inputs, outputs, num_negs) / num_negs
confidence = 1 + alpha * tf.math.log(1 + cnt_inputs / beta)
loss = K.sum(confidence * wbce_loss)
model.add_loss(loss)
model.add_metric(K.mean(wbce_loss), 'weighted_binarycrossentropy')
model.compile(optimizer=Adagrad(learning_rate))
return model
def build_dense_model(num_features):
""" Simple two layer MLP """
regression_target = layers.Input(shape=(1,), name='ground_truth')
feature_input = layers.Input(shape=(num_features,), name='feature_input')
encoder_output = layers.GaussianDropout(0.1)(feature_input)
encoder_output = layers.Dense(64, activation='tanh', name='encoder_hidden')(encoder_output)
encoder_output = layers.Dense(64, activation='tanh', name='encoder_hidden_2')(encoder_output)
z_mean, z_log_var = layers.Dense(LATENT_DIM, name='z_mean')(encoder_output), \
layers.Dense(LATENT_DIM, name='z_log_var')(encoder_output)
r_mean, r_log_var = layers.Dense(1, name='r_mean')(encoder_output), \
layers.Dense(1, name='r_log_var')(encoder_output)
# Sample latent and regression target
z = layers.Lambda(sampling, output_shape=(LATENT_DIM,), name='z')([z_mean, z_log_var])
r = layers.Lambda(sampling, output_shape=(1,), name='r')([r_mean, r_log_var])
# Latent generator
pz_mean = layers.Dense(LATENT_DIM,
kernel_constraint=constraints.unit_norm(),
name='pz_mean')(r)
encoder = Model([feature_input, regression_target],
[z_mean, z_log_var, z,
r_mean, r_log_var, r,
pz_mean],
name='encoder')
latent_input = layers.Input(shape=(LATENT_DIM,), name='decoder_input')
decoder_output = layers.Dense(64, activation='tanh', name='decoder_hidden')(latent_input)
decoder_output = layers.Dense(64, activation='tanh', name='decoder_hidden_2')(decoder_output)
decoder_output = layers.Dense(num_features, name='decoder_output')(decoder_output)
decoder = Model(latent_input, decoder_output, name='decoder')
encoder_decoder_output = decoder(encoder([feature_input, regression_target])[2])
vae = Model([feature_input, regression_target], encoder_decoder_output, name='vae')
# Manually write up losses
reconstruction_loss = mse(feature_input, encoder_decoder_output)
kl_loss = 1 + z_log_var - K.square(z_mean - pz_mean) - K.exp(z_log_var)
kl_loss = -0.5 * K.sum(kl_loss, axis=-1)
label_loss = tf.divide(0.5 * K.square(r_mean - regression_target), K.exp(r_log_var)) + 0.5 * r_log_var
vae_loss = K.mean(reconstruction_loss + kl_loss + label_loss)
vae.add_loss(vae_loss)
vae.compile(optimizer=Adam())
regressor = Model(feature_input, r_mean, name='regressor')
return vae, regressor
def create_transEModel(num_nodes,
num_edges,
embed_size=50,
ord='l1',
margin=1,
learning_rate=2e-1):
# build transE Model
pos_sub_inputs = Input(shape=(), name='pos_subject')
neg_sub_inputs = Input(shape=(), name='neg_subject')
pos_obj_inputs = Input(shape=(), name='pos_object')
neg_obj_inputs = Input(shape=(), name='neg_object')
rel_inputs = Input(shape=(), name='relation')
inputs = {
"pos_subject": pos_sub_inputs,
"neg_subject": neg_sub_inputs,
"pos_object": pos_obj_inputs,
"neg_object": neg_obj_inputs,
"relation": rel_inputs
}
# 초기화 방식은 논문에 나와있는 방식으로 구성
init_range = 6 / np.sqrt(embed_size)
init_op = RandomUniform(-init_range, init_range)
node_layer = Embedding(input_dim=num_nodes,
output_dim=embed_size,
embeddings_initializer=init_op,
name='node_embedding')
edge_layer = Embedding(input_dim=num_edges,
output_dim=embed_size,
embeddings_initializer=init_op,
name='edge_embedding')
pos_sub = node_layer(pos_sub_inputs)
neg_sub = node_layer(neg_sub_inputs)
pos_obj = node_layer(pos_obj_inputs)
neg_obj = node_layer(neg_obj_inputs)
rel = edge_layer(rel_inputs)
score = TransEScore(ord, margin)([pos_sub, neg_sub, pos_obj, neg_obj, rel])
model = Model(inputs, score)
# Compile transE Model
model.add_loss(score)
model.compile(optimizer=Adagrad(learning_rate))
return model
def vae_model(input_shape, hidden_dim, latent_dim, original_dim):
"""
Variational autoencoder
:param input_shape: flatten genotype input shape
:param hidden_dim: dimension of hidden layer
:param latent_dim: dimension of latent layer
:param original_dim: dimension of original genotype data
"""
inputs = Input(shape=input_shape, name='encoder_input')
x = Dense(hidden_dim, activation='relu')(inputs)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Lambda(sampling, output_shape=(latent_dim, ),
name='z')([z_mean, z_log_var])
# encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
latent_inputs = Input(shape=(latent_dim, ), name='z_sampling')
encoder.summary()
x = Dense(hidden_dim, activation='relu')(latent_inputs)
outputs = Dense(original_dim, activation='softmax')(x)
# decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
outputs = decoder(encoder(inputs)[2])
vae = Model(inputs, outputs, name='vae_mlp')
# define loss
# reconstruction loss
reconstruction_loss = binary_crossentropy(inputs, outputs)
reconstruction_loss *= original_dim
# kl divergence
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
vae_loss = K.mean(reconstruction_loss + kl_loss)
vae.add_loss(vae_loss)
vae.compile(optimizer='adam')
return vae, encoder
def model_build(self):
z_mean, z_log_var, z = self.encoder(self.encoder_inputs)
outputs = self.decoder(z)
model = Model(self.encoder_inputs, outputs)
reconstruction_loss = binary_crossentropy(self.encoder_inputs, outputs)
reconstruction_loss *= self.image_size * self.image_size * 3
kl_loss = 1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var)
kl_loss = tf.reduce_mean(kl_loss)
kl_loss *= -0.5
vae_loss = tf.keras.backend.mean(reconstruction_loss + kl_loss)
model.add_loss(vae_loss)
model.compile(optimizer='adam')
return model
def build_bandit_lstm_classifier(timesteps=32,
feature_size=784,
output_shape=3,
repr_size=64,
activation='tanh',
inp_drop=0.0,
re_drop=0.0,
l2_coef=1e-3,
lr=3e-4,
translation=0.0):
seq_inputs = layers.Input(shape=(timesteps, feature_size),
name='Sequential_Input')
x = layers.Masking(mask_value=0, name='Masking')(seq_inputs)
x = layers.LSTM(repr_size,
activation=activation,
use_bias=True,
dropout=inp_drop,
recurrent_dropout=re_drop,
return_sequences=False,
name='Sequential_Representation')(x)
class_pred = layers.Dense(output_shape,
activation='softmax',
use_bias=True,
kernel_regularizer=l2(l2_coef),
name='Class_Prediction')(x)
action = layers.Input(shape=(output_shape, ),
name='Action_Input',
dtype=tf.int32)
propen = layers.Input(shape=(), name='Propensity_Input', dtype=tf.float32)
delta = layers.Input(shape=(), name='Delta_Input', dtype=tf.float32)
ips_loss = IpsLossLayer(translation=translation, name='ipsloss')(
[class_pred, action, propen, delta])
m = Model(inputs=[seq_inputs, action, propen, delta],
outputs=ips_loss,
name='training')
m.add_loss(ips_loss)
m.compile(optimizer=Adam(lr=lr))
test_m = Model(inputs=m.get_layer('Sequential_Input').input,
outputs=m.get_layer('Class_Prediction').output,
name='testing')
test_m.compile(optimizer=Adam(lr=lr),
loss='categorical_crossentropy',
metrics=['accuracy'])
print('model is built and compiled')
return m, test_m
def create_model_and_compile(self):
input_shape = self.in_shape
self.base_model = self.base_network()
self.cs_layer = Dense(self.num_classes,
use_bias=False,
name='CS_layer')
qpn_in = Input(shape=input_shape, name='in_qpn')
qpny = Input(shape=(self.num_classes, ), name='in_qpny')
qpny_label = Input(shape=(1, ), name='in_qpny_label')
qpn_out = self.base_model(qpn_in)
qpn_cls_sig = self.cs_layer(qpn_out)
fe_loss = Lambda(self.triplet_loss_all_combinations,
name='triplet_loss_FE')(qpn_out) * self.fe_weight
fe_accuracy = Lambda(self.FE_accuracy,
name='FE_accuracy_metric')(qpn_out)
cs_loss = Lambda(self.manual_CS_loss, name='CS_loss_calc')(
[qpn_cls_sig, qpny]) * self.cs_weight
cs_accuracy = Lambda(self.CS_accuracy,
name='CS_Acc')([qpn_cls_sig, qpny])
total_loss = fe_loss + cs_loss
model = Model(inputs=[qpn_in, qpny, qpny_label],
outputs=[qpn_cls_sig],
name='FEModel')
if 'adm' in self.optim:
optm = Adam(lr=self.LR)
elif 'ranger' in self.optim: # option to use a newer optimizer
radam = tfa.optimizers.RectifiedAdam(lr=self.LR, min_lr=1e-7)
optm = tfa.optimizers.Lookahead(radam,
sync_period=6,
slow_step_size=0.5)
model.add_loss(total_loss)
model.compile(optimizer=optm)
# Metrics to track the accuracy and loss progression
model.add_metric(fe_accuracy, name='fe_a', aggregation='mean')
model.add_metric(cs_accuracy, name='cs_a', aggregation='mean')
model.add_metric(fe_loss, name='fe_loss', aggregation='mean')
model.add_metric(cs_loss, name='cs_loss_out', aggregation='mean')
return model, optm
def _build_vae(self):
#VAE = encoder + decoder
outputs = self.decoder(
self.encoder(self.inputs)
[2]) #the position 2 refers to the latent vector output z
vae = Model(inputs=self.inputs, outputs=outputs, name='vae')
# VAE loss = mse_loss or xent_loss + kl_loss
reconstruction_loss = binary_crossentropy(K.flatten(self.inputs),
K.flatten(outputs))
#alternativly: reconstruction_loss = mse(K.flatten(inputs), K.flatten(outputs))
reconstruction_loss *= self.image_size * self.image_size
#calc total loss and add to model
vae_loss = K.mean(reconstruction_loss + self.kl_loss)
vae.add_loss(vae_loss)
vae.compile(optimizer='rmsprop')
vae.summary()
return vae, outputs
def vae(original_dim, intermediate_dim=512, latent_dim=20):
'''
vae.fit(x_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, None))
bottleneck_representation,_,_ = encoder.predict(x_test)
'''
# encoder
input_shape = (original_dim, )
inputs = Input(shape=input_shape, name='encoder_input')
x = Dense(intermediate_dim, activation='relu')(inputs)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
z = Lambda(sampling, output_shape=(latent_dim, ),
name='z')([z_mean, z_log_var])
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
# encoder.summary()
# plot_model(encoder, to_file='vae_mlp_encoder.png', show_shapes=True)
# decoder
latent_inputs = Input(shape=(latent_dim, ), name='z_sampling')
x = Dense(intermediate_dim, activation='relu')(latent_inputs)
outputs = Dense(original_dim, activation='sigmoid')(x)
decoder = Model(latent_inputs, outputs, name='decoder')
# decoder.summary()
# plot_model(decoder, to_file='vae_mlp_decoder.png', show_shapes=True)
# VAE model
outputs = decoder(encoder(inputs)[2])
vae = Model(inputs, outputs, name='vae')
# loss
reconstruction_loss = binary_crossentropy(inputs, outputs)
reconstruction_loss *= original_dim
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
vae_loss = K.mean(reconstruction_loss + kl_loss)
vae.add_loss(vae_loss)
vae.compile(optimizer='adam')
# vae.summary()
# plot_model(vae, to_file='vae_mlp.png', show_shapes=True)
return vae, encoder
def _cnn_variational_autoencoder(self, orignal_dim):
inputs = Input(shape= orignal_dim, name = 'encoder_input')
x = Conv2D(64, 3, padding='same', activation='relu')(inputs)
x = Conv2D(32, 3, padding='same', activation='relu')(x)
x = Conv2D(3, 3, padding='same', activation='relu')(x)
shape_bf_flatten = x.shape[1:]
x = Flatten()(x)
x = Dense(np.prod(shape_bf_flatten), activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(1000, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(self.latent_dim, activation = 'relu', kernel_initializer= 'he_uniform')(x)
z_mean = Dense(self.latent_dim, activation = None, name='z_mean')(x)
z_log_var = Dense(self.latent_dim, activation = None, name='z_log_var'
,kernel_initializer = initializers.glorot_normal())(x)
z = Lambda(self._sampling, output_shape = (self.latent_dim,), name ='z')([z_mean, z_log_var])
encoder = Model(inputs, [z_mean, z_log_var, z], name ='encoder')
latent_input = Input(shape=(self.latent_dim,), name = 'z_sampling')
x = Dense(1000, activation = 'relu', kernel_initializer= 'he_uniform')(latent_input)
x = Dense(np.prod(shape_bf_flatten), activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Reshape(shape_bf_flatten)(x)
x = Conv2D(3, 3, padding='same', activation='relu')(x)
x = Conv2D(32, 3, padding='same', activation='relu')(x)
x = Conv2D(64, 3, padding='same', activation='relu')(x)
x = Conv2D(1, 3, padding='same', activation='relu')(x)
decoder = Model(latent_input, x, name ='decoder')
output = decoder(encoder(inputs)[2])
def _vae_loss():
model_input = K.flatten(inputs)
model_output = K.flatten(output)
recon_loss= mse(model_input, model_output)
# recon_loss *= self.input_shape[0]
kl_loss = -5e-4 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
return K.mean(recon_loss + kl_loss)
vae = Model(inputs, output, name='vae')
vae.add_loss(vae_loss())
return vae, encoder, decoder
def _variational_autoencoder(self, orignal_dim):
orignal_dim = int(orignal_dim[0])
inputs = Input(shape= orignal_dim, name = 'encoder_input')
x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(inputs)
x = Dense(128, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(32, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(30, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(self.latent_dim, activation = 'relu', kernel_initializer= 'he_uniform')(x)
z_mean = Dense(self.latent_dim, activation = None, name='z_mean')(x)
z_log_var = Dense(self.latent_dim, activation = None, name='z_log_var'
,kernel_initializer = initializers.glorot_normal())(x)
z = Lambda(self._sampling, output_shape = (self.latent_dim,), name ='z')([z_mean, z_log_var])
encoder = Model(inputs, [z_mean, z_log_var, z], name ='encoder')
latent_input = Input(shape=(self.latent_dim,), name = 'z_sampling')
x = Dense(30, activation = 'relu', kernel_initializer= 'he_uniform')(latent_input)
x = Dense(32, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(128, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(x)
x = Dense(orignal_dim, activation = None, kernel_initializer= None)(x)
decoder = Model(latent_input, x, name ='decoder')
output = decoder(encoder(inputs)[2])
def vae_loss():
model_input = K.flatten(inputs)
model_output = K.flatten(output)
recon_loss= mse(model_input, model_output)
# recon_loss = binary_crossentropy(model_input, model_output)
# recon_loss *= self.input_shape[0]
kl_loss = -5e-4 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
return K.mean(recon_loss + kl_loss)
vae = Model(inputs, output, name='vae')
vae.add_loss(vae_loss())
return vae, encoder, decoder
