train=False,
download=True,
transform=None)
dataset_size = len(train)
input_variable = np.reshape(train.train_data.numpy(),
newshape=(dataset_size, number_pixels, 1))
output_labels = train.train_labels.numpy()
# Data sampling 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)
# 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")
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(logits=final_activations, name="k")
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
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")
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",
lr=0.005)
loss_list = model.diagnostics["loss curve"]
#Plot results
plt.plot(loss_list)
plt.show()
decoder_output3 = DeterministicVariable(decoder3(z3),
name="decoder_output3")
x = BinomialVariable(total_count=1,
logits=decoder_output3["mean"],
name="x")
model = ProbabilisticModel([x, z1, z2, z3, labels])
# Amortized variational distribution
minibatch_indices = RandomIndices(dataset_size=dataset_size,
batch_size=b_size,
name="indices",
is_observed=True)
Qx = EmpiricalVariable(dataset,
indices=minibatch_indices,
name="x",
is_observed=True)
Qlabels = EmpiricalVariable(output_labels,
indices=minibatch_indices,
name="labels",
is_observed=True)
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"],
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])
from brancher import inference
from brancher.inference import WassersteinVariationalGradientDescent as WVGD
# Data
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)
import numpy as np import chainer import chainer.links as L import chainer.functions as F from brancher.variables import DeterministicVariable, RandomVariable, ProbabilisticModel from brancher.standard_variables import NormalVariable, EmpiricalVariable, RandomIndices from brancher.functions import BrancherFunction import brancher.functions as BF ## Data ## dataset_size = 100 number_dimensions = 1 dataset1 = np.random.normal(0, 1, (dataset_size, number_dimensions)) ## Variables ## indices = RandomIndices(dataset_size=dataset_size, batch_size=5, name="indices") a = EmpiricalVariable(dataset1, indices=indices, name='a', is_observed=True) b = EmpiricalVariable(dataset1, indices=indices, name='a', is_observed=True) model = ProbabilisticModel([a, b]) ## Sample ## samples = model._get_sample(1) print(samples[a]) print(samples[b])