def wikenheiser2015_lookahead(goal_no,
start,
alpha,
tau,
goal_weight=20.,
goal_absorb=True,
backmove=False,
opt_policy_weight=0.9,
sigma=0.5,
n_samp=n_samp,
n_step=n_step):
ENVlh = CircularTrack(n_state=n_state_circ,
start=start,
goal_no=goal_no,
goal_weight=goal_weight,
goal_absorb=goal_absorb,
backmove=backmove,
opt_policy_weight=opt_policy_weight)
GENlh = Generator(ENV=ENVlh, symmetrize=symmetrize, jump_rate=jump_rate)
PROPlh = Propagator(GEN=GENlh, sigma=sigma, tau=tau, alpha=alpha)
EXPlh = Explorer(PROP=PROPlh, rho_init=start, no_dwell=no_dwell)
EXPlh.sample_sequences(n_samp=n_samp, n_step=n_step)
EXPlh.traj_width = 0
EXPlh.start_pos = True
EXPlh.state_msize = state_msize
return EXPlh, PROPlh, GENlh, ENVlh
def circulartrack_lookahead(start,
alpha,
tau,
sigma=1,
n_samp=n_samp,
n_step=n_step):
ENVlh = CircularTrack(n_state=n_state_circ, start=start, goal_no=None)
GENlh = Generator(ENV=ENVlh, symmetrize=symmetrize, jump_rate=jump_rate)
PROPlh = Propagator(GEN=GENlh, sigma=sigma, tau=tau, alpha=alpha)
EXPlh = Explorer(PROP=PROPlh, rho_init=start, no_dwell=no_dwell)
EXPlh.sample_sequences(n_samp=n_samp, n_step=n_step)
EXPlh.traj_width = 0
EXPlh.start_pos = True
EXPlh.state_msize = state_msize
return EXPlh, PROPlh, GENlh, ENVlh
'cmap_samp': 'husl',
'cmap_traj': plt.cm.cool
}
# SAMPLE CROSS-CORRELOGRAMS
ENV = LinearTrack(scale=scale_track)
if start == 'default':
ENV.start = ENV.start_center
else:
ENV.start = start
GEN = Generator(ENV=ENV, symmetrize=symmetrize, jump_rate=jump_rate)
# generate trajectories under diffusion (alpha) and turbulence (+ spectral noise)
PROPt = Propagator(GEN=GEN,
sigma=sigma,
tau=tau,
alpha=alpha_turb,
spec_noise=spec_noise)
PROPd = Propagator(GEN=GEN,
sigma=sigma,
tau=tau,
alpha=alpha_diff,
spec_noise=0.)
PROPd.plot_prop_kernels(n=6)
EXPt = Explorer(PROP=PROPt, rho_init=ENV.start, mass=mass, no_dwell=no_dwell)
EXPd = Explorer(PROP=PROPd, rho_init=ENV.start, mass=mass, no_dwell=no_dwell)
EXPt.set_viz_scheme(**kwargs)
EXPd.set_viz_scheme(**kwargs)
EXPt.sample_sequences(n_samp=n_samp, n_step=n_step)
EXPd.sample_sequences(n_samp=n_samp, n_step=n_step)
EXPt.plot_trajectory()
state_bneck_in = states_bneck[c + 1][0]
states_clique = [s for s in states_cliques[c] if s != state_bneck_out]
ENV.T[states_clique, state_bneck_out] = 1.
ENV.T[state_bneck_out, state_bneck_in] = 1.
state_bneck_out = states_bneck[-1][1]
state_bneck_in = states_bneck[0][0]
states_clique = [s for s in states_cliques[-1] if s != state_bneck_out]
ENV.T[states_clique, state_bneck_out] = 1.
ENV.T[state_bneck_out, state_bneck_in] = 1.
ENV.T[(ENV.T < 1) & (ENV.T > 0)] = eps
ENV.T = row_norm(ENV.T)
ENV.__name__ += '-anticlockwise'
# %%
GEN = Generator(ENV=ENV, jump_rate=jump_rate)
PROPd = Propagator(GEN=GEN, tau=tau_diff, alpha=alpha_diff)
PROPs = Propagator(GEN=GEN, tau=tau_supdiff, alpha=alpha_supdiff)
PROPo = Propagator(GEN=GEN, tau=tau_diff, alpha=alpha_diff)
PROPo.min_zero_cf(lags=lags_opt, rho_init=rho_init)
print('DIFF: average autotransition prob = %0.3f' % np.diag(PROPd.etO).mean())
print('SUPDIFF: average autotransition prob = %0.3f' %
np.diag(PROPs.etO).mean())
# %% SIMS
if run_explorer:
exp_eff_s = []
exp_eff_d = []
exp_eff_o = []
cov_visits_s = []
cov_visits_d = []
)
# %% tau x t and sample panels
ENV = RoomWorld(start=0, scale=scale_lowres)
start = ENV.n_state // 4 - 10
n_step = 5
for alpha in alphas:
width = page_width
height = row_height * 3
fig, axes = plt.subplots(nrows=3, ncols=4, figsize=(width, height))
for ix_tau, tau in enumerate(taus):
GEN = Generator(ENV=ENV,
forward=forward,
symmetrize=symmetrize,
jump_rate=jump_rate)
PROP = Propagator(GEN=GEN, sigma=sigma, tau=tau, alpha=alpha)
SIM = Simulator(PROP=PROP, rho_init=start, no_dwell=no_dwell)
SIM.sample_sequences(n_samp=1, n_step=n_step)
samps = SIM._retrieve_state(coords=False).squeeze()
SIM.set_target_axis(ax=axes[ix_tau][3])
SIM.color_time = True
SIM.state_msize = state_msize
SIM.plot_trajectory()
for ix_t, t in enumerate(ts):
PROP.set_target_axis(ax=axes[ix_tau][ix_t])
PROP.plot_prop_kernels(n=1,
first_state=int(samps[ix_t]),
wrap_col=1,
autoprop_off=False)
axes[ix_tau][ix_t].set_title("")
fig.subplots_adjust(left=0.01,
# SAMPLING
ENV = OpenBox(scale=scale)
ENV.env_lw = env_lw
state_away_default = 26
states_away = [26, 48, 598, 576]
n_states_away = len(states_away) # corners
state_home = 335 # slightly off center as in Pfeiffer2013
states_home = [state_home]
states_home = [310, 311, 336, 335]
GEN = Generator(ENV=ENV, symmetrize=symmetrize, jump_rate=jump_rate)
GENh = Generator(ENV=ENV, symmetrize=symmetrize, jump_rate=jump_rate)
GENh.highlight_states(states=states_home, weight=goal_weight)
PROPd = Propagator(GEN=GENh, tau=tau_diff, alpha=alpha_diff)
PROPs = Propagator(GEN=GENh, tau=tau_sdiff, alpha=alpha_sdiff)
# multi-start away explorers
EXPds = []
EXPss = []
PROPds = []
PROPss = []
for start in states_away:
EXPd = Explorer(PROP=PROPd,
rho_init=start,
no_dwell=no_dwell,
label='diff-start%i' % start)
EXPs = Explorer(PROP=PROPs,
rho_init=start,
no_dwell=no_dwell,
iterables_eval = [alphas, taus, comps]
iterables_comp = [comps, x]
ix_prop = pd.MultiIndex.from_product(iterables_prop,
names=['alpha', 'tau', 'x'])
ix_eval = pd.MultiIndex.from_product(iterables_eval,
names=['alpha', 'tau', 'comp'])
ix_comp = pd.MultiIndex.from_product(iterables_comp, names=['comp', 'x'])
df_prop = pd.DataFrame(index=ix_prop, columns=['prob', 'cdf'], dtype='float')
df_spec = pd.DataFrame(index=ix_eval,
columns=['eval', 'evec_no', 'gain', 'log_gain'],
dtype='float')
df_comp = pd.DataFrame(index=ix_comp,
columns=['evec_no', 'phi', 'log_phi'],
dtype='float')
for alpha, tau in alpha_tau_combos:
PROP = Propagator(GEN=GEN, tau=tau, alpha=alpha, beta=beta)
y_state = PROP.etO[0, :].real
y = interp1d(x_state, y_state, kind='cubic')
df_prop.loc[pd.IndexSlice[alpha, tau, :], 'prob'] = y(x)
df_prop.loc[pd.IndexSlice[alpha, tau, :], 'cdf'] = 1. - y(x)
df_spec.loc[pd.IndexSlice[alpha, tau, :], 'eval'] = evals
df_spec.loc[pd.IndexSlice[alpha, tau, :], 'evec_no'] = comps
df_spec.loc[pd.IndexSlice[alpha, tau, :], 'gain'] = np.diag(PROP.wetD)
df_spec.loc[pd.IndexSlice[alpha, tau, :],
'log_gain'] = np.log(np.diag(PROP.wetD))
for comp in comps:
y_state = PROP.U[:, comp - 1].real
phi_func = interp1d(x_state, y_state, kind='cubic')
phi = phi_func(x)
log_phi = np.log(phi - phi.min() + 0.01)
alpha_sdiff = 0.5
no_dwell = False
# SETTINGS - EXPLORER
n_step = 75
n_samp = 20
target_coverage = 0.5
flight_vision = True
# SAMPLING
ENV = RoomWorld(scale=scale)
start_prop = ENV.start_center_TL
GEN = Generator(ENV=ENV, symmetrize=symmetrize, jump_rate=jump_rate)
PROP_diff_base = Propagator(GEN=GEN, tau=tau_diff, alpha=alpha_diff)
PROP_sdiff_base = Propagator(GEN=GEN, tau=tau_sdiff, alpha=alpha_sdiff)
# parallel explorer
EXP_diff_base = Explorer(PROP=PROP_diff_base,
rho_init=start_prop,
no_dwell=no_dwell,
label='diffusion')
EXP_sdiff_base = Explorer(PROP=PROP_sdiff_base,
rho_init=start_prop,
no_dwell=no_dwell,
label='superdiffusion')
EXP_diff_base.sample_sequences(n_samp=n_samp, n_step=n_step)
EXP_sdiff_base.sample_sequences(n_samp=n_samp, n_step=n_step)
EXP_diff_base.compute_diagnostics(target_coverage=target_coverage,
flight_vision=flight_vision)
sims_plot = [0, 6] # which simulations to plot in panel E
# ENVIRONMENT
ENV = TJunction(start=state_start,
directed=True,
complete_circuit=False,
backflow=backflow)
rho_rand = np.ones((ENV.n_state, )) / ENV.n_state
ENV.env_lw = env_lw
# GENERATOR
GEN = Generator(ENV=ENV, symmetrize=symmetrize, jump_rate=jump_rate)
rho_inf = GEN.stationary_dist()
# PROPAGATOR
PROP_diff = Propagator(GEN=GEN, sigma=sigma, tau=tau, alpha=alpha_diff)
PROP_sdiff = Propagator(GEN=GEN, sigma=sigma, tau=tau, alpha=alpha_sdiff)
PROP_opt = Propagator(GEN=GEN, sigma=sigma, tau=tau, alpha=alpha_diff)
PROP_opt.min_zero_cf(lags=lags_opt, rho_init=rho_init)
spectrum_blend = repmat(PROP_diff.power_spec, n=1, m=n_arm_states)
spectrum_blend = np.multiply(1 - blend_weights.reshape(
(n_arm_states, 1)), spectrum_blend) + np.multiply(
blend_weights.reshape((n_arm_states, 1)),
repmat(PROP_opt.power_spec, n=1, m=n_arm_states))
PROP_blend = []
for i in range(n_arm_states):
spectrum = spectrum_blend[i, :]
PROP_blend.append(Propagator(GEN=GEN, power_spec=spectrum))
# SIMULATIONS
SIM_blend = []
raise ValueError('untested')
n_spec = int((params.size - 1) // 2)
spec_diff = params[1:n_spec + 1]
spec_sdiff = params[n_spec + 1:]
thresh = params[0]
prop_diff_spec = prop_sr(spectrum=spec_diff, thresh=thresh, norm=True)
prop_sdiff_spec = prop_sr(spectrum=spec_sdiff, thresh=thresh, norm=True)
err_diff = kl_div(prop_diff_spec.flatten(), prop_diff_target.flatten())
err_sdiff = kl_div(prop_sdiff_spec.flatten(), prop_sdiff_target.flatten())
err_diff[np.where(np.isinf(err_diff))] = kl_div(0.1, 0.01)
err_sdiff[np.where(np.isinf(err_sdiff))] = kl_div(0.1, 0.01)
return err_diff.sum() + err_sdiff.sum()
PROP_diff = Propagator(GEN=GEN, tau=tau_diff, alpha=alpha_diff)
PROP_sdiff = Propagator(GEN=GEN, tau=tau_sdiff, alpha=alpha_sdiff)
PROP_diff_sr = Propagator(GEN=GEN_sr, tau=tau_diff, alpha=alpha_diff)
PROP_sdiff_sr = Propagator(GEN=GEN_sr, tau=tau_sdiff, alpha=alpha_sdiff)
# make temp copies
etO_diff = PROP_diff.etO.copy()
etO_sdiff = PROP_sdiff.etO.copy()
# spectrum-optimization via KL-divergence
tau_diff_sr = tau_diff
alpha_diff_sr = alpha_diff
tau_sdiff_sr = tau_sdiff
alpha_sdiff_sr = alpha_sdiff
diff_sr_obj = partial(loss_kl_prop, prop_target=etO_diff)
sdiff_sr_obj = partial(loss_kl_prop, prop_target=etO_sdiff)
start_prop = ENV.start_center # None, ENV.start
GEN = Generator(ENV=ENV, symmetrize=True)
# PLOT
markersize = 4
# mu_sleep_mean/sem
data_md_sleep_mean = (df_data[(df_data.state == "sleep")
& (df_data.stat == "mean")
& (df_data.type == "actual")].groupby(
"time_disp").spatial_disp.mean())
data_md_sleep_sem = (df_data[(df_data.state == "sleep")
& (df_data.stat == "sem")
& (df_data.type == "actual")].groupby(
"time_disp").spatial_disp.mean())
K_sleep = sigma * data_md_sleep_mean[1]
PROP_sleep = Propagator(GEN=GEN, tau=tau, alpha=alpha_sleep_avg)
sim_msd_sleep_mean = PROP_sleep.msd(t_steps, K=K_sleep)
sim_md_sleep_mean = PROP_sleep.mean_displacement(t_steps, K=K_sleep)
# mu_awake_mean/sem
data_md_wake_mean = (df_data[(df_data.state == "awake")
& (df_data.stat == "mean")
& (df_data.type == "actual")].groupby(
"time_disp").spatial_disp.mean())
data_md_wake_sem = (df_data[(df_data.state == "awake")
& (df_data.stat == "sem")
& (df_data.type == "actual")].groupby(
"time_disp").spatial_disp.mean())
K_wake = sigma * data_md_wake_mean[1]
PROP_wake = Propagator(GEN=GEN, tau=tau, alpha=alpha_wake_avg)
sim_msd_awake_mean = PROP_wake.msd(t_steps, K=K_wake)
x_state = np.linspace(0,1,n_state)
x = np.linspace(0,1,n_x)
comps = range(1,n_state+1)
comps_rev = [c for c in reversed(comps)]
# generate pandas dataaset
iterables_prop = [alphas, taus, x]
iterables_eval = [alphas, taus, comps]
iterables_comp = [comps, x]
ix_prop = pd.MultiIndex.from_product(iterables_prop, names=['alpha','tau','x'])
ix_eval = pd.MultiIndex.from_product(iterables_eval, names=['alpha','tau','comp'])
ix_comp = pd.MultiIndex.from_product(iterables_comp, names=['comp','x'])
df_prop = pd.DataFrame(index=ix_prop, columns=['prob','cdf'], dtype='float')
df_spec = pd.DataFrame(index=ix_eval, columns=['eval', 'evec_no', 'gain', 'log_gain'], dtype='float')
df_comp = pd.DataFrame(index=ix_comp, columns=['evec_no', 'phi','log_phi'], dtype='float')
for alpha,tau in alpha_tau_combos:
PROP = Propagator(GEN=GEN, tau=tau, alpha=alpha, beta=beta)
y_state = PROP.etO[0,:].real
y = interp1d(x_state, y_state, kind='cubic')
df_prop.loc[pd.IndexSlice[alpha,tau,:],'prob'] = y(x)
df_prop.loc[pd.IndexSlice[alpha,tau,:],'cdf'] = 1.- y(x)
df_spec.loc[pd.IndexSlice[alpha,tau,:],'eval'] = evals
df_spec.loc[pd.IndexSlice[alpha,tau,:],'evec_no'] = comps
df_spec.loc[pd.IndexSlice[alpha,tau,:],'gain'] = np.diag(PROP.wetD)
df_spec.loc[pd.IndexSlice[alpha,tau,:],'log_gain'] = np.log(np.diag(PROP.wetD))
for comp in comps:
y_state = PROP.U[:,comp-1].real
phi_func = interp1d(x_state, y_state, kind='cubic')
phi = phi_func(x)
log_phi = np.log(phi-phi.min()+0.01)
df_comp.loc[pd.IndexSlice[comp,:],'evec_no'] = comp