def callback(params):
print("Log likelihood {}, Squared Error {}".format(-objective(params),squared_error(params,X,y,n_samples)))
# Show posterior marginals.
if dimensions[0] == 1:
plot_xs = np.reshape(np.linspace(-5, 5, 300), (300,1))
plot_deep_gp(ax_end_to_end, params, plot_xs)
deep_map = create_deep_map(params)
if dimensions == [1,1]:
ax_end_to_end.plot(np.ndarray.flatten(deep_map[0][0]['x0']),deep_map[0][0]['y0'], 'ro')
elif dimensions == [1,1,1]:
plot_single_gp(ax_x_to_h,params,0,0,plot_xs)
ax_x_to_h.set_title("Inputs to hiddens, pesudo data in red")
plot_single_gp(ax_h_to_y,params,1,0,plot_xs)
ax_h_to_y.set_title("Hiddens to outputs, pesudo data in red")
elif dimensions == [1,1,1,1]:
plot_single_gp(ax_x_to_h, params,0,0, plot_xs)
ax_x_to_h.set_title("Inputs to Hidden 1, pesudo data in red")
plot_single_gp(ax_h_to_h2, params,1,0,plot_xs)
ax_h_to_h2.set_title("Hidden 1 to Hidden 2, pesudo data in red")
plot_single_gp(ax_h2_to_y, params,2,0, plot_xs)
ax_h2_to_y.set_title("Hidden 2 to Outputs, pesudo data in red")
elif dimensions[0] == 2:
plot_xs = np.array([np.array([a,b]) for a in np.linspace(-1,1,40) for b in np.linspace(-1,1,40)])
plot_deep_gp_2d(ax, params, plot_xs)
plt.draw()
plt.pause(1.0/60.0)
def plot_deep_gp_2d(ax,params,plot_xs):
ax.cla()
rs = npr.RandomState(0)
sampled_means_and_covs = [sample_mean_cov_from_deep_gp(params, plot_xs) for i in xrange(n_samples)]
sampled_means, sampled_covs = zip(*sampled_means_and_covs)
avg_pred_mean = np.mean(sampled_means, axis = 0)
avg_pred_cov = np.mean(sampled_covs, axis = 0)
#print("X*",avg_pred_mean)
#rint("X*",plot_xs[0:4])
#sampled_means_and_covs_orig = [sample_mean_cov_from_deep_gp(params, X) for i in xrange(n_samples)]
#sampled_means_orig, sampled_covs_orig = zip(*sampled_means_and_covs_orig)
#avg_pred_mean_orig = np.mean(sampled_means_orig, axis = 0)
#print("Orignal Xs",avg_pred_mean_orig)
X0 = params[5:5+num_pseudo_params*2].reshape(num_pseudo_params,2)
y0 = params[5+num_pseudo_params*2:5+num_pseudo_params*3]
#ax.scatter(X0[:,0],X0[:,1],c = y0)
avg_pred_mean = avg_pred_mean.reshape(40,40)
ax.contourf(np.linspace(-1,1,40),np.linspace(-1,1,40), avg_pred_mean)
ax.scatter(X[:,0],X[:,1],c=y)
ax.set_xticks([])
ax.set_yticks([])
ax.set_title("Full Deep GP")
def build_toy_dataset(D=1, n_data=20, noise_std=0.1):
rs = npr.RandomState(0)
inputs = np.concatenate([np.linspace(0, 3, num=n_data/2),
np.linspace(6, 8, num=n_data/2)])
targets = (np.cos(inputs) + rs.randn(n_data) * noise_std) / 2.0
inputs = (inputs - 4.0) / 2.0
inputs = inputs.reshape((len(inputs), D))
return inputs, targets
def make_pinwheel_data(num_spokes=5, points_per_spoke=40, rate=1.0, noise_std=0.005):
"""Make synthetic data in the shape of a pinwheel."""
spoke_angles = np.linspace(0, 2 * np.pi, num_spokes + 1)[:-1]
rs = npr.RandomState(0)
x = np.linspace(0.1, 1, points_per_spoke)
xs = np.concatenate([x * np.cos(angle + x * rate) + noise_std * rs.randn(len(x)) for angle in spoke_angles])
ys = np.concatenate([x * np.sin(angle + x * rate) + noise_std * rs.randn(len(x)) for angle in spoke_angles])
return np.concatenate([np.expand_dims(xs, 1), np.expand_dims(ys, 1)], axis=1)
def build_toy_dataset(n_data=80, noise_std=0.1):
rs = npr.RandomState(0)
inputs = np.concatenate([np.linspace(0, 3, num=n_data/2),
np.linspace(6, 8, num=n_data/2)])
targets = np.cos(inputs) + rs.randn(n_data) * noise_std
inputs = (inputs - 4.0) / 2.0
inputs = inputs[:, np.newaxis]
targets = targets[:, np.newaxis] / 2.0
return inputs, targets
def init():
offset = 2.0
#if optimum[0] < np.inf:
# xmin = min(results['ADAM'][0][0], optimum[0]) - offset
# xmax = max(results['ADAM'][0][0], optimum[0]) + offset
#else:
xmin = domain[0, 0]
xmax = domain[0, 1]
#if optimum[1] < np.inf:
# ymin = min(results['ADAM'][1][0], optimum[1]) - offset
# ymax = max(results['ADAM'][1][0], optimum[1]) + offset
#else:
ymin = domain[1, 0]
ymax = domain[1, 1]
x = np.arange(xmin, xmax, 0.01)
y = np.arange(ymin, ymax, 0.01)
X, Y = np.meshgrid(x, y)
Z = np.zeros(np.shape(Y))
for a, _ in np.ndenumerate(Y):
Z[a] = func(X[a], Y[a])
level = fdict['level']
if level is None:
level = np.linspace(Z.min(), Z.max(), 20)
else:
if level[0] == 'normal':
level = np.linspace(Z.min(), Z.max(), level[1])
if level[0] == 'log':
level = np.logspace(np.log(Z.min()), np.log(Z.max()), level[1])
CF = ax[0].contour(X,Y,Z, levels=level)
#plt.colorbar(CF, orientation='horizontal', format='%.2f')
ax[0].grid()
ax[0].plot(results['ADAM'][0][0], results['ADAM'][1][0],
'h', markersize=15, color = '0.75')
if optimum[0] < np.inf and optimum[1] < np.inf:
ax[0].plot(optimum[0], optimum[1], '*', markersize=40,
markeredgewidth = 2, alpha = 0.5, color = '0.75')
ax[0].legend(loc='upper center', ncol=3, bbox_to_anchor=(0.5, 1.15))
ax[1].plot(0, results['ADAM'][2][0], 'o')
ax[1].axis([0, T, -0.5, max_err + 0.5])
ax[1].set_xlabel('num. iteration')
ax[1].set_ylabel('loss')
line1.set_data([], [])
line2.set_data([], [])
line3.set_data([], [])
line4.set_data([], [])
line5.set_data([], [])
err1.set_data([], [])
err2.set_data([], [])
err3.set_data([], [])
err4.set_data([], [])
err5.set_data([], [])
return line1, line2, line3, line4, line5, \
err1, err2, err3, err4, err5,
def plot_isocontours(ax, func, xlimits=[-2, 2], ylimits=[-4, 2], numticks=101):
x = np.linspace(*xlimits, num=numticks)
y = np.linspace(*ylimits, num=numticks)
X, Y = np.meshgrid(x, y)
zs = func(np.concatenate([np.atleast_2d(X.ravel()), np.atleast_2d(Y.ravel())]).T)
Z = zs.reshape(X.shape)
plt.contour(X, Y, Z)
ax.set_yticks([])
ax.set_xticks([])
def make_pinwheel_data(num_classes, num_per_class, rate=2.0, noise_std=0.001):
spoke_angles = np.linspace(0, 2*np.pi, num_classes+1)[:-1]
rs = npr.RandomState(0)
x = np.linspace(0.1, 1, num_per_class)
xs = np.concatenate([rate *x * np.cos(angle + x * rate) + noise_std * rs.randn(num_per_class)
for angle in spoke_angles])
ys = np.concatenate([rate *x * np.sin(angle + x * rate) + noise_std * rs.randn(num_per_class)
for angle in spoke_angles])
return np.concatenate([np.expand_dims(xs, 1), np.expand_dims(ys,1)], axis=1)
def build_toy_dataset(n_data=40, noise_std=0.1):
D = 1
rs = npr.RandomState(0)
inputs = np.concatenate([np.linspace(0, 2, num=n_data/2),
np.linspace(6, 8, num=n_data/2)])
targets = np.cos(inputs) + rs.randn(n_data) * noise_std
inputs = (inputs - 5.0) / 4.0
inputs = inputs.reshape((len(inputs), D))
targets = targets.reshape((len(targets), D))
return inputs, targets
def callback(params):
print("Log likelihood {}".format(-objective(params)))
plt.cla()
pred_mean, pred_cov = predict(params, X, y, plot_xs)
pred_mean = pred_mean.reshape(40,40)
ax.contourf(np.linspace(-1,1,40),np.linspace(-1,1,40), pred_mean)
ax.scatter(X[:,0],X[:,1],c=y)
ax.set_xticks([])
ax.set_yticks([])
plt.draw()
plt.pause(1.0/60.0)
def plot_error_surface(loss_fun, params, ax=None):
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
w0s = np.linspace(-2*params[0], 2*params[0], 10)
w1s = np.linspace(-2*params[1], 2*params[1], 10)
w0_grid, w1_grid = np.meshgrid(w0s, w1s)
lossvec = np.vectorize(loss_fun)
z = lossvec(w0_grid, w1_grid)
cs = ax.contour(w0s, w1s, z)
ax.clabel(cs)
ax.plot(params[0], params[1], 'rx', markersize=14)
return ax
def plot_trace(ps, ttl):
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = rosen(np.vstack([X.ravel(), Y.ravel()])).reshape((100,100))
ps = np.array(ps)
plt.figure(figsize=(12,4))
plt.subplot(121)
plt.contour(X, Y, Z, np.arange(10)**5)
plt.plot(ps[:, 0], ps[:, 1], '-o')
plt.plot(1, 1, 'r*', markersize=12) # global minimum
plt.subplot(122)
plt.semilogy(range(len(ps)), rosen(ps.T))
plt.title(ttl)
def plot_error_surface(xtrain, ytrain, model, ax=None):
params = model.params
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
w0s = np.linspace(-2*params[0], 2*params[0], 10)
w1s = np.linspace(-2*params[1], 2*params[1], 10)
w0_grid, w1_grid = np.meshgrid(w0s, w1s)
def loss(w0, w1):
return model.objective([w0, w1], xtrain, ytrain)
lossvec = np.vectorize(loss)
z = lossvec(w0_grid, w1_grid)
cs = ax.contour(w0s, w1s, z)
ax.clabel(cs)
ax.plot(params[0], params[1], 'rx', markersize=14)
def plot_gmm(params, ax, num_points=100):
angles = np.expand_dims(np.linspace(0, 2*np.pi, num_points), 1)
xs, ys = np.cos(angles), np.sin(angles)
circle_pts = np.concatenate([xs, ys], axis=1) * 2.0
for log_proportion, mean, chol in zip(*unpack_params(params)):
cur_pts = mean + np.dot(circle_pts, chol)
ax.plot(cur_pts[:, 0], cur_pts[:, 1], '-')
def equal_size_cv(n, num_chunks):
bs = map(int, np.linspace(0,n,num_chunks))
ans = []
for (l,r) in itertools.izip(bs[0:-1],bs[1:]):
ans.append([range(l,(l+r)/2), range((l+r)/2,r)])
ans.append([range((l+r)/2,r), range(l,(l+r)/2)])
return ans
def plot_true_posterior():
true_posterior_contour_levels = [0.01, 0.2, 1.0, 10.0]
x = np.linspace(*xlimits, num=200)
y = np.linspace(*ylimits, num=200)
X, Y = np.meshgrid(x, y)
fig = plt.figure(0); fig.clf()
fig.set_size_inches((5,4))
ax = fig.add_subplot(111)
zs = np.array([nllfun(np.concatenate(([x],[y]))) for x,y in zip(np.ravel(X), np.ravel(Y))])
Z = zs.reshape(X.shape)
plt.contour(X, Y, np.exp(-Z), true_posterior_contour_levels, colors='k')
ax.set_yticks([])
ax.set_xticks([])
return ax
def callback(params):
print("Log likelihood {}".format(-objective(params)))
plt.cla()
print(params)
# Show posterior marginals.
plot_xs = np.reshape(np.linspace(-7, 7, 300), (300,1))
pred_mean, pred_cov = predict(params, X, y, plot_xs)
marg_std = np.sqrt(np.diag(pred_cov))
ax.plot(plot_xs, pred_mean, 'b')
ax.fill(np.concatenate([plot_xs, plot_xs[::-1]]),
np.concatenate([pred_mean - 1.96 * marg_std,
(pred_mean + 1.96 * marg_std)[::-1]]),
alpha=.15, fc='Blue', ec='None')
# Show samples from posterior.
rs = npr.RandomState(0)
sampled_funcs = rs.multivariate_normal(pred_mean, pred_cov, size=10)
ax.plot(plot_xs, sampled_funcs.T)
ax.plot(X, y, 'kx')
ax.set_ylim([-1.5, 1.5])
ax.set_xticks([])
ax.set_yticks([])
plt.draw()
plt.pause(1.0/60.0)
def PyLQR_TrajCtrl_TrackingTest():
n_pnts = 200
x_coord = np.linspace(0.0, 2*np.pi, n_pnts)
y_coord = np.sin(x_coord)
#concatenate to have trajectory
ref_traj = np.array([x_coord, y_coord]).T
weight_mats = [ np.eye(ref_traj.shape[1])*100 ]
#draw reference trajectory
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hold(True)
ax.plot(ref_traj[:, 0], ref_traj[:, 1], '.-k', linewidth=3.5)
ax.plot([ref_traj[0, 0]], [ref_traj[0, 1]], '*k', markersize=16)
lqr_traj_ctrl = PyLQR_TrajCtrl(use_autograd=True)
lqr_traj_ctrl.build_ilqr_tracking_solver(ref_traj, weight_mats)
n_queries = 5
for i in range(n_queries):
#start from a perturbed point
x0 = ref_traj[0, :] + np.random.rand(2) * 2 - 1
syn_traj = lqr_traj_ctrl.synthesize_trajectory(x0)
#plot it
ax.plot(syn_traj[:, 0], syn_traj[:, 1], linewidth=3.5)
plt.show()
return
def build_sigmoid_dataset():
def sigmoid(x):
return 1.0 / (1 + np.exp(-x))
n_data = 500
X = np.linspace(-6, 6, n_data)
y = sigmoid(X) + .3*np.random.randn(len(X))
X = X.reshape((len(X),1))
return X,y
def callback(params, t, g):
# log_weights = params[:10] - logsumexp(params[:10])
print("Iteration {} lower bound {}".format(t, -objective(params, t)))
# print (np.exp(log_weights))
mean = params[0]
log_std = params[1]
print ('mean', mean)
print ('std', np.exp(log_std))
# print ('u0', params[2][0][0])
# print ('u1', params[2][1][0])
# print ('w0', params[2][0][1])
# print ('w1', params[2][1][1])
# print ('b0', params[2][0][2])
# print ('b1', params[2][1][2])
# x_inverse =
plt.cla()
target_distribution = lambda x: np.exp(log_density(x))
var_distribution = lambda x: np.exp(variational_log_density(params, x))
plot_isocontours(ax, target_distribution)
plot_isocontours(ax, var_distribution, cmap=plt.cm.bone)
ax.set_autoscale_on(False)
#PLot the z0 density
var_distribution0 = lambda x: np.exp(diag_gaussian_log_density(x, mean, log_std))
plot_isocontours(ax, var_distribution0)
for transform in params[2]:
xlimits=[-6, 6]
w = transform[1]
b = transform[2]
x = np.linspace(*xlimits, num=101)
plt.plot(x, (-w[0]*x - b)/w[1], '-')
u = transform[0]
plt.plot(x, (-u[0]*x)/u[1], '-')
#PLot variational samples
samples = variational_sampler(params)
plt.plot(samples[:, 0], samples[:, 1], 'x')
# #Plot q0 variational samples
# rs = npr.RandomState(0)
# samples = sample_diag_gaussian(mean, log_std, n_samples, rs)
# plt.plot(samples[:, 0], samples[:, 1], 'x')
plt.draw()
plt.pause(1.0/30.0)
def plot_ellipse(ax, alpha, mean, cov, line=None):
t = np.linspace(0, 2*np.pi, 100) % (2*np.pi)
circle = np.vstack((np.sin(t), np.cos(t)))
ellipse = 2.*np.dot(np.linalg.cholesky(cov), circle) + mean[:,None]
if line:
line.set_data(ellipse)
line.set_alpha(alpha)
else:
ax.plot(ellipse[0], ellipse[1], alpha=alpha, linestyle='-', linewidth=2)
def job_scf_gwgrid(sample_source, tr, te, r, J):
rand_state = np.random.get_state()
np.random.seed(r+92856)
d = tr.dim()
T_randn = np.random.randn(J, d)
np.random.set_state(rand_state)
# grid search to determine the initial gwidth
mean_sd = tr.mean_std()
scales = 2.0**np.linspace(-4, 4, 20)
list_gwidth = np.hstack( (mean_sd*scales*(d**0.5), 2**np.linspace(-10, 10, 20) ))
list_gwidth.sort()
besti, powers = tst.SmoothCFTest.grid_search_gwidth(tr, T_randn,
list_gwidth, alpha)
# initialize with the best width from the grid search
best_width = list_gwidth[besti]
scf_gwgrid = tst.SmoothCFTest(T_randn, best_width, alpha)
return scf_gwgrid.perform_test(te)
def generate_random_star(self):
"""
Generate a random star (not yet fully implemented)
Args:
None
Returns:
None
"""
theta = np.linspace(0, np.pi, num=40)[:, None]
phi = np.linspace(-np.pi, np.pi, num=40)
pix = hp.ang2pix(self.NSIDE, theta, phi)
healpix_map = np.zeros(hp.nside2npix(self.NSIDE), dtype=np.double)
healpix_map[pix] = np.random.randn(40,40)
stop()
def initParams(num):
mat = np.random.randn(m, m)
return dict({num + 'z': np.reshape(np.linspace(0.0, 1.0, num=m), (m, 1)),
num + 'u_mean': np.random.randn(m, 1),
num + 'u_cov_fac': mat @ mat.T,
num + 'h_mean': np.random.randn(n, 1),
num + 'h_cov_fac': np.random.randn(n, 1),
num + 'kernel_noise': np.ones((1, 1)),
num + 'kernel_lenscale': np.ones((1, 1)),
num + 'function_noise': np.ones((1, 1))})
def make_data_linreg_1d(N=21, linear=True):
xtrain = np.linspace(0, 20, N)
sigma2 = 2
w_true = np.array([-1.5, 1/9.])
if linear:
fun = lambda x: w_true[0] + w_true[1]*x
else:
fun = lambda x: w_true[0] + w_true[1]*np.sin(x)
noise = np.random.normal(0, 1, xtrain.shape) * np.sqrt(sigma2)
ytrain = fun(xtrain) + noise
return xtrain, ytrain, w_true
def plot_deep_gp_2d(ax,params,plot_xs):
ax.cla()
sampled_means_and_covs = [sample_mean_cov_from_deep_gp(params, plot_xs) for i in xrange(n_samples)]
sampled_means, sampled_covs = zip(*sampled_means_and_covs)
avg_pred_mean = np.mean(sampled_means, axis = 0)
avg_pred_cov = np.mean(sampled_covs, axis = 0)
if dimensions[1] == 1:
deep_map = create_deep_map(params)
x0 = deep_map[0][0]['x0']
y0 = deep_map[0][0]['y0']
ax.scatter(x0[:,0],x0[:,1],c = y0)
avg_pred_mean = avg_pred_mean.reshape(40,40)
ax.contourf(np.linspace(-1,1,40),np.linspace(-1,1,40), avg_pred_mean)
ax.scatter(X[:,0],X[:,1],c=y)
ax.set_xticks([])
ax.set_yticks([])
ax.set_title("Full Deep GP")
def callback(params, t, g):
print("Iteration {} log likelihood {}".format(t, -objective(params, t)))
# Plot data and functions.
plt.cla()
ax.plot(inputs.ravel(), targets.ravel(), 'bx', ms=12)
plot_inputs = np.reshape(np.linspace(-7, 7, num=300), (300,1))
outputs = nn_predict(params, plot_inputs)
ax.plot(plot_inputs, outputs, 'r', lw=3)
ax.set_ylim([-1, 1])
plt.draw()
plt.pause(1.0/60.0)
def plot_data_and_pred(x, y, model, draw_verticals=True):
x_range = np.linspace(np.min(x), np.max(x), 100)
yhat_range = model.predict(x_range)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x, y, 'o', label='observed')
ax.plot(x_range, yhat_range, 'r-', label='predicted')
if draw_verticals: # from observed value to predicted true
yhat_sparse = model.predict(x)
for x0, y0, yhat0 in zip(x, y, yhat_sparse):
ax.plot([x0, x0],[y0, yhat0],'k-')
plt.legend() #[line_pred, line_true], ['predicted', 'true'])
def PyLQR_TrajCtrl_GeneralTest():
#build RBF basis
rbf_basis = np.array([
[-1.0, -1.0],
[-1.0, 1.0],
[1.0, -1.0],
[1.0, 1.0]
])
gamma = 1
T = 100
R = 1e-5
# rbf_funcs = [lambda x, u, t, aux: np.exp(-gamma*np.linalg.norm(x[0:2]-basis)**2) + .01*np.linalg.norm(u)**2 for basis in rbf_basis]
rbf_funcs = [
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[0])**2) + R*np.linalg.norm(u)**2,
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[1])**2) + R*np.linalg.norm(u)**2,
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[2])**2) + R*np.linalg.norm(u)**2,
lambda x, u, t, aux: -np.exp(-gamma*np.linalg.norm(x[0:2]-rbf_basis[3])**2) + R*np.linalg.norm(u)**2
]
weights = np.array([.75, .5, .25, 1.])
weights = weights / (np.sum(weights) + 1e-6)
cost_func = lambda x, u, t, aux: np.sum(weights * np.array([basis_func(x, u, t, aux) for basis_func in rbf_funcs]))
lqr_traj_ctrl = PyLQR_TrajCtrl(use_autograd=True)
lqr_traj_ctrl.build_ilqr_general_solver(cost_func, n_dims=rbf_basis.shape[1], T=T)
n_eval_pnts = 50
coords = np.linspace(-2.5, 2.5, n_eval_pnts)
xv, yv = np.meshgrid(coords, coords)
z = [[cost_func(np.array([xv[i, j], yv[i, j]]), np.zeros(2), None, None) for j in range(yv.shape[1])] for i in range(len(xv))]
fig = plt.figure()
ax = fig.add_subplot(111)
ax.hold(True)
ax.contour(xv, yv, z)
n_queries = 5
u_array = np.random.rand(2, T-1).T * 2 - 1
for i in range(n_queries):
#start from a perturbed point
x0 = np.random.rand(2) * 4 - 2
syn_traj = lqr_traj_ctrl.synthesize_trajectory(x0, u_array)
#plot it
ax.plot([x0[0]], [x0[1]], 'k*', markersize=12.0)
ax.plot(syn_traj[:, 0], syn_traj[:, 1], linewidth=3.5)
plt.show()
return
def make_pinwheel_data(radial_std, tangential_std, num_classes, num_per_class, rate):
rads = np.linspace(0, 2*np.pi, num_classes, endpoint=False)
features = npr.randn(num_classes*num_per_class, 2) \
* np.array([radial_std, tangential_std])
features[:,0] += 1.
labels = np.repeat(np.arange(num_classes), num_per_class)
angles = rads[labels] + rate * np.exp(features[:,0])
rotations = np.stack([np.cos(angles), -np.sin(angles), np.sin(angles), np.cos(angles)])
rotations = np.reshape(rotations.T, (-1, 2, 2))
return 10*npr.permutation(np.einsum('ti,tij->tj', features, rotations))
def main():
#====== Setup =======
n_iters, n_samples, d = 2500, 2000, 2
init_vals = np.random.rand(n_samples, d) * 5.0
logprob = make_logprob()
allsamps = []
#====== Tests =======
t = dt.datetime.now()
print('running 2d tests ...')
samps = langevin(logprob,
copy(init_vals),
num_iters=n_iters,
num_samples=n_samples,
step_size=0.05)
print('done langevin in', dt.datetime.now() - t, '\n')
allsamps.append(samps)
samps = MALA(logprob,
copy(init_vals),
num_iters=n_iters,
num_samples=n_samples,
step_size=0.05)
print('done MALA in', dt.datetime.now() - t, '\n')
allsamps.append(samps)
t = dt.datetime.now()
samps = RK_langevin(logprob,
copy(init_vals),
num_iters=n_iters,
num_samples=n_samples,
step_size=0.01)
print('done langevin_RK in', dt.datetime.now() - t, '\n')
allsamps.append(samps)
t = dt.datetime.now()
samps = RWMH(logprob,
copy(init_vals),
num_iters=n_iters,
num_samples=n_samples,
sigma=0.5)
print('done RW MH in', dt.datetime.now() - t, '\n')
allsamps.append(samps)
t = dt.datetime.now()
samps = HMC(logprob,
copy(init_vals),
num_iters=n_iters // 5,
num_samples=n_samples,
step_size=0.05,
num_leap_iters=5)
print('done HMC in', dt.datetime.now() - t, '\n')
allsamps.append(samps)
#====== Plotting =======
pts = np.linspace(-7, 7, 1000)
X, Y = np.meshgrid(pts, pts)
pos = np.empty(X.shape + (2, ))
pos[:, :, 0] = X
pos[:, :, 1] = Y
Z = np.exp(logprob(pos))
f, axes = plt.subplots(2, 3)
names = ['langevin', 'MALA', 'langevin_RK', 'RW MH', 'HMC']
for i, (name, samps) in enumerate(zip(names, allsamps)):
row = i // 3
col = i % 3
ax = axes[row, col]
ax.contour(X, Y, Z)
ax.hist2d(samps[:, 0], samps[:, 1], alpha=0.5, bins=25)
ax.set_title(name)
axes[1, 2].hist2d(init_vals[:, 0], init_vals[:, 1], bins=25)
axes[1, 2].set_title('Initial samples.')
plt.show()
bounds = np.array([[-5, 10], [0, 15]])
if True:
target_function = hyper_ellipsoid_function
x = np.random.random((2, N)) * 10 + np.array([[-5], [5]])
bounds = np.array([[-5, 5], [-5, 5]])
y = target_function(x)
kernel = gp.kernels.Matern()
model_gp = gp.GaussianProcessRegressor(kernel=kernel,
alpha=1e-5,
n_restarts_optimizer=10,
normalize_y=True)
# plot the surface
lambdas = np.linspace(-5, 10, 100)
gammas = np.linspace(0, 15, 100)
# We need the cartesian combination of these two vectors
param_grid = np.array([[C, gamma] for gamma in gammas for C in lambdas])
real_loss = [barnin_function(params[:, np.newaxis]) for params in param_grid]
# The maximum is at:
print param_grid[np.array(real_loss).argmin(), :]
C, G = np.meshgrid(lambdas, gammas)
plt.figure()
cp = plt.contourf(C, G, np.array(real_loss).reshape(C.shape))
plt.colorbar(cp)
plt.savefig('surface_grid.png')
#plt.show()
plt.clf()
help='Whether to save or not an animated GIF')
parser.add_argument('--save_tikz',
action='store_true',
help='Whether to save or not a tikz plot for LaTeX')
args = parser.parse_args()
# args = argparse.Namespace()
#
# args.animate = True
# args.nsteps = 120
# args.good_init = True
# args.lr = 0.25
# args.save_gif = True
# args.save_tikz = True
xx = np.linspace(-1, 1, 64)
yy = np.linspace(-3, 1.5, 64)
x, y = np.meshgrid(xx, yy)
z = f(x, y)
if args.good_init:
x_init = 0.2
y_init = -0.1
else:
x_init = -0.3
y_init = 0.4
levelsf = MaxNLocator(nbins=20).tick_values(z.min(), z.max())
levels = MaxNLocator(nbins=20).tick_values(z.min(), z.max())
psy_t = psy_trial(xi, net_out)
gradient_of_trial = psy_grad(xi, net_out)
second_gradient_of_trial = psy_grad2(xi, net_out)
func = f(xi, psy_t, gradient_of_trial)
err_sqr = (second_gradient_of_trial - func)**2
loss_sum += err_sqr
return loss_sum - 0.1 * np.dot(W[0].flatten(), W[0].flatten(
)) - 0.1 * np.dot(W[1].flatten(), W[1].flatten())
#%%
x_space = np.linspace(0, 2, nx)
y_space = psy_analytic(x_space)
W = [ran.randn(1, 20), ran.randn(20, 1), ran.randn(20), ran.randn(1)]
lmb = 0.001
for i in range(1000):
loss_grad = grad(loss_function)(W, x_space)
W[0] = W[0] - lmb * loss_grad[0]
W[1] = W[1] - lmb * loss_grad[1]
W[2] = W[2] - lmb * loss_grad[2]
W[3] = W[3] - lmb * loss_grad[3]
#%%
print(loss_function(W, x_space))
print(W)
def plot_fit_and_feature_space(self, w, model, feat, **kwargs):
# construct figure
fig, axs = plt.subplots(1, 3, figsize=(9, 4))
# create subplot with 2 panels
gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1])
ax1 = plt.subplot(gs[0])
ax2 = plt.subplot(gs[1])
view = [20, 20]
if 'view' in kwargs:
view = kwargs['view']
##### plot left panel in original space ####
# scatter points
xmin, xmax, ymin, ymax = self.scatter_pts_2d(self.x, ax1)
# clean up panel
ax1.set_xlim([xmin, xmax])
ax1.set_ylim([ymin, ymax])
# label axes
ax1.set_xlabel(r'$x$', fontsize=16)
ax1.set_ylabel(r'$y$', rotation=0, fontsize=16, labelpad=10)
# create fit
s = np.linspace(xmin, xmax, 300)[np.newaxis, :]
normalizer = lambda a: a
if 'normalizer' in kwargs:
normalizer = kwargs['normalizer']
t = model(normalizer(s), w)
ax1.plot(s.flatten(), t.flatten(), linewidth=4, c='k', zorder=0)
ax1.plot(s.flatten(), t.flatten(), linewidth=2, c='lime', zorder=0)
#### plot fit in transformed feature space #####
# check if feature transform has internal parameters
x_transformed = 0
sig = signature(feat)
if len(sig.parameters) == 2:
if np.shape(w)[1] == 1:
x_transformed = feat(normalizer(self.x), w)
else:
x_transformed = feat(normalizer(self.x), w[0])
else:
x_transformed = feat(normalizer(self.x))
# two dimensional transformed feature space
if x_transformed.shape[0] == 1:
s = np.linspace(xmin, xmax, 300)[np.newaxis, :]
# scatter points
xmin, xmax, ymin, ymax = self.scatter_pts_2d(x_transformed, ax2)
# produce plot
s2 = copy.deepcopy(s)
if len(sig.parameters) == 2:
if np.shape(w)[1] == 1:
s2 = feat(normalizer(s), w)
else:
s2 = feat(normalizer(s), w[0])
else:
s2 = feat(normalizer(s))
t = model(normalizer(s), w)
ax2.plot(s2.flatten(), t.flatten(), linewidth=4, c='k', zorder=0)
ax2.plot(s2.flatten(),
t.flatten(),
linewidth=2,
c='lime',
zorder=0)
# label axes
ax2.set_xlabel(r'$f\left(x,\mathbf{w}^{\star}\right)$',
fontsize=16)
ax2.set_ylabel(r'$y$', rotation=0, fontsize=16, labelpad=10)
# three dimensional transformed feature space
if x_transformed.shape[0] == 2:
# create panel
ax2 = plt.subplot(gs[1], projection='3d')
s = np.linspace(xmin, xmax, 100)[np.newaxis, :]
# plot data in 3d
xmin, xmax, xmin1, xmax1, ymin, ymax = self.scatter_3d_points(
x_transformed, ax2)
# create and plot fit
s2 = copy.deepcopy(s)
if len(sig.parameters) == 2:
s2 = feat(normalizer(s), w[0])
else:
s2 = feat(normalizer(s))
# reshape for plotting
a = s2[0, :]
b = s2[1, :]
a = np.linspace(xmin, xmax, 100)
b = np.linspace(xmin1, xmax1, 100)
a, b = np.meshgrid(a, b)
# get firstem
a.shape = (1, np.size(s)**2)
f1 = feat(normalizer(a))[0, :]
# secondm
b.shape = (1, np.size(s)**2)
f2 = feat(normalizer(b))[1, :]
# tack a 1 onto the top of each input point all at once
c = np.vstack((a, b))
o = np.ones((1, np.shape(c)[1]))
c = np.vstack((o, c))
r = (np.dot(c.T, w))
# various
a.shape = (np.size(s), np.size(s))
b.shape = (np.size(s), np.size(s))
r.shape = (np.size(s), np.size(s))
ax2.plot_surface(a,
b,
r,
alpha=0.1,
color='lime',
rstride=15,
cstride=15,
linewidth=0.5,
edgecolor='k')
ax2.set_xlim([np.min(a), np.max(a)])
ax2.set_ylim([np.min(b), np.max(b)])
'''
a,b = np.meshgrid(t1,t2)
a.shape = (1,np.size(s)**2)
b.shape = (1,np.size(s)**2)
'''
'''
c = np.vstack((a,b))
o = np.ones((1,np.shape(c)[1]))
c = np.vstack((o,c))
# tack a 1 onto the top of each input point all at once
r = (np.dot(c.T,w))
a.shape = (np.size(s),np.size(s))
b.shape = (np.size(s),np.size(s))
r.shape = (np.size(s),np.size(s))
ax2.plot_surface(a,b,r,alpha = 0.1,color = 'lime',rstride=15, cstride=15,linewidth=0.5,edgecolor = 'k')
'''
# label axes
#self.move_axis_left(ax2)
ax2.set_xlabel(r'$f_1(x)$', fontsize=12, labelpad=5)
ax2.set_ylabel(r'$f_2(x)$', rotation=0, fontsize=12, labelpad=5)
ax2.set_zlabel(r'$y$', rotation=0, fontsize=12, labelpad=0)
self.move_axis_left(ax2)
ax2.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax2.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax2.view_init(view[0], view[1])
def get_Ap(nb_sampled_frequencies, passband_edge, stopband_edge, order_length):
sampled_frequencies = np.linspace(passband_edge, stopband_edge, nb_sampled_frequencies)
App = np.array([get_cl(w, order_length) for w in sampled_frequencies], dtype=np.float64)
Anp = np.array([-np.array(get_cl(w, order_length)) for w in sampled_frequencies], dtype=np.float64)
return np.concatenate((App, Anp))
import autograd
from autograd import numpy as np
from defaults import pennylane as qml, BaseTest
from pennylane.qnode import _flatten, unflatten, QNode, QuantumFunctionError
from pennylane.plugins.default_qubit import CNOT, Rotx, Roty, Rotz, I, Y, Z
from pennylane._device import DeviceError
def expZ(state):
return np.abs(state[0])**2 - np.abs(state[1])**2
thetas = np.linspace(-2 * np.pi, 2 * np.pi, 7)
a = np.linspace(-1, 1, 64)
a_shapes = [(64, ), (64, 1), (32, 2), (16, 4), (8, 8), (16, 2, 2),
(8, 2, 2, 2), (4, 2, 2, 2, 2), (2, 2, 2, 2, 2, 2)]
b = np.linspace(-1., 1., 8)
b_shapes = [(8, ), (8, 1), (4, 2), (2, 2, 2), (2, 1, 2, 1, 2)]
class BasicTest(BaseTest):
"""Qnode basic tests.
"""
def setUp(self):
self.dev1 = qml.device('default.qubit', wires=1)
self.dev2 = qml.device('default.qubit', wires=2)
def fun(x, y):
return np.linspace(x, y, num)
