# Get the final particle positions and estimate KL(true posterior | KDE)
particle_positions = []
for nnid in range(len(model.nns)):
weight1 = model.nns[nnid].nn_params[0].weight.detach().numpy()[0]
weight2 = model.nns[nnid].nn_params[1].weight.detach().numpy()[0]
particle_positions.append([weight1[0], weight2[0]])
for nnid in range(len(sampled_bnn)):
weight1 = sampled_bnn[nnid].nn_params[0].weight.detach().numpy()[0]
weight2 = sampled_bnn[nnid].nn_params[1].weight.detach().numpy()[0]
particle_positions.append([weight1[0], weight2[0]])
particle_positions = np.array(particle_positions)
jsd = estimate_jensen_shannon_divergence_from_numerical_distribution(particle_positions, Xs, ys, plot=False)
print("JSD(kde(particles) | estimated posterior) = ", jsd)
print("Plotting weight distribution")
distribution = plot_weight_distribution(sampled_bnn, data, target, \
filename="./particle_N={}_C={}_nsvgd={}_nhmc={}_total={}_jsd={}.png".format\
(N, num_networks, n_svgd, n_hmc, num_iters , np.around(jsd, 4)), show=False)
# Initialize the figure
fig, ax = plt.subplots()
fig.set_tight_layout(True)
def update(i):
plt.clf()
pos, svgd = positions_over_time[i]
plt.clf()
pos, svgd = positions_over_time[i]
position = np.array(pos)
xpos = position[:, 0]
ypos = position[:, 1]
label = 'Epoch {0}'.format(i)
color = "b" if svgd else "r"
plt.scatter(xpos, ypos, c=color)
plt.ylim(-15, 15)
plt.xlim(-15, 15)
plt.xlabel(label)
jsd = estimate_jensen_shannon_divergence_from_numerical_distribution(np.array(positions_over_time[-1][0]),x_N=Xs, y_N=ys,h=h,plot=True)
jsd = np.around(jsd, decimals=4)
jsd_array.append(jsd)
print("With C = {} neural networks, N = {}, rbf = {}, h = {}, average jsd = {}, std-jsd = {}".format\
(num_networks, N, rbf, h, np.mean(jsd_array), np.std(jsd_array)))
# Producing gifs that track the particles' motion
fig, ax = plt.subplots()
fig.set_tight_layout(True)
anim = FuncAnimation(fig, update, frames=np.arange(0, len(positions_over_time)), interval=100)
anim.save('SVGD_N={}_C={}_rbf={}_particles_jsd={}_h={}.gif'.format\
(N, num_networks, rbf, np.mean(jsd_array), h), dpi=80, writer='imagemagick')
# plt.show()
# Initialize the model
x_dim = 1
y_dim = 1
num_networks = 20
network_structure = []
l = 1
p = 1
rbf = 1
# Fit
batch_size = 10 # Batch size (100 is full batch, otherwise mini-batch)
train_loader = CyclicMiniBatch(xs=Xs, ys=ys, batch_size=batch_size)
model = SG_HMC_BNN(x_dim, y_dim, num_networks, network_structure, l, p, rbf)
sampled_bnn = model.fit(train_loader=train_loader,
num_iterations=100,
n_leapfrog_steps=20,
step_size=0.001,
momentum=0.995)
# track_position_over_time(sampled_bnn)
distribution = plot_weight_distribution(sampled_bnn, data, target)
kl = estimate_jensen_shannon_divergence_from_numerical_distribution(
distribution, Xs, ys, plot=False)
print("JSD(estimated true posterior | KDE(particles stochastic HMC)) = ", kl)
x_N = x_N_big
y_N = y_N_big
for i in range(n_retries):
# Initialize train loader
train_loader = MiniBatch(xs=x_N, ys=y_N, batch_size=batch_size)
model = SVGD_simple(x_dim, y_dim, num_networks, network_structure, l_sigma,
p_sigma, rbf)
# num_epochs = max(25, num_networks * 2)
num_epochs = 25
positions_over_time = run_svgd_model(model, train_loader, num_epochs,
step_size)
# After training
# Compute the jensen shannon divergence
jsd = estimate_jensen_shannon_divergence_from_numerical_distribution(
np.array(positions_over_time[-1][0]), x_N=x_N, y_N=y_N, plot=False)
jsd_array.append(jsd)
print(jsd)
jsd = estimate_jensen_shannon_divergence_from_numerical_distribution(
np.array(positions_over_time[-1][0]), x_N=x_N, y_N=y_N, plot=False)
jsd_array.append(jsd)
jsd = np.around(np.mean(jsd_array), 4)
particles = np.array(positions_over_time[-1][0])
plt.scatter(particles[:, 0], particles[:, 1])
print("For {} particles, rbf = {}, average jsd = {}".format(
num_networks, rbf, jsd))
plt.ylim([-4, 4])
plt.xlim([-4, 4])
savefile = os.path.join(
n_hmc = 50
num_iters = 2000
# Initialize train loader
# NOTE: it has to be Cyclic
# NOTE: the type of hybrid algorithm
train_loader = CyclicMiniBatch(xs=x_N, ys=y_N, batch_size=batch_size)
# model = SVGD_SGHMC_hybrid(x_dim, y_dim, num_networks, network_structure, l_sigma, p_sigma, rbf, \
# svgd_step_size=step_size, hmc_step_size=0.001, hmc_n_leapfrog_steps=15)
model = SVGD_naive_SHMC_hybrid(x_dim, y_dim, num_networks, network_structure, l_sigma, p_sigma, rbf, \
svgd_step_size=step_size, hmc_step_size=0.01, hmc_n_leapfrog_steps=20)
model.fit(train_loader=train_loader, num_iterations=num_iters, svgd_iteration=n_svgd, hmc_iteration=n_hmc)
positions_over_time = model.positions_over_time
sampled_bnn = model.hmc_sampled_bnn
particles = plot_weight_distribution_hmc(sampled_bnn, show=False)
# After training Compute the jensen shannon divergence
jsd = estimate_jensen_shannon_divergence_from_numerical_distribution(particles,
x_N=x_N, y_N=y_N, plot=False)
jsd = np.around(jsd, decimals=4)
plot_particle_positions(outdir, particles, num_networks, rbf, jsd)
# track_position_over_time(outdir, positions_over_time, N, num_networks, n_svgd, n_hmc, num_iters ,jsd)