# 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 model = ProbabilisticModel([k]) # Observations k.observe(labels) # Variational Model Qb1 = NormalVariable(np.zeros((number_hidden_units, 1)), 0.2 * np.ones((number_hidden_units, 1)), "b1", learnable=True) Qb2 = NormalVariable(np.zeros((number_output_classes, 1)),
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 = [ np.random.normal(0., 1., (number_output_classes, number_regressors)) for _ in range(num_particles) ] particles = [
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 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 = [
imagesGT = [] imagesNoise = [] images1 = [] images2 = [] images3 = [] for rep in range(N_rep): 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 = [
np.ones((hidden_size, )), 'epsilon', learnable=True) AR_model = ProbabilisticModel(x + y + [epsilon]) Qepsilon = NormalVariable(np.zeros((hidden_size, 1)), np.ones((hidden_size, )), 'epsilon', learnable=True) W1 = RootVariable(np.random.normal(0, 0.1, (hidden_size, latent_size)), "W1", learnable=True) W2 = RootVariable(np.random.normal(0, 0.1, (3 * T, hidden_size)), "W2", learnable=True) pre_x = BF.matmul(W2, BF.sigmoid(BF.matmul(W1, Qepsilon))) Qx = [] Qh = [] Qz = [] for t in range(0, T): Qx.append( NormalVariable(pre_x[t], driving_noise, x_names[t], learnable=True)) Qh.append( NormalVariable(pre_x[T + t], driving_noise, h_names[t], learnable=True)) Qz.append(
def forward_transform(self, x, dim): return BF.matmul(x, BF.transpose(x, -2, -1))
# Structured NN distribution # hidden_size = 5 latent_size = 5 out_size = N_groups + N_people Qepsilon = Normal(np.zeros((latent_size, 1)), np.ones((latent_size, )), 'epsilon', learnable=True) W1 = RootVariable(np.random.normal(0, 0.1, (hidden_size, latent_size)), "W1", learnable=True) W2 = RootVariable(np.random.normal(0, 0.1, (out_size, hidden_size)), "W2", learnable=True) pre_x = BF.matmul(W2, BF.sigmoid(BF.matmul(W1, Qepsilon))) Qgroup_means = [ Normal(pre_x[n], 4., "group_mean_{}".format(n), learnable=True) for n in range(N_groups) ] Qpeople_means = [ Normal(pre_x[N_groups + m], 0.1, "person_{}".format(m), learnable=True) for m, assignment_list in enumerate(assignment_matrix) ] model.set_posterior_model(ProbabilisticModel(Qpeople_means + Qgroup_means)) # Inference # inference.perform_inference(model, number_iterations=N_itr,
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)), np.ones((1, number_regressors)),
#hidden_size1 = 30 #hidden_size2 = 10 out_size = 10 # Weights #W1 = Deterministic(np.random.normal(0., 0.1, (hidden_size1, input_size)), "W1", learnable=True) #W2 = Deterministic(np.random.normal(0., 0.1, (hidden_size2, hidden_size1)), "W2", learnable=True) #W3 = Deterministic(np.random.normal(0., 0.1, (out_size, hidden_size2)), "W3", learnable=True) V = Deterministic(np.random.normal(0., 0.1, (out_size, input_size)), "W3", learnable=True) #z1 = Deterministic(BF.relu(BF.matmul(W1, BF.reshape(x, shape=(input_size, 1)))), "z1") #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)
def __call__(self, var): output = BF.matmul(self.tri_matrix, var) log_det = -BF.sum(BF.log(BF.abs(self.tri_matrix[:, self.diag_indices[0], self.diag_indices[1]]) + self.shift), axis=1) return DeterministicVariable(output, log_determinant=log_det, name="L {}".format(var.name))