def multinomial_likelihood(neural_network, data, weights, temperature):
y = data[:, neural_network.topology[0]:neural_network.topology[0] +
neural_network.topology[2]]
fx = neural_network.generate_output(data, weights)
rmse = Network.calculate_rmse(
fx,
y) # Can be replaced by calculate_nmse function for reporting NMSE
probability = neural_network.softmax(fx)
loss = 0
for index_1 in range(y.shape[0]):
for index_2 in range(y.shape[1]):
if y[index_1, index_2] == 1:
loss += np.log(probability[index_1, index_2])
accuracy = Network.calculate_accuracy(fx, y)
return [loss / temperature, rmse, accuracy]
def run(self):
print(f'Entered Run, chain: {self.temperature:.2f}')
np.random.seed(int(self.temperature * 1000))
save_knowledge = True
train_rmse_file = open(
os.path.join(self.directory,
'train_rmse_{:.4f}.csv'.format(self.temperature)),
'w')
test_rmse_file = open(
os.path.join(self.directory,
'test_rmse_{:.4f}.csv'.format(self.temperature)), 'w')
if self.problem_type == 'classification':
train_acc_file = open(
os.path.join(self.directory,
'train_acc_{:.4f}.csv'.format(self.temperature)),
'w')
test_acc_file = open(
os.path.join(self.directory,
'test_acc_{:.4f}.csv'.format(self.temperature)),
'w')
swarm_initial, best_swarm_pos, best_swarm_err = self.swarm, self.best_swarm_pos, self.best_swarm_err
# Initialize MCMC
print(f'Initialize MCMC, chain: {self.temperature:.2f}')
self.start_time = time.time()
train_size = self.train_data.shape[0]
test_size = self.test_data.shape[0]
y_test = self.test_data[:, self.topology[0]:self.topology[0] +
self.topology[2]]
y_train = self.train_data[:, self.topology[0]:self.topology[0] +
self.topology[2]]
swarm_current = copy.copy(swarm_initial)
swarm_proposal = copy.copy(swarm_initial)
eta = [None for n in range(self.pop_size)]
eta_proposal = [None for n in range(self.pop_size)]
tau_proposal = [None for n in range(self.pop_size)]
prior = [None for n in range(self.pop_size)]
likelihood = [None for n in range(self.pop_size)]
rmse_train = [None for n in range(self.pop_size)]
rmse_test = [None for n in range(self.pop_size)]
acc_test = [None for n in range(self.pop_size)]
acc_train = [None for n in range(self.pop_size)]
for i in range(self.pop_size):
prediction_train = self.neural_network.generate_output(
self.train_data, swarm_current[i].position)
prediction_test = self.neural_network.generate_output(
self.test_data, swarm_current[i].position)
eta[i] = np.log(np.var(prediction_train - y_train))
eta_proposal[i] = copy.copy(eta[i])
tau_proposal[i] = np.exp(eta[i])
prior[i] = self.prior_function(swarm_current[i].position,
tau_proposal[i])
likelihood[i], rmse_train[i], acc_train[
i] = self.likelihood_function(self.neural_network,
self.train_data,
swarm_current[i].position,
tau_proposal[i],
self.temperature)
rmse_test[i] = Network.calculate_rmse(prediction_test, y_test)
if self.problem_type == 'classification':
acc_test[i] = Network.calculate_accuracy(
prediction_test, y_test)
# Save values into previous variables
rmse_train_current = rmse_train
rmse_test_current = rmse_test
num_accept = 0
if self.problem_type == 'classification':
acc_test_current = acc_test
acc_train_current = acc_train
writ = 0
if save_knowledge:
train_rmse_file.write(str(rmse_train_current) + "\n")
test_rmse_file.write(str(rmse_test_current) + "\n")
if self.problem_type == 'classification':
train_acc_file.write(str(acc_train_current) + "\n")
test_acc_file.write(str(acc_test_current) + "\n")
writ += 1
print(f'Starting sampling, chain:{self.temperature:.2f}')
# Start sampling
for sample in range(1, self.num_samples):
# swarm_evolved, best_swarm_evolved_pos, best_swarm_evolved_err= self.evolve(copy.copy(swarm_current), best_swarm_pos, best_swarm_err)
swarm_evolved, best_swarm_pos, best_swarm_err = self.evolve(
copy.copy(swarm_current), best_swarm_pos, best_swarm_err)
arr = []
for i in range(self.pop_size):
arr.append(swarm_evolved[i].position)
arr = np.asarray(arr)
np.savetxt(f'test/{sample}.txt', arr, delimiter=',')
# for i in range(self.pop_size):
# swarm_proposal[i].position = swarm_evolved[i].position #+ np.random.normal(0, self.weights_stepsize, size=self.num_params)
# eta_proposal[i] = eta[i] + np.random.normal(0, self.eta_stepsize, 1)
# tau_proposal[i] = np.exp(eta_proposal[i])
# # print(f'Temperature: {self.temperature:.2f} Sample: {sample} P3')
# if self.problem_type == 'classification':
# accept, rmse_train[i], rmse_test[i], acc_train[i], acc_test[i], likelihood[i], prior[i] = self.evaluate_proposal(self.neural_network, self.train_data, self.test_data, swarm_proposal[i].position, tau_proposal[i], likelihood[i], prior[i])
# else:
# accept, rmse_train[i], rmse_test[i], likelihood[i], prior[i] = self.evaluate_proposal(self.neural_network, self.train_data, self.test_data, swarm_proposal[i].position, tau_proposal[i], likelihood[i], prior[i])
# if accept:
# num_accept += 1
# swarm_current[i] = swarm_proposal[i]
# eta[i] = eta_proposal[i]
# # save values into previous variables
# rmse_train_current[i] = rmse_train[i]
# rmse_test_current[i] = rmse_test[i]
# if self.problem_type == 'classification':
# acc_train_current[i] = acc_train[i]
# acc_test_current[i] = acc_test[i]
# if swarm_current[i].error < best_swarm_err:
# best_swarm_err = swarm_current[i].error
# best_swarm_pos = copy.copy(swarm_current[i].position)
# if save_knowledge:
# train_rmse_file.write(str(rmse_train_current)+"\n")
# test_rmse_file.write(str(rmse_test_current)+"\n")
# if self.problem_type == 'classification':
# train_acc_file.write(str(acc_train_current)+"\n")
# test_acc_file.write(str(acc_test_current)+"\n")
# writ += 1
print(
f'Temperature: {self.temperature:.2f} Sample: {sample} Next swap at: {self.swap_sample.value} Best rmse: {best_swarm_err} P4'
)
# SWAPPING PREP
if (sample == self.swap_sample.value):
# print('\nTemperature: {} Swapping weights: {}'.format(self.temperature, weights_current[:2]))
# param = np.concatenate([weights_current, np.asarray([eta]).reshape(1), np.asarray([likelihood*self.temperature]),np.asarray([self.temperature])])
# self.parameter_queue.put(param)
self.event.clear()
self.signal_main.set()
# print(f'Temperature: {self.temperature:.2f} Current sample: {sample} out of {self.num_samples} is num with {self.swap_sample.value} as next swap')
# # Wait for signal from Master
result = self.event.wait()
# # retrieve parameters fom queues if it has been swapped
# print(f'Temperature: {self.temperature:.2f} Call get')
# result = self.parameter_queue.get(timeout=2)
# while not result.all():
# time.sleep(0.01)
# result = self.parameter_queue.get(timeout=2)
# weights_current = result[0:self.w_size]
# self.population[self.best_index] = weights_current
# self.fitness[self.best_index] = self.fitness_function(weights_current)
# eta = result[self.w_size]
# likelihood = result[self.w_size+1]/self.temperature
# print(f'Temperature: {self.temperature:.2f} Swapped weights: {weights_current[:2]}')
# elif (sample >= self.swap_sample.value):
# with self.swap_sample.get_lock():
# self.swap_sample.value += self.swap_interval
# print(f'Temperature: {self.temperature:.2f} Sample: {sample} P5')
elapsed_time = ":".join(
Replica.convert_time(time.time() - self.start_time))
# print("Temperature: {} Sample: {:d}, Best Fitness: {:.4f}, Proposal: {:.4f}, Time Elapsed: {:s}".format(self.temperature, sample, rmse_train_current, rmse_train, elapsed_time))
elapsed_time = time.time() - self.start_time
accept_ratio = num_accept / self.num_samples
print("Written {} values for Accuracies".format(writ))
# Close the files
train_rmse_file.close()
test_rmse_file.close()
with self.active_chains.get_lock():
self.active_chains.value -= 1
with self.num_accepted.get_lock():
self.num_accepted.value += num_accept
print(
f"Temperature: {self.temperature} done, {sample+1} samples sampled out of {self.num_samples}. Number of active chains: {self.active_chains.value}"
)