def xform_dynamic(x): return tf1.placeholder_with_default(x, shape=None)
def dynamic_run(fun, x_value, **kwargs): x_value = np.array(x_value, dtype=np.float32) placeholder = tf1.placeholder_with_default(x_value, shape=None) return self.evaluate(fun(placeholder, **kwargs))
def _build_tensor(self, ndarray): if self.use_static_batch_size: shape = ndarray.shape else: shape = [None] + list(ndarray.shape[1:]) return tf1.placeholder_with_default(input=ndarray, shape=shape)
def execute(configs): tf.reset_default_graph() random.seed(configs["random_state"]) nprand.seed(configs["random_state"]) DECAY_FACTOR = 0.80 decay_steps = 1000 latent_dim = configs["latent_dim"] som_dim = [configs["som_dim"], configs["som_dim"]] num_classes = 10 global_step = tf.Variable(0, trainable=False, name="global_step") embeddings = tf.get_variable("embeddings", som_dim+[latent_dim], initializer=tf.truncated_normal_initializer(stddev=0.05)) x_patient = tf.placeholder(tf.float32, shape=[None, 98]) y = tf.placeholder(tf.int32, shape=[None]) train = tf.placeholder(tf.bool, name="train") batch_size = tf.shape(x_patient)[0] with tf.variable_scope("encoder"): dense_1=tf.keras.layers.Dense(configs["conv_size"])(x_patient) dense_2=tf.keras.layers.Dense(configs["conv_size"])(dense_1) z_e = tf.keras.layers.Dense(latent_dim)(dense_2) z_dist = tf.squared_difference(tf.expand_dims(tf.expand_dims(z_e, 1), 1), tf.expand_dims(embeddings, 0)) z_dist_red = tf.reduce_sum(z_dist, axis=-1) z_dist_flat = tf.reshape(z_dist_red, [batch_size, -1]) k = tf.argmin(z_dist_flat, axis=-1) k_1 = k // som_dim[1] k_2 = k % som_dim[1] k_stacked = tf.stack([k_1, k_2], axis=1) z_q = tf.gather_nd(embeddings, k_stacked) def decoder(z_tensor): with tf.variable_scope("decoder", reuse=tf.AUTO_REUSE): dec_dense_1 = tf.keras.layers.Dense(configs["conv_size"])(z_tensor) dec_dense_2 = tf.keras.layers.Dense(configs["conv_size"])(dec_dense_1) flat_dec=tf.keras.layers.Dense(98)(dec_dense_2) x_hat = flat_dec return x_hat x_hat = decoder(z_q) beta = 0.25 loss_rec_mse = tf.losses.mean_squared_error(x_patient, x_hat) loss_vq = tf.reduce_mean(tf.squared_difference(tf.stop_gradient(z_e), z_q)) loss_commit = tf.reduce_mean(tf.squared_difference(z_e, tf.stop_gradient(z_q))) loss = loss_rec_mse + loss_vq + beta*loss_commit learning_rate = tf.placeholder_with_default(0.001, []) lr_decay = tf.train.exponential_decay(learning_rate, global_step, decay_steps, DECAY_FACTOR, staircase=True) decoder_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "decoder") decoder_grads = list(zip(tf.gradients(loss, decoder_vars), decoder_vars)) encoder_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "encoder") grad_z = tf.gradients(loss_rec_mse, z_q) encoder_grads = [(tf.gradients(z_e,var,grad_z)[0]+beta*tf.gradients(loss_commit,var)[0],var) for var in encoder_vars] embed_grads = list(zip(tf.gradients(loss_vq, embeddings),[embeddings])) optimizer = tf.train.AdamOptimizer(lr_decay) train_step = optimizer.apply_gradients(decoder_grads+encoder_grads+embed_grads) BATCH_SIZE = configs["batch_size"] EPOCHS = configs["n_epochs"] NUM_TESTS = 1 if configs["benchmark"]: times_per_epoch=[] for data_set in configs["DATASETS"]: if not configs["debug_mode"]: with open("../results/vqvae_{}_{}.tsv".format(data_set,configs["random_state"]),'w') as fp: csv_fp=csv.writer(fp,delimiter='\t') csv_fp.writerow(["model","task","nmi"]) if data_set=="eicu": data_train, data_test, labels_train, labels_test = get_data(test=True, train_ratio=configs["train_ratio"]) for _ in range(NUM_TESTS): with tf.Session() as sess: sess.run(tf.global_variables_initializer()) indices_unsup = np.arange(data_train.shape[0]) with tqdm(total=EPOCHS*(data_train.shape[0]//BATCH_SIZE)) as pbar: for epoch in range(EPOCHS): if configs["benchmark"]: t_begin=timeit.default_timer() np.random.shuffle(indices_unsup) test_mse = sess.run(loss_rec_mse, feed_dict={x_patient: data_test[:100], train: False}) for i in range(indices_unsup.shape[0]//BATCH_SIZE): batch_data = data_train[indices_unsup[BATCH_SIZE*i:BATCH_SIZE*(i+1)]] if i%100 == 0: train_mse, train_commit, train_loss = sess.run([loss_rec_mse, loss_commit, loss], feed_dict={x_patient: batch_data, train: False}) train_step.run(feed_dict={x_patient: batch_data, train: True}) pbar.set_postfix(epoch=epoch, train_mse=train_mse, train_commit=train_commit, test_mse=test_mse, refresh=False) pbar.update(1) if configs["benchmark"]: t_end=timeit.default_timer() times_per_epoch.append(t_end-t_begin) if configs["benchmark"]: print("Times per epoch: {:.3f}".format(np.mean(times_per_epoch))) sys.exit(0) test_k_all = [] test_x_hat_all = [] for i in trange(data_test.shape[0]//100): batch_data = data_test[100*i:100*(i+1)] test_k_all.extend(sess.run(k, feed_dict={x_patient: batch_data, train: False})) test_x_hat_all.extend(sess.run(x_hat, feed_dict={x_patient: batch_data, train: False})) test_x_hat_all = np.array(test_x_hat_all) test_k_all=np.array(test_k_all) data_test=data_test[:test_x_hat_all.shape[0]] for task_desc,task_idx in [("apache_0",0), ("apache_6",1), ("apache_12",2), ("apache_24",3)]: labels_test_task=labels_test[:,task_idx] aggregated_mses = [] aggregated_NMIs = [] aggregated_purities = [] aggregated_mses.append(mean_squared_error(data_test, test_x_hat_all)) aggregated_NMIs.append(normalized_mutual_info_score(test_k_all, labels_test_task[:len(test_k_all)])) aggregated_purities.append(cluster_purity(test_k_all, labels_test_task[:len(test_k_all)])) print("Results for {} on task: {}".format(data_set,task_desc)) print("Test MSE: {} +- {}\nTest NMI: {} +- {}\nTest purity: {} +- {}".format(np.mean(aggregated_mses), np.std(aggregated_mses)/np.sqrt(NUM_TESTS), np.mean(aggregated_NMIs), np.std(aggregated_NMIs)/ np.sqrt(NUM_TESTS), np.mean(aggregated_purities), np.std(aggregated_purities)/np.sqrt(NUM_TESTS))) if not configs["debug_mode"]: with open("../results/vqvae_{}_{}.tsv".format(data_set,configs["random_state"]),'a') as fp: csv_fp=csv.writer(fp,delimiter='\t') csv_fp.writerow(["vqvae",task_desc,str(aggregated_NMIs[0])])
def testShapes(self): # We'll use a batch shape of [2, 3, 5, 7, 11] # 5x5 grid of index points in R^2 and flatten to 25x2 index_points = np.linspace(-4., 4., 5, dtype=np.float64) index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) index_points = np.reshape(index_points, [-1, 2]) # ==> shape = [25, 2] batched_index_points = np.reshape(index_points, [1, 1, 25, 2]) batched_index_points = np.stack([batched_index_points] * 5) # ==> shape = [5, 1, 1, 25, 2] # Kernel with batch_shape [2, 3, 1, 1, 1] amplitude = np.array([1., 2.], np.float64).reshape([2, 1, 1, 1, 1]) length_scale = np.array([.1, .2, .3], np.float64).reshape([1, 3, 1, 1, 1]) observation_noise_variance = np.array([1e-9], np.float64).reshape( [1, 1, 1, 1, 1]) jitter = np.float64(1e-6) observation_index_points = (np.random.uniform( -1., 1., (7, 1, 7, 2)).astype(np.float64)) observations = np.random.uniform(-1., 1., (11, 7)).astype(np.float64) def cholesky_fn(x): return tf.linalg.cholesky( tf.linalg.set_diag(x, tf.linalg.diag_part(x) + 1.)) if not self.is_static: amplitude = tf1.placeholder_with_default(amplitude, shape=None) length_scale = tf1.placeholder_with_default(length_scale, shape=None) batched_index_points = tf1.placeholder_with_default( batched_index_points, shape=None) observation_index_points = tf1.placeholder_with_default( observation_index_points, shape=None) observations = tf1.placeholder_with_default(observations, shape=None) kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale) gprm = tfd.GaussianProcessRegressionModel(kernel, batched_index_points, observation_index_points, observations, observation_noise_variance, cholesky_fn=cholesky_fn, jitter=jitter, validate_args=True) batch_shape = [2, 3, 5, 7, 11] event_shape = [25] sample_shape = [9, 3] samples = gprm.sample(sample_shape, seed=test_util.test_seed()) self.assertIs(cholesky_fn, gprm.cholesky_fn) if self.is_static or tf.executing_eagerly(): self.assertAllEqual(gprm.batch_shape_tensor(), batch_shape) self.assertAllEqual(gprm.event_shape_tensor(), event_shape) self.assertAllEqual(samples.shape, sample_shape + batch_shape + event_shape) self.assertAllEqual(gprm.batch_shape, batch_shape) self.assertAllEqual(gprm.event_shape, event_shape) self.assertAllEqual(samples.shape, sample_shape + batch_shape + event_shape) else: self.assertAllEqual(self.evaluate(gprm.batch_shape_tensor()), batch_shape) self.assertAllEqual(self.evaluate(gprm.event_shape_tensor()), event_shape) self.assertAllEqual( self.evaluate(samples).shape, sample_shape + batch_shape + event_shape) self.assertIsNone(tensorshape_util.rank(samples.shape)) self.assertIsNone(tensorshape_util.rank(gprm.batch_shape)) self.assertEqual(tensorshape_util.rank(gprm.event_shape), 1) self.assertIsNone( tf.compat.dimension_value( tensorshape_util.dims(gprm.event_shape)[0]))
} # get dataset dataset = BinaryDbReader(mode='training', batch_size=8, shuffle=True, use_wrist_coord=False, hand_crop=True, coord_uv_noise=False, crop_center_noise=False) # build network graph data = dataset.get() # build network evaluation = tf.placeholder_with_default(True, shape=()) net = ColorHandPose3DNetwork() keypoints_scoremap = net.inference_pose2d(data['image_crop'], train=True) s = data['scoremap'].get_shape().as_list() keypoints_scoremap = [ tf.image.resize_images(x, (s[1], s[2])) for x in keypoints_scoremap ] # Start TF gpu_options = tf.GPUOptions(allow_growth=True, ) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) tf.train.start_queue_runners(sess=sess) # Loss loss = 0.0 s = data['scoremap'].get_shape().as_list()
def _make_placeholder(self, x): return tf1.placeholder_with_default( x, shape=(x.shape if self.use_static_shape else None))
def _input(self, value): """Helper to create inputs with varied dtypes an static shapes.""" value = tf.cast(value, self.dtype) return tf1.placeholder_with_default( value, shape=value.shape if self.use_static_shape else None)
def make_tensor_hiding_attributes(value, hide_shape, hide_value=True): if not hide_value: return tf.convert_to_tensor(value) shape = None if hide_shape else getattr(value, 'shape', None) return tf1.placeholder_with_default(value, shape=shape)
def _init_placeholders(self): self.input_ids_ph = tf.placeholder(shape=(None, None), dtype=tf.int32, name='ids_ph') self.input_masks_ph = tf.placeholder(shape=(None, None), dtype=tf.int32, name='masks_ph') self.token_types_ph = tf.placeholder(shape=(None, None), dtype=tf.int32, name='token_types_ph') self.is_train_ph = tf.placeholder_with_default(False, shape=[], name='is_train_ph')
def testShapes(self): # 5x5 grid of index points in R^2 and flatten to 25x2 index_points = np.linspace(-4., 4., 5, dtype=np.float32) index_points = np.stack(np.meshgrid(index_points, index_points), axis=-1) index_points = np.reshape(index_points, [-1, 2]) # ==> shape = [25, 2] # Kernel with batch_shape [2, 4, 3, 1] amplitude = np.array([1., 2.], np.float32).reshape([2, 1, 1, 1]) length_scale = np.array([1., 2., 3., 4.], np.float32).reshape([1, 4, 1, 1]) observation_noise_variance = np.array([1e-5, 1e-6, 1e-5], np.float32).reshape([1, 1, 3, 1]) batched_index_points = np.stack([index_points] * 6) # ==> shape = [6, 25, 2] if not self.is_static: amplitude = tf1.placeholder_with_default(amplitude, shape=None) length_scale = tf1.placeholder_with_default(length_scale, shape=None) batched_index_points = tf1.placeholder_with_default( batched_index_points, shape=None) kernel = psd_kernels.ExponentiatedQuadratic(amplitude, length_scale) gp = tfd.GaussianProcess( kernel, batched_index_points, observation_noise_variance=observation_noise_variance, jitter=1e-5) batch_shape = [2, 4, 3, 6] event_shape = [25] sample_shape = [5, 3] samples = gp.sample(sample_shape) if self.is_static or tf.executing_eagerly(): self.assertAllEqual(gp.batch_shape_tensor(), batch_shape) self.assertAllEqual(gp.event_shape_tensor(), event_shape) self.assertAllEqual(samples.shape, sample_shape + batch_shape + event_shape) self.assertAllEqual(gp.batch_shape, batch_shape) self.assertAllEqual(gp.event_shape, event_shape) self.assertAllEqual(samples.shape, sample_shape + batch_shape + event_shape) self.assertAllEqual(gp.mean().shape, batch_shape + event_shape) self.assertAllEqual(gp.variance().shape, batch_shape + event_shape) else: self.assertAllEqual(self.evaluate(gp.batch_shape_tensor()), batch_shape) self.assertAllEqual(self.evaluate(gp.event_shape_tensor()), event_shape) self.assertAllEqual( self.evaluate(samples).shape, sample_shape + batch_shape + event_shape) self.assertIsNone(tensorshape_util.rank(samples.shape)) self.assertIsNone(tensorshape_util.rank(gp.batch_shape)) self.assertEqual(tensorshape_util.rank(gp.event_shape), 1) self.assertIsNone( tf.compat.dimension_value( tensorshape_util.dims(gp.event_shape)[0])) self.assertAllEqual(self.evaluate(tf.shape(input=gp.mean())), batch_shape + event_shape) self.assertAllEqual(self.evaluate(tf.shape(input=gp.variance())), batch_shape + event_shape)
def test_variable_shapes(self, normalize_weights, share_combining_weights, data_format): spatial_rank = 2 kernel_size = 3 filters = 16 if data_format == 'channels_last': input_shape = [2, 32, 32, 3] elif data_format == 'channels_first': input_shape = [2, 3, 32, 32] images = tf.constant(np.random.randn(*tuple(input_shape)), dtype=tf.float32) # Test handling variable input size if weights shared across one dimension. if share_combining_weights == (True, False): input_shape_ = input_shape[:] if data_format == 'channels_last': input_shape_[2] = None elif data_format == 'channels_first': input_shape_[3] = None images = tf.placeholder_with_default(images, shape=tuple(input_shape_)) elif share_combining_weights == (False, True): input_shape_ = input_shape[:] if data_format == 'channels_last': input_shape_[1] = None elif data_format == 'channels_first': input_shape_[2] = None images = tf.placeholder_with_default(images, shape=tuple(input_shape_)) layer = layers.LowRankLocallyConnected2D( filters=filters, kernel_size=(kernel_size, kernel_size), strides=(1, 1), spatial_rank=spatial_rank, normalize_weights=normalize_weights, share_row_combining_weights=share_combining_weights[0], share_col_combining_weights=share_combining_weights[1], data_format=data_format, input_dependent=False) output = layer(images) var_dict = {v.op.name: v for v in tf.global_variables()} # Make sure all generated weights are tracked in layer.weights. self.assertLen(var_dict, len(layer.weights)) # Make sure the number of weights generated is correct. if share_combining_weights[0] and share_combining_weights[1]: # weights rows, weights cols, bias (rows, cols, channels), kernel bases self.assertLen(var_dict, 6) else: self.assertLen(var_dict, 4) self.evaluate(tf.global_variables_initializer()) combining_weights = self.evaluate(layer.combining_weights) if data_format == 'channels_last': self.assertEqual( self.evaluate(output).shape, (input_shape[0], input_shape[1] - kernel_size + 1, input_shape[2] - kernel_size + 1, filters)) elif data_format == 'channels_first': self.assertEqual( self.evaluate(output).shape, ( input_shape[0], filters, input_shape[2] - kernel_size + 1, input_shape[3] - kernel_size + 1, )) if normalize_weights == 'softmax': self.assertNDArrayNear(np.sum(combining_weights, axis=-1), np.ones(combining_weights.shape[:-1], dtype=np.float32), err=1e-5) elif normalize_weights == 'norm': self.assertNDArrayNear(np.sqrt( np.sum(combining_weights**2, axis=-1)), np.ones(combining_weights.shape[:-1], dtype=np.float32), err=1e-5)
def main(latent_dim, som_dim, learning_rate, decay_factor, alpha, beta, gamma, theta, ex_name, more_runs, data_set, dropout, prior_var, convolution, prior, validation, epochs_pretrain, num_epochs, batch_size): """Main method to build a model, train it and evaluate it. Returns: dict: Results of the evaluation (NMI, Purity). """ if not os.path.exists('../models'): os.mkdir('../models') # Dimensions for MNIST-like data input_length = 28 input_channels = 28 lr_val = tf.placeholder_with_default(learning_rate, []) model = DPSOM(latent_dim=latent_dim, som_dim=som_dim, learning_rate=lr_val, alpha=alpha, decay_factor=decay_factor, input_length=input_length, input_channels=input_channels, beta=beta, theta=theta, gamma=gamma, convolution=convolution, dropout=dropout, prior_var=prior_var, prior=prior) if data_set == "MNIST": mnist = tf.keras.datasets.mnist.load_data(path='mnist.npz') data_total = np.reshape(mnist[0][0], [-1, 28 * 28]) maxx = np.reshape(np.amax(data_total, axis=-1), [-1, 1]) data_total = np.reshape(data_total / maxx, [-1, 28, 28, 1]) labels_total = mnist[0][1] data_test = np.reshape(mnist[1][0], [-1, 28 * 28]) maxx = np.reshape(np.amax(data_test, axis=-1), [-1, 1]) data_test = np.reshape(data_test / maxx, [-1, 28, 28, 1]) labels_test = mnist[1][1] data_train, data_val, labels_train, labels_val = train_test_split( data_total, labels_total, test_size=0.15, random_state=42) else: ((data_total, labels_total), (data_test, labels_test)) = tf.keras.datasets.fashion_mnist.load_data() data_total = np.reshape(data_total, [-1, 28 * 28]) maxx = np.reshape(np.amax(data_total, axis=-1), [-1, 1]) data_total = np.reshape(data_total / maxx, [-1, 28, 28, 1]) data_test = np.reshape(data_test, [-1, 28 * 28]) maxx = np.reshape(np.amax(data_test, axis=-1), [-1, 1]) data_test = np.reshape(data_test / maxx, [-1, 28, 28, 1]) data_train, data_val, labels_train, labels_val = train_test_split( data_total, labels_total, test_size=0.15, random_state=42) data_generator = get_data_generator(data_train, data_val, labels_train, labels_val, data_test, labels_test) if not validation: data_val = data_test if more_runs: NMI = [] PUR = [] for i in range(10): results = train_model(model, data_train, data_val, data_generator, lr_val) NMI.append(results["NMI"]) PUR.append(results["Purity"]) NMI_mean = np.mean(NMI) NMI_sd = np.std(NMI) / np.sqrt(10) PUR_mean = np.mean(PUR) PUR_sd = np.std(PUR) / np.sqrt(10) print("\nRESULTS NMI: %f +- %f, PUR: %f +- %f. Name: %r. \n" % (NMI_mean, NMI_sd, PUR_mean, PUR_sd, ex_name)) if data_set == "MNIST": f = open("evaluation_MNIST.txt", "a+") else: f = open("evaluation_fMNIST.txt", "a+") f.write( "som_dim=[%d,%d], latent_dim= %d, batch_size= %d, learning_rate= %f, theta= %f, " "dropout=%f, prior=%f, gamma=%d, beta%f, epochs_pretrain=%d, epochs= %d" % (som_dim[0], som_dim[1], latent_dim, batch_size, learning_rate, theta, dropout, prior, gamma, beta, epochs_pretrain, num_epochs)) f.write(", RESULTS NMI: %f + %f, PUR: %f + %f. Name: %r \n" % (NMI_mean, NMI_sd, PUR_mean, PUR_sd, ex_name)) f.close() else: results = train_model(model, data_train, data_val, data_generator, lr_val) print("\n NMI: {}, AMI: {}, PUR: {}. Name: %r.\n".format( results["NMI"], results["AMI"], results["Purity"], ex_name)) return results
def testExplicitBlocks(self, dynamic_shape, batch_shape): block_sizes = tf.convert_to_tensor(value=[2, 1, 3]) block_sizes = tf1.placeholder_with_default( block_sizes, shape=None if dynamic_shape else block_sizes.shape) exp = tfb.Exp() sp = tfb.Softplus() aff = tfb.Affine(scale_diag=[2., 3., 4.]) blockwise = tfb.Blockwise(bijectors=[exp, sp, aff], block_sizes=block_sizes, maybe_changes_size=False) x = tf.cast([0.1, 0.2, 0.3, 0.4, 0.5, 0.6], dtype=tf.float32) for s in batch_shape: x = tf.expand_dims(x, 0) x = tf.tile(x, [s] + [1] * (tensorshape_util.rank(x.shape) - 1)) x = tf1.placeholder_with_default( x, shape=None if dynamic_shape else x.shape) # Identity to break the caching. blockwise_y = tf.identity(blockwise.forward(x)) blockwise_fldj = blockwise.forward_log_det_jacobian(x, event_ndims=1) blockwise_x = blockwise.inverse(blockwise_y) blockwise_ildj = blockwise.inverse_log_det_jacobian(blockwise_y, event_ndims=1) if not dynamic_shape: self.assertEqual(blockwise_y.shape, batch_shape + [6]) self.assertEqual(blockwise_fldj.shape, batch_shape + []) self.assertEqual(blockwise_x.shape, batch_shape + [6]) self.assertEqual(blockwise_ildj.shape, batch_shape + []) self.assertAllEqual(self.evaluate(tf.shape(blockwise_y)), batch_shape + [6]) self.assertAllEqual(self.evaluate(tf.shape(blockwise_fldj)), batch_shape + []) self.assertAllEqual(self.evaluate(tf.shape(blockwise_x)), batch_shape + [6]) self.assertAllEqual(self.evaluate(tf.shape(blockwise_ildj)), batch_shape + []) expl_y = tf.concat([ exp.forward(x[..., :2]), sp.forward(x[..., 2:3]), aff.forward(x[..., 3:]), ], axis=-1) expl_fldj = sum([ exp.forward_log_det_jacobian(x[..., :2], event_ndims=1), sp.forward_log_det_jacobian(x[..., 2:3], event_ndims=1), aff.forward_log_det_jacobian(x[..., 3:], event_ndims=1) ]) expl_x = tf.concat([ exp.inverse(expl_y[..., :2]), sp.inverse(expl_y[..., 2:3]), aff.inverse(expl_y[..., 3:]) ], axis=-1) expl_ildj = sum([ exp.inverse_log_det_jacobian(expl_y[..., :2], event_ndims=1), sp.inverse_log_det_jacobian(expl_y[..., 2:3], event_ndims=1), aff.inverse_log_det_jacobian(expl_y[..., 3:], event_ndims=1) ]) self.assertAllClose(self.evaluate(expl_y), self.evaluate(blockwise_y)) self.assertAllClose(self.evaluate(expl_fldj), self.evaluate(blockwise_fldj)) self.assertAllClose(self.evaluate(expl_x), self.evaluate(blockwise_x)) self.assertAllClose(self.evaluate(expl_ildj), self.evaluate(blockwise_ildj))
def _testMVN(self, base_distribution_class, base_distribution_kwargs, batch_shape=(), event_shape=(), not_implemented_message=None): # Overriding shapes must be compatible w/bijector; most bijectors are # batch_shape agnostic and only care about event_ndims. # In the case of `Affine`, if we got it wrong then it would fire an # exception due to incompatible dimensions. batch_shape_pl = tf1.placeholder_with_default( input=np.int32(batch_shape), shape=None, name='dynamic_batch_shape') event_shape_pl = tf1.placeholder_with_default( input=np.int32(event_shape), shape=None, name='dynamic_event_shape') fake_mvn_dynamic = self._cls()( distribution=base_distribution_class(validate_args=True, **base_distribution_kwargs), bijector=tfb.Affine(shift=self._shift, scale_tril=self._tril), batch_shape=batch_shape_pl, event_shape=event_shape_pl, validate_args=True) fake_mvn_static = self._cls()( distribution=base_distribution_class(validate_args=True, **base_distribution_kwargs), bijector=tfb.Affine(shift=self._shift, scale_tril=self._tril), batch_shape=batch_shape, event_shape=event_shape, validate_args=True) actual_mean = np.tile(self._shift, [2, 1]) # Affine elided this tile. actual_cov = np.matmul(self._tril, np.transpose(self._tril, [0, 2, 1])) def actual_mvn_log_prob(x): return np.concatenate([ [ # pylint: disable=g-complex-comprehension stats.multivariate_normal(actual_mean[i], actual_cov[i]).logpdf(x[:, i, :]) ] for i in range(len(actual_cov)) ]).T actual_mvn_entropy = np.concatenate([[ stats.multivariate_normal(actual_mean[i], actual_cov[i]).entropy() ] for i in range(len(actual_cov))]) self.assertAllEqual([3], fake_mvn_static.event_shape) self.assertAllEqual([2], fake_mvn_static.batch_shape) if not tf.executing_eagerly(): self.assertAllEqual(tf.TensorShape(None), fake_mvn_dynamic.event_shape) self.assertAllEqual(tf.TensorShape(None), fake_mvn_dynamic.batch_shape) x = self.evaluate(fake_mvn_static.sample(5, seed=test_util.test_seed())) for unsupported_fn in (fake_mvn_static.log_cdf, fake_mvn_static.cdf, fake_mvn_static.survival_function, fake_mvn_static.log_survival_function): with self.assertRaisesRegexp(NotImplementedError, not_implemented_message): unsupported_fn(x) num_samples = 7e3 for fake_mvn in [fake_mvn_static, fake_mvn_dynamic]: # Ensure sample works by checking first, second moments. y = fake_mvn.sample(int(num_samples), seed=test_util.test_seed()) x = y[0:5, ...] sample_mean = tf.reduce_mean(input_tensor=y, axis=0) centered_y = tf.transpose(a=y - sample_mean, perm=[1, 2, 0]) sample_cov = tf.matmul(centered_y, centered_y, transpose_b=True) / num_samples [ sample_mean_, sample_cov_, x_, fake_event_shape_, fake_batch_shape_, fake_log_prob_, fake_prob_, fake_mean_, fake_entropy_, ] = self.evaluate([ sample_mean, sample_cov, x, fake_mvn.event_shape_tensor(), fake_mvn.batch_shape_tensor(), fake_mvn.log_prob(x), fake_mvn.prob(x), fake_mvn.mean(), fake_mvn.entropy(), ]) self.assertAllClose(actual_mean, sample_mean_, atol=0.1, rtol=0.1) self.assertAllClose(actual_cov, sample_cov_, atol=0., rtol=0.1) # Ensure all other functions work as intended. self.assertAllEqual([5, 2, 3], x_.shape) self.assertAllEqual([3], fake_event_shape_) self.assertAllEqual([2], fake_batch_shape_) self.assertAllClose(actual_mvn_log_prob(x_), fake_log_prob_, atol=0., rtol=1e-6) self.assertAllClose(np.exp(actual_mvn_log_prob(x_)), fake_prob_, atol=0., rtol=1e-5) self.assertAllClose(actual_mean, fake_mean_, atol=0., rtol=1e-6) self.assertAllClose(actual_mvn_entropy, fake_entropy_, atol=0., rtol=1e-6)
def test_num_paddings_dynamic(self): n = tf1.placeholder_with_default(2, shape=None) x = ps.pad([2, 3], paddings=[[0, n]], constant_values=1) if not ps.is_numpy(x): x = self.evaluate(x) self.assertAllEqual([2, 3, 1, 1], x)
def testMatrixEvent(self): batch_shape = [2] event_shape = [2, 3, 3] batch_shape_pl = tf1.placeholder_with_default( input=np.int32(batch_shape), shape=None, name='dynamic_batch_shape') event_shape_pl = tf1.placeholder_with_default( input=np.int32(event_shape), shape=None, name='dynamic_event_shape') scale = 2. loc = 0. fake_mvn_dynamic = self._cls()(distribution=tfd.Normal(loc=loc, scale=scale), bijector=DummyMatrixTransform(), batch_shape=batch_shape_pl, event_shape=event_shape_pl, validate_args=True) fake_mvn_static = self._cls()(distribution=tfd.Normal(loc=loc, scale=scale), bijector=DummyMatrixTransform(), batch_shape=batch_shape, event_shape=event_shape, validate_args=True) def actual_mvn_log_prob(x): # This distribution is the normal PDF, reduced over the # last 3 dimensions + a jacobian term which corresponds # to the determinant of x. return ( np.sum(stats.norm(loc, scale).logpdf(x), axis=(-1, -2, -3)) + np.sum(np.linalg.det(x), axis=-1)) self.assertAllEqual([2, 3, 3], fake_mvn_static.event_shape) self.assertAllEqual([2], fake_mvn_static.batch_shape) if not tf.executing_eagerly(): self.assertAllEqual(tf.TensorShape(None), fake_mvn_dynamic.event_shape) self.assertAllEqual(tf.TensorShape(None), fake_mvn_dynamic.batch_shape) num_samples = 5e3 for fake_mvn in [fake_mvn_static, fake_mvn_dynamic]: # Ensure sample works by checking first, second moments. y = fake_mvn.sample(int(num_samples), seed=test_util.test_seed()) x = y[0:5, ...] [ x_, fake_event_shape_, fake_batch_shape_, fake_log_prob_, fake_prob_, ] = self.evaluate([ x, fake_mvn.event_shape_tensor(), fake_mvn.batch_shape_tensor(), fake_mvn.log_prob(x), fake_mvn.prob(x), ]) # Ensure all other functions work as intended. self.assertAllEqual([5, 2, 2, 3, 3], x_.shape) self.assertAllEqual([2, 3, 3], fake_event_shape_) self.assertAllEqual([2], fake_batch_shape_) self.assertAllClose(actual_mvn_log_prob(x_), fake_log_prob_, atol=0., rtol=1e-6) # With this many dimensions and samples, the direct space probability # may underflow. self.assertAllClose(np.exp(actual_mvn_log_prob(x_)), fake_prob_, atol=1e-12, rtol=1e-5)
def test_ones_like(self): x = tf1.placeholder_with_default(tf.ones([2], dtype=tf.float32), shape=None) self.assertEqual(dtype_util.convert_to_dtype(ps.ones_like(x)), tf.float32)
def construct_model(input_tensors, encoder_w0, prefix=None): """Construct model.""" facto = tf.placeholder_with_default(1.0, ()) context_xs = input_tensors['inputa'] context_ys = input_tensors['labela'] target_xs = input_tensors['inputb'] target_ys = input_tensors['labelb'] # sample ws ~ w|(x_all,a), rs = T(ws, ys), r = mean(rs), z = T(r) # x_all = tf.concat([context_xs, target_xs], axis=1) #n_task * 20 * (128*128) # y_all = tf.concat([context_ys, target_ys], axis=1) x_all = context_xs y_all = context_ys # n_task * [n_im] * d_z if 'train' in prefix: z_samples, mu_w_all, sigma_w_all = xy_to_z(x_all, y_all, encoder_w0) z_samples = z_samples * facto else: z_samples, _, _ = xy_to_z(context_xs, context_ys, encoder_w0) z_samples = z_samples * facto target_ws, _, _ = encoder_w(target_xs, encoder_w0) input_zxs = tf.concat([z_samples, target_ws], axis=-1) # sample y_hat ~ y|(w,z) target_yhat_mu = decoder_g(input_zxs) # n_task * n_im * dim_y # when var of p(y | x,z) is fixed, neg-loglik <=> MSE mse_loss = mse(target_yhat_mu, target_ys) tf.summary.scalar(prefix + 'mse', mse_loss) optimizer1 = tf.train.AdamOptimizer(FLAGS.update_lr) optimizer2 = tf.train.AdamOptimizer(0.001) if 'train' in prefix: # mu_w_all is n_task * n_im * dim_w # target_yhat_mu is n_task * n_im * dim_w kl_ib = kl_qp_gaussian(mu_w_all, sigma_w_all, tf.zeros(tf.shape(mu_w_all)), tf.ones(tf.shape(mu_w_all))) THETA = ( # pylint: disable=invalid-name tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='decoder') + tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='encoder_w')) all_var = tf.trainable_variables() PHI = [v for v in all_var if v not in THETA] # pylint: disable=invalid-name loss = mse_loss + FLAGS.beta * kl_ib gvs_theta = optimizer1.compute_gradients(loss, THETA) train_theta_op = optimizer1.apply_gradients(gvs_theta) gvs_phi = optimizer2.compute_gradients(loss, PHI) train_phi_op = optimizer2.apply_gradients(gvs_phi) with tf.control_dependencies([train_theta_op, train_phi_op]): train_op = tf.no_op() tf.summary.scalar(prefix + 'kl', kl_ib) tf.summary.scalar(prefix + 'full_loss', loss) return mse_loss, kl_ib, train_op, facto else: return mse_loss
def testDynamicBatchShape(self, params, shape): tensor_params = tf1.placeholder_with_default(params, shape=None) k = TestKernel(tensor_params) self.assertAllEqual(shape, self.evaluate(k.batch_shape_tensor()))
def make_tensor(self, x): x = tf.cast(x, self.dtype) return tf1.placeholder_with_default( input=x, shape=x.shape if self.use_static_shape else None)
def test_dynamic(self): if tf.executing_eagerly(): return x = tf1.placeholder_with_default(tf.random.normal([3, 4, 5]), shape=None) self.assertAllEqual(3 * 4 * 5, self.evaluate(prefer_static.size(x)))
def testForwardInverse(self, input_shape, event_dims, training): """Tests forward and backward passes with different event shapes and axes. Args: input_shape: Tuple of shapes for input tensor. event_dims: Tuple of dimension indices that will be normalized. training: Boolean of whether bijector runs in training or inference mode. """ x_ = np.arange(5 * 4 * 2).astype(np.float32).reshape(input_shape) x = tf1.placeholder_with_default( x_, input_shape if 0 in event_dims else (None, ) + input_shape[1:]) # When training, memorize the exact mean of the last # minibatch that it normalized (instead of moving average assignment). layer = tf.keras.layers.BatchNormalization(axis=event_dims, momentum=0., epsilon=0.) batch_norm = tfb.BatchNormalization(batchnorm_layer=layer, training=training) # Minibatch statistics are saved only after norm_x has been computed. norm_x = batch_norm.inverse(x) with tf.control_dependencies(batch_norm.batchnorm.updates): moving_mean = tf.identity(batch_norm.batchnorm.moving_mean) moving_var = tf.identity(batch_norm.batchnorm.moving_variance) denorm_x = batch_norm.forward(tf.identity(norm_x)) fldj = batch_norm.forward_log_det_jacobian( x, event_ndims=len(event_dims)) # Use identity to invalidate cache. ildj = batch_norm.inverse_log_det_jacobian( tf.identity(denorm_x), event_ndims=len(event_dims)) self.evaluate(tf1.global_variables_initializer()) # Update variables. norm_x_ = self.evaluate(norm_x) [ norm_x_, moving_mean_, moving_var_, denorm_x_, ildj_, fldj_, ] = self.evaluate([ norm_x, moving_mean, moving_var, denorm_x, ildj, fldj, ]) self.assertStartsWith(batch_norm.name, "batch_normalization") reduction_axes = self._reduction_axes(input_shape, event_dims) keepdims = len(event_dims) > 1 expected_batch_mean = np.mean(x_, axis=reduction_axes, keepdims=keepdims) expected_batch_var = np.var(x_, axis=reduction_axes, keepdims=keepdims) if training: # When training=True, values become normalized across batch dim and # original values are recovered after de-normalizing. zeros = np.zeros_like(norm_x_) self.assertAllClose(np.mean(zeros, axis=reduction_axes), np.mean(norm_x_, axis=reduction_axes)) self.assertAllClose(expected_batch_mean, moving_mean_) self.assertAllClose(expected_batch_var, moving_var_) self.assertAllClose(x_, denorm_x_, atol=1e-5) # Since moving statistics are set to batch statistics after # normalization, ildj and -fldj should match. self.assertAllClose(ildj_, -fldj_) # ildj is computed with minibatch statistics. expected_ildj = np.sum( np.log(1.) - .5 * np.log(expected_batch_var + batch_norm.batchnorm.epsilon)) self.assertAllClose(expected_ildj, np.squeeze(ildj_)) else: # When training=False, moving_mean, moving_var remain at their # initialized values (0., 1.), resulting in no scale/shift (a small # shift occurs if epsilon > 0.) self.assertAllClose(x_, norm_x_) self.assertAllClose(x_, denorm_x_, atol=1e-5) # ildj is computed with saved statistics. expected_ildj = np.sum( np.log(1.) - .5 * np.log(1. + batch_norm.batchnorm.epsilon)) self.assertAllClose(expected_ildj, np.squeeze(ildj_))
def run_training(adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask, model_type, model=None): # Set random seed seed = 123 np.random.seed(seed) tf.random.set_random_seed(seed) #set_random_seed(seed) random.set_seed # Settings try: flags = tf.app.flags FLAGS = flags.FLAGS flags.DEFINE_string('f', '', 'kernel') flags.DEFINE_string('model', 'gcn', 'Model string.') # 'gcn', 'gcn_cheby', 'dense' flags.DEFINE_float('learning_rate', 0.000001, 'Initial learning rate.') flags.DEFINE_integer('epochs', 500, 'Number of epochs to train.') flags.DEFINE_integer('hidden1', 16, 'Number of units in hidden layer 1.') flags.DEFINE_float('dropout', 0.5, 'Dropout rate (1 - keep probability).') flags.DEFINE_float('weight_decay', 5e-4, 'Weight for L2 loss on embedding matrix.') flags.DEFINE_integer('early_stopping', 10, 'Tolerance for early stopping (# of epochs).') flags.DEFINE_integer('max_degree', 3, 'Maximum Chebyshev polynomial degree.') FLAGS = flags.FLAGS except: pass # Load data # adj, features, y_train, y_val, y_test, train_mask, val_mask, test_mask = load_data(FLAGS.dataset) # print(type(adj), adj.shape) # print(type(features), features.shape) # print(type(y_train), y_train.shape) # print(type(y_val), y_val.shape) # print(type(y_test), y_test.shape) # print(type(train_mask), train_mask.shape) # print(type(val_mask), val_mask.shape) # print(type(test_mask), test_mask.shape) # Some preprocessing features = preprocess_features(features) if model_type == 'gcn': support = [preprocess_adj(adj)] num_supports = 1 model_func = GCN elif model_type == 'gcn_cheby': support = chebyshev_polynomials(adj, FLAGS.max_degree) num_supports = 1 + FLAGS.max_degree model_func = GCN elif model_type == 'dense': support = [preprocess_adj(adj)] # Not used num_supports = 1 model_func = MLP else: raise ValueError('Invalid argument for model: ' + str(FLAGS.model)) # Define placeholders placeholders = { 'support': [tf.sparse_placeholder(tf.float32) for _ in range(num_supports)], 'features': tf.sparse_placeholder(tf.float32, shape=tf.constant(features[2], dtype=tf.int64)), 'labels': tf.placeholder(tf.float32, shape=(None, y_train.shape[1])), 'labels_mask': tf.placeholder(tf.int32), 'dropout': tf.placeholder_with_default(0., shape=()), 'num_features_nonzero': tf.placeholder(tf.int32) # helper variable for sparse dropout } # Create model if model is None: model = model_func(placeholders, input_dim=features[2][1], logging=True) else: model.placeholders = placeholders model.inputs = placeholders['features'] model.output_dim = placeholders['labels'].get_shape().as_list()[1] model.input_dim = features[2][1] # Initialize session sess = tf.Session() # Define model evaluation function def evaluate(features, support, labels, mask, placeholders): t_test = time.time() feed_dict_val = construct_feed_dict(features, support, labels, mask, placeholders) outs_val = sess.run([model.loss, model.accuracy, model.outputs], feed_dict=feed_dict_val) return outs_val[0], outs_val[1], outs_val[2], (time.time() - t_test) # Init variables sess.run(tf.global_variables_initializer()) cost_val = [] # Train model for epoch in range(FLAGS.epochs): t = time.time() # Construct feed dictionary feed_dict = construct_feed_dict(features, support, y_train, train_mask, placeholders) feed_dict.update({placeholders['dropout']: FLAGS.dropout}) # Training step outs = sess.run([model.opt_op, model.loss, model.accuracy], feed_dict=feed_dict) # Validation cost, acc, _, duration = evaluate(features, support, y_val, val_mask, placeholders) cost_val.append(cost) # Print results print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(outs[1]), "train_acc=", "{:.5f}".format(outs[2]), "val_loss=", "{:.5f}".format(cost), "val_acc=", "{:.5f}".format(acc), "time=", "{:.5f}".format(time.time() - t)) if epoch > FLAGS.early_stopping and cost_val[-1] > np.mean( cost_val[-(FLAGS.early_stopping + 1):-1]): print("Early stopping...") break # print("Optimization Finished!") # Testing test_cost, test_acc, test_outputs, test_duration = evaluate( features, support, y_test, test_mask, placeholders) print("Training results:", "cost=", "{:.5f}".format(test_cost), "time=", "{:.5f}".format( test_duration)) #"accuracy=", "{:.5f}".format(test_acc) return model, test_outputs
def testCopy(self): # 5 random index points in R^2 index_points_1 = np.random.uniform(-4., 4., (5, 2)).astype(np.float32) # 10 random index points in R^2 index_points_2 = np.random.uniform(-4., 4., (10, 2)).astype(np.float32) observation_index_points_1 = (np.random.uniform( -4., 4., (7, 2)).astype(np.float32)) observation_index_points_2 = (np.random.uniform( -4., 4., (9, 2)).astype(np.float32)) observations_1 = np.random.uniform(-1., 1., 7).astype(np.float32) observations_2 = np.random.uniform(-1., 1., 9).astype(np.float32) # ==> shape = [6, 25, 2] if not self.is_static: index_points_1 = tf1.placeholder_with_default(index_points_1, shape=None) index_points_2 = tf1.placeholder_with_default(index_points_2, shape=None) observation_index_points_1 = tf1.placeholder_with_default( observation_index_points_1, shape=None) observation_index_points_2 = tf1.placeholder_with_default( observation_index_points_2, shape=None) observations_1 = tf1.placeholder_with_default(observations_1, shape=None) observations_2 = tf1.placeholder_with_default(observations_2, shape=None) mean_fn = lambda x: np.array([0.], np.float32) kernel_1 = psd_kernels.ExponentiatedQuadratic() kernel_2 = psd_kernels.ExpSinSquared() gprm1 = tfd.GaussianProcessRegressionModel( kernel=kernel_1, index_points=index_points_1, observation_index_points=observation_index_points_1, observations=observations_1, mean_fn=mean_fn, jitter=1e-5, validate_args=True) gprm2 = gprm1.copy(kernel=kernel_2, index_points=index_points_2, observation_index_points=observation_index_points_2, observations=observations_2) precomputed_gprm1 = ( tfd.GaussianProcessRegressionModel.precompute_regression_model( kernel=kernel_1, index_points=index_points_1, observation_index_points=observation_index_points_1, observations=observations_1, mean_fn=mean_fn, jitter=1e-5, validate_args=True)) precomputed_gprm2 = precomputed_gprm1.copy(index_points=index_points_2) self.assertIs(precomputed_gprm1.mean_fn, precomputed_gprm2.mean_fn) self.assertIs(precomputed_gprm1.kernel, precomputed_gprm2.kernel) event_shape_1 = [5] event_shape_2 = [10] self.assertIsInstance(gprm1.kernel.base_kernel, psd_kernels.ExponentiatedQuadratic) self.assertIsInstance(gprm2.kernel.base_kernel, psd_kernels.ExpSinSquared) if self.is_static or tf.executing_eagerly(): self.assertAllEqual(gprm1.batch_shape, gprm2.batch_shape) self.assertAllEqual(gprm1.event_shape, event_shape_1) self.assertAllEqual(gprm2.event_shape, event_shape_2) self.assertAllEqual(gprm1.index_points, index_points_1) self.assertAllEqual(gprm2.index_points, index_points_2) self.assertAllEqual(tf.get_static_value(gprm1.jitter), tf.get_static_value(gprm2.jitter)) else: self.assertAllEqual(self.evaluate(gprm1.batch_shape_tensor()), self.evaluate(gprm2.batch_shape_tensor())) self.assertAllEqual(self.evaluate(gprm1.event_shape_tensor()), event_shape_1) self.assertAllEqual(self.evaluate(gprm2.event_shape_tensor()), event_shape_2) self.assertEqual(self.evaluate(gprm1.jitter), self.evaluate(gprm2.jitter)) self.assertAllEqual(self.evaluate(gprm1.index_points), index_points_1) self.assertAllEqual(self.evaluate(gprm2.index_points), index_points_2)
else: # First 5 is a hard-coded symmetric frame padding, ignored but time added! print("Warming up %d" % (5 - i)) print("total time " + str(srtime) + ", frame number " + str(max_iter)) # The training mode elif FLAGS.mode == 'train': # hard coded save filelist = [ 'main.py', 'lib/Teco.py', 'lib/frvsr.py', 'lib/dataloader.py', 'lib/ops.py' ] for filename in filelist: shutil.copyfile('./' + filename, FLAGS.summary_dir + filename.replace("/", "_")) useValidat = tf.placeholder_with_default(tf.constant(False, dtype=tf.bool), shape=()) rdata = frvsr_gpu_data_loader(FLAGS, useValidat) # Data = collections.namedtuple('Data', 'paths_HR, s_inputs, s_targets, image_count, steps_per_epoch') print('tData count = %d, steps per epoch %d' % (rdata.image_count, rdata.steps_per_epoch)) if (FLAGS.ratio > 0): Net = TecoGAN(rdata.s_inputs, rdata.s_targets, FLAGS) else: Net = FRVSR(rdata.s_inputs, rdata.s_targets, FLAGS) # Network = collections.namedtuple('Network', 'gen_output, train, learning_rate, update_list, ' # 'update_list_name, update_list_avg, image_summary') # Add scalar summary tf.summary.scalar('learning_rate', Net.learning_rate) train_summary = [] for key, value in zip(Net.update_list_name, Net.update_list_avg):
def _build_tensor(ndarray, dtype, use_static_shape): # Enforce parameterized dtype and static/dynamic testing. ndarray = np.asarray(ndarray).astype(dtype) return tf1.placeholder_with_default( input=ndarray, shape=ndarray.shape if use_static_shape else None)
def testIncompatibleArgShapesGraph(self): if tf.executing_eagerly(): return scale = tf1.placeholder_with_default(tf.ones([4, 1]), shape=None) with self.assertRaisesRegexp(tf.errors.OpError, r'Incompatible shapes'): d = tfd.Normal(loc=tf.zeros([2, 3]), scale=scale, validate_args=True) self.evaluate(d.mean())
def testWithCallable(self, use_init_state, use_bijector, use_dynamic_shape): if (JAX_MODE or tf.executing_eagerly()) and use_dynamic_shape: self.skipTest('Dynamic shape test.') def target_log_prob_fn(x, y): return tf.reduce_sum(-x**2, -1) - y**2 dtype = { 'x': self.dtype, 'y': self.dtype, } if use_init_state: if use_dynamic_shape: kwargs = dict( init_state={ 'x': tf.zeros((64, 2), dtype=self.dtype), 'y': tf.zeros(64, dtype=self.dtype), }) else: kwargs = dict( init_state={ 'x': tf1.placeholder_with_default(tf.zeros( (64, 2), dtype=self.dtype), shape=[None, None]), 'y': tf1.placeholder_with_default( tf.zeros(64, dtype=self.dtype), shape=[None]), }) else: if use_dynamic_shape: kwargs = dict( event_dtype=dtype, event_shape={ 'x': tf1.placeholder_with_default(tf.constant( [2], dtype=tf.int32), shape=[1]), 'y': tf1.placeholder_with_default(tf.constant( [], dtype=tf.int32), shape=[0]), }, ) else: kwargs = dict( event_dtype=dtype, event_shape={ 'x': [2], 'y': [], }, ) if use_bijector: kwargs.update(event_space_bijector={ 'x': tfb.Exp(), 'y': tfb.Identity() }) seed = test_util.test_seed(sampler_type='stateless') results = tfp.experimental.mcmc.sample_snaper_hmc(target_log_prob_fn, 2, num_burnin_steps=2, seed=seed, **kwargs) trace = self.evaluate(results.trace) states = trace[0] self.assertAllAssertsNested(self.assertAllNotNan, states) self.assertEqual(dtype, tf.nest.map_structure(lambda x: x.dtype, states)) self.assertTrue( hasattr(results.final_kernel_results, 'target_accept_prob'))
def _build_placeholder(self, ndarray): ndarray = np.asarray(ndarray).astype(self.dtype) return tf1.placeholder_with_default( input=ndarray, shape=ndarray.shape if self.use_static_shape else None)