def design_and_compile_full_model(self):
self.encoder = self.design_and_compile_encoder()
self.sampler = self.design_and_compile_sampler()
self.decoder = self.design_and_compile_decoder()
# encoder input right there
# shape change it after
encoder_input = Input(shape=(self.max_sequence_length,
self.vocabulary_size),
name="encoder_input")
# None dim, prepare case where 1 timestep long sequences are sent
decoder_input = Input(shape=(None, self.vocabulary_size),
name="decoder_input")
z_mean, z_log_var = self.encoder(encoder_input)
z = self.sampler([z_mean, z_log_var])
rnn_state_last, x_decoded_mean = self.decoder([z, decoder_input])
self.model = Model([encoder_input, decoder_input], x_decoded_mean)
x = encoder_input
xent_loss = self.original_dim * metrics.binary_crossentropy(
K.flatten(x), K.flatten(x_decoded_mean))
kl_loss = -0.5 * K.sum(
1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
vae_loss = K.mean(xent_loss + kl_loss)
self.model.add_loss(vae_loss)
self.model.compile(optimizer="adam")
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 call(self, x):
z_mean, z_log_var = self.encoder(x)
z = sampling((z_mean, z_log_var))
y_pred = self.decoder(z)
xent_loss = original_dim * metrics.binary_crossentropy(x, y_pred) #ok
kl_loss = -0.5 * K.sum(
1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
loss = xent_loss + kl_loss
return loss
def vae_loss(x, x_decoded_mean):
#my tips:logloss
xent_loss = original_dim * metrics.binary_crossentropy(x,
x_decoded_mean) #ok
kl_loss = -0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var),
axis=-1)
return xent_loss + kl_loss
def vae_loss(inputs, outputs):
xent_loss = metrics.binary_crossentropy(K.flatten(inputs),
K.flatten(outputs))
xent_loss *= self.image_size * self.image_size
kl_loss = 1 + z_log_var * 2 - K.square(z_mean) - K.exp(
z_log_var * 2)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
vae_loss = K.mean(xent_loss + kl_loss)
return vae_loss
def vae_loss(self, x_in, x_out):
# --- reconstruction loss
x_in_flat = K.flatten(x_in)
x_out_flat = K.flatten(x_out)
recon_loss = binary_crossentropy(x_in_flat, x_out_flat)
#recon_loss = mse(x_in_flat, x_out_flat)
recon_loss = recon_loss * original_dim
# --- KL loss
KL_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
KL_loss = (-0.5) * K.sum(KL_loss, axis=-1)
KL_loss = KL_loss
# --- total loss
return K.mean(recon_loss + KL_loss)
def vae_loss_function(true, pred):
# --- reconstruction loss
true_flat = K.flatten(true)
pred_flat = K.flatten(pred)
# flattening required to be combined with KL loss
# recon_loss = mse(true_flat, pred_flat) #: select bce or mse
recon_loss = binary_crossentropy(true_flat, pred_flat)
recon_loss = recon_loss * original_dim
# required to reduce the impact of flattening. If not, down-scale KL loss
# --- KL loss
KL_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
KL_loss = (-0.5) * K.sum(KL_loss, axis=-1)
# --- total loss
vae_loss = K.mean(KL_loss + recon_loss)
return vae_loss
def obj(X, X_mu):
X = backend.flatten(X)
X_mu = backend.flatten(X_mu)
Lp = 0.5 * backend.mean( 1 + Z_lsgms - backend.square(Z_mu) - backend.exp(Z_lsgms), axis=-1)
Lx = - metrics.binary_crossentropy(X, X_mu) # Pixels have a Bernoulli distribution
Ly = Y_normal_logpdf(Y, Y_mu, Y_lsgms) # Voxels have a Gaussian distribution
lower_bound = backend.mean(Lp + 10000 * Lx + Ly)
cost = - lower_bound
return cost
def show_metrics(Y, prediction):
Y = np.squeeze(Y)
prediction = np.squeeze(prediction)
print(confusion_matrix(Y, prediction > .5))
print("recall", recall_score(Y, prediction > .5))
print("precision", precision_score(Y, prediction > .5))
# keras placeholder used for evaluation
labels_k = backend.placeholder([None], dtype=tf.float32)
preds_k = backend.placeholder([None], dtype=tf.float32)
val_loss_op = backend.mean(metrics.binary_crossentropy(labels_k, preds_k))
loss, = backend.get_session().run([val_loss_op],
feed_dict={
labels_k: Y,
preds_k: prediction
})
print("log loss", loss)
def design_and_compile_full_model(self):
self.encoder = self.design_and_compile_encoder()
self.sampler = self.design_and_compile_sampler()
self.decoder = self.design_and_compile_decoder()
# encoder input right there
x = Input(shape=self.X_tr.shape[1:], name="input")
# define decoder input here
z_mean, z_log_var = self.encoder(x)
z = self.sampler([z_mean, z_log_var])
# pass decoder output here
x_decoded_mean = self.decoder(z)
self.model = Model(x, x_decoded_mean)
xent_loss = self.original_dim * metrics.binary_crossentropy(
K.flatten(x), K.flatten(x_decoded_mean)
)
kl_loss = - 0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
vae_loss = K.mean(xent_loss + kl_loss)
self.model.add_loss(vae_loss)
self.model.compile(optimizer='adam')
def xent(y_true, y_pred):
return binary_crossentropy(y_true, y_pred)
def bce_logdice_loss(y_true, y_pred):
return binary_crossentropy(y_true,
y_pred) - K.log(1. - dice_loss(y_true, y_pred))
activation = self.hidden_layer(z)
output_layer = self.output_layer(activation)
return output_layer
encoder = Encoder(intermediate_dim, latent_dim)
decoder = Decoder(intermediate_dim, original_dim)
inputs = Input(batch_shape=(batch_size, original_dim))
z_mean, z_log_var = encoder(inputs)
z = Lambda(sampling, output_shape=(latent_dim, ))([z_mean, z_log_var])
y_pred = decoder(z)
autoencoder = Model(inputs, y_pred, name='autoencoder')
# 重构loss
xent_loss = original_dim * metrics.binary_crossentropy(inputs, y_pred)
# KL loss
kl_loss = -0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var),
axis=-1)
# vae_loss = K.mean(xent_loss + kl_loss)
vae_loss = xent_loss + kl_loss
#########################################y
#autoencoder.add_loss(vae_loss)
#autoencoder.compile(optimizer='rmsprop')
############################n
#autoencoder.compile(optimizer='rmsprop', loss=vae_loss)
#############################################
# def vae_lossfun(loss):
def logx_loss(y_true, y_pred):
y_true_flat = K.flatten(y_true)
y_pred_flat = K.flatten(y_pred)
xent_loss = 28 * 28 * metrics.binary_crossentropy(y_true_flat, y_pred_flat)
return xent_loss