def plot_res2ele(samples=1000, noise=0., subplot=111):
ele, azi, azi_diff, res = [], [], [], []
theta_s, phi_s = fibonacci_sphere(samples=samples, fov=161)
phi_s = phi_s[theta_s <= np.pi / 2]
theta_s = theta_s[theta_s <= np.pi / 2]
phi_s = phi_s[theta_s > np.pi / 18]
theta_s = theta_s[theta_s > np.pi / 18]
samples = theta_s.size
for e, a in zip(theta_s, phi_s):
d_err, d_eff, tau, _, _ = evaluate(sun_azi=a, sun_ele=e, tilting=False, noise=noise)
azi.append(a)
ele.append(e)
res.append(tau.flatten())
ele = np.rad2deg(ele).flatten()
res = (np.array(res).flatten() - 1.06) * 7 / 4
ele = ele[res <= 2]
res = res[res <= 2]
ele_pred = 26 * (1 - 2 * np.arcsin(1 - res) / np.pi) + 15 # + np.random.randn(res.size)
plt.subplot(subplot)
plt.scatter(res, ele, c='black', marker='.')
plt.scatter(res, ele_pred, c='red', marker='.')
plt.plot([-.5, 3 * np.pi / 4], [18.75, 18.75], "k--")
plt.plot([-.5, 3 * np.pi / 4], [65.98, 65.98], "k--")
plt.ylabel(r'$\epsilon (\circ)$')
plt.xlabel(r'$\tau$')
plt.xlim([-.5, 3 * np.pi / 4])
plt.ylim([90, 0])
# plt.xticks([0, 90, 180, 270, 360])
return plt
def one_test(**kwargs):
print "Running single test:", kwargs
d_err, d_eff, t, _, _ = evaluate(**kwargs)
d_mean = np.nanmean(d_err)
d_se = np.nanstd(d_err) / np.sqrt(d_err.size)
print "Mean cost: %.2f +/- %.4f -- Certainty: %.2f" % (
d_mean, d_se, np.nanmean(np.rad2deg(t)))
def plot_gate_cost(samples=500, **kwargs):
d_err, d_eff, tau, _, _ = evaluate(samples=samples, tilting=True, **kwargs)
tau = np.rad2deg(tau)
d_mean = np.nanmean(d_err)
d_se = d_err.std() / np.sqrt(d_err.size)
print "Tilt overall 0 deg 30 deg 60 deg "
print "---------------------------------------------------------------------------------------"
print "Mean cost %.2f +/- %.4f" % (d_mean, d_se),
if samples == 1000:
samples /= 2
theta_s, phi_s = fibonacci_sphere(samples=samples, fov=161)
phi_s = phi_s[theta_s <= np.pi / 2]
theta_s = theta_s[theta_s <= np.pi / 2]
d_00 = d_err[:, 0]
d_30 = np.nanmean(d_err[:, 1:9], axis=1)
d_60 = np.nanmean(d_err[:, 9:], axis=1)
print " %.2f +/- %.4f" % (np.nanmean(d_00), np.nanstd(d_00) / d_00.size),
print " %.2f +/- %.4f" % (np.nanmean(
d_err[:, 1:9]), np.nanstd(d_err[:, 1:9]) / d_err[:, 1:9].size),
print " %.2f +/- %.4f" % (np.nanmean(
d_err[:, 9:]), np.nanstd(d_err[:, 9:]) / d_err[:, 9:].size)
for i, ang, dd in zip(range(3), [0, np.pi / 6, np.pi / 3],
[d_00, d_30, d_60]):
ax = plt.subplot2grid((1, 10), (0, i * 3), colspan=3, polar=True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
plt.scatter(phi_s,
np.rad2deg(theta_s),
marker=".",
c=dd,
cmap="Reds",
vmin=0,
vmax=90)
plt.scatter(np.pi,
np.rad2deg(ang),
marker="o",
c="yellowgreen",
edgecolors="black")
plt.text(-np.deg2rad(50), 145, ["A", "B", "C"][i], fontsize=12)
plt.axis("off")
plt.subplot2grid((3, 10), (1, 9))
plt.imshow(np.array([np.arange(0, np.pi / 2, np.pi / 180)] * 10).T,
cmap="Reds")
plt.xticks([])
plt.yticks([0, 45, 89], [r"0", r"$\frac{\pi}{4}$", r"$\geq\frac{\pi}{2}$"])
return plt
def plot_gate_optimisation(load="data/gate-costs.npz", save=None, **kwargs):
ax = plt.subplot(111, polar=True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
sigmas = np.linspace(np.pi / 180, np.pi / 2, 90)
shifts = np.linspace(0, 2 * np.pi, 361)
if load is not None:
data = np.load(load)
shifts, sigmas, means = data["shifts"], data["sigmas"], data["costs"]
else:
sigmas, shifts = np.meshgrid(sigmas, shifts)
means = np.zeros(sigmas.size)
for ii, sigma, shift in zip(np.arange(sigmas.size), sigmas.flatten(),
shifts.flatten()):
d_err, d_eff, tau, _, _ = evaluate(sigma=sigma,
shift=shift,
verbose=False,
**kwargs)
means[ii] = d_err.mean()
print "Sigma: %d, Shift: %d, Cost: %.2f" % (
np.rad2deg(sigma), np.rad2deg(shift), d_err.mean())
means = means.reshape(shifts.shape)
np.savez_compressed(save, shifts=shifts, sigmas=sigmas, costs=means)
ii = np.argmin(means.flatten())
sigma_min = sigmas.flatten()[ii]
shift_min = shifts.flatten()[ii]
means_min = means.flatten()[ii]
print 'Minimum cost (%.2f) for Sigma = %.2f, Shift = %.2f' % (
means_min, np.rad2deg(sigma_min), np.rad2deg(shift_min))
with plt.rc_context({'ytick.color': 'white'}):
plt.pcolormesh(shifts, sigmas, means, cmap="Reds", vmin=0, vmax=90)
plt.scatter(shift_min, sigma_min, s=20, c='yellowgreen', marker='o')
plt.yticks([0, np.pi / 6, np.pi / 3, np.pi / 2],
[r"$0$", r"$30^\circ$", r"$60^\circ$", r"$90^\circ$"])
plt.xticks(np.linspace(0, 2 * np.pi, 8, endpoint=False), [
r'$0^\circ$', r'$45^\circ$', r'$90^\circ$', r'$135^\circ$',
r'$180^\circ$', r'$-135^\circ$', r'$-90^\circ$', r'$-45^\circ$'
])
plt.ylim([0, np.pi / 2])
ax.grid(alpha=0.2)
return plt
def tilt_ephem_test(**kwargs):
print "Running simple tilt and ephemeris test:", kwargs
kwargs['samples'] = kwargs.get('samples', 1)
kwargs['show_plots'] = kwargs.get('show_plots', True)
kwargs['show_structure'] = kwargs.get('show_structure', False)
kwargs['sun_azi'] = kwargs.get('sun_azi', -np.pi / 3)
kwargs['sun_ele'] = kwargs.get('sun_ele', np.pi / 3)
# kwargs['tilting'] = kwargs.get('tilting', False)
kwargs['tilting'] = kwargs.get('tilting',
(np.pi / 9, np.pi / 2 + np.pi / 3))
kwargs['ephemeris'] = kwargs.get('ephemeris', True)
d_err, d_eff, t, _, _ = evaluate(**kwargs)
d_mean = np.nanmean(d_err)
d_se = np.nanstd(d_err) / np.sqrt(d_err.size)
print "Mean cost: %.2f +/- %.4f -- Certainty: %.2f" % (
d_mean, d_se, np.nanmean(np.rad2deg(t)))
def responses(sun_ele=np.pi / 3, uniform=True, noise=.5, bl=.5):
sun_azi = np.linspace(-np.pi, np.pi, 36, endpoint=False)
sun_ele = np.full_like(sun_azi, sun_ele)
phi_maxs = [[]] * 8
r_means = [[]] * 8
r_stds = [[]] * 8
p_values = [[]] * 8
tb1s = np.empty((0, sun_azi.shape[0], 8), dtype=sun_azi.dtype)
for n_tb1 in np.arange(8):
tb1s = np.empty((0, sun_azi.shape[0], 8), dtype=sun_azi.dtype)
for _ in np.linspace(0, 1, 100):
d_deg, d_eff, t, phi, r_tb1 = evaluate(
uniform_polariser=uniform,
sun_azi=sun_azi,
sun_ele=sun_ele,
tilting=False,
noise=noise)
tb1s = np.vstack([tb1s, np.transpose(r_tb1, axes=(1, 0, 2))])
r_mean = np.median(tb1s[..., n_tb1], axis=0)
z = r_mean.max() - r_mean.min()
r_mean = (r_mean - r_mean.min()) / z - bl
r_means[n_tb1] = r_mean
r_stds[n_tb1] = tb1s[..., n_tb1].std(axis=0) / np.sqrt(z)
p_values[n_tb1] = rayleightest(sun_azi, weights=r_mean + bl)
phi_max = circmean(sun_azi, weights=np.power(r_mean + bl, 50))
phi_maxs[n_tb1] = phi_max
z = tb1s.max() - tb1s.min()
tb1s = (tb1s - tb1s.min()) / z
phis = np.transpose(np.array([[sun_azi] * 100] * 8), axes=(1, 2, 0))
phi_means = circmean(phis, axis=1, weights=np.power(tb1s, 50)).T
return np.array(phi_maxs)[::-1], phi_means[::-1], np.array(
r_means)[::-1], np.array(r_stds)[::-1], np.array(p_values)[::-1]
def plot_res2ele(samples=1000, noise=0., subplot=111):
ele, azi, azi_diff, res = [], [], [], []
theta_s, phi_s = fibonacci_sphere(samples=samples, fov=161)
phi_s = phi_s[theta_s <= np.pi / 2]
theta_s = theta_s[theta_s <= np.pi / 2]
phi_s = phi_s[theta_s > np.pi / 18]
theta_s = theta_s[theta_s > np.pi / 18]
samples = theta_s.size
for e, a in zip(theta_s, phi_s):
d_err, d_eff, tau, _, _ = evaluate(sun_azi=a,
sun_ele=e,
tilting=False,
noise=noise)
azi.append(a)
ele.append(e)
res.append(tau.flatten())
ele = np.rad2deg(ele).flatten()
res = np.array(res).flatten()
ele_pred = 26 * (
1 - 2 * np.arcsin(np.clip(2.855 - 3.5 * res, -1, 1)) / np.pi) + 15
plt.subplot(subplot)
plt.scatter(res, ele, c='black', marker='.')
plt.scatter(np.clip(res, 0, 4), ele_pred, c='red', marker='.')
plt.plot([-.5, 3 * np.pi / 4], [18.75, 18.75], "k--")
plt.plot([-.5, 3 * np.pi / 4], [65.98, 65.98], "k--")
plt.ylabel(r'$\epsilon (\circ)$')
plt.xlabel(r'$\tau$')
plt.xticks([0.5, 0.75, 1, 1.25])
plt.xlim([.43, 1.21])
plt.ylim([90, 0])
return plt
def plot_accuracy(save=None, repeats=10, verbose=False, **kwargs):
ax1 = plt.subplot(132)
ax3 = plt.subplot(131)
sun_ele = np.linspace(0, np.pi / 2, 91)
sun_azi = np.linspace(0, 2 * np.pi, 360, endpoint=False)
sun_ele = kwargs.get('sun_ele', sun_ele)
d_mean = np.zeros_like(sun_ele)
d_se = np.zeros_like(sun_ele)
tau = np.zeros_like(sun_ele)
kwargs['sun_azi'] = kwargs.get('sun_azi', sun_azi)
kwargs['tilting'] = kwargs.get('tilting', False)
kwargs['verbose'] = kwargs.get('verbose', False)
for j, noise in enumerate(np.linspace(0, 1, 5, endpoint=False)):
kwargs['noise'] = noise
for i, theta_s in enumerate(sun_ele):
kwargs['sun_ele'] = np.full_like(sun_azi, theta_s)
d_err, d_eff, t, a_ret, tb1 = evaluate(**kwargs)
d_mean[i] = np.nanmean(d_err)
d_se[i] = np.nanstd(d_err) / np.sqrt(np.sum(~np.isnan(d_err)))
tau[i] += np.nanmean(np.clip(t, 0., 2.)) / 5.
# print tau
# if j == 0:
# tau[i] = np.nanmean(t)
ax1.fill_between(np.rad2deg(sun_ele),
d_mean - d_se,
d_mean + d_se,
facecolor='C%d' % j,
alpha=.5)
ax1.plot(np.rad2deg(sun_ele),
d_mean,
color='C%d' % j,
label=r'$\eta = %.1f$' % noise)
ax3.fill_between(np.rad2deg(sun_ele),
d_mean - d_se,
d_mean + d_se,
facecolor='C%d' % j,
alpha=.5)
ax3.plot(np.rad2deg(sun_ele),
d_mean,
color='C%d' % j,
label=r'$\eta = %.1f$' % noise)
plt.legend()
ax1.set_yticks([0, 10, 20, 30])
ax1.set_ylim([0, 30])
ax1.set_xticks([0, 30, 60, 90])
ax1.set_xlim([0, 90])
ax1.set_ylabel(r'MSE ($J_s$) [$^\circ$]')
ax1.set_xlabel(r'sun elevation ($\theta_s$) [$^\circ$]')
ax2 = ax1.twinx()
ax2.plot(np.rad2deg(sun_ele), tau, 'k--')
ax2.set_ylim([0, 1.2])
ax2.set_yticks([0, .4, .8, 1.2])
ax3.set_yticks([0, .03, .06, .09])
ax3.set_ylim([0, .09])
ax3.set_xticks([0, 30, 60, 90])
ax3.set_xlim([0, 90])
ax3.set_ylabel("")
ax3.set_xlabel(r'sun elevation ($\theta_s$) [$^\circ$]')
ax1 = plt.subplot(133)
kwargs['sun_ele'] = None
kwargs['sun_azi'] = None
etas = np.linspace(0, 1, 21)
taus = np.zeros_like(etas)
means = np.zeros_like(etas)
ses = np.zeros_like(etas)
for i in xrange(repeats):
noise = np.ones(60, int)
x = np.argsort(np.absolute(np.random.randn(noise.size)))
for ii, eta in enumerate(etas):
noise[:] = 0
noise[x[:int(eta * float(noise.size))]] = 1
kwargs['noise'] = noise
d_err, d_eff, tau, _, _ = evaluate(**kwargs)
means[ii] = (means[ii] * i + d_err.mean()) / (i + 1)
ses[ii] = (ses[ii] * i + d_err.std() / np.sqrt(d_err.size)) / (i +
1)
taus[ii] = (taus[ii] * i + np.maximum(tau, 0).mean()) / (i + 1)
if verbose:
print " Disturbance Cost Confidence "
print "-----------------------------------------------------"
for i, eta in enumerate(etas):
print " % 3.2f%% % 2.2f +/- %.4f % 2.2f" % (
eta * 100, means[i], ses[i], taus[i])
ax1.fill_between(etas * 100, means - ses, means + ses, facecolor="grey")
ax1.plot(etas * 100, means, color="black", linestyle="-", label=r'$J_s$')
ax1.plot(etas * 100,
tau2sigma(taus),
color="black",
linestyle="--",
label=r'$\sigma$')
ax1.set_ylim([0, 30])
ax1.set_yticks([])
ax1.set_xlim([0, 100])
ax1.set_xlabel(r'disturbance ($\eta$) [%]')
ax2 = ax1.twinx()
ax2.plot(etas * 100, taus, color="grey", linestyle="--", label=r'$\tau$')
ax2.set_ylim([0, 1.2])
ax2.set_yticks([0, .4, .8, 1.2])
plt.legend()
if save:
plt.savefig(save)
return plt
def elevation_test(**kwargs):
print "Running elevation test:", kwargs
sun_ele = np.linspace(0, np.pi / 2, 91)
sun_azi = np.linspace(0, 2 * np.pi, 360, endpoint=False)
sun_ele = kwargs.get('sun_ele', sun_ele)
d_mean = np.zeros_like(sun_ele)
d_se = np.zeros_like(sun_ele)
tau = np.zeros_like(sun_ele)
kwargs['sun_azi'] = kwargs.get('sun_azi', sun_azi)
kwargs['tilting'] = kwargs.get('tilting', False)
kwargs['weighted'] = kwargs.get('weighted', True)
plt.figure("elevation", figsize=(4.5, 3))
for j, noise in enumerate(np.linspace(0, 2, 5)):
# plt.figure("elevation-%02d" % (10 * noise), figsize=(5, 2))
# kwargs['noise'] = kwargs.get('noise', noise)
kwargs['noise'] = noise
d = np.zeros((sun_azi.shape[0], sun_ele.shape[0]))
for i, theta_s in enumerate(sun_ele):
kwargs['sun_ele'] = np.full_like(sun_azi, theta_s)
d_err, d_eff, t, a_ret, tb1 = evaluate(**kwargs)
d_mean[i] = np.nanmean(d_err)
d_se[i] = np.nanstd(d_err) / np.sqrt(np.sum(~np.isnan(d_err)))
tau[i] += np.rad2deg(np.nanmean(t))
print "Mean cost: %.2f +/- %.4f -- Certainty: %.2f -- ele: %.2f" % (
d_mean[i], d_se[i], tau[i], np.rad2deg(theta_s))
plt.fill_between(np.rad2deg(sun_ele),
d_mean - d_se,
d_mean + d_se,
facecolor='C%d' % j,
alpha=.5)
# plt.semilogy(np.rad2deg(sun_ele), d_mean, color='C%d' % j, label=r'$\eta = %.1f$' % noise)
plt.plot(np.rad2deg(sun_ele),
d_mean,
color='C%d' % j,
label=r'$\eta = %.1f$' % noise)
tau /= 5.
plt.plot(np.rad2deg(sun_ele), tau, 'k--')
plt.legend()
# plt.yticks([0.01, 0.1, 1, 10, 100])
plt.yticks([0, 30, 60, 90])
# plt.ylim([0.001, 120])
plt.ylim([0, 90])
plt.xticks([0, 30, 60, 90])
plt.xlim([0, 90])
plt.ylabel(r'MSE [$\circ$]')
plt.xlabel(r'sun elevation [$\circ$]')
# kwargs.pop('sun_azi')
# kwargs.pop('sun_ele')
# noises = np.linspace(0, 2, 100)
# d_mean = np.zeros_like(noises)
# d_se = np.zeros_like(noises)
# tau = np.zeros_like(noises)
#
# plt.figure("noise", figsize=(3, 3))
# for j, noise in enumerate(noises):
# kwargs['noise'] = noise
# d_err, d_eff, t, a_ret, tb1 = evaluate(**kwargs)
# d_mean[j] = np.nanmean(d_err)
# d_se[j] = np.nanstd(d_err) / np.sqrt(np.sum(~np.isnan(d_err)))
# tau[j] = np.rad2deg(np.nanmean(t))
# print "Mean cost: %.2f +/- %.4f -- Certainty: %.2f -- noise: %.2f" % (d_mean[j], d_se[j], tau[j], noise)
# plt.fill_between(noises, d_mean - d_se, d_mean + d_se, facecolor='black', alpha=.5)
# # plt.semilogy(noises, d_mean, 'k-%s' % ('' if weighted else '-'),
# # label=r'%s' % ('weighted' if weighted else ' simple'))
# plt.plot(noises, d_mean, 'k-', label=r'$E[J]$')
# plt.plot(noises, tau, 'k--', label=r'$E[\tau]$')
#
# plt.legend()
# # plt.yticks([0.01, 0.1, 1, 10, 100])
# plt.yticks([0, 30, 60, 90])
# # plt.ylim([0.001, 120])
# plt.ylim([0, 90])
# plt.xticks([0, 0.5, 1, 1.5, 2])
# plt.xlim([0, 2])
# plt.xlabel(r'noise ($\eta$)')
plt.show()
def heinze_1f(eta=.5, uniform=False):
from astropy.stats import circmean
phi_tb1 = 3 * np.pi / 2 - np.linspace(np.pi, 0, 8)
# phi_tb1 = np.pi / 2 + np.linspace(0, np.pi, 8)
sun_azi = np.linspace(-np.pi, np.pi, 36, endpoint=False)
sun_ele = np.full_like(sun_azi, np.pi / 2)
# phi_tb1 = np.linspace(0., 2 * np.pi, 8, endpoint=False) # TB1 preference angles
tb1_ids = np.empty((0, sun_azi.shape[0], 8), dtype=sun_azi.dtype)
tb1s = np.empty((0, sun_azi.shape[0], 8), dtype=sun_azi.dtype)
for _ in np.linspace(0, 1, 100):
d_deg, d_eff, t, phi, r_tb1 = evaluate(uniform_polariser=uniform,
sun_azi=sun_azi,
sun_ele=sun_ele,
tilting=False,
noise=eta)
tb1s = np.vstack([tb1s, np.transpose(r_tb1, axes=(1, 0, 2))])
tb1_ids = np.vstack(
[tb1_ids, np.array([sun_azi] * 8).T.reshape((1, 36, 8))])
z = tb1s.max() - tb1s.min()
tb1s = (tb1s - tb1s.min()) / z
phis = np.transpose(np.array([[sun_azi] * 100] * 8), axes=(1, 2, 0))
d_deg, d_eff, t, phi, r_tb1 = evaluate(uniform_polariser=uniform,
sun_azi=sun_azi,
sun_ele=sun_ele,
tilting=False,
noise=0.)
tb1 = np.transpose(r_tb1, axes=(1, 0, 2)) * 1e+15
if uniform:
phi_mean = circmean(phis, axis=1, weights=np.power(tb1s, 50))
for i in xrange(phi_mean.shape[1]):
d_00 = np.absolute((phi_mean[:, i] - phi_tb1[-1 - i] + np.pi) %
(2 * np.pi) - np.pi)
d_pi = np.absolute((phi_mean[:, i] - phi_tb1[-1 - i]) %
(2 * np.pi) - np.pi)
phi_mean[d_00 > d_pi, i] += np.pi
phi_max = circmean(phis[0][np.newaxis],
axis=1,
weights=np.power(tb1, 50)).flatten()
for i, phi_max_i in enumerate(phi_max):
d_00 = np.absolute((phi_max_i - phi_tb1[-1 - i] + np.pi) %
(2 * np.pi) - np.pi)
d_pi = np.absolute((phi_max_i - phi_tb1[-1 - i]) % (2 * np.pi) -
np.pi)
if d_00 > d_pi:
phi_max[i] += np.pi
else:
phi_mean = circmean(phis, axis=1, weights=np.power(tb1s, 50))
phi_max = circmean(phi_mean, axis=0)
x, y = [], []
for i, phi_max_i in enumerate(phi_max):
x.append([(phi_max[i] + np.pi / 18) % (2 * np.pi) - np.pi / 18, 1])
y.append(i)
# for i, phi_mean_i in enumerate(phi_mean.T):
# for phi_mean_j in phi_mean_i:
# x.append([(phi_mean_j + np.pi/18) % (2 * np.pi) - np.pi/18, 1])
# y.append(i)
x = np.array(x)
y = np.array(y)
a, b = np.linalg.pinv(x).dot(y)
plt.figure("heinze-%sfig-1F" % ("uni-" if uniform else ""), figsize=(5, 5))
# phi = circmean(tb1_ids, weights=tb1s, axis=1)
plt.scatter([0, 1, 2, 3, 4, 5, 6, 7][::-1] * 100,
np.rad2deg(phi_mean) % 360,
s=20,
c='black')
plt.scatter([0, 1, 2, 3, 4, 5, 6, 7][::-1],
np.rad2deg(phi_max) % 360,
s=50,
c='red',
marker='*')
plt.plot([-1, 8][::-1], np.rad2deg([(-1 - b) / a, (8 - b) / a]), 'r-.')
plt.xticks([0, 1, 2, 3, 4, 5, 6, 7], [
tb1_names[0], '', tb1_names[1], '', tb1_names[2], '', tb1_names[3], ''
])
plt.yticks([0, 45, 90, 135, 180, 225, 270, 315, 360],
['0', '', '90', '', '180', '', '270', '', '360'])
plt.ylim([-20, 380])
plt.xlim([-1, 8])
plt.show()
def heinze_experiment(n_tb1=0,
eta=.0,
sun_ele=np.pi / 2,
absolute=False,
uniform=False):
sun_azi = np.linspace(-np.pi, np.pi, 36, endpoint=False)
sun_ele = np.full_like(sun_azi, sun_ele)
tb1s = np.empty((0, sun_azi.shape[0], 8), dtype=sun_azi.dtype)
for _ in np.linspace(0, 1, 100):
d_deg, d_eff, t, phi, r_tb1 = evaluate(uniform_polariser=uniform,
sun_azi=sun_azi,
sun_ele=sun_ele,
tilting=False,
noise=eta)
tb1s = np.vstack([tb1s, np.transpose(r_tb1, axes=(1, 0, 2))])
if absolute:
tb1s = np.absolute(tb1s)
bl = .5
r_mean = np.median(tb1s[..., n_tb1], axis=0)
z = r_mean.max() - r_mean.min()
r_mean = (r_mean - r_mean.min()) / z - bl
r_std = tb1s[..., n_tb1].std(axis=0) / np.sqrt(z)
p_value = rayleightest(sun_azi, weights=r_mean + bl)
if uniform:
# phi_mean_00 = circmean((sun_azi - np.pi / 2) % np.pi + np.pi / 2, weights=np.power(r_mean + bl, 8))
# phi_var_00 = circvar((sun_azi - np.pi / 2) % np.pi + np.pi / 2, weights=np.power(r_mean + bl, 8))
# phi_mean_90 = circmean(sun_azi % np.pi, weights=np.power(r_mean + bl, 8))
# phi_var_90 = circvar(sun_azi % np.pi, weights=np.power(r_mean + bl, 8))
# phi_mean = phi_mean_00 if phi_var_00 < phi_var_90 else phi_mean_90
phi_mean = circmean(sun_azi, weights=np.power(r_mean + bl, 50))
else:
phi_mean = circmean(sun_azi, weights=np.power(r_mean + bl, 50))
# phi_max[j].append(phi_mean)
plt.figure(
"heinze-%s%s" %
("abs-" if absolute else "uni-" if uniform else "", tb1_names[n_tb1]),
figsize=(3, 3))
ax = plt.subplot(111, polar=True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
y_min, y_max = -.3, 1.1
plt.bar((sun_azi + np.pi) % (2 * np.pi) - np.pi,
bl + r_mean,
.1,
yerr=r_std,
facecolor='black')
plt.plot(np.linspace(-np.pi, np.pi, 361), np.full(361, bl), 'k-')
if uniform:
x_mean = [phi_mean, phi_mean, phi_mean + np.pi, phi_mean + np.pi]
plt.plot(x_mean, [y_max, y_min, y_min, y_max], 'r-.')
else:
plt.plot([phi_mean, phi_mean], [y_max, y_min], 'r-.')
plt.yticks([])
plt.xticks(np.linspace(0, 2 * np.pi, 8, endpoint=False), [
r'%d$^\circ$' % x
for x in ((np.linspace(0, 360, 8, endpoint=False) + 180) % 360 - 180)
])
plt.ylim([y_min, y_max])
# plt.savefig("heinze-%s%d.eps" % ("abs-" if absolute else "uni-" if uniform else "", n_tb1))
plt.show()
def structure_test(save=None, mode=0, **kwargs):
print "Running structure test:", kwargs
plt.figure("Structure", figsize=(10, 5))
ns = np.linspace(0, 360, 91)
ns[0] = 1
omegas = np.linspace(1, 180, 180)
# ns = np.array([4, 12, 60, 112, 176, 272, 368, 840])
# omegas = np.array([14, 30, 60, 90, 120, 150, 180])
filename = "structure-costs.npz"
if mode < 2:
plt.subplot(121)
means = np.zeros_like(ns)
ses = np.zeros_like(ns)
n_default = kwargs.pop('n', 360)
omega_default = kwargs.pop('omega', 56)
for ii, n in enumerate(ns.astype(int)):
d_err, d_eff, tau, _, _ = evaluate(n=n,
omega=omega_default,
verbose=False,
**kwargs)
means[ii] = np.mean(d_err)
ses[ii] = d_err.std() / np.sqrt(d_err.size)
print 'N = % 3d, Omega = %.2f | Mean cost: %.2f +/- %.4f' % (
n, omega_default, means[ii], ses[ii])
means = means.reshape(ns.shape)
plt.fill_between(ns, means - ses, means + ses, facecolor="grey")
plt.plot(ns, means, color="black", label=r'$n$')
plt.ylim([0, 60])
plt.xlim([1, 360])
plt.yticks([0, 15, 30, 45, 60],
[r'%d$^\circ$' % o for o in [0, 15, 30, 45, 60]])
plt.xticks([4, 12, 60, 112, 176, 272, 360])
plt.xlabel(r'units ($n$)')
plt.ylabel(r'MSE ($^\circ$)')
plt.subplot(122)
means = np.zeros_like(omegas)
ses = np.zeros_like(omegas)
for ii, omega in enumerate(omegas):
d_err, d_eff, tau, _, _ = evaluate(n=n_default,
omega=omega,
verbose=False,
**kwargs)
means[ii] = np.mean(d_err)
ses[ii] = d_err.std() / np.sqrt(d_err.size)
print 'N = % 3d, Omega = %.2f | Mean cost: %.2f +/- %.4f' % (
n_default, omega, means[ii], ses[ii])
means = means.reshape(omegas.shape)
plt.fill_between(omegas,
means - ses,
means + ses,
facecolor="grey",
alpha=.5)
plt.plot(omegas, means, color="black", label=r'$\omega$')
plt.ylim([0, 60])
plt.xlim([0, 180])
plt.yticks([0, 15, 30, 45, 60],
[r'%d$^\circ$' % o for o in [0, 15, 30, 45, 60]])
plt.xticks(
np.linspace(0, 180, 7, endpoint=True),
[r'%d$^\circ$' % o for o in np.linspace(0, 180, 7, endpoint=True)])
plt.xlabel(r'receptive field ($\omega$)')
plt.ylabel(r'MSE ($^\circ$)')
# plt.legend()
else:
ax = plt.subplot(111, polar=True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
if mode > 2:
data = np.load(filename)
ns, omegas, means = data["ns"], data["omegas"], data["costs"]
else:
ns, omegas = np.meshgrid(ns, omegas)
means = np.zeros(omegas.size)
for ii, omega, n in zip(np.arange(omegas.size), omegas.flatten(),
ns.flatten()):
kwargs["n"] = n
kwargs["omega"] = omega
d_err, d_eff, tau, _, _ = evaluate(verbose=False, **kwargs)
means[ii] = np.mean(d_err)
se = d_err.std() / np.sqrt(d_err.size)
print 'N = % 3d, Omega = %.2f | Mean cost: %.2f +/- %.4f' % (
n, omega, means[ii], se)
means = means.reshape(omegas.shape)
np.savez_compressed(filename, omegas=omegas, ns=ns, costs=means)
ii = np.nanargmin(means, axis=0)
jj = np.nanargmin(means[ii, np.arange(91)])
omega_min = omegas[ii, np.arange(91)]
n_min = ns[ii, np.arange(91)]
means_min = means[ii, np.arange(91)]
print means_min
print n_min
print omega_min
print 'Minimum cost (%.2f) for N = %d, Omega = %.2f' % (
means_min[jj], n_min[jj], omega_min[jj])
print 'Mean omega %.2f +/- %.4f' % (omega_min.mean(), omega_min.std() /
np.sqrt(omega_min.size))
with plt.rc_context({'ytick.color': 'white'}):
plt.pcolormesh(np.deg2rad(omegas),
ns,
means,
cmap="Reds",
vmin=0,
vmax=90)
# plt.scatter(np.deg2rad(omega_min), n_min, s=20, c='yellowgreen', marker='o')
plt.plot(np.deg2rad(omega_min), n_min, 'g-')
plt.yticks([4, 12, 60, 112, 176, 272, 360], [""] * 7)
plt.xticks(np.deg2rad([14, 30, 60, 90, 120, 150, 180]))
plt.ylim([4, 360])
plt.xlim([0, 180])
ax.grid(alpha=0.2)
if save:
plt.savefig(save)
plt.show()
def gate_test(save=None, mode=2, filename="gate-costs.npz", **kwargs):
print "Running gating test:", kwargs
plt.figure(filename[:-4], figsize=(5, 5))
ax = plt.subplot(111, polar=True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
sigmas = np.linspace(np.pi / 90, np.pi / 2, 45)
shifts = np.linspace(0, 2 * np.pi, 91)
if mode < 2:
means = np.zeros_like(sigmas)
ses = np.zeros_like(sigmas)
for ii, sigma in enumerate(sigmas):
d_err, d_eff, _, _, _ = evaluate(sigma_pol=sigma,
verbose=False,
**kwargs)
means[ii] = d_err.mean()
ses[ii] = d_err.std() / np.sqrt(d_err.size)
print "Sigma: %.2f | Mean cost: %.2f +/- %.4f" % (
np.rad2deg(sigma), means[ii], ses[ii])
plt.fill_between(sigmas,
means - ses,
means + ses,
facecolor="C1",
alpha=.5)
plt.plot(sigmas, means, color="C1", label="sigma")
means = np.zeros_like(shifts)
ses = np.zeros_like(shifts)
for ii, shift in enumerate(shifts):
d_err, d_eff, _, _, _ = evaluate(shift_pol=shift,
verbose=False,
**kwargs)
means[ii] = d_err.mean()
ses[ii] = d_err.std() / np.sqrt(d_err.size)
print "Shift: %.2f | Mean cost: %.2f +/- %.4f" % (
np.rad2deg(shift), means[ii], ses[ii])
plt.fill_between(shifts,
means - ses,
means + ses,
facecolor="C2",
alpha=.5)
plt.plot(shifts, means, color="C2", label="shift")
plt.ylim([0, 60])
# plt.xlim([0, np.rad2deg(shifts.max())])
plt.yticks([10, 30, 60])
plt.xticks(
np.linspace(-3 * np.pi / 4, 5 * np.pi / 4, 8, endpoint=False))
# plt.xlabel(r'Variance ($\sigma$)')
# plt.ylabel(r'MSE ($^\circ$)')
plt.legend()
else:
if mode > 2:
data = np.load(filename)
shifts, sigmas, means = data["shifts"], data["sigmas"], data[
"costs"]
else:
# TODO parametrise this to work in batches so that I can run it in multiple processors
sigmas_pol, shifts_pol, sigmas_sol, shifts_sol = np.meshgrid(
sigmas, shifts, sigmas, shifts)
means = np.zeros(sigmas_pol.size)
for ii, sigma_pol, shift_pol, sigma_sol, shift_sol in zip(
np.arange(sigmas_pol.size), sigmas_pol.flatten(),
shifts_pol.flatten(), sigmas_sol.flatten(),
shifts_sol.flatten()):
d_err, d_eff, tau, _, _ = evaluate(sigma_pol=sigma_pol,
shift_pol=shift_pol,
sigma_sol=sigma_sol,
shift_sol=shift_sol,
verbose=False,
**kwargs)
means[ii] = d_err.mean()
se = np.rad2deg(d_err.std() / np.sqrt(d_err.size))
print r'S_p = % 3.2f, T_p = % 3.2f, S_s = % 3.2f, T_s = % 3.2f | Mean cost: %.2f +/- %.4f' % (
np.rad2deg(sigma_pol), np.rad2deg(shift_pol),
np.rad2deg(sigma_sol), np.rad2deg(shift_sol), means[ii],
se)
means = means.reshape(shifts_pol.shape)
np.savez_compressed(filename,
shifts=shifts_pol,
sigmas=sigmas_pol,
costs=means)
ii = np.argmin(means.flatten())
sigma_min = sigmas.flatten()[ii]
shift_min = shifts.flatten()[ii]
means_min = means.flatten()[ii]
print 'Minimum cost (%.2f) for Sigma = %.2f, Shift = %.2f' % (
means_min, np.rad2deg(sigma_min), np.rad2deg(shift_min))
with plt.rc_context({'ytick.color': 'white'}):
plt.pcolormesh(shifts, sigmas, means, cmap="Reds", vmin=0, vmax=90)
plt.scatter(shift_min,
sigma_min,
s=20,
c='yellowgreen',
marker='o')
plt.yticks([0, np.pi / 6, np.pi / 3, np.pi / 2],
[r"$0$", r"$30^\circ$", r"$60^\circ$", r"$90^\circ$"])
plt.xticks(np.linspace(0, 2 * np.pi, 8, endpoint=False), [
r'$0^\circ$', r'$45^\circ$', r'$90^\circ$', r'$135^\circ$',
r'$180^\circ$', r'$-135^\circ$', r'$-90^\circ$', r'$-45^\circ$'
])
plt.ylim([0, np.pi / 2])
ax.grid(alpha=0.2)
if save:
plt.savefig(save)
plt.show()
def noise_test(save=None, mode=0, repeats=10, **kwargs):
from sphere.transform import sph2vec
print "Running noise test:", kwargs
modes = ['normal', 'corridor', 'side']
print "Mode:", modes[mode]
plt.figure("noise-%s" % modes[mode], figsize=(5, 5))
n, omega = 60, 56
etas = np.linspace(0, 1, 21)
taus = np.zeros_like(etas)
means = np.zeros_like(etas)
ses = np.zeros_like(etas)
for i in xrange(10):
noise = np.ones(n, int)
if mode > 0:
theta, phi, fit = angles_distribution(n, float(omega))
x, _, _ = sph2vec(theta, phi)
else:
x = np.argsort(np.absolute(np.random.randn(n)))
for ii, eta in enumerate(etas):
if mode == 0:
noise[:] = 0
noise[x[:int(eta * float(n))]] = 1
else:
noise[:] = 0
if mode > 1:
noise[x > (1 - 2 * eta)] = 1
else:
noise[np.abs(x) > (1 - eta)] = 1
d_err, d_eff, tau, _, _ = evaluate(n=n,
omega=omega,
noise=noise,
verbose=False,
tilting=True,
**kwargs)
means[ii] = (means[ii] * i + d_err.mean()) / (i + 1)
ses[ii] = (ses[ii] * i + d_err.std() / np.sqrt(d_err.size)) / (i +
1)
taus[ii] = (taus[ii] * i + tau.mean()) / (i + 1)
print "Noise level: %.2f (%03d) | Mean cost: %.2f +/- %.4f" % (
eta, np.sum(noise), means[ii], ses[ii])
plt.fill_between(etas * 100, means - ses, means + ses, facecolor="grey")
plt.plot(etas * 100, means, color="red", linestyle="-", label="tilting")
plt.plot(etas * 100,
taus * 45,
color="red",
linestyle="--",
label="tau-tilting")
taus = np.zeros_like(etas)
means = np.zeros_like(etas)
ses = np.zeros_like(etas)
for i in xrange(repeats):
noise = np.ones(n, int)
if mode > 0:
theta, phi, fit = angles_distribution(n, float(omega))
x, _, _ = sph2vec(theta, phi)
else:
x = np.argsort(np.absolute(np.random.randn(n)))
for ii, eta in enumerate(etas):
if mode == 0:
noise[:] = 0
noise[x[:int(eta * float(n))]] = 1
else:
noise[:] = 0
if mode > 1:
noise[x > (1 - 2 * eta)] = 1
else:
noise[np.abs(x) > (1 - eta)] = 1
d_err, d_eff, tau, _, _ = evaluate(n=n,
omega=omega,
noise=noise,
verbose=False,
tilting=False,
**kwargs)
means[ii] = (means[ii] * i + d_err.mean()) / (i + 1)
ses[ii] = (ses[ii] * i + d_err.std() / np.sqrt(d_err.size)) / (i +
1)
taus[ii] = (taus[ii] * i + tau.mean()) / (i + 1)
print "Noise level: %.2f (%03d) | Mean cost: %.2f +/- %.4f" % (
eta, np.sum(noise), means[ii], ses[ii])
plt.fill_between(etas * 100,
means - ses,
means + ses,
facecolor="grey",
alpha=.5)
plt.plot(etas * 100, means, color="black", linestyle="-", label="plane")
plt.plot(etas * 100,
taus * 45,
color="black",
linestyle="--",
label="tau-plane")
plt.ylim([0, 90])
plt.yticks([0, 30, 60, 90], [r'%d$^\circ$' % o for o in [0, 30, 60, 90]])
plt.xlim([0, 100])
plt.xlabel(r'noise ($\eta$)')
plt.ylabel("MAE ($^\circ$)")
# plt.legend()
if save:
plt.savefig(save)
plt.show()
def nb_neurons_test(save=None, mode=0, **kwargs):
print "Running number of neurons test:", kwargs
plt.figure("Structure", figsize=(10, 5))
nb_tb1s = np.linspace(4, 360, 90)
nb_cl1s = np.linspace(4, 360, 90)
filename = "structure-costs.npz"
if mode < 2:
plt.subplot(121)
means = np.zeros_like(nb_tb1s)
ses = np.zeros_like(nb_tb1s)
nb_tb1_default = kwargs.pop('nb_tb1', 8)
nb_cl1_default = kwargs.pop('nb_cl1', 16)
for ii, nb_tb1 in enumerate(nb_tb1s):
d_err, d_eff, tau, _, _ = evaluate(nb_tb1=nb_tb1,
nb_cl1=nb_cl1_default,
verbose=False,
**kwargs)
means[ii] = (d_err * tau / tau.sum()).sum()
ses[ii] = d_err.std() / np.sqrt(d_err.size)
print 'TB1 = %03d, CL1 = %03d | Mean cost: %.2f +/- %.4f' % (
nb_tb1, nb_cl1_default, means[ii], ses[ii])
means = means.reshape(nb_tb1s.shape)
plt.fill_between(nb_tb1s, means - ses, means + ses, facecolor="grey")
plt.plot(nb_tb1s, means, color="black", label=r'$n$')
plt.ylim([0, 20])
plt.xlim([0, 360])
plt.yticks([0, 5, 10, 15, 20],
[r'%d$^\circ$' % o for o in [0, 5, 10, 15, 20]])
plt.xticks([8, 24, 60, 90, 180, 270, 360])
plt.xlabel(r'TB1 neurons')
plt.ylabel(r'MSE ($^\circ$)')
plt.subplot(122)
means = np.zeros_like(nb_cl1s)
ses = np.zeros_like(nb_cl1s)
for ii, nb_cl1 in enumerate(nb_cl1s):
d_err, d_eff, tau, _, _ = evaluate(nb_tb1=nb_tb1_default,
nb_cl1=nb_cl1,
verbose=False,
**kwargs)
means[ii] = (d_err * tau / tau.sum()).sum()
ses[ii] = d_err.std() / np.sqrt(d_err.size)
print 'TB1 = %03d, CL1 = %03d | Mean cost: %.2f +/- %.4f' % (
nb_tb1_default, nb_cl1, means[ii], ses[ii])
means = means.reshape(nb_cl1s.shape)
plt.fill_between(nb_cl1s,
means - ses,
means + ses,
facecolor="grey",
alpha=.5)
plt.plot(nb_cl1s, means, color="black", label=r'$\omega$')
plt.ylim([0, 20])
plt.xlim([0, 360])
plt.yticks([0, 5, 10, 15, 20],
[r'%d$^\circ$' % o for o in [0, 5, 10, 15, 20]])
plt.xticks([8, 24, 60, 90, 180, 270, 360])
plt.xlabel(r'CL1 neurons')
plt.ylabel(r'MSE ($^\circ$)')
# plt.legend()
else:
ax = plt.subplot(111, polar=True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
if mode > 2:
data = np.load(filename)
nb_tb1s, nb_cl1s, means = data["nb_tb1"], data["nb_cl1"], data[
"costs"]
else:
nb_tb1s, nb_cl1s = np.meshgrid(nb_tb1s, nb_cl1s)
means = np.zeros(nb_cl1s.size)
for ii, nb_tb1, nb_cl1 in zip(np.arange(nb_cl1s.size),
nb_tb1s.flatten(),
nb_cl1s.flatten()):
d_err, d_eff, tau, _, _ = evaluate(nb_tb1=nb_tb1,
nb_cl1=nb_cl1,
verbose=False,
**kwargs)
means[ii] = (d_err * tau / tau.sum()).sum()
se = d_err.std() / np.sqrt(d_err.size)
print 'TB1 = %03d, CL1 = %03d | Mean cost: %.2f +/- %.4f' % (
nb_tb1, nb_cl1, means[ii], se)
means = means.reshape(nb_cl1s.shape)
np.savez_compressed(filename,
nb_tb1=nb_tb1s,
nb_cl1=nb_cl1s,
costs=means)
ii = np.nanargmin(means, axis=0)
tb1_min = nb_tb1s[ii, np.arange(91)]
cl1_min = nb_cl1s[ii, np.arange(91)]
means_min = means[ii, np.arange(91)]
print 'Minimum cost (%.2f) for %d TB1, CL1 = %d neurons' % (
means_min[15], tb1_min[15], cl1_min[30])
print 'Mean TB1 %.2f +/- %.4f' % (tb1_min.mean(), tb1_min.std() /
np.sqrt(tb1_min.size))
with plt.rc_context({'ytick.color': 'white'}):
plt.pcolormesh(np.deg2rad(nb_tb1s),
nb_cl1s,
means,
cmap="Reds",
vmin=0,
vmax=90)
plt.plot(np.deg2rad(tb1_min), cl1_min, 'g-')
plt.yticks([4, 12, 60, 112, 176, 272, 360], [""] * 7)
plt.xticks(np.deg2rad([14, 30, 60, 90, 120, 150, 180]))
plt.ylim([4, 360])
plt.xlim([0, 180])
ax.grid(alpha=0.2)
if save:
plt.savefig(save)
plt.show()
def noise_test(save=None, mode=0, repeats=10, **kwargs):
from sphere.transform import sph2vec
print "Running noise test:", kwargs
modes = ['uniform', 'corridor', 'canopy']
print "Mode:", modes[mode]
plt.figure("noise-%s" % modes[mode], figsize=(4, 3))
n, omega = 60, 56
etas = np.linspace(0, 1, 21)
taus = np.zeros_like(etas)
means = np.zeros_like(etas)
ses = np.zeros_like(etas)
data = []
theta, phi, fit = angles_distribution(n, float(omega))
for i in xrange(repeats):
for ii, eta in enumerate(etas):
noise = get_noise(theta, phi, eta, mode=modes[mode])
d_err, d_eff, tau, _, _ = evaluate(n=n,
omega=omega,
noise=noise,
verbose=False,
tilting=True,
**kwargs)
data.append([tau, d_err])
means[ii] = (means[ii] * i + d_err.mean()) / (i + 1)
ses[ii] = (ses[ii] * i + d_err.std() / np.sqrt(d_err.size)) / (i +
1)
taus[ii] = (taus[ii] * i + tau.mean()) / (i + 1)
print "Noise level: %.2f (%03d) | Mean cost: %.2f +/- %.4f | tau: %.2f --> sigma: %2f" % (
eta, np.sum(noise), means[ii], ses[ii], taus[ii],
6. / taus[ii] + 6)
np.savez_compressed("../data/noise-%s.npz" % modes[mode],
x=np.array(data)[:, 0],
y=np.array(data)[:, 1])
sigmas = 6. / taus + 6.
plt.fill_between(etas * 100, means - ses, means + ses, facecolor="grey")
plt.plot(etas * 100, means, color="red", linestyle="-", label="tilting")
plt.plot(etas * 100,
taus * 45,
color="red",
linestyle="--",
label="tau-tilting")
plt.plot(etas * 100,
sigmas,
color="red",
linestyle="--",
label="sigma-tilting")
taus = np.zeros_like(etas)
means = np.zeros_like(etas)
ses = np.zeros_like(etas)
for i in xrange(repeats):
for ii, eta in enumerate(etas):
noise = get_noise(theta, phi, eta, mode=modes[mode])
d_err, d_eff, tau, _, _ = evaluate(n=n,
omega=omega,
noise=noise,
verbose=False,
tilting=False,
**kwargs)
data.append([tau, d_err])
means[ii] = (means[ii] * i + d_err.mean()) / (i + 1)
ses[ii] = (ses[ii] * i + d_err.std() / np.sqrt(d_err.size)) / (i +
1)
taus[ii] = (taus[ii] * i + tau.mean()) / (i + 1)
print "Noise level: %.2f (%03d) | Mean cost: %.2f +/- %.4f | tau: %.2f --> sigma: %2f" % (
eta, np.sum(noise), means[ii], ses[ii], taus[ii],
4. / taus[ii] + 2)
np.savez_compressed("../data/noise-%s.npz" % modes[mode],
x=np.array(data)[:, 0],
y=np.array(data)[:, 1])
sigmas = 4. / taus - 2.
plt.fill_between(etas * 100,
means - ses,
means + ses,
facecolor="grey",
alpha=.5)
plt.plot(etas * 100, means, color="black", linestyle="-", label="plane")
plt.plot(etas * 100,
taus * 45,
color="black",
linestyle="--",
label="tau-plane")
plt.plot(etas * 100,
sigmas,
color="black",
linestyle="--",
label="sigma-plane")
plt.ylim([0, 90])
plt.yticks([0, 30, 60, 90], [r'%d$^\circ$' % o for o in [0, 30, 60, 90]])
plt.xlim([0, 100])
plt.xlabel(r'noise ($\eta$)')
plt.ylabel("MAE ($^\circ$)")
# plt.legend()
if save:
plt.savefig(save)
plt.show()
def plot_structure_optimisation(load="data/structure-costs.npz",
save=None,
**kwargs):
ns = np.linspace(0, 360, 91)
ns[0] = 1
omegas = np.linspace(1, 180, 180)
plt.subplot2grid((1, 5), (0, 0), colspan=2)
means = np.zeros_like(ns)
ses = np.zeros_like(ns)
n_default = kwargs.pop('n', 360)
omega_default = kwargs.pop('omega', 56)
for ii, n in enumerate(ns.astype(int)):
d_err, d_eff, tau, _, _ = evaluate(nb_pol=n,
omega=omega_default,
verbose=False,
**kwargs)
means[ii] = np.mean(d_err)
ses[ii] = d_err.std() / np.sqrt(d_err.size)
means = means.reshape(ns.shape)
plt.fill_between(ns, means - ses, means + ses, facecolor="grey")
plt.plot(ns, means, color="black", label=r'$n$')
plt.ylim([0, 60])
plt.xlim([1, 360])
plt.yticks([0, 15, 30, 45, 60],
[r'%d$^\circ$' % o for o in [0, 15, 30, 45, 60]])
plt.xticks([4, 12, 60, 112, 176, 272, 360])
plt.xlabel(r'units ($n$)')
plt.ylabel(r'MSE ($^\circ$)')
plt.subplot2grid((1, 5), (0, 2), colspan=2)
means = np.zeros_like(omegas)
ses = np.zeros_like(omegas)
for ii, omega in enumerate(omegas):
d_err, d_eff, tau, _, _ = evaluate(nb_pol=n_default,
omega=omega,
verbose=False,
**kwargs)
means[ii] = np.mean(d_err)
ses[ii] = d_err.std() / np.sqrt(d_err.size)
means = means.reshape(omegas.shape)
plt.fill_between(omegas,
means - ses,
means + ses,
facecolor="grey",
alpha=.5)
plt.plot(omegas, means, color="black", label=r'$\omega$')
plt.ylim([0, 60])
plt.xlim([0, 180])
plt.yticks([0, 15, 30, 45, 60],
[r'%d$^\circ$' % o for o in [0, 15, 30, 45, 60]])
plt.xticks(
np.linspace(0, 180, 7, endpoint=True),
[r'%d$^\circ$' % o for o in np.linspace(0, 180, 7, endpoint=True)])
plt.xlabel(r'receptive field ($\omega$)')
ax = plt.subplot2grid((1, 5), (0, 4), polar=True)
# ax = plt.subplot(133, polar=True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
ax.set_thetamin(0)
ax.set_thetamax(180)
if load is not None:
data = np.load(load)
ns, omegas, means = data["ns"], data["omegas"], data["costs"]
else:
ns, omegas = np.meshgrid(ns, omegas)
means = np.zeros(omegas.size)
kwargs["verbose"] = False
for ii, omega, n in zip(np.arange(omegas.size), omegas.flatten(),
ns.flatten()):
kwargs["nb_pol"] = n
kwargs["omega"] = omega
d_err, d_eff, tau, _, _ = evaluate(**kwargs)
means[ii] = np.mean(d_err)
se = d_err.std() / np.sqrt(d_err.size)
# print 'N = % 3d, Omega = %.2f | Mean cost: %.2f +/- %.4f' % (n, omega, means[ii], se)
means = means.reshape(omegas.shape)
if save is not None:
np.savez_compressed(save, omegas=omegas, ns=ns, costs=means)
ii = np.nanargmin(means, axis=0)
jj = np.nanargmin(means[ii, np.arange(91)])
omega_min = omegas[ii, np.arange(91)]
n_min = ns[ii, np.arange(91)]
means_min = means[ii, np.arange(91)]
print 'Minimum cost (%.2f) for N = %d, Omega = %.2f' % (
means_min[jj], n_min[jj], omega_min[jj])
print 'Mean omega %.2f +/- %.4f' % (omega_min.mean(), omega_min.std() /
np.sqrt(omega_min.size))
with plt.rc_context({'ytick.color': 'white'}):
plt.pcolormesh(np.deg2rad(omegas),
ns,
means,
cmap="Reds",
vmin=0,
vmax=90)
plt.scatter(np.deg2rad(omega_min),
n_min,
s=1,
c='yellowgreen',
marker='o')
plt.plot(np.deg2rad(omega_min), n_min, 'g-')
plt.yticks([4, 12, 60, 112, 176, 272, 360], [""] * 7)
plt.xticks(np.deg2rad([14, 30, 60, 90, 120, 150, 180]))
plt.ylim([4, 360])
plt.xlim([0, 180])
ax.grid(alpha=0.2)
ax.set_thetamin(0)
ax.set_thetamax(180)
return plt
if mode is "res2ele":
samples = 1000
ele, azi, azi_diff, res = [], [], [], []
theta_s, phi_s = fibonacci_sphere(samples=samples, fov=161)
phi_s = phi_s[theta_s <= np.pi / 2]
theta_s = theta_s[theta_s <= np.pi / 2]
phi_s = phi_s[theta_s > np.pi / 18]
theta_s = theta_s[theta_s > np.pi / 18]
samples = theta_s.size
for e, a in zip(theta_s, phi_s):
d_err, d_eff, tau, _, _ = evaluate(sun_azi=a,
sun_ele=e,
tilting=False,
noise=0.)
azi.append(a)
ele.append(e)
res.append(tau.flatten())
# res.append(d_eff.flatten())
ele = np.rad2deg(ele).flatten()
# res = np.array(res).flatten() - np.pi/2 # Min: 0.02, Max: 2.04; Min: 18.22, Max: 66.91
res = (np.array(res).flatten() - 1.06) * 7 / 4
# res = (np.array(res).flatten() - 1) * 35 / 20
# res = (np.array(res).flatten() - 2.12) * 7 / 8
# res = np.array(res)
ele_pred = 26 * (1 - 2 * np.arcsin(1 - res) /
np.pi) + 15 # + np.random.randn(res.size)
