# 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)")
plt.show()
#Plot posterior
plot_posterior(model, variables=["p"])
plt.show()
## Sample ##
num_timepoints = 20
temporal_sample = Y.get_timeseries_sample(1,
query_points=num_timepoints,
input_values={
sigma: 1.,
b: 1.
})
temporal_sample.plot()
plt.show()
## Observe model ##
data = temporal_sample
query_points = range(num_timepoints)
Y.observe(data, query_points)
## Perform ML inference ##
perform_inference(Y,
inference_method=ReverseKL(),
number_iterations=1000,
optimizer="SGD",
lr=0.005)
loss_list = Y.active_submodel.diagnostics["loss curve"]
plt.plot(loss_list)
plt.show()
## Sample ##
post_temporal_sample = Y.get_posterior_timeseries_sample(20, query_points=100)
post_temporal_sample.plot()
plt.show()
print("Done")
num_timepoints = 50
temporal_sample = X.get_timeseries_sample(1,
query_points=num_timepoints,
input_values={
sigma: 1.,
b: 1.,
c: -0.05
})
#temporal_sample.plot()
#plt.show()
## Observe model ##
data = temporal_sample
query_points = range(num_timepoints)
X.observe(data, query_points)
## Perform ML inference ##
perform_inference(X,
inference_method=MAP(),
number_iterations=1000,
optimizer="SGD",
lr=0.001)
loss_list = X.active_submodel.diagnostics["loss curve"]
plt.plot(loss_list)
plt.show()
## Sample ##
post_temporal_sample = X.get_posterior_timeseries_sample(20, query_points=100)
post_temporal_sample.plot()
plt.show()
# Observations
k.observe(labels)
# Variational Model
Qweights = NormalVariable(np.zeros((number_output_classes, number_pixels)),
0.1 * np.ones(
(number_output_classes, number_pixels)),
"weights",
learnable=True)
variational_model = ProbabilisticModel([Qweights])
model.set_posterior_model(variational_model)
# Inference
inference.perform_inference(model,
number_iterations=1000,
number_samples=10,
optimizer="Adam",
lr=0.005)
# Loss Curve
plt.plot(model.diagnostics["loss curve"])
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.reshape(test.test_data.numpy(),
learnable=True),
NormalVariable(loc=loc2,
scale=0.1,
name="weights2",
learnable=True)
]) for loc1, loc2 in zip(initial_locations1, initial_locations2)
]
# Inference
inference_method = WVGD(variational_samplers=variational_samplers,
particles=particles,
biased=False)
inference.perform_inference(model,
inference_method=inference_method,
number_iterations=1000,
number_samples=100,
optimizer="Adam",
lr=0.0025,
posterior_model=particles,
pretraining_iterations=0)
loss_list = model.diagnostics["loss curve"]
# 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,
if t in y_range:
l = 1.
else:
l = 1.
Qx_mean.append(RootVariable(0, x_names[t] + "_mean", learnable=True))
Qlambda.append(RootVariable(l, x_names[t] + "_lambda", learnable=True))
new_mu = (-1 - omega ** 2 * dt ** 2 + b * dt) * Qx[t - 2] + (2 - b * dt) * Qx[t - 1]
Qx.append(NormalVariable(BF.sigmoid(Qlambda[t])*new_mu + (1 - BF.sigmoid(Qlambda[t]))*Qx_mean[t],
np.sqrt(dt) * driving_noise, x_names[t], learnable=True))
variational_posterior = ProbabilisticModel(Qx)
AR_model.set_posterior_model(variational_posterior)
# Inference #
inference.perform_inference(AR_model,
number_iterations=N_itr,
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("PE {}".format(ELBO1[-1]))
# Mean-field variational distribution #
Qx = [NormalVariable(0., 1., 'x0', learnable=True)]
for t in range(1, T):
Qx.append(NormalVariable(0, 2., x_names[t], learnable=True))
variational_posterior = ProbabilisticModel(Qx)
#Generate data
data = y.get_sample(20, input_values={z1: 1, z2: 0})
data.hist(bins=20)
plt.show()
#Observe data
y.observe(data)
#Variational Model
Qz1 = BernulliVariable(logits=0., name="z1", learnable=True)
Qz2 = BernulliVariable(logits=0., name="z2", learnable=True)
variational_model = ProbabilisticModel([Qz1, Qz2])
model.set_posterior_model(variational_model)
# Joint-contrastive inference
inference.perform_inference(
model,
inference_method=ReverseKL(gradient_estimator=Taylor1Estimator),
number_iterations=600,
number_samples=20,
optimizer="SGD",
lr=0.001)
loss_list = model.diagnostics["loss curve"]
#Plot results
plt.plot(loss_list)
plt.show()
#Plot posterior
model.get_posterior_sample(200).hist(bins=20)
plt.show()
#z2 = Deterministic(BF.relu(BF.matmul(W2, z1)), "z2")
#rho = Deterministic(0.1*BF.matmul(W3, z2), "rho")
rho = Deterministic(BF.matmul(V, x / 255), "rho")
k = Categorical(logits=rho, name="k")
# Observe
k.observe(labels)
model = ProbabilisticModel([k])
# Train
from brancher.inference import MaximumLikelihood
from brancher.inference import perform_inference
perform_inference(model,
inference_method=MaximumLikelihood(),
number_iterations=150,
optimizer="Adam",
lr=0.01)
loss_list = model.diagnostics["loss curve"]
plt.plot(loss_list)
print(loss_list[-1])
plt.show()
# import torch
#
#
# class PytorchNetwork(torch.nn.Module):
# def __init__(self):
# super(PytorchNetwork, self).__init__()
# out_channels = 5
# image_size = 28
# 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()
# Importance sampling distributions
variational_samplers = [
ProbabilisticModel(
[NormalVariable(mu=location, sigma=0.1, name="theta", learnable=True)])
for location in initial_locations
]
# Inference
inference_method = WVGD(variational_samplers=variational_samplers,
particles=particles,
biased=False,
number_post_samples=20000)
inference.perform_inference(model,
inference_method=inference_method,
number_iterations=800,
number_samples=50,
optimizer=chainer.optimizers.Adam(0.005),
posterior_model=particles,
pretraining_iterations=0)
loss_list = model.diagnostics["loss curve"]
# Local variational models
plt.plot(loss_list)
plt.show()
# Samples
print(inference_method.weights)
M = 2000
[sampler._get_sample(M) for sampler in inference_method.sampler_model]
samples = [sampler.get_sample(M) for sampler in inference_method.sampler_model]
ensemble_histogram(samples,
torch.ones((T, 1)),
"z",
learnable=True)
Qtrz = PlanarFlow(w2, u2, b2)(PlanarFlow(w1, u1, b1)(z))
Qx = []
for t in range(0, T):
Qx.append(DeterministicVariable(Qtrz[t], name=x_names[t]))
variational_model = ProbabilisticModel(Qx)
AR_model.set_posterior_model(variational_model)
# Inference #
inference.perform_inference(AR_model,
number_iterations=300,
number_samples=50,
optimizer="Adam",
lr=0.01)
loss_list = AR_model.diagnostics["loss curve"]
# Statistics
posterior_samples = AR_model._get_posterior_sample(2000)
x_mean = []
lower_bound = []
upper_bound = []
for xt in x:
x_posterior_samples = posterior_samples[xt].detach().numpy().flatten()
mean = np.mean(x_posterior_samples)
sd = np.sqrt(np.var(x_posterior_samples))
k.observe(labels)
# Variational model
num_particles = 5 #10
initial_locations = [np.random.normal(0., 1., (number_output_classes, number_regressors))
for _ in range(num_particles)]
particles = [ProbabilisticModel([RootVariable(location, name="weights", learnable=True)])
for location in initial_locations]
initial_particles = copy.deepcopy(particles)
# Inference
inference_method = SVGD()
inference.perform_inference(model,
inference_method=inference_method,
number_iterations=3000,
number_samples=100,
optimizer="SGD",
lr=0.0025,
posterior_model=particles)
loss_list = model.diagnostics["loss curve"]
# Local variational models
plt.plot(loss_list)
plt.show()
plot_particles(initial_particles, "weights", 1, 2, c="r")
plot_particles(particles, "weights", 1, 2, c="b")
plt.show()
# Test accuracy
test_size = len(ind[dataset_size:])
num_images = test_size*3
from brancher import geometric_ranges
x = DeterministicVariable(1., "x", is_observed=True)
y = NormalVariable(-1., 0.1, "y", is_observed=True)
z = NormalVariable(0., 0.1, "z", is_observed=True)
w = DirichletVariable(np.ones((3, 1)), "w", is_policy=True, learnable=True)
r = DeterministicVariable((w[0] * x + w[1] * y + w[2] * z),
"r",
is_reward=True,
is_observed=True)
model = ProbabilisticModel([w, x, y, z, r])
print(model.get_average_reward(10))
# Train control
num_itr = 3000
inference.perform_inference(model,
inference_method=inference.MaximumLikelihood(),
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))
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
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,
Qx = [NormalVariable(0., 1., 'x0', learnable=True)]
Qx_mean = [RootVariable(0., 'x0_mean', learnable=True)]
for t in range(1, T):
Qx_mean.append(RootVariable(0., x_names[t] + "_mean", learnable=True))
Qx.append(
NormalVariable(logit_b_post * Qx[t - 1] + Qx_mean[t],
1.,
x_names[t],
learnable=True))
variational_posterior = ProbabilisticModel([Qb] + Qx)
AR_model.set_posterior_model(variational_posterior)
# Inference #
inference.perform_inference(AR_model,
number_iterations=200,
number_samples=100,
optimizer='Adam',
lr=0.05)
loss_list = AR_model.diagnostics["loss curve"]
# Statistics
posterior_samples = AR_model._get_posterior_sample(2000)
b_posterior_samples = posterior_samples[b].detach().numpy().flatten()
b_mean = np.mean(b_posterior_samples)
b_sd = np.sqrt(np.var(b_posterior_samples))
x_mean = []
lower_bound = []
upper_bound = []
for xt in x:
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.perform_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)
name="z")
decoder_output = DeterministicVariable(decoder(z), name="decoder_output")
x = BinomialVariable(total_count=1, logits=decoder_output["mean"], name="x")
model = ProbabilisticModel([x, z])
# Amortized variational distribution
Qx = EmpiricalVariable(dataset, batch_size=100, name="x", is_observed=True)
encoder_output = DeterministicVariable(encoder(Qx), name="encoder_output")
Qz = NormalVariable(encoder_output["mean"], encoder_output["sd"], name="z")
model.set_posterior_model(ProbabilisticModel([Qx, Qz]))
# 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:
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,
optimizer='SGD',
lr=0.0001)
loss_list = model.diagnostics["loss curve"]
plt.plot(loss_list)
plt.title("Loss (negative ELBO)")
plt.show()
from brancher.visualizations import plot_posterior
plot_posterior(model, variables=["mu", "nu", "x"])
plt.show()
NormalVariable(PCoperator(F(Qz[-1], W1, W2), Qalpha[-1],
Qlambda[-1]),
0.5 * np.ones((h_size, 1)),
"z{}".format(t),
learnable=True))
variational_model = ProbabilisticModel(Qz)
model.set_posterior_model(variational_model)
# Inference
from brancher import inference
# Inference #
inference.perform_inference(model,
number_iterations=n_itr,
number_samples=3,
optimizer="Adam",
lr=0.01)
loss_list1.append(model.diagnostics["loss curve"])
psamples = model._get_posterior_sample(1)
images1.append([
np.reshape(psamples[img[t]].detach().numpy(),
(3, image_size, image_size)) for t in range(T)
])
# plt.show()
#### 2 Mean field ####
particles = [ProbabilisticModel([l]) for l in particle_locations]
# Importance sampling distributions
voranoi_set = VoronoiSet(particle_locations) #TODO: Bug if you use variables instead of probabilistic models
variational_samplers = [ProbabilisticModel([TruncatedNormalVariable(mu=initial_location_1, sigma=0.1,
truncation_rule=lambda a: voranoi_set(a, 0),
name="weights", learnable=True)]),
ProbabilisticModel([TruncatedNormalVariable(mu=initial_location_2, sigma=0.1,
truncation_rule=lambda a: voranoi_set(a, 1),
name="weights", learnable=True)])]
# Inference
inference.perform_inference(model,
inference_method=WVGD(biased=True),
number_iterations=1000,
number_samples=50,
optimizer=chainer.optimizers.Adam(0.005),
posterior_model=particles,
sampler_model=variational_samplers,
pretraining_iterations=0)
loss_list = model.diagnostics["loss curve"]
# 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)
# Variational process #
#Qx0 = Normal(0, 1, "x_0", learnable=True)
#QX = MarkovProcess(Qx0, lambda t, x: Normal(0., 0.5, name="x_{}".format(t), has_bias=False, learnable=True))
Qx10 = Normal(float(temporal_sample[9:10].values), 0.25, "x_10")
QX = [Qx10]
for idx in range(11, 30):
QX.append(Normal(QX[idx-11], 0.25, "x_{}".format(idx), has_bias=True, learnable=True))
QX = ProbabilisticModel(QX)
#X.set_posterior_model(process=QX)
## Perform ML inference ##
perform_inference(X,
posterior_model=QX,
inference_method=ReverseKL(),
number_iterations=3000,
number_samples=50,
optimizer="SGD",
lr=0.005)
loss_list = X.active_submodel.diagnostics["loss curve"]
plt.plot(loss_list)
plt.show()
## Sample ##
post_temporal_sample = X.get_posterior_timeseries_sample(100, query_points=100)
post_temporal_sample.plot(alpha=0.25)
temporal_sample.plot()
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))
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
posterior_samples = AR_model._get_posterior_sample(2000)
x_mean1 = []
lower_bound1 = []
upper_bound1 = []
Qw2 = Norm(0., 1., name="w2", learnable=True)
Qw12 = Norm(0., 1., name="w12", learnable=True)
Qnu = LogNorm(0.2, 0.5, name="nu", learnable=True)
variational_model = ProbabilisticModel([Qb, Qw1, Qw2, Qw12, Qnu])
model.set_posterior_model(variational_model)
# Generate data
ground_samples = model._get_sample(1)
# Observe data
data = np.reshape(ground_samples[y].cpu().detach().numpy(), newshape=(n, 1, 1))
y.observe(data)
# Inference
inference.perform_inference(model,
number_iterations=5000,
number_samples=100,
optimizer='Adam')
# Plot
#plt.plot(model.diagnostics["loss curve"])
#plt.show()
n_post_samples = 1000
post_samples = model._get_posterior_sample(n_post_samples)
s_x1 = np.reshape(x1.value.cpu().detach().numpy(), newshape=(n, ))
s_x2 = np.reshape(x2.value.cpu().detach().numpy(), newshape=(n, ))
post_mean = 0.
for k in range(n_post_samples):
s_b = float(post_samples[b].cpu().detach().numpy()[k, :])
s_w1 = float(post_samples[w1].cpu().detach().numpy()[k, :])
s_w2 = float(post_samples[w2].cpu().detach().numpy()[k, :])
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)
test_images = EmpiricalVariable(np.reshape(test.test_data.numpy(),
newshape=(test.test_data.shape[0],
number_pixels, 1)),
indices=test_indices,
name="x_test",
scale=1. * np.ones((num_classes, 1)),
name="b")
reshaped_z = BF.reshape(z, shape=(image_size * image_size * out_channels, 1))
k = Categorical(logits=BF.linear(reshaped_z, Wl, b), name="k")
k.observe(labels)
from brancher.inference import MAP
from brancher.inference import perform_inference
from brancher.variables import ProbabilisticModel
convolutional_model = ProbabilisticModel([k])
perform_inference(convolutional_model,
inference_method=MAP(),
number_iterations=1,
optimizer="Adam",
lr=0.0025)
loss_list = convolutional_model.diagnostics["loss curve"]
#plt.plot(loss_list)
#plt.show()
import torch
import torch
## PyTorch model ##
class PytorchNetwork(torch.nn.Module):
def __init__(self):
super(PytorchNetwork, self).__init__()
