is_observed=True) test_images = EmpiricalVariable( dataset["data"][ind[dataset_size:], :].astype("float32"), indices=test_indices, name="x_test", is_observed=True) test_labels = EmpiricalVariable( dataset["target"][ind[dataset_size:]].astype("int32"), indices=test_indices, name="labels", is_observed=True) test_model = ProbabilisticModel([test_images, test_labels]) for model_index in range(num_particles): s = 0 model.set_posterior_model( inference_method.sampler_model[model_index]) scores_0 = [] test_image_list = [] test_label_list = [] for _ in range(num_images): test_sample = test_model._get_sample(1) test_image, test_label = test_sample[test_images], test_sample[ test_labels] test_image_list.append(test_image) test_label_list.append(test_label) for test_image, test_label in zip(test_image_list, test_label_list): model_output = np.reshape(np.mean(model._get_posterior_sample( 30, input_values={x: test_image})[k].detach().numpy(), axis=0),
Qb2 = NormalVariable(np.zeros((number_output_classes, 1)), 0.2 * np.ones((number_output_classes, 1)), "b2", learnable=True) Qweights1 = NormalVariable(np.zeros((number_hidden_units, number_pixels)), 0.2 * np.ones((number_hidden_units, number_pixels)), "weights1", learnable=True) Qweights2 = NormalVariable(np.zeros( (number_output_classes, number_hidden_units)), 0.2 * np.ones( (number_output_classes, number_hidden_units)), "weights2", learnable=True) variational_model = ProbabilisticModel([Qb1, Qb2, Qweights1, Qweights2]) model.set_posterior_model(variational_model) # Inference inference.perform_inference(model, number_iterations=2000, number_samples=50, optimizer='Adam', lr=0.005) #0.05 # Test accuracy num_images = 500 test_size = len(test) test_indices = RandomIndices(dataset_size=test_size, batch_size=1, name="test_indices", is_observed=True)
# Initialize encoder and decoders encoder = BF.BrancherFunction(EncoderArchitecture(image_size=image_size, latent_size=latent_size)) decoder = BF.BrancherFunction(DecoderArchitecture(latent_size=latent_size, image_size=image_size)) # Generative model z = NormalVariable(np.zeros((latent_size,)), np.ones((latent_size,)), name="z") decoder_output = decoder(z) x = NormalVariable(decoder_output["mean"], decoder_output["sd"], name="x") model = ProbabilisticModel([x, z]) # Amortized variational distribution Qx = EmpiricalVariable(dataset, batch_size=50, name="x", is_observed=True) encoder_output = encoder(Qx) Qz = NormalVariable(encoder_output["mean"], encoder_output["sd"], name="z") model.set_posterior_model(ProbabilisticModel([Qx, Qz])) # Joint-contrastive inference inference.perform_inference(model, number_iterations=5000, number_samples=1, optimizer="Adam", lr=0.005) loss_list = model.diagnostics["loss curve"] #Plot results plt.plot(loss_list) plt.show() sample = model.get_sample(1) plt.imshow(np.reshape(sample["x"][0], newshape=(28, 28)))
Qh.append( NormalVariable(BF.sigmoid(Qhlambda[t]) * new_h + (1 - BF.sigmoid(Qhlambda[t])) * Qh_mean[t], 2 * driving_noise, h_names[t], learnable=True)) Qz.append( NormalVariable(BF.sigmoid(Qzlambda[t]) * new_z + (1 - BF.sigmoid(Qzlambda[t])) * Qz_mean[t], 2 * driving_noise, z_names[t], learnable=True)) variational_posterior = ProbabilisticModel(Qx + Qh + Qz) AR_model.set_posterior_model(variational_posterior) # Inference # inference.perform_inference(AR_model, number_iterations=N_itr_PC, number_samples=N_smpl, optimizer=optimizer, lr=lr) loss_list1 = AR_model.diagnostics["loss curve"] # ELBO #ELBO1.append(float(AR_model.estimate_log_model_evidence(N_ELBO_smpl).detach().numpy())) #print("PC {}".format(ELBO1[-1])) # MSE
# Observations sample = model.get_sample(1) data = sample.filter(regex="^score").filter(regex="^((?!scale).)*$") model.observe(data) # Variational model Qgroup_means = [ Normal(0., 4., "group_mean_{}".format(n), learnable=True) for n in range(N_groups) ] Qpeople_means = [ Normal(0., 0.1, "person_{}".format(m), learnable=True) for m, assignment_list in enumerate(assignment_matrix) ] model.set_posterior_model(ProbabilisticModel(Qpeople_means + Qgroup_means)) # Inference # N_itr = 300 N_smpl = 50 optimizer = "SGD" lr = 0.00001 inference.perform_inference(model, number_iterations=N_itr, number_samples=N_smpl, optimizer=optimizer, lr=lr) loss_list2 = model.diagnostics["loss curve"] N_ELBO = 1000 ELBO2 = model.estimate_log_model_evidence(1000)
print(sample) # Print samples from single variable x_sample = x.get_sample(10) print(x_sample) # Print samples conditional on an input in_sample = model.get_sample(10, input_values={mu: 100.}) print(in_sample) # # Generate data data = x_real._get_sample(number_samples=50) # Observe data x.observe(data[x_real][:, 0, :]) # Variational model Qnu = LogNormalVariable(0., 1., "nu", learnable=True) Qmu = NormalVariable(0., 1., "mu", learnable=True) model.set_posterior_model(ProbabilisticModel([Qmu, Qnu])) # Inference inference.stochastic_variational_inference(model, number_iterations=100, number_samples=50, optimizer=chainer.optimizers.Adam(0.1)) loss_list = model.diagnostics["loss curve"] # print posterior sample post_samples = model.get_posterior_sample(10) print(post_samples)
#samples = model._get_sample(300) #model.calculate_log_probability(samples) # Observations k.observe(labels) #observed_model = inference.get_observed_model(model) #observed_samples = observed_model._get_sample(number_samples=1, observed=True) # Variational Model Qweights = NormalVariable(np.zeros((1, number_regressors)), np.ones((1, number_regressors)), "weights", learnable=True) model.set_posterior_model(ProbabilisticModel([Qweights])) # Inference inference.perform_inference(model, number_iterations=200, number_samples=100, optimizer='Adam', lr=0.05) loss_list = model.diagnostics["loss curve"] plt.plot(loss_list) plt.show() # Statistics posterior_samples = model._get_posterior_sample(50) weights_posterior_samples = posterior_samples[weights].cpu().detach().numpy()
encoder_output1 = DeterministicVariable(encoder1(Qx), name="encoder_output1") Qz3 = NormalVariable(encoder_output1["mean"], encoder_output1["sd"], name="z3") encoder_output2 = DeterministicVariable(encoder2(encoder_output1["mean"]), name="encoder_output2") Qz2 = NormalVariable(encoder_output2["mean"], encoder_output2["sd"], name="z2") encoder_output3 = DeterministicVariable(encoder3(encoder_output2["mean"]), name="encoder_output3") Qz1 = NormalVariable(encoder_output3["mean"], encoder_output3["sd"], name="z1") model.set_posterior_model(ProbabilisticModel([Qx, Qz1, Qz2, Qz3, Qlabels])) # Joint-contrastive inference inference.perform_inference( model, inference_method=ReverseKL( gradient_estimator=PathwiseDerivativeEstimator), number_iterations=num_itr, number_samples=1, optimizer="Adam", lr=0.0005) loss_list1.append(np.array(model.diagnostics["loss curve"])) ELBO1 = [] for n in range(N_ELBO_ITR): ELBO1.append(
# Local variational models plt.plot(loss_list) plt.show() # Test accuracy num_images = 2000 test_size = len(test) test_indices = RandomIndices(dataset_size=test_size, batch_size=1, name="test_indices", is_observed=True) test_images = EmpiricalVariable(np.array([np.reshape(image[0], newshape=(number_pixels, 1)) for image in test]).astype("float32"), indices=test_indices, name="x_test", is_observed=True) test_labels = EmpiricalVariable(np.array([image[1]*np.ones((1, 1)) for image in test]).astype("int32"), indices=test_indices, name="labels", is_observed=True) test_model = ProbabilisticModel([test_images, test_labels]) s = 0 model.set_posterior_model(variational_samplers[0]) scores_0 = [] test_image_list = [] test_label_list = [] for _ in range(num_images): test_sample = test_model._get_sample(1) test_image, test_label = test_sample[test_images], test_sample[test_labels] test_image_list.append(test_image) test_label_list.append(test_label) for test_image, test_label in zip(test_image_list,test_label_list): model_output = np.reshape(np.mean(model._get_posterior_sample(10, input_values={x: test_image})[k].data, axis=0), newshape=(10,)) output_label = int(np.argmax(model_output)) scores_0.append(1 if output_label == int(test_label.data) else 0) s += 1 if output_label == int(test_label.data) else 0
def perform_inference(joint_model, number_iterations, number_samples=1, optimizer='Adam', input_values={}, inference_method=None, posterior_model=None, sampler_model=None, pretraining_iterations=0, **opt_params): #TODO: input values """ Summary Parameters --------- """ if isinstance(joint_model, StochasticProcess): joint_model = joint_model.active_submodel if isinstance(joint_model, Variable): joint_model = ProbabilisticModel([joint_model]) if not inference_method: warnings.warn( "The inference method was not specified, using the default reverse KL variational inference" ) inference_method = ReverseKL() if not posterior_model and joint_model.posterior_model is not None: posterior_model = joint_model.posterior_model else: posterior_model = inference_method.construct_posterior_model( joint_model) if not sampler_model: #TODO: clean up if not sampler_model: try: sampler_model = inference_method.sampler_model except AttributeError: try: sampler_model = joint_model.posterior_sampler except AttributeError: sampler_model = None joint_model.update_observed_submodel() def append_prob_optimizer(model, optimizer, **opt_params): prob_opt = ProbabilisticOptimizer( model, optimizer, **opt_params ) # TODO: this should be better! handling models with no params if prob_opt.optimizer: optimizers_list.append(prob_opt) optimizers_list = [] if inference_method.learnable_posterior: append_prob_optimizer(posterior_model, optimizer, **opt_params) if inference_method.learnable_model: append_prob_optimizer(joint_model, optimizer, **opt_params) if inference_method.learnable_sampler: append_prob_optimizer(sampler_model, optimizer, **opt_params) loss_list = [] inference_method.check_model_compatibility(joint_model, posterior_model, sampler_model) for iteration in tqdm(range(number_iterations)): loss = inference_method.compute_loss(joint_model, posterior_model, sampler_model, number_samples) if torch.isfinite(loss.detach()).all().item(): [opt.zero_grad() for opt in optimizers_list] loss.backward() inference_method.correct_gradient(joint_model, posterior_model, sampler_model, number_samples) optimizers_list[0].update() if iteration > pretraining_iterations: [opt.update() for opt in optimizers_list[1:]] loss_list.append(loss.cpu().detach().numpy().flatten()) else: warnings.warn("Numerical error, skipping sample") loss_list.append(loss.cpu().detach().numpy()) joint_model.diagnostics.update({"loss curve": np.array(loss_list)}) inference_method.post_process( joint_model) #TODO: this could be implemented with a with block if joint_model.posterior_model is None and inference_method.learnable_posterior: joint_model.set_posterior_model(posterior_model)
# Observe observable_data = sample[[x.name for x in x_series] + [y.name for y in y_series]] dynamic_causal_model.observe(observable_data) # Variational model Qa = LogNormalVariable(0., 0.5, name="a", learnable=True) Qb = LogNormalVariable(0., 0.5, name="b", learnable=True) Qc = NormalVariable(0., 0.1, name="c", learnable=True) Qd = NormalVariable(0., 0.1, name="d", learnable=True) Qe = NormalVariable(0., 5., name="e", learnable=True) Qxi = LogNormalVariable(0.1, 0.1, name="xi", learnable=True) Qchi = LogNormalVariable(0.1, 0.1, name="chi", learnable=True) variational_posterior = ProbabilisticModel([Qa, Qb, Qc, Qd, Qe, Qxi, Qchi]) dynamic_causal_model.set_posterior_model(variational_posterior) # Inference # inference.perform_inference(dynamic_causal_model, number_iterations=100, number_samples=5, optimizer='Adam', lr=0.01) loss_list = dynamic_causal_model.diagnostics["loss curve"] plt.plot(loss_list) plt.show() # Plot posterior plot_posterior(dynamic_causal_model, variables=["a", "b", "c", "d", "e", "xi", "chi"]) plt.show()
plt.show() # Test accuracy test_size = len(ind[dataset_size:]) num_images = test_size*3 test_indices = RandomIndices(dataset_size=test_size, batch_size=1, name="test_indices", is_observed=True) test_images = EmpiricalVariable(dataset["data"][ind[dataset_size:], :].astype("float32"), indices=test_indices, name="x_test", is_observed=True) test_labels = EmpiricalVariable(dataset["target"][ind[dataset_size:]].astype("int32"), indices=test_indices, name="labels", is_observed=True) test_model = ProbabilisticModel([test_images, test_labels]) for model_index in range(num_particles): s = 0 model.set_posterior_model(particles[model_index]) scores_0 = [] test_image_list = [] test_label_list = [] for _ in range(num_images): test_sample = test_model._get_sample(1) test_image, test_label = test_sample[test_images], test_sample[test_labels] test_image_list.append(test_image) test_label_list.append(test_label) for test_image, test_label in zip(test_image_list,test_label_list): model_output = np.reshape(np.mean(model._get_posterior_sample(80, input_values={x: test_image})[k].detach().numpy(), axis=0), newshape=(number_output_classes,)) output_label = int(np.argmax(model_output)) scores_0.append(1 if output_label == int(test_label.detach().numpy()) else 0) s += 1 if output_label == int(test_label.detach().numpy()) else 0 print("Accuracy {}: {} %".format(model_index, 100*s/float(num_images)))
# Forward pass final_activations = BF.matmul(weights, x) k = CategoricalVariable(logits=final_activations, name="k") # Probabilistic model model = ProbabilisticModel([k]) # Observations k.observe(labels) # Variational model initial_weights = np.random.normal(0., 1., (number_output_classes, number_regressors)) model.set_posterior_model( ProbabilisticModel( [RootVariable(initial_weights, name="weights", learnable=True)])) # Inference inference.perform_inference(model, inference_method=MAP(), number_iterations=3000, number_samples=100, optimizer="SGD", lr=0.0025) loss_list = model.diagnostics["loss curve"] plt.show() # Test accuracy test_size = len(ind[dataset_size:]) num_images = test_size * 3