def construct_deterministic_parents(self, learnable, ranges, kwargs): for parameter_name, value in kwargs.items(): if not isinstance(value, (Variable, PartialLink)): if isinstance(value, np.ndarray): dim = value.shape[ 0] #TODO: This is probably not general enough elif isinstance(value, numbers.Number): dim = 1 else: dim = [ ] #TODO: You should consider the other possible cases individually deterministic_parent = DeterministicVariable( ranges[parameter_name].inverse_transform(value, dim), self.name + "_" + parameter_name, learnable, is_observed=self._observed) kwargs.update({ parameter_name: ranges[parameter_name].forward_transform( deterministic_parent, dim) })
# link=lambda values: {'mu': F.sin(values[a]*values[b] + values[c]), 'sigma': values[c] + values[a]}) import numpy as np #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
#import chainer.functions as F import chainer import chainer.links as L 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')
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] ground_truth = [float(data[xt].data) for xt in x] true_b = data[b].data print("The true coefficient is: {}".format(float(true_b))) # Observe data # [yt.observe(data[yt][:, 0, :]) for yt in y] # Autoregressive variational distribution # Qb = LogitNormalVariable(0.5, 0.5, "b", learnable=True) logit_b_post = DeterministicVariable(0., 'logit_b_post', learnable=True) Qx = [NormalVariable(0., 1., 'x0', learnable=True)] Qx_mean = [DeterministicVariable(0., 'x0_mean', learnable=True)] for t in range(1, T): Qx_mean.append( DeterministicVariable(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.stochastic_variational_inference(
# 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)] particles = [ProbabilisticModel([DeterministicVariable(location, name="weights", learnable=True)]) for location in initial_locations] # Importance sampling distributions variational_samplers = [ProbabilisticModel([NormalVariable(loc=location, scale=0.1, name="weights", learnable=True)]) for location in initial_locations] # 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,
import matplotlib.pyplot as plt import numpy as np from brancher.variables import DeterministicVariable, ProbabilisticModel from brancher.standard_variables import NormalVariable as Norm from brancher.standard_variables import LogNormalVariable as LogNorm from brancher import inference import brancher.functions as BF # Regressors 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)
from brancher.standard_variables import NormalVariable from brancher.inference import maximal_likelihood 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:
# 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)) particle_1 = DeterministicVariable(initial_location_1, name="weights", learnable=True) particle_2 = DeterministicVariable(initial_location_2, name="weights", learnable=True) particle_locations = [particle_1, particle_2] 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,
from brancher import inference import brancher.functions as BF # Data number_regressors = 2 number_samples = 50 x1_input_variable = np.random.normal(1.5, 1.5, (int(number_samples/2), number_regressors, 1)) x1_labels = 0*np.ones((int(number_samples/2), 1)) x2_input_variable = np.random.normal(-1.5, 1.5, (int(number_samples/2), number_regressors, 1)) x2_labels = 1*np.ones((int(number_samples/2),1)) input_variable = np.concatenate((x1_input_variable, x2_input_variable), axis=0) labels = np.concatenate((x1_labels, x2_labels), axis=0) # Probabilistic model weights = NormalVariable(np.zeros((1, number_regressors)), 0.5*np.ones((1, number_regressors)), "weights") x = DeterministicVariable(input_variable, "x", is_observed=True) logit_p = BF.matmul(weights, x) k = BinomialVariable(1, logit_p=logit_p, name="k") model = ProbabilisticModel([k]) samples = model._get_sample(300) # Observations k.observe(labels) # Variational Model #Qweights = NormalVariable(np.zeros((1, number_regressors)), # np.ones((1, number_regressors)), "weights", learnable=True) Qweights = MultivariateNormalVariable(loc=np.zeros((1, number_regressors)), covariance_matrix=np.identity(number_regressors), name="weights", learnable=True)
k.observe(labels) # Variational model num_particles = N initial_locations1 = [ np.random.normal(0., 1., (number_hidden_nodes, number_regressors)) for _ in range(num_particles) ] initial_locations2 = [ np.random.normal(0., 1., (number_output_classes, number_hidden_nodes)) for _ in range(num_particles) ] particles = [ ProbabilisticModel([ DeterministicVariable(loc1, name="weights1", learnable=True), DeterministicVariable(loc2, name="weights2", learnable=True) ]) for loc1, loc2 in zip(initial_locations1, initial_locations2) ] # Importance sampling distributions variational_samplers = [ ProbabilisticModel([ NormalVariable(loc=loc1, scale=0.1, name="weights1", learnable=True), NormalVariable(loc=loc2, scale=0.1, name="weights2", learnable=True)
# Generate data N = 4 theta_real = 0.5 x_real = NormalVariable(theta_real, 0.4, "x") data = x_real._get_sample(number_samples=N) # Observe data x.observe(data[x_real][:, 0, :]) # Variational model num_particles = 6 initial_locations = [np.random.normal(0., 1.) for _ in range(num_particles)] particles = [ ProbabilisticModel( [DeterministicVariable(p, name="theta", learnable=True)]) for p in initial_locations ] # 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)
from brancher.stochastic_processes import GaussianProcess as GP from brancher.stochastic_processes import SquaredExponentialCovariance as SquaredExponential from brancher.stochastic_processes import WhiteNoiseCovariance as WhiteNoise from brancher.stochastic_processes import HarmonicCovariance as Harmonic from brancher.stochastic_processes import ConstantMean from brancher.variables import DeterministicVariable from brancher.standard_variables import NormalVariable as Normal from brancher.standard_variables import LogNormalVariable as LogNormal from brancher.inference import WassersteinVariationalGradientDescent as WVGD from brancher import inference from brancher.visualizations import plot_particles, plot_density import brancher.functions as BF num_datapoints = 50 x_range = np.linspace(0, 2, num_datapoints) x = DeterministicVariable(x_range, name="x") # Model length_scale = LogNormal(0., 0.3, name="length_scale") noise_var = LogNormal(0., 0.3, name="noise_var") amplitude = LogNormal(0., 0.3, name="amplitude") mu = ConstantMean(0.5) cov = amplitude*SquaredExponential(scale=length_scale) + WhiteNoise(magnitude=noise_var) f = GP(mu, cov, name="f") y = f(x) model = ProbabilisticModel([y]) # Observe data noise_level = 0.3 f0 = 2.5 df = 0.
# 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 initial_weights = np.random.normal(0., 1., (number_output_classes, number_regressors)) model.set_posterior_model( ProbabilisticModel([ DeterministicVariable(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
import numpy as np import matplotlib.pyplot as plt import pandas as pd from brancher.variables import ProbabilisticModel from brancher.stochastic_processes import GaussianProcess as GP from brancher.stochastic_processes import SquaredExponentialCovariance as SquaredExponential from brancher.stochastic_processes import ConstantMean from brancher.variables import DeterministicVariable from brancher.standard_variables import NormalVariable as Normal from brancher import inference num_datapoints = 20 x_range = np.linspace(-2, 2, num_datapoints) x = DeterministicVariable(x_range, name="x") # Model mu = ConstantMean(0.) cov = SquaredExponential(scale=0.2, jitter=10**-4) f = GP(mu, cov, name="f") y = Normal(f(x), 0.2, name="y") model = ProbabilisticModel([y]) # Observe data noise_level = 0.2 data = np.sin(2 * np.pi * 0.4 * x_range) + noise_level * np.random.normal( 0., 1., (1, num_datapoints)) y.observe(data) #Variational Model
# Probabilistic model model = ProbabilisticModel([k]) # Observations k.observe(labels) # Variational model num_particles = N initial_locations = [ np.random.normal(0., 1., (number_output_classes, number_regressors)) for _ in range(num_particles) ] particles = [ ProbabilisticModel([ DeterministicVariable(location, name="weights", learnable=True) ]) for location in initial_locations ] # Importance sampling distributions variational_samplers = [ ProbabilisticModel([ NormalVariable(loc=location, scale=0.1, name="weights", learnable=True) ]) for location in initial_locations ] # Inference inference_method = WVGD(variational_samplers=variational_samplers,