# Real model nu_real = 1. mu_real = -2. x_real = NormalVariable(mu_real, nu_real, "x_real") # Normal model nu = LogNormalVariable(0., 1., "nu") mu = NormalVariable(0., 10., "mu") x = NormalVariable(mu, nu, "x") model = ProbabilisticModel([x]) print(model) # Print samples sample = model.get_sample(10) 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, :])
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))) plt.show() sample = model.get_sample(1) plt.imshow(np.reshape(sample["x"][0], newshape=(28, 28))) plt.show() sample = model.get_sample(1) plt.imshow(np.reshape(sample["x"][0], newshape=(28, 28))) plt.show()
import numpy as np from brancher.variables import ProbabilisticModel from brancher.standard_variables import BetaVariable, BinomialVariable from brancher import inference from brancher.visualizations import plot_posterior # betaNormal/Binomial model number_tosses = 1 p = BetaVariable(1., 1., "p") k = BinomialVariable(number_tosses, probs=p, name="k") model = ProbabilisticModel([k, p]) # Generate data p_real = 0.8 data = model.get_sample(number_samples=30, input_values={p: p_real}) # Observe data k.observe(data) # Inference inference.perform_inference(model, number_iterations=1000, number_samples=500, lr=0.1, optimizer='SGD') loss_list = model.diagnostics["loss curve"] #Plot loss plt.plot(loss_list) plt.title("Loss (negative ELBO)")
# Joint-contrastive inference inference.perform_inference( model, inference_method=ReverseKL(gradient_estimator=PathwiseDerivativeEstimator), number_iterations=1000, number_samples=1, optimizer="Adam", lr=0.001) loss_list = model.diagnostics["loss curve"] #Plot results plt.plot(loss_list) plt.show() sigmoid = lambda x: 1 / (np.exp(-x) + 1) image_grid = [] z_range = np.linspace(-3, 3, 30) for z1 in z_range: image_row = [] for z2 in z_range: sample = model.get_sample(1, input_values={z: np.array([z1, z2])}) image = sigmoid( np.reshape(sample["decoder_output"].values[0]["mean"], newshape=(28, 28))) image_row += [image] image_grid += [np.concatenate(image_row, axis=0)] image_grid = np.concatenate(image_grid, axis=1) plt.imshow(image_grid) plt.colorbar() plt.show()
"muy_{}".format(t + 1), is_observed=True)) mx.append(new_mx) my.append(new_my) sx.append(new_sx) sy.append(new_sy) model = ProbabilisticModel(w + r + mux + muy) variational_filter = ProbabilisticModel(Qmux + Qmuy) # Variational model print(model.get_average_reward(10)) # Train control num_itr = 3000 inference.perform_inference(model, posterior_model=variational_filter, number_iterations=num_itr, number_samples=9, optimizer="Adam", lr=0.01) reward_list = model.diagnostics[ "reward curve"] #TODO: Very important. Solve the trained determinant problem. (it should be possible to specify which parameter is trainable) print(model.get_sample(20)[["r"]]) plt.plot(reward_list) plt.show() print(model.get_average_reward(15))
Qlambda31 = RootVariable(l0 * np.ones((latent_size3, )), 'lambda31', learnable=True) Qlambda32 = RootVariable(l0 * np.ones((latent_size3, )), 'lambda32', learnable=True) Qz3 = NormalVariable( BF.sigmoid(Qlambda31) * BF.relu(Qdecoder_output2["mean"]) + (1 - BF.sigmoid(Qlambda31)) * encoder_output1["mean"], BF.sigmoid(Qlambda32) * z3sd + (1 - BF.sigmoid(Qlambda32)) * encoder_output1["sd"], name="z3") model.set_posterior_model(ProbabilisticModel([Qx, Qz1, Qz2, Qz3, Qlabels])) model.get_sample(1) model.posterior_model.get_sample(1) # Joint-contrastive inference inference.perform_inference( model, inference_method=ReverseKL( gradient_estimator=PathwiseDerivativeEstimator), number_iterations=num_itr, number_samples=1, optimizer="Adam", lr=0.002) loss_list2.append(np.array(model.diagnostics["loss curve"])) # ELBO2 = [] for n in range(N_ELBO_ITR):
# Joint-contrastive inference inference.perform_inference( model, inference_method=ReverseKL(gradient_estimator=Taylor2Estimator), number_iterations=2000, number_samples=1, optimizer="SGD", lr=0.001) loss_list = model.diagnostics["loss curve"] #Plot results plt.plot(loss_list) plt.show() sigmoid = lambda x: 1 / (np.exp(-x) + 1) image_grid = [] num_images = 30 z_values = [ np.random.binomial(1, 0.5 * np.ones(latent_size, )) for _ in range(num_images) ] for z_val in z_values: sample = model.get_sample(1, input_values={z: z_val}) image = sigmoid( np.reshape(sample["decoder_output"].values[0]["mean"], newshape=(28, 28))) image_grid += [image] image_grid = np.concatenate(image_grid, axis=1) plt.imshow(image_grid) plt.colorbar() plt.show()
from brancher.standard_variables import NormalVariable, LogNormalVariable from brancher import inference # Normal model nu = LogNormalVariable(0., 1., "nu") mu = NormalVariable(0., 10., "mu") x = NormalVariable(mu, nu, "x") model = ProbabilisticModel( [x]) # to fix plot_posterior (flatten automatically?) # # Generate data nu_real = 1. mu_real = -2. data = model.get_sample(number_samples=20, input_values={ mu: mu_real, nu: nu_real }) # Observe data x.observe(data) # 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.perform_inference(model, number_iterations=300, number_samples=100,
# Probabilistic model T = 2. N = 100 dt = T/float(N) time_range = np.linspace(0., T, N) a = BetaVariable(1., 1., name="a") b = BetaVariable(1., 1., name="b") c = NormalVariable(0., 0.1, name="c") d = NormalVariable(0., 0.1, name="d") xi = LogNormalVariable(0.1, 0.1, name="xi") chi = LogNormalVariable(0.1, 0.1, name="chi") x_series = [NormalVariable(0., 1., name="x_0")] y_series = [NormalVariable(0., 1., name="y_0")] for n, t in enumerate(time_range): x_new_mean = (1-dt*a)*x_series[-1] + dt*c*y_series[-1] y_new_mean = (1-dt*b)*y_series[-1] + dt*d*x_series[-1] x_series += [NormalVariable(x_new_mean, np.sqrt(dt)*xi, name="x_{}".format(n+1))] y_series += [NormalVariable(x_new_mean, np.sqrt(dt)*chi, name="y_{}".format(n+1))] dynamic_causal_model = ProbabilisticModel([x_series[-1], y_series[-1]]) # Run dynamics sample = dynamic_causal_model.get_sample(number_samples=3) # 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
x_series += [ NormalVariable(x_new_mean, np.sqrt(dt) * xi, name="x_{}".format(n + 1)) ] y_series += [ NormalVariable(y_new_mean, np.sqrt(dt) * chi, name="y_{}".format(n + 1)) ] dynamic_causal_model = ProbabilisticModel([x_series[-1], y_series[-1]]) # Run dynamics sample = dynamic_causal_model.get_sample(number_samples=2, input_values={ a: 1., b: 1., c: 0., d: 3., e: 10., xi: 2., chi: 2. }) # Plot sample time_series = sample[[x.name for x in x_series]].transpose().plot() plt.show() # 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
# # model = ProbabilisticModel([k]) # # perform_inference(model, # inference_method=MaximumLikelihood(), # number_iterations=100, # optimizer="Adam", # lr=0.001) # loss_list = model.diagnostics["loss curve"] # plt.plot(loss_list) # print(loss_list[-1]) # plt.show() N = 500 test_size = test.test_data.numpy().shape[0] test_images = np.reshape(test.test_data.numpy(), newshape=(test_size, image_size * image_size)) pred_labels = np.argmax(model.get_sample(1, input_values={x: test_images[:N, :] })["k"][0], axis=1) true_labels = test.test_labels.numpy()[:N] s = 0 for p_l, l in zip(pred_labels, true_labels): if p_l == l: s += 1 print("Accuracy: {}".format(s / float(N)))
Wk2, stride=2, padding=0), (2, 3)), name="z") Wl = NormalVariable(loc=np.zeros((num_classes, out_channels2)), scale=np.ones((num_classes, out_channels2)), name="Wl") b = NormalVariable(loc=np.zeros((num_classes, 1)), scale=np.ones((num_classes, 1)), name="b") reshaped_z = BF.reshape(z, shape=(out_channels2, 1)) k = CategoricalVariable(logits=BF.linear(reshaped_z, Wl, b), name="k") # Probabilistic model model = ProbabilisticModel([k]) samples = model.get_sample(10) # Observations k.observe(labels) # Variational model num_particles = 4 #10 wk1_locations = [ np.random.normal(0., 1., (out_channels1, in_channels, 3, 3)) for _ in range(num_particles) ] wk2_locations = [ np.random.normal(0., 1., (out_channels2, out_channels1, 3, 3)) for _ in range(num_particles) ] wl_locations = [
nu = LogNormalVariable(-1, 0.01, name="nu") receptive_field = BF.exp((-(x - mu_x)**2 - (y - mu_y)**2) / (2. * v**2)) / (2. * BF.sqrt(np.pi * v**2)) mean_response = BF.sum(BF.sum(receptive_field * experimental_input, dim=1, keepdim=True), dim=2, keepdim=True) #TODO; not very intuitive response = NormalVariable(mean_response, nu, name="response") model = ProbabilisticModel([response, experimental_input]) # Generate data and observe the model sample = model.get_sample(15, input_values={ mu_x: 1., mu_y: 2., v: 0.3, nu: 0.1 })[["x", "y", "w1", "w2", "b", "response"]] model.observe(sample) # Variational model Qmu_x = NormalVariable(0., 1., name="mu_x", learnable=True) Qmu_y = NormalVariable(0., 1., name="mu_y", learnable=True) Qv = LogNormalVariable(0., 0.1, name="v", learnable=True) Qnu = LogNormalVariable(-1, 0.01, name="nu", learnable=True) variational_posterior = ProbabilisticModel([Qmu_x, Qmu_y, Qv, Qnu]) model.set_posterior_model(variational_posterior) # Inference # inference.perform_inference(model,