def invert2(settings, samples, para_path, g_tolerance=None, e_tolerance=0.1, n_iter=None, max_iter=10000, heuristic_sigma=None): """ Return the latent space points corresponding to a set of a samples (from gradient descent) Note: this function is designed for ONE sample generation """ # num_samples = samples.shape[0] # cast samples to float32 samples = np.float32(samples) # get the model # if settings is a string, assume it's an identifier and load if type(settings) == str: settings = json.load( open('./experiments/settings/' + settings + '.txt', 'r')) # get parameters parameters = model.load_parameters(para_path) Z = tf.compat.v1.get_variable( name='Z', shape=[1, settings['seq_length'], settings['latent_dim']], initializer=tf.compat.v1.random_normal_initializer()) # create outputs G_samples = generator_o(Z, settings['hidden_units_g'], settings['seq_length'], 1, settings['num_generated_features'], reuse=False, parameters=parameters) # generator_vars = ['hidden_units_g', 'seq_length', 'batch_size', 'num_generated_features', 'cond_dim', 'learn_scale'] # generator_settings = dict((k, settings[k]) for k in generator_vars) # G_samples = model.generator(Z, **generator_settings, reuse=True) # G_samples = model.generator(Z, settings['hidden_units_g'], settings['seq_length'], 1, settings['num_generated_features'], reuse=False, parameters=parameters) fd = None # define loss mmd-based loss if heuristic_sigma is None: heuristic_sigma = mmd.median_pairwise_distance_o( samples) # this is noisy print('heuristic_sigma:', heuristic_sigma) samples = tf.compat.v1.reshape( samples, [1, settings['seq_length'], settings['num_generated_features']]) Kxx, Kxy, Kyy, wts = mmd._mix_rbf_kernel(G_samples, samples, sigmas=tf.constant( value=heuristic_sigma, shape=(1, 1))) similarity_per_sample = tf.compat.v1.diag_part(Kxy) reconstruction_error_per_sample = 1 - similarity_per_sample # reconstruction_error_per_sample = tf.reduce_sum((tf.nn.l2_normalize(G_samples, dim=1) - tf.nn.l2_normalize(samples, dim=1))**2, axis=[1,2]) similarity = tf.compat.v1.reduce_mean(similarity_per_sample) reconstruction_error = 1 - similarity # updater # solver = tf.compat.v1.train.AdamOptimizer().minimize(reconstruction_error_per_sample, var_list=[Z]) # solver = tf.train.RMSPropOptimizer(learning_rate=500).minimize(reconstruction_error, var_list=[Z]) solver = tf.compat.v1.train.RMSPropOptimizer(learning_rate=0.1).minimize( reconstruction_error_per_sample, var_list=[Z]) # solver = tf.train.MomentumOptimizer(learning_rate=0.1, momentum=0.9).minimize(reconstruction_error_per_sample, var_list=[Z]) grad_Z = tf.compat.v1.gradients(reconstruction_error_per_sample, Z)[0] grad_per_Z = tf.compat.v1.norm(grad_Z, axis=(1, 2)) grad_norm = tf.compat.v1.reduce_mean(grad_per_Z) # solver = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(reconstruction_error, var_list=[Z]) print('Finding latent state corresponding to samples...') sess = tf.compat.v1.Session() sess.run(tf.compat.v1.global_variables_initializer()) with tf.compat.v1.Session() as sess: # graph = tf.compat.v1.Graph() # graphDef = graph.as_graph_def() sess.run(tf.compat.v1.global_variables_initializer()) error = sess.run(reconstruction_error, feed_dict=fd) g_n = sess.run(grad_norm, feed_dict=fd) # print(g_n) i = 0 if not n_iter is None: while i < n_iter: _ = sess.run(solver, feed_dict=fd) error = sess.run(reconstruction_error, feed_dict=fd) i += 1 else: if not g_tolerance is None: while g_n > g_tolerance: _ = sess.run(solver, feed_dict=fd) error, g_n = sess.run([reconstruction_error, grad_norm], feed_dict=fd) i += 1 print(error, g_n) if i > max_iter: break else: while np.abs(error) > e_tolerance: _ = sess.run(solver, feed_dict=fd) error = sess.run(reconstruction_error, feed_dict=fd) i += 1 # print(error) if i > max_iter: break Zs = sess.run(Z, feed_dict=fd) Gs = sess.run(G_samples, feed_dict={Z: Zs}) error_per_sample = sess.run(reconstruction_error_per_sample, feed_dict=fd) print('Z found in', i, 'iterations with final reconstruction error of', error) tf.compat.v1.reset_default_graph() return Gs, Zs, error_per_sample, heuristic_sigma
def invert(settings, epoch, samples, g_tolerance=None, e_tolerance=0.1, n_iter=None, max_iter=10000, heuristic_sigma=None, C_samples=None): """ Return the latent space points corresponding to a set of a samples ( from gradient descent ) """ # cast samples to float32 samples = np.float32(samples[:, :, :]) # get the model if type(settings) == str: settings = json.load(open('./experiments/settings/' + settings + '.txt', 'r')) num_samples = samples.shape[0] print('Inverting', num_samples, 'samples using model', settings['identifier'], 'at epoch', epoch,) if not g_tolerance is None: print('until gradient norm is below', g_tolerance) else: print('until error is below', e_tolerance) # get parameters parameters = load_parameters(settings['identifier'] + '_' + str(epoch)) # assertions assert samples.shape[2] == settings['num_generated_features'] # create VARIABLE Z Z = tf.get_variable(name='Z', shape=[num_samples, settings['seq_length'], settings['latent_dim']], initializer=tf.random_normal_initializer()) if C_samples is None: # create outputs G_samples = generator(Z, settings['hidden_units_g'], settings['seq_length'], num_samples, settings['num_generated_features'], reuse=False, parameters=parameters) fd = None else: CG = tf.placeholder(tf.float32, [num_samples, settings['cond_dim']]) assert C_samples.shape[0] == samples.shape[0] # CGAN G_samples = generator(Z, settings['hidden_units_g'], settings['seq_length'], num_samples, settings['num_generated_features'], reuse=False, parameters=parameters, cond_dim=settings['cond_dim'], c=CG) fd = {CG: C_samples} # define loss if heuristic_sigma is None: heuristic_sigma = mmd.median_pairwise_distance(samples) # this is noisy print('heuristic_sigma:', heuristic_sigma) Kxx, Kxy, Kyy, wts = mmd._mix_rbf_kernel(G_samples, samples, sigmas=tf.constant(value=heuristic_sigma, shape=(1, 1))) similarity_per_sample = tf.diag_part(Kxy) reconstruction_error_per_sample = 1 - similarity_per_sample #reconstruction_error_per_sample = tf.reduce_sum((tf.nn.l2_normalize(G_samples, dim=1) - tf.nn.l2_normalize(samples, dim=1))**2, axis=[1,2]) similarity = tf.reduce_mean(similarity_per_sample) reconstruction_error = 1 - similarity # updater # solver = tf.train.AdamOptimizer().minimize(reconstruction_error_per_sample, var_list=[Z]) #solver = tf.train.RMSPropOptimizer(learning_rate=500).minimize(reconstruction_error, var_list=[Z]) solver = tf.train.RMSPropOptimizer(learning_rate=0.1).minimize(reconstruction_error_per_sample, var_list=[Z]) #solver = tf.train.MomentumOptimizer(learning_rate=0.1, momentum=0.9).minimize(reconstruction_error_per_sample, var_list=[Z]) grad_Z = tf.gradients(reconstruction_error_per_sample, Z)[0] grad_per_Z = tf.norm(grad_Z, axis=(1, 2)) grad_norm = tf.reduce_mean(grad_per_Z) #solver = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(reconstruction_error, var_list=[Z]) print('Finding latent state corresponding to samples...') with tf.Session() as sess: sess.run(tf.global_variables_initializer()) error = sess.run(reconstruction_error, feed_dict=fd) g_n = sess.run(grad_norm, feed_dict=fd) print(g_n) i = 0 if not n_iter is None: while i < n_iter: _ = sess.run(solver, feed_dict=fd) error = sess.run(reconstruction_error, feed_dict=fd) i += 1 else: if not g_tolerance is None: while g_n > g_tolerance: _ = sess.run(solver, feed_dict=fd) error, g_n = sess.run([reconstruction_error, grad_norm], feed_dict=fd) i += 1 print(error, g_n) if i > max_iter: break else: while np.abs(error) > e_tolerance: _ = sess.run(solver, feed_dict=fd) error = sess.run(reconstruction_error, feed_dict=fd) i += 1 print(error) if i > max_iter: break Zs = sess.run(Z, feed_dict=fd) error_per_sample = sess.run(reconstruction_error_per_sample, feed_dict=fd) print('Z found in', i, 'iterations with final reconstruction error of', error) tf.reset_default_graph() return Zs, error_per_sample, heuristic_sigma
print('Zs:{}'.format(aaa)) sess.run(tf.global_variables_initializer()) Z_latent = sess.run(Zs, feed_dict=fd) # Zs = model.sample_Z(batch_size, seq_length, latent_dim, use_time) # create outputs gs_sample = sess.run(G_sample, feed_dict={Z: Z_latent}) gs_sample = np.float32(gs_sample[:, :, :]) # gs_sample = model.generator(Zs, **generator_settings, reuse=True, c=CG) # define loss mmd-based loss heuristic_sigma = mmd.median_pairwise_distance_o( ts_sample) # this is noisy print('heuristic_sigma:', heuristic_sigma) Kxx, Kxy, Kyy, wts = mmd._mix_rbf_kernel(gs_sample, ts_sample, sigmas=tf.constant( value=heuristic_sigma, shape=(1, 1))) similarity_per_sample = tf.diag_part(Kxy) reconstruction_error_per_sample = 1 - similarity_per_sample similarity = tf.reduce_mean(similarity_per_sample) reconstruction_error = 1 - similarity # updater # from differential_privacy.dp_sgd.dp_optimizer import dp_optimizer # from differential_privacy.dp_sgd.dp_optimizer import sanitizer # from differential_privacy.privacy_accountant.tf import accountant # solver = tf.train.AdamOptimizer().minimize(reconstruction_error_per_sample, var_list=[Zs]) # solver = tf.train.RMSPropOptimizer(learning_rate=500).minimize(reconstruction_error, var_list=[Zs]) # solver = tf.train.RMSPropOptimizer(learning_rate=0.1).minimize(reconstruction_error_per_sample, var_list=Zs)