import brancher.functions as BF
from brancher.functions import BrancherFunction as bf
# Parameters
number_regressors = 1
number_observations = 15
real_weights = np.random.normal(0, 1, (number_regressors, 1))
real_sigma = 0.6
input_variable = np.random.normal(0, 1,
(number_observations, number_regressors))
# ProbabilisticModel
regression_link = bf(L.Linear(number_regressors, 1))
x = DeterministicVariable(input_variable, "x", is_observed=True)
sigma = DeterministicVariable(0.1, "sigma", learnable=True)
y = NormalVariable(regression_link(x), BF.exp(sigma), "y")
# Observations
data = (np.matmul(x.value.data, real_weights) +
np.random.normal(0, real_sigma, (number_observations, 1)))
y.observe(data)
print(y)
# Maximal Likelihood
loss_list = maximal_likelihood(y, number_iterations=1000)
a_range = np.linspace(-2, 2, 40)
model_prediction = []
for a in a_range:
x.value = a
sigma.value = -20.
minibatch_indices = RandomIndices(dataset_size=dataset_size,
batch_size=minibatch_size,
name="indices",
is_observed=True)
x = EmpiricalVariable(input_variable,
indices=minibatch_indices,
name="x",
is_observed=True)
labels = EmpiricalVariable(output_labels,
indices=minibatch_indices,
name="labels",
is_observed=True)
# Architecture parameters
weights = NormalVariable(
np.zeros((number_output_classes, number_regressors)), 10 * np.ones(
(number_output_classes, number_regressors)), "weights")
# 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
num_particles = 2 #10
initial_locations = [
minibatch_indices = RandomIndices(dataset_size=dataset_size,
batch_size=minibatch_size,
name="indices",
is_observed=True)
x = EmpiricalVariable(input_variable,
indices=minibatch_indices,
name="x",
is_observed=True)
labels = EmpiricalVariable(output_labels,
indices=minibatch_indices,
name="labels",
is_observed=True)
# Architecture parameters
number_hidden_units = 20
b1 = NormalVariable(np.zeros((number_hidden_units, 1)), 10 * np.ones(
(number_hidden_units, 1)), "b1")
b2 = NormalVariable(np.zeros((number_output_classes, 1)), 10 * np.ones(
(number_output_classes, 1)), "b2")
weights1 = NormalVariable(np.zeros(
(number_hidden_units, number_pixels)), 10 * np.ones(
(number_hidden_units, number_pixels)), "weights1")
weights2 = NormalVariable(
np.zeros((number_output_classes, number_hidden_units)), 10 * np.ones(
(number_output_classes, number_hidden_units)), "weights2")
# Forward pass
hidden_units = BF.tanh(BF.matmul(weights1, x) + b1)
final_activations = BF.matmul(weights2, hidden_units) + b2
k = CategoricalVariable(softmax_p=final_activations, name="k")
# Probabilistic model
import chainer.functions as F
import torch
#from brancher.links import brancher_decorator
from brancher.variables import DeterministicVariable, RandomVariable, ProbabilisticModel
from brancher.standard_variables import NormalVariable
from brancher.functions import BrancherFunction
import brancher.functions as BF
#import brancher.links as BL
##
a = DeterministicVariable(data=1.5, name='a', learnable=True)
b = DeterministicVariable(0.3, 'b')
c = DeterministicVariable(0.3, 'c')
d = NormalVariable((a * b + c), c + a**2, 'd')
##
print(a._get_sample(10))
##
e1 = BF.cat(
(a, b), 2
) #TODO: to change later, so that user does not have to specify dim explicitly (adjust cat)
e2 = BF.cat((a, c), 2)
f = NormalVariable(e1**2, e2**1, 'f')
g = NormalVariable(BF.relu(f), 1., 'g')
##
print(g._get_sample(10))
minibatch_indices = RandomIndices(dataset_size=dataset_size,
batch_size=minibatch_size,
name="indices",
is_observed=True)
x = EmpiricalVariable(input_variable,
indices=minibatch_indices,
name="x",
is_observed=True)
labels = EmpiricalVariable(output_labels,
indices=minibatch_indices,
name="labels",
is_observed=True)
# Architecture parameters
weights = NormalVariable(np.zeros(
(number_output_classes, number_pixels)), 10 * np.ones(
(number_output_classes, number_pixels)), "weights")
# Forward pass
final_activations = BF.matmul(weights, x)
k = CategoricalVariable(softmax_p=final_activations, name="k")
# Probabilistic model
model = ProbabilisticModel([k])
# Observations
k.observe(labels)
# Variational Model
Qweights = NormalVariable(np.zeros((number_output_classes, number_pixels)),
0.1 * np.ones(
import chainer import chainer.functions as F import matplotlib.pyplot as plt import numpy as np from brancher.distributions import NormalDistribution, LogNormalDistribution from brancher.variables import DeterministicVariable, RandomVariable, ProbabilisticModel from brancher.standard_variables import NormalVariable, LogNormalVariable from brancher import inference import brancher.functions as BF # 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)
self.l3 = nn.Linear(hidden_size, image_size) # Latent log sd output
self.softplus = nn.Softplus()
def __call__(self, x):
h = self.relu(self.l1(x))
output_mean = self.l2(h)
output_log_sd = self.l3(h)
return {"mean": output_mean, "sd": self.softplus(output_log_sd) + 0.01}
# 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",
import matplotlib.pyplot as plt
import numpy as np
from brancher.variables import DeterministicVariable, ProbabilisticModel
from brancher.standard_variables import NormalVariable, EmpiricalVariable
from brancher import inference
import brancher.functions as BF
# Data
# Neural architectures
#Encoder
#Decoder
# Generative model
latent_size = (10, )
z = NormalVariable(np.zeros(latent_size), np.ones(latent_size))
decoder_output = decoder(z)
x = NormalVariable(decoder_output["mean"],
BF.exp(decoder_output["log_var"]),
name="x")
model = ProbabilisticModel([x, z])
# Amortized variational distribution
Qx = EmpiricalVariable(dataset, name="x")
encoder_output = encoder(Qx)
Qz = NormalVariable(decoder_output["mean"],
BF.exp(decoder_output["log_var"]),
name="z")
variational_model = ProbabilisticModel([Qx, Qz])
def bayesian_update(r, w0, w1, mx, my, sx, sy):
out = brancher_net(r, w0, w1, mx, my, sx, sy)
return [out[0], out[1], out[2], out[3]]
# Model
T = 20
sigma = 0.1
mx = [DeterministicVariable(0., "mx_0")]
my = [DeterministicVariable(0., "my_0")]
sx = [DeterministicVariable(0., "sx_0")]
sy = [DeterministicVariable(0., "sy_0")]
mux = [NormalVariable(mx[0].value, sx[0].value, "mux_0")]
muy = [NormalVariable(my[0].value, sy[0].value, "muy_0")]
Qmux = [NormalVariable(mx[0], sx[0], "mux_0")]
Qmuy = [NormalVariable(my[0], sy[0], "muy_0")]
w = []
r = []
for t in range(T):
# Reward
w.append(
DirichletVariable(np.ones((2, 1)),
"w_{}".format(t),
is_policy=True,
learnable=True))
r.append(
NormalVariable((w[t][0] * mux[t] + w[t][1] * muy[t]),
n = np.random.choice(range(N))
short_y = ts_y[n:n+T]
short_y = sg.detrend(short_y, type='linear')
short_y = (short_y - np.mean(short_y))/np.sqrt(np.var(short_y))
noise = 0.3 # 0.5
noisy_y = short_y + np.random.normal(0, noise, (T,))
#plt.plot(noisy_y)
#plt.show()
# Probabilistic model #
transform = lambda x: x + 0.5*x**5
dt = 0.01
driving_noise = 0.8 #0.5
measure_noise = noise
x0 = NormalVariable(0., 1., 'x0')
y0 = NormalVariable(x0, measure_noise, 'y0')
x1 = NormalVariable(0., 1., 'x1')
y1 = NormalVariable(x1, measure_noise, 'y1')
b = 50
f = 9.
omega = NormalVariable(2 * np.pi * f, 1., "omega")
x = [x0, x1]
y = [y0, y1]
x_names = ["x0", "x1"]
y_names = ["y0", "y1"]
y_range = [t for t in range(T) if (t < 15 or t > T - 15)]
for t in range(2, T):
x_names.append("x{}".format(t))
new_mu = (-1 - omega**2*dt**2 + b*dt)*x[t - 2] + (2 - b*dt)*x[t - 1]
number_output_classes = 3
dataset_size = 50
dataset = datasets.load_iris()
ind = list(range(dataset["target"].shape[0]))
np.random.shuffle(ind)
input_variable = dataset["data"][ind[:dataset_size], :].astype("float32")
output_labels = dataset["target"][ind[:dataset_size]].astype("int32")
# Data sampling model
minibatch_size = dataset_size
minibatch_indices = RandomIndices(dataset_size=dataset_size, batch_size=minibatch_size, name="indices", is_observed=True)
x = EmpiricalVariable(input_variable, indices=minibatch_indices, name="x", is_observed=True)
labels = EmpiricalVariable(output_labels, indices=minibatch_indices, name="labels", is_observed=True)
# Architecture parameters
weights = NormalVariable(np.zeros((number_output_classes, number_regressors)),
10 * np.ones((number_output_classes, number_regressors)), "weights")
# Forward pass
final_activations = BF.matmul(weights, x)
k = CategoricalVariable(softmax_p=final_activations, name="k")
# Probabilistic model
model = ProbabilisticModel([k])
# Observations
k.observe(labels)
# Variational model
num_particles = 1 #10
initial_locations = [np.random.normal(0., 1., (number_output_classes, number_regressors))
for _ in range(num_particles)]
number_pixels = 28*28
number_output_classes = 10
train, test = chainer.datasets.get_mnist()
#dataset_size = len(train)
dataset_size = 50
input_variable = np.array([np.reshape(image[0], newshape=(number_pixels, 1)) for image in train][0:dataset_size]).astype("float32")
output_labels = np.array([image[1]*np.ones((1, 1)) for image in train][0:dataset_size]).astype("int32")
# Data sampling model
minibatch_size = 50
minibatch_indices = RandomIndices(dataset_size=dataset_size, batch_size=minibatch_size, name="indices", is_observed=True)
x = EmpiricalVariable(input_variable, indices=minibatch_indices, name="x", is_observed=True)
labels = EmpiricalVariable(output_labels, indices=minibatch_indices, name="labels", is_observed=True)
# Architecture parameters
weights = NormalVariable(np.zeros((number_output_classes, number_pixels)),
10*np.ones((number_output_classes, number_pixels)), "weights")
# Forward pass
final_activations = BF.matmul(weights, x)
k = CategoricalVariable(softmax_p=final_activations, name="k")
# Probabilistic model
model = ProbabilisticModel([k])
# Observations
k.observe(labels)
# Variational model
number_particles = 2
initial_location_1 = np.random.normal(0., 1., (number_output_classes, number_pixels))
initial_location_2 = np.random.normal(0., 1., (number_output_classes, number_pixels))
import matplotlib.pyplot as plt
import numpy as np
from brancher.variables import DeterministicVariable, RandomVariable, ProbabilisticModel
from brancher.standard_variables import NormalVariable, LogNormalVariable, BetaVariable
from brancher import inference
import brancher.functions as BF
# Probabilistic model #
T = 100
nu = LogNormalVariable(0.3, 1., 'nu')
x0 = NormalVariable(0., 1., 'x0')
b = BetaVariable(0.5, 1.5, 'b')
x = [x0]
names = ["x0"]
for t in range(1, T):
names.append("x{}".format(t))
x.append(NormalVariable(b * x[t - 1], nu, names[t]))
AR_model = ProbabilisticModel(x)
# Generate data #
data = AR_model._get_sample(number_samples=1)
time_series = [float(data[xt].cpu().detach().numpy()) for xt in x]
true_b = data[b].cpu().detach().numpy()
true_nu = data[nu].cpu().detach().numpy()
print("The true coefficient is: {}".format(float(true_b)))
# Observe data #
[xt.observe(data[xt][:, 0, :]) for xt in x]
import brancher.config as cfg
cfg.set_device("cpu")
import matplotlib.pyplot as plt
import numpy as np
from brancher.variables import ProbabilisticModel
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)
latent_size2=latent_size2))
decoder2 = BF.BrancherFunction(
DecoderArchitecture2(latent_size2=latent_size2,
latent_size3=latent_size3))
decoder3 = BF.BrancherFunction(
DecoderArchitecture3(latent_size3=latent_size3, image_size=image_size))
decoderLabel = BF.BrancherFunction(
DecoderArchitectureLabel(latent_size2=latent_size2,
num_classes=num_classes))
# # Generative model
z1sd = 1.5 # 1
z2sd = 0.25 # 0.25
z3sd = 0.15
z1 = NormalVariable(np.zeros((latent_size1, )),
z1sd * np.ones((latent_size1, )),
name="z1")
decoder_output1 = DeterministicVariable(decoder1(z1),
name="decoder_output1")
z2 = NormalVariable(BF.relu(decoder_output1["mean"]),
z2sd * np.ones((latent_size2, )),
name="z2")
label_logits = DeterministicVariable(decoderLabel(z2), "label_logits")
labels = CategoricalVariable(logits=label_logits, name="labels")
decoder_output2 = DeterministicVariable(decoder2(z2),
name="decoder_output2")
z3 = NormalVariable(BF.relu(decoder_output2["mean"]),
z3sd * np.ones((latent_size3, )),
name="z3")
decoder_output3 = DeterministicVariable(decoder3(z3),
name="decoder_output3")
import matplotlib.pyplot as plt from brancher.variables import ProbabilisticModel from brancher.standard_variables import NormalVariable, LogNormalVariable from brancher.transformations import truncate_model from brancher.visualizations import plot_density # Normal model mu = NormalVariable(0., 1., "mu") x = NormalVariable(mu, 0.1, "x") model = ProbabilisticModel([x]) # decision rule model_statistics = lambda dic: dic[x].data truncation_rule = lambda a: ((a > 0.5) & (a < 0.6)) | ((a > -0.6) & (a < -0.5)) # Truncated model truncated_model = truncate_model(model, truncation_rule, model_statistics) plot_density(truncated_model, variables=["mu", "x"], number_samples=10000) plt.show()
N_ELBO_smpl = 1000
for cond, label in zip(condition_list, condition_label):
ELBO1 = []
ELBO2 = []
ELBO3 = []
ELBO4 = []
for rep in range(N_rep):
print("Repetition: {}".format(rep))
# Probabilistic model #
T = 40
dt = 0.01
driving_noise = 0.5
measure_noise = 0.2
x0 = NormalVariable(0., driving_noise, 'x0')
y0 = NormalVariable(x0, measure_noise, 'y0')
x1 = NormalVariable(0., driving_noise, 'x1')
y1 = NormalVariable(x1, measure_noise, 'y1')
b = 20
omega = 2*np.pi*8
x = [x0, x1]
y = [y0, y1]
x_names = ["x0", "x1"]
y_names = ["y0", "y1"]
y_range = [t for t in range(T) if cond(t)]
for t in range(2, T):
x_names.append("x{}".format(t))
new_mu = (-1 - omega**2*dt**2 + b*dt)*x[t - 2] + (2 - b*dt)*x[t - 1]
x.append(NormalVariable(new_mu, np.sqrt(dt)*driving_noise, x_names[t]))
# Probabilistic model
minibatch_size = 30
minibatch_indices = RandomIndices(dataset_size=dataset_size,
batch_size=minibatch_size,
name="indices",
is_observed=True)
x = EmpiricalVariable(input_variable,
indices=minibatch_indices,
name="x",
is_observed=True)
labels = EmpiricalVariable(output_labels,
indices=minibatch_indices,
name="labels",
is_observed=True)
weights = NormalVariable(np.zeros((1, number_regressors)), 0.5 * np.ones(
(1, number_regressors)), "weights")
logit_p = BF.matmul(weights, x)
k = BinomialVariable(1, logit_p=logit_p, name="k")
model = ProbabilisticModel([k])
#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)),
h_size = 120
W1 = DeterministicVariable(np.random.normal(0., 0.2, (h_size, h_size)),
"W1",
learnable=False)
W2 = DeterministicVariable(np.random.normal(0., 0.2, (h_size, h_size)),
"W2",
learnable=False)
#V = DeterministicVariable(np.random.normal(0., 1., (100, h_size)), "V", learnable=False)
f = lambda z, W: z + BF.tanh(BF.matmul(W, z))
F = lambda z, W1, W2: f(f(z, W1), W2)
measurement_noise = 2. #1.5
z = [
NormalVariable(np.zeros((h_size, 1)),
np.ones((h_size, 1)),
"z0",
learnable=False)
]
img = [
DeterministicVariable(decoder(BF.reshape(z[0], (h_size, 1, 1))),
"img0",
learnable=False)
]
x = [
NormalVariable(img[0],
measurement_noise * np.ones(
(3, image_size, image_size)),
"x0",
learnable=False)
]
import matplotlib.pyplot as plt
import numpy as np
import torch
from brancher.variables import ProbabilisticModel
from brancher.standard_variables import NormalVariable, DeterministicVariable, LogNormalVariable
import brancher.functions as BF
from brancher.visualizations import plot_density
from brancher.transformations import PlanarFlow
from brancher import inference
from brancher.visualizations import plot_posterior
# Model
M = 8
y = NormalVariable(torch.zeros((M, )), 1. * torch.ones((M, )), "y")
y0 = DeterministicVariable(y[1], "y0")
d = NormalVariable(y, torch.ones((M, )), "d")
model = ProbabilisticModel([d, y, y0])
# get samples
d.observe(d.get_sample(55, input_values={y: 1. * torch.ones((M, ))}))
# Variational distribution
u1 = DeterministicVariable(torch.normal(0., 1., (M, 1)), "u1", learnable=True)
w1 = DeterministicVariable(torch.normal(0., 1., (M, 1)), "w1", learnable=True)
b1 = DeterministicVariable(torch.normal(0., 1., (1, 1)), "b1", learnable=True)
u2 = DeterministicVariable(torch.normal(0., 1., (M, 1)), "u2", learnable=True)
w2 = DeterministicVariable(torch.normal(0., 1., (M, 1)), "w2", learnable=True)
b2 = DeterministicVariable(torch.normal(0., 1., (1, 1)), "b2", learnable=True)
z = NormalVariable(torch.zeros((M, 1)),
torch.ones((M, 1)),
import matplotlib.pyplot as plt
from brancher.variables import ProbabilisticModel
from brancher.standard_variables import BernulliVariable, NormalVariable
import brancher.functions as BF
from brancher import inference
from brancher.inference import ReverseKL
from brancher.gradient_estimators import BlackBoxEstimator, Taylor1Estimator
#Model
z1 = BernulliVariable(logits=0., name="z1")
z2 = BernulliVariable(logits=0., name="z2")
y = NormalVariable(2 * z1 + z2, 1., name="y")
model = ProbabilisticModel([y])
#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(
import chainer
import matplotlib.pyplot as plt
import numpy as np
from brancher.variables import ProbabilisticModel
from brancher.standard_variables import ConcreteVariable, NormalVariable
from brancher import inference
import brancher.functions as BF
# Probabilistic Model
x = ConcreteVariable(tau=0.1, p=np.ones((2, 1))/2., name="x")
mu0 = -2
nu0 = 0.5
mu1 = 2
nu1 = 0.2
y = NormalVariable(x[0]*mu0 + x[1]*mu1, x[0]*nu0 + x[1]*nu1, "y")
samples = y._get_sample(1000)
plt.hist(samples[y].data._flatten(), 60)
print(y.calculate_log_probability(samples))
plt.title("Concrete mixture of Gaussians")
plt.show()
import chainer
import matplotlib.pyplot as plt
import numpy as np
from brancher.variables import DeterministicVariable, RandomVariable, ProbabilisticModel
from brancher.standard_variables import NormalVariable, LogNormalVariable, LogitNormalVariable
from brancher import inference
import brancher.functions as BF
# Probabilistic model #
T = 20
driving_noise = 1.
measure_noise = 0.5
x0 = NormalVariable(0., driving_noise, 'x0')
y0 = NormalVariable(x0, measure_noise, 'x0')
b = LogitNormalVariable(0.5, 1., 'b')
x = [x0]
y = [y0]
x_names = ["x0"]
y_names = ["y0"]
for t in range(1, T):
x_names.append("x{}".format(t))
y_names.append("y{}".format(t))
x.append(NormalVariable(b * x[t - 1], driving_noise, x_names[t]))
y.append(NormalVariable(x[t], measure_noise, y_names[t]))
AR_model = ProbabilisticModel(x + y)
# Generate data #
data = AR_model._get_sample(number_samples=1)
time_series = [float(data[yt].data) for yt in y]
import numpy as np import matplotlib.pyplot as plt import chainer from brancher.variables import RootVariable, ProbabilisticModel from brancher.particle_inference_tools import VoronoiSet from brancher.standard_variables import EmpiricalVariable, NormalVariable, LogNormalVariable from brancher import inference from brancher.inference import WassersteinVariationalGradientDescent as WVGD from brancher.visualizations import ensemble_histogram from brancher.pandas_interface import reformat_sample_to_pandas # Model dimensionality = 1 theta = NormalVariable(loc=0., scale=2., name="theta") x = NormalVariable(theta**2, scale=0.2, name="x") model = ProbabilisticModel([x, theta]) # Generate data N = 3 theta_real = 0.1 x_real = NormalVariable(theta_real**2, 0.2, "x") data = x_real._get_sample(number_samples=N) # Observe data x.observe(data[x_real][:, 0, :]) # Variational model num_particles = 2 initial_locations = [-2, 2]
Lk4 = []
MSE1 = []
MSE2 = []
MSE3 = []
MSE4 = []
for rep in range(N_rep):
print("Repetition: {}".format(rep))
# Probabilistic model #
T = 30 #30
dt = 0.02
driving_noise = 0.5
measure_noise = 2. #1.
s = 10.
r = 28.
b = 8 / 3.
x0 = NormalVariable(0., driving_noise, 'x0')
h0 = NormalVariable(0., driving_noise, 'h0')
z0 = NormalVariable(0., driving_noise, 'z0')
x = [x0]
h = [h0]
z = [z0]
y = []
x_names = ["x0"]
h_names = ["h0"]
z_names = ["z0"]
y_names = ["y0"]
y_range = [t for t in range(T) if cond(t)]
if 0 in y_range:
y0 = NormalVariable(x0, measure_noise, 'y0')
for t in range(1, T):
x_max = 1.
n = 100
x_range = np.linspace(-x_max, x_max, n)
x1 = DeterministicVariable(np.sin(2 * np.pi * 2 * x_range),
name="x1",
is_observed=True)
x2 = DeterministicVariable(x_range, name="x2", is_observed=True)
# Multivariate Regression
b = Norm(0., 1., name="b")
w1 = Norm(0., 1., name="w1")
w2 = Norm(0., 1., name="w2")
w12 = Norm(0., 1., name="w12")
nu = LogNorm(0.2, 0.5, name="nu")
mean = b + w1 * x1 + w2 * x2 + w12 * x1 * x2
y = Norm(mean, nu, name="y")
model = ProbabilisticModel([y])
# Variational distributions
Qb = Norm(0., 1., name="b", learnable=True)
Qw1 = Norm(0., 1., name="w1", learnable=True)
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
minibatch_indices = RandomIndices(dataset_size=dataset_size,
batch_size=minibatch_size,
name="indices",
is_observed=True)
x = EmpiricalVariable(input_variable,
indices=minibatch_indices,
name="x",
is_observed=True)
labels = EmpiricalVariable(output_labels,
indices=minibatch_indices,
name="labels",
is_observed=True)
# Architecture parameters
weights1 = NormalVariable(
np.zeros((number_hidden_nodes, number_regressors)), 10 * np.ones(
(number_hidden_nodes, number_regressors)), "weights1")
weights2 = NormalVariable(
np.zeros((number_output_classes, number_hidden_nodes)),
10 * np.ones(
(number_output_classes, number_hidden_nodes)), "weights2")
# Forward pass
final_activations = BF.matmul(weights2, BF.tanh(BF.matmul(weights1,
x)))
k = CategoricalVariable(softmax_p=final_activations, name="k")
# Probabilistic model
model = ProbabilisticModel([k])
# Observations
import numpy as np
from brancher import functions as BF
from brancher.standard_variables import NormalVariable as Normal
from brancher.standard_variables import DeterministicVariable
in_channels = 4
out_channels = 5
a = Normal(loc=np.zeros((in_channels, 28, 28)),
scale=1.,
name="a")
W = Normal(loc=np.zeros((out_channels, in_channels, 3, 3)),
scale=np.ones((out_channels, in_channels, 3, 3)),
name="W")
y = Normal(BF.conv2d(a, W), 0.1, name="y")
samples = y.get_sample(9)["y"]
print(samples[0].shape)
print(len(samples))
#import chainer.functions as F
import chainer
import chainer.links as L
import chainer.functions as F
#from brancher.links import brancher_decorator
from brancher.variables import DeterministicVariable, RandomVariable, ProbabilisticModel
from brancher.standard_variables import NormalVariable
from brancher.functions import BrancherFunction
import brancher.functions as BF
#import brancher.links as BL
a = DeterministicVariable(1.5, 'a')
b = DeterministicVariable(0.3, 'b')
c = DeterministicVariable(0.3, 'c')
d = NormalVariable((a * b + c), c + a**2, 'd')
e1 = BF.concat((a, b), 2)
e2 = BF.concat((a, c), 2)
f = NormalVariable(e1**2, e2**1, 'f')
f._get_sample(10)
a_val = chainer.Variable(0.25 * np.pi * np.ones((1, 1), dtype="float32"))
b_val = chainer.Variable(0.25 * np.pi * np.ones((1, 1), dtype="float32"))
c_val = chainer.Variable(2 * np.ones((1, 1), dtype="float32"))
#z = BF.sin(a + b)/c
#print(z.fn({a: a_val, b: b_val, c: c_val}))
BLink = BrancherFunction(L.Linear(1, 10))
import matplotlib.pyplot as plt
import numpy as np
from brancher.variables import DeterministicVariable, RandomVariable, ProbabilisticModel
from brancher.standard_variables import NormalVariable, LogNormalVariable, BetaVariable
from brancher import inference
import brancher.functions as BF
# 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)