def vae_loss(y_true, y_pred): generation_loss = img_rows * img_cols \ * metrics.binary_crossentropy(x, x_decoded) kl_loss = 0.5 * tf.reduce_sum(K.square(z_mean) + K.square(z_var) - K.log(K.square(z_var + 1e-8)) - 1, axis=1) return tf.reduce_mean(generation_loss + kl_loss)
def vae_loss(x, x_decoded_mean): # NOTE: binary_crossentropy expects a batch_size by dim # for x and x_decoded_mean, so we MUST flatten these! x = K.flatten(x) x_decoded_mean = K.flatten(x_decoded_mean) xent_loss = img_rows * img_cols * metrics.binary_crossentropy(x, x_decoded_mean) kl_loss = - 0.5 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return xent_loss + kl_loss
def vae_loss(self, x, x_decoded_mean_squash, z_mean, z_log_var): x = K.flatten(x) x_decoded_mean_squash = K.flatten(x_decoded_mean_squash) img_rows, img_cols = self._img_rows, self._img_cols # generative or reconstruction loss xent_loss = img_rows * img_cols * \ metrics.binary_crossentropy(x, x_decoded_mean_squash) # Kullback-Leibler divergence loss kl_loss = - 0.5 * K.mean( 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(xent_loss + kl_loss)
def vae_loss(self, x, x_decoded_mean_squash): x = K.flatten(x) x_decoded_mean_squash = K.flatten(x_decoded_mean_squash) xent_loss = img_rows * img_cols * metrics.binary_crossentropy(x, x_decoded_mean_squash) kl_loss = - 0.5 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(xent_loss + kl_loss)
def vae_loss(self, x, x_decoded_mean): xent_loss = input_dim * \ metrics.binary_crossentropy(x, x_decoded_mean) kl_loss = -0.5 * K.sum( 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(xent_loss + kl_loss)
return z_mean + K.exp(z_log_var / 2) * epsilon # note that "output_shape" isn't necessary with the TensorFlow backend z = Lambda(sampling, output_shape=(latent_dim,))([z_mean, z_log_var]) # we instantiate these layers separately so as to reuse them later decoder_h = Dense(intermediate_dim, activation='relu') decoder_mean = Dense(original_dim, activation='sigmoid') h_decoded = decoder_h(z) x_decoded_mean = decoder_mean(h_decoded) # instantiate VAE model vae = Model(x, x_decoded_mean) # Compute VAE loss xent_loss = original_dim * metrics.binary_crossentropy(x, 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) vae.add_loss(vae_loss) vae.compile(optimizer='rmsprop') vae.summary() # train the VAE on MNIST digits (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:]))) x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))
def vae_loss(_x, x_decoded_mean): # Compute VAE loss xent_loss = metrics.binary_crossentropy(_x, x_decoded_mean) kl_loss = -0.5 * K.mean( 1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma), axis=-1) return xent_loss + kl_loss
def vae_loss(self, x, x_decoded_mean): xent_loss = original_dim * metrics.binary_crossentropy( x, x_decoded_mean) kl_loss = -KLWeight * 0.5 * K.sum( 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(xent_loss + kl_loss) / (original_dim + KLWeight)
def bce(y_true, y_pred): y_true_f = K.clip(K.batch_flatten(y_true), K.epsilon(), 1.) y_pred_f = K.clip(K.batch_flatten(y_pred), K.epsilon(), 1.) bce = binary_crossentropy(y_true_f, y_pred_f) return bce
def metric(self, x, x_decoded): return self.weight * metrics.binary_crossentropy(x, x_decoded)
z_mu, z_sigma = residual_enc_model(tdw_img, E_enc, settings.latent_noise_dim) epsilon = tf.random_normal(tf.shape(z_mu)) latent_noise_input_ = z_mu + (z_sigma) * epsilon G_dec = gen_model(E_enc, latent_noise_input_, input_shape, reuse=True) G_dec_randY = gen_model(E_enc_randY, latent_noise_input_, input_shape, reuse=True) # randY z_sigma_sq = tf.square(z_sigma) z_log_sigma_sq = tf.log(z_sigma_sq + 1e-10) kld_loss = tf.reduce_mean(-0.5 * tf.reduce_sum( 1 + z_log_sigma_sq - tf.square(z_mu) - tf.exp(z_log_sigma_sq), 1)) gloss = tf.reduce_mean( 64 * 64 * 3 * tf.reduce_mean(metrics.binary_crossentropy(tdw_img, G_dec)) + kld_loss) if settings.add_encoder: eloss, G_dec_e = enc_graph_simgan(settings, enc_model, simvae_model, gen_model, tdw_img, latent_code_input) if settings.add_mi_penalty: closs, gloss_ = mi_penalty_graph(settings, enc_model, mi_disc_model, G_dec_e, latent_code_dim) if settings.add_infogan_penalty: infogan_loss = infogan_penalty_graph(settings, zbar, latent_noise_input) t_vars = tf.trainable_variables() sim_vars = [var for var in t_vars if 'simvae' in var.name] d_vars = [var for var in t_vars if 'dec' in var.name] #simgan_decoder c_vars = [
def vae_loss(self, x_input, x_decoded): reconstruction_loss = original_dim * metrics.binary_crossentropy(x_input, x_decoded) # ERGamazon: Tried 0.3, 0.7 kl_loss = - 0.5 * K.sum(1 + z_log_var_encoded - K.square(z_mean_encoded) - K.exp(z_log_var_encoded), axis=-1) return K.mean(reconstruction_loss + (K.get_value(beta) * kl_loss))
#outputs = decoder(z) cvae = Model([img, label], h_decoded) #def vae_loss(y_true, y_pred): # """loss = reconstruction loss + KL loss for each data batch""" # # # E[log P(X|z)] # recon = K.sum(binary_crossentropy(y_pred, y_true)) # # # D_KL(Q(z|x) || P(z|X)) # kl = -0.5 * K.sum( 1. + log_sigma - K.exp(log_sigma) - K.square(mu), axis = -1) # # return K.mean(recon + kl) #define loss xent_loss = img_rows * img_cols * channels * metrics.binary_crossentropy( K.flatten(img), K.flatten(h_decoded)) kl_loss = -0.5 * K.sum(1 + log_sigma - K.square(mu) - K.exp(log_sigma), axis=-1) cvae_loss = K.mean(xent_loss + kl_loss) cvae.add_loss(cvae_loss) cvae.compile(optimizer='adam') cvae.summary() cvae.fit([x_train, y_train], batch_size=m, epochs=n_epoch) #%% encoder = Model([img, label], [mu, log_sigma, z]) decoder_input = Input(shape=(latent_dim, )) d = Concatenate(axis=-1)([decoder_input, label]) d = Dense(4 * 4 * 128, activation='relu')(decoder_input) d = Reshape((4, 4, 128))(d) d = BatchNormalization()(d)
def unnormalised_reconstruction_loss(x_decoded, y): rec_loss = metrics.binary_crossentropy(K.flatten(x_decoded), K.flatten(y)) print("Rec loss: " + str(rec_loss)) return rec_loss
# reshape here to flatten the contexts of each central word #x_hot_flat=K.reshape(x_hot, (-1,original_dim )) # #x_hot = tf.Print(data=[x_hot],input_=x_hot, message="x_hot") #x_hot_flat=K.reshape(x_hot, (-1,)) #x_hot_flat=K.flatten(x_hot) ##print("shape x_hot=", x_hot_flat.shape) #x_hot_flat_2 = K.one_hot(x_hot_flat, original_dim) #x_decoded_mean = tf.Print(data=[x_decoded_mean],input_=x_decoded_mean, message="x_dec") print("shape x_hot_flat_2=", x_hot_flat_2.shape) print("x_decoded_mean=", x_decoded_mean.shape) #reconstruction_loss = original_dim * metrics.categorical_crossentropy(x_decoded_mean,x_hot_flat_2) reconstruction_loss = original_dim * metrics.binary_crossentropy( x_decoded_mean, x_hot_flat_2) #reconstruction_loss = tf.Print(data=[reconstruction_loss],input_=reconstruction_loss, message="recon_loss") print("rec_loss=", reconstruction_loss.shape) print("rec_loss=", reconstruction_loss.shape) kl_loss = K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) #kl_loss_prior = K.sum(1 + prior_scale - K.square(prior_location) - K.exp(prior_scale), axis=-1) #total_kl_loss = kl_loss_posterior + kl_loss_prior print("z_log_var=", z_log_var.shape) print("K.square(z_mean)=", K.square(z_mean).shape) kl_loss *= -0.5 kl_loss = K.repeat_elements(kl_loss, context_sz, axis=0) #kl_loss = tf.Print(data=[kl_loss],input_=kl_loss, message="kl_loss") print("kl_loss=", kl_loss.shape)
def __init__(self, config): self.config = config self.weights_path = os.path.join(config.model_path, 'weights_best.h5') self.overfit_path = os.path.join(config.model_path, 'weights_overfit.h5') self.logs_path = os.path.join(config.model_path, 'logs') self.images_path = os.path.join(config.model_path, 'images') self.train_path = os.path.join(config.data_path, 'train') self.dev_path = os.path.join(config.data_path, 'dev') self.test_path = os.path.join(config.data_path, 'test') if not os.path.exists(config.model_path): os.makedirs(config.model_path) if not os.path.exists(self.logs_path): os.makedirs(self.logs_path) image_size = config.image_size filters = config.filters latent_size = config.latent_size batch_size = config.batch_size learning_rate = config.learning_rate x = Input(shape=(image_size, image_size, 3)) conv1 = Conv2D(3, kernel_size=(2, 2), padding='same', activation='relu')(x) conv2 = Conv2D(filters, kernel_size=(2, 2), padding='same', activation='relu', strides=(2, 2))(conv1) conv3 = Conv2D(filters, kernel_size=3, padding='same', activation='relu', strides=1)(conv2) conv4 = Conv2D(filters, kernel_size=3, padding='same', activation='relu', strides=1)(conv3) flat = Flatten()(conv4) z_mean = Dense(latent_size)(flat) z_stddev = Dense(latent_size)(flat) def sampling(args): z_mean, z_stddev = args epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_size), mean=0., stddev=1.0) return z_mean + K.exp(z_stddev) * epsilon z = Lambda(sampling, output_shape=(latent_size, ))([z_mean, z_stddev]) decoder_upsample = Dense(filters * (image_size // 2) * (image_size // 2), activation='relu') output_shape = (batch_size, image_size // 2, image_size // 2, filters) decoder_reshape = Reshape(output_shape[1:]) decoder_deconv1 = Conv2DTranspose(filters, kernel_size=3, padding='same', strides=1, activation='relu') decoder_deconv2 = Conv2DTranspose(filters, kernel_size=3, padding='same', strides=1, activation='relu') output_shape = (batch_size, filters, image_size + 1, image_size + 1) decoder_deconv3_upsamp = Conv2DTranspose(filters, kernel_size=(3, 3), strides=(2, 2), padding='valid', activation='relu') decoder_reconstr = Conv2D(3, kernel_size=2, padding='valid', activation='sigmoid') up_decoded = decoder_upsample(z) reshape_decoded = decoder_reshape(up_decoded) deconv1_decoded = decoder_deconv1(reshape_decoded) deconv2_decoded = decoder_deconv2(deconv1_decoded) x_decoded_relu = decoder_deconv3_upsamp(deconv2_decoded) x_reconstr = decoder_reconstr(x_decoded_relu) self.vae = Model(x, x_reconstr) xent_loss = image_size * image_size * metrics.binary_crossentropy( K.flatten(x), K.flatten(x_reconstr)) kl_loss = -0.5 * K.sum( 1 + z_stddev - K.square(z_mean) - K.exp(z_stddev), axis=-1) vae_loss = K.mean(xent_loss + kl_loss) self.vae.add_loss(vae_loss) optimizer = optimizers.Adam(lr=learning_rate) self.vae.compile(optimizer=optimizer) self.vae.summary() self.encoder = Model(x, z_mean) decoder_input = Input(shape=(latent_size, )) _up_decoded = decoder_upsample(decoder_input) _reshape_decoded = decoder_reshape(_up_decoded) _deconv1_decoded = decoder_deconv1(_reshape_decoded) _deconv2_decoded = decoder_deconv2(_deconv1_decoded) _x_decoded_relu = decoder_deconv3_upsamp(_deconv2_decoded) _x_reconstr = decoder_reconstr(_x_decoded_relu) self.generator = Model(decoder_input, _x_reconstr) try: self.vae.load_weights(self.weights_path) print('Loaded weights') except: print('Couldn\'t find/load weights')
def recon_loss(y_true, y_pred): #return(K.sum(K.binary_crossentropy(y_pred, y_true), axis=1)) return (w * h * metrics.binary_crossentropy(y_true, y_pred))
def xent(y_true, y_pred): return binary_crossentropy(y_true, y_pred)
############ decoder_h = Dense(intermediate_dim, activation='relu') print(decoder_h) decoder_mean = Dense(original_dim, activation = 'sigmoid') print (decoder_mean) h_decoded = decoder_h(z) print (h_decoded) x_decoded_mean = decoder_mean(h_decoded) print (K.shape(x_decoded_mean)) # instantiate VAE model vae = Model(x, x_decoded_mean) xent_loss = original_dim * metrics.binary_crossentropy(x, x_decoded_mean) # Entropy loss of input and output # oss_ = (rho * tf.log(rho / rho_hat)) + (rho_hat * tf.log((1 - rho) / (1 - rho_hat))) kl_loss = - 0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) # KL-divergence loss print ('62342367462387468236426378462 ', kl_loss.shape) # The KL-divergence loss tries to bring the latent variables closer to a unit gaussian distribution. vae_loss = K.mean(xent_loss + kl_loss) aa = vae.add_loss(vae_loss) vae.compile(optimizer='rmsprop', loss=aa) vae.summary() ######### model (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train[np.where((y_train==6) | (y_train == 8))[0]]
vae = Model([x, z_log_var], x_decoded_mean) else: vae = Model(x, x_decoded_mean) # instantiate generator model decoder_input = Input(shape=(latent_dim,)) _h_decoded = decoder_h(decoder_input) _x_decoded_mean = decoder_mean(_h_decoded) generator = Model(inputs=decoder_input, outputs=_x_decoded_mean) # instantiate encoder model encoder = Model(x, z_mean) # compute VAE loss if args.conv: xent_loss = original_dim * metrics.binary_crossentropy(K.flatten(x), K.flatten(x_decoded_mean)) else: xent_loss = original_dim * metrics.binary_crossentropy(x, 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) vae.add_loss(vae_loss) vae.compile(optimizer='rmsprop') # vae.summary() # train the VAE on MNIST digits (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. if args.conv: x_train = x_train.reshape((len(x_train), x_train.shape[1], x_train.shape[2], 1)) x_test = x_test.reshape((len(x_test), x_train.shape[1], x_train.shape[2], 1))
# we instantiate these layers separately so as to reuse them later decoder_h = Dense(intermediate_dim, activation='relu') decoder_mean = Dense(original_dim, activation='sigmoid') h_decoded = decoder_h( z ) # from the sampled distribution to an intertmedaite dimension (decoding) x_decoded_mean = decoder_mean( h_decoded ) # from the intertmedaite dimension to the original size, final layer (decoding) # instantiate VAE model vae = Model(x, x_decoded_mean) # Compute VAE loss xent_loss = original_dim * metrics.binary_crossentropy( x, x_decoded_mean ) # binary cross entropy (wouldnt it better tro use regresion?) kl_loss = -0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) # kl divergence vae_loss = K.mean(xent_loss + 2 * kl_loss) vae.add_loss(vae_loss) vae.compile(optimizer='rmsprop') vae.summary() # train the VAE on MNIST digits (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
def stacked_vae( input_dim, hidden_dims=None, latent_dim=100, initial_beta_val=0, learning_rate=0.0005, epsilon_std=1.0, kappa=1.0, epochs=50, batch_size=50, batch_normalize_inputs=True, batch_normalize_intermediaries=True, batch_normalize_embedding=True, relu_intermediaries=True, relu_embedding=True, max_beta_val=1, ): """ This is a deep, or stacked, vae. `hidden_dims` denotes the size of each successive hidden layer, until `latent_dim` which is the middle layer. The default `hidden_dims` is [300]. """ if hidden_dims is None: hidden_dims = [300] # Function for reparameterization trick to make model differentiable def sampling(args): import tensorflow as tf # Function with args required for Keras Lambda function z_mean, z_log_var = args # Draw epsilon of the same shape from a standard normal distribution epsilon = K.random_normal(shape=tf.shape(z_mean), mean=0.0, stddev=epsilon_std) # The latent vector is non-deterministic and differentiable # in respect to z_mean and z_log_var z = z_mean + K.exp(z_log_var / 2) * epsilon return z # Init beta value beta = K.variable(initial_beta_val, name="beta") # Input place holder for RNAseq data with specific input size original_dim = input_dim # Input place holder for RNAseq data with specific input size rnaseq_input = Input(shape=(original_dim, ), name="input") if batch_normalize_inputs: batchnorm_input = BatchNormalization( name="batchnorm_input")(rnaseq_input) else: batchnorm_input = rnaseq_input prev = batchnorm_input encoder_target = batchnorm_input if hidden_dims: for i, hidden_dim in enumerate(hidden_dims): z, z_mean_component = make_variational_layer( prev, hidden_dim, batch_normalize_intermediaries, relu_intermediaries, sampling, name=f"hidden_dim_{i}", ) prev = z # the encoder part to have a path that doesn't do sampling or ReLU'ing encoder_target = z_mean_component(encoder_target) else: z = prev # variational layer for latent dim l_mean_component = Dense(latent_dim, kernel_initializer="glorot_uniform", name="latent_mean") l_mean_dense_linear = l_mean_component(z) if batch_normalize_embedding: l_mean_dense_batchnorm = BatchNormalization( name="batchnorm_latent_mean")(l_mean_dense_linear) else: l_mean_dense_batchnorm = l_mean_dense_linear if relu_embedding: l_mean_encoded = Activation( "relu", name="relu_latent_mean")(l_mean_dense_batchnorm) else: l_mean_encoded = l_mean_dense_batchnorm l_log_var_dense_linear = Dense(latent_dim, kernel_initializer="glorot_uniform", name="latent_log_var")(z) if batch_normalize_embedding: l_log_var_dense_batchnorm = BatchNormalization( name="batchnorm_latent_log_var")(l_log_var_dense_linear) else: l_log_var_dense_batchnorm = l_log_var_dense_linear if relu_embedding: l_log_var_encoded = Activation( "relu", name="relu_latent_log_var")(l_log_var_dense_batchnorm) else: l_log_var_encoded = l_log_var_dense_batchnorm l = Lambda(sampling, output_shape=(latent_dim, ), name="sample_latent")([l_mean_encoded, l_log_var_encoded]) # the encoder part's l to come from the path that only considers mean encoder_target = l_mean_component(encoder_target) if batch_normalize_embedding: encoder_target = BatchNormalization( name="batchnorm_encoder_target")(encoder_target) if relu_embedding: encoder_target = Activation("relu", name="relu_encoder_target")(encoder_target) # decoder latent->hidden prev = l if hidden_dims: for i, hidden_dim in reversed(list(enumerate(hidden_dims))): h = Dense( hidden_dim, kernel_initializer="glorot_uniform", activation="relu", name=f"decode_hidden_{i}", )(prev) prev = h else: h = Dense( latent_dim, kernel_initializer="glorot_uniform", activation="relu", name="decode_hidden", )(prev) reconstruction = Dense( original_dim, kernel_initializer="glorot_uniform", activation="sigmoid", name="reconstruction", )(h) adam = optimizers.Adam(lr=learning_rate) vae = Model(rnaseq_input, reconstruction) reconstruction_loss = original_dim * metrics.binary_crossentropy( rnaseq_input, reconstruction) kl_loss = -0.5 * K.sum( 1 + l_log_var_encoded - K.square(l_mean_encoded) - K.exp(l_log_var_encoded), axis=-1, ) vae_loss = K.mean(reconstruction_loss + (K.get_value(beta) * kl_loss)) vae.add_loss(vae_loss) vae.compile(optimizer=adam) # non-sampling encoder encoder = Model(rnaseq_input, encoder_target) # sampling encoder sampling_encoder = Model(rnaseq_input, l) # Also, create a decoder model encoded_input = Input(shape=(latent_dim, )) prev = encoded_input if hidden_dims: for i in reversed(range(len(hidden_dims) + 1)): prev = vae.layers[-(i + 1)](prev) decoder = Model(encoded_input, prev) return vae, encoder, sampling_encoder, decoder, beta
Model_Inputs.append(Filter_In) Model_Inputs.append(Unit_Con) # Produce the Model ModVAE = Model(Model_Inputs, Model_Outputs) KL_loss = 0 RE_loss = 0 MSE_loss = 0 # Add the Loss Function for jj in range(batch_size): KL_loss += -0.5 * K.sum( 1 + Z_log_sd[jj] - K.square(Z_mean[jj]) - K.exp(Z_log_sd[jj]), axis=-1) RE_loss += im_dim * im_dim * metrics.binary_crossentropy( K.flatten(Model_Inputs[jj]), K.flatten(Model_Outputs[jj])) MSE_loss += metrics.mean_squared_error(F_mu, Clamped_Latents[jj]) vae_loss = K.mean(alpha * RE_loss + beta * KL_loss + lambda_ * MSE_loss) ModVAE.add_loss(vae_loss) ModVAE.compile(optimizer='adam', loss=None) ModVAE.summary() # ModVAE.load_weights("modvae_32_final.h5") if gen_data: train_data = LoadData(dup=False) test_data = LoadData(method='test') ModVAE.load_weights("modvae_32_final.h5")
def vae_loss(x, x_decoded_mean_squash): xent_loss = self.image_size * self.image_size * metrics.binary_crossentropy(K.flatten(x), K.flatten(x_decoded_mean_squash)) 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) return vae_loss
def vae_loss(x, x_decoded_mean): xent_loss = original_dim * metrics.binary_crossentropy( x, x_decoded_mean) 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(self, x, x_decoded_mean): xent_loss = self.original_dim * metrics.binary_crossentropy(x, x_decoded_mean) kl_loss = - 0.5 * backend.sum(1 + self.z_log_var_encoded - backend.square(self.z_mean_encoded) - backend.exp(self.z_log_var_encoded), axis=-1) return backend.mean(xent_loss + (backend.get_value(self.beta) * kl_loss))
_conv_1 = conv_1(_reshape_1) up_1 = UpSampling2D((2, 2)) _up_1 = up_1(_conv_1) conv_2 = Conv2D(16, (3, 3), activation='relu', padding='same') _conv_2 = conv_2(_up_1) up_2 = UpSampling2D((2, 2)) _up_2 = up_2(_conv_2) out = Conv2D(1, (3, 3), activation='sigmoid', padding='same') outputs = out(_up_2) vae = Model(inputs, outputs, name='vae') ########################################################### # Compute VAE loss xent_loss = original_dim * metrics.binary_crossentropy(K.flatten(inputs), K.flatten(outputs)) 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.add_loss(vae_loss) vae.compile(optimizer='rmsprop') vae.summary() # train the VAE on MNIST digits (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train = x_train.reshape( (len(x_train), input_shape[0], input_shape[1], input_shape[2]))
activation='sigmoid') hid_decoded = decoder_hid(z) up_decoded = decoder_upsample(hid_decoded) reshape_decoded = decoder_reshape(up_decoded) deconv_1_decoded = decoder_deconv_1(reshape_decoded) deconv_2_decoded = decoder_deconv_2(deconv_1_decoded) x_decoded_relu = decoder_deconv_3_upsamp(deconv_2_decoded) x_decoded_mean_squash = decoder_mean_squash(x_decoded_relu) # instantiate VAE model vae = Model(x, x_decoded_mean_squash) # Compute VAE loss xent_loss = img_rows * img_cols * metrics.binary_crossentropy( K.flatten(x), K.flatten(x_decoded_mean_squash)) 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.add_loss(vae_loss) vae.compile(optimizer='rmsprop') vae.summary() # train the VAE on MNIST digits (x_train, _), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255. x_train = x_train.reshape((x_train.shape[0],) + original_img_size) x_test = x_test.astype('float32') / 255. x_test = x_test.reshape((x_test.shape[0],) + original_img_size)
z = Lambda(sampling, output_shape=(latent_dim, ))([z_mean, z_log_var]) # We instentiate these layers separately so as to reuse them later decoder_h = Dense(intermediate_dim, activation='relu') decoder_mean = Dense(original_dim, activation='sigmoid') h_decoded = decoder_h(z) #x_decoded_mean为最后还原的x x_decoded_mean = decoder_mean(h_decoded) # Instantiate VAE model vae = Model(x, x_decoded_mean) # Compute VAE loss xent_loss = original_dim * metrics.binary_crossentropy(x, 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) vae.add_loss(vae_loss) vae.compile(optimizer='rmsprop', loss=None) vae.summary() # Train the VAE on Mnist digits (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255 x_test = x_test.astype('float32') / 255 x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:]))) # np.prod()所有元素相乘的结果 x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))
def log_p_x_given_z(x, x_decoded): # The cross extropy loss here is also -log(p(x|z)). xent_loss = -data_size * metrics.binary_crossentropy(x, x_decoded) return K.mean(xent_loss)
def log_px_l(x, y): return -data_size * metrics.binary_crossentropy( K.reshape(sym_x_l, (K.shape(sym_x_l)[0], -1)), K.reshape(mux_train_l, (K.shape(sym_x_l)[0], -1)))
def vae_loss(self, x_input, x_decoded): reconstruction_loss = original_dim * metrics.binary_crossentropy(x_input, x_decoded) kl_loss = - 0.5 * K.sum(1 + l_log_var_dense_linear - K.square(l_mean_dense_linear) - K.exp(l_log_var_dense_linear), axis=-1) return K.mean(reconstruction_loss + (K.get_value(beta) * kl_loss))
padding='valid', activation='sigmoid') hid_decoded = decoder_hid(z) up_decoded = decoder_upsample(hid_decoded) reshape_decoded = decoder_reshape(up_decoded) deconv_1_decoded = decoder_deconv_1(reshape_decoded) deconv_2_decoded = decoder_deconv_2(deconv_1_decoded) x_decoded_relu = decoder_deconv_3_upsamp(deconv_2_decoded) x_decoded_mean_squash = decoder_mean_squash(x_decoded_relu) # instantiate VAE model vae = Model(x, x_decoded_mean_squash) # Compute VAE loss xent_loss = img_rows * img_cols * metrics.binary_crossentropy( K.flatten(x), K.flatten(x_decoded_mean_squash)) 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) if K.backend() == 'mxnet': raise NotImplementedError( "MXNet Backend: Custom loss is not supported yet.") vae.add_loss(vae_loss) vae.compile(optimizer='rmsprop') vae.summary() # train the VAE on MNIST digits (x_train, _), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255.
def log_px_given_z_u(x, y): return -data_size * metrics.binary_crossentropy( K.reshape(x_u, (K.shape(x_u)[0], -1)), K.reshape(mux_train, (K.shape(x_u)[0], -1)))
def vae_loss(self, x, x_decoded_mean): xent_loss = original_dim * metrics.binary_crossentropy(x, x_decoded_mean) kl_loss = - 0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(xent_loss + kl_loss)
def vae_loss(x, x_decoded_mean): xent_loss = metrics.binary_crossentropy(x, x_decoded_mean) kl_loss = -0.5 * K.mean( 1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma), axis=-1) print(xent_loss) return xent_loss + kl_loss