def plot_divisive_normalization_weber_law(data_flags,
axes_to_plot=[0, 1],
projected_variable_components=dict()
):
# Define the plot indices
assert len(data_flags) % 2 == 0, \
"Need command line arguments to be normalization_idxs*2, " \
"first half Weber law and second half non-Weber law."
# Ready the plotting window; colormaps; colors; signals to plot
cmaps = [cm.Reds, cm.Blues]
shades = sp.linspace(0.3, 0.85, len(data_flags) / 2)
# Plot success error figures
for data_flag_idx, data_flag in enumerate(data_flags):
Weber_idx = int(data_flag_idx / (len(data_flags) / 2))
normalization_idx = int(data_flag_idx % (len(data_flags) / 2))
# Decoding accuracy subfigures
fig = divisive_normalization_subfigures()
# Blue for non-adapted; red for adapted
cmap = cmaps[Weber_idx]
# Shade darkens for successive plots
shade = shades[normalization_idx]
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
Nn = list_dict['params']['Nn']
iter_plot_var = iter_vars.keys()[axes_to_plot[0]]
x_axis_var = iter_vars.keys()[axes_to_plot[1]]
data = load_signal_decoding_weber_law(data_flag)
successes = data['successes']
nAxes = len(successes.shape)
if nAxes > 2:
successes = project_tensor(successes, iter_vars,
projected_variable_components,
axes_to_plot)
# Switch axes if necessary
if axes_to_plot[0] > axes_to_plot[1]:
successes = successes.T
# Plot successes, averaged over second axis of successes array
avg_successes = sp.average(successes, axis=1) * 100.0
plt.plot(iter_vars[iter_plot_var],
avg_successes,
color=cmap(shade),
zorder=normalization_idx,
lw=4.0)
# Save same plot in both Weber Law and non-Weber Law folders
for Weber_idx in range(2):
data_flag = data_flags[data_flag_idx]
save_decoding_accuracy_fig(fig, data_flag)
def plot_signal_decoding_vs_Kk(data_flag,
nonzero_bounds=[0.75, 1.25],
zero_bound=1. / 10.,
threshold_pct_nonzero=100.0,
threshold_pct_zero=100.0):
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
Nn = list_dict['params']['Nn']
# Decoding accuracy subfigures
fig = signal_decoding_vs_Kk_subfigures()
assert len(iter_vars) == 3, "Need 3 iter_vars"
iter_plot_var = iter_vars.keys()[0]
x_axis_var = iter_vars.keys()[1]
Kk_axis_var = iter_vars.keys()[2]
data = load_signal_decoding_weber_law(data_flag)
successes = data['successes']
# Plot successes, averaged over second axis of successes array
avg_successes = sp.average(successes, axis=1) * 100.0
plt.pcolormesh(avg_successes.T,
cmap=plt.cm.hot,
rasterized=True,
vmin=-5,
vmax=110)
plt.colorbar()
save_decoding_accuracy_vs_Kk_fig(fig, data_flag)
def plot_tuning_curves(data_flags):
# First entries are for mu_dSs, second are for tuning_width
#plot_vars = [[0, 9, 18], [7, 11, 19]]
plot_vars = [[0, 1, 2], [0, 1, 2]]
cmaps = [[cm.Greys, cm.Purples, cm.Blues],
[cm.Greys, cm.Purples, cm.Blues]]
for data_idx, data_flag in enumerate(data_flags):
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
tuning_curve_data = load_tuning_curve(data_flag)
tuning_curve = tuning_curve_data['tuning_curve']
epsilons = tuning_curve_data['epsilons']
if data_idx == 0:
fig, plot_dims, axes_tuning, axes_eps, axes_signal = \
tuning_curve_plot_epsilon(plot_vars, iter_vars, params)
for idx, idx_var in enumerate(plot_vars[0]):
for idy, idy_var in enumerate(plot_vars[1]):
colors = cmaps[data_idx][idx](sp.linspace(
0.75, 0.3, params['Mm']))
for iM in range(params['Mm']):
axes_tuning[idx,
idy].plot(sp.arange(params['Nn'] / 2),
sp.sort(tuning_curve[idx_var,
idy_var, ::2,
iM]),
color=colors[iM],
linewidth=0.7,
zorder=params['Mm'] - iM)
axes_tuning[idx,
idy].plot(sp.arange(params['Nn'] / 2 - 1,
params['Nn'] - 1),
sp.sort(tuning_curve[idx_var,
idy_var, 1::2,
iM])[::-1],
color=colors[iM],
linewidth=0.7,
zorder=params['Mm'] - iM)
axes_eps[idy].plot(range(params['Mm']),
epsilons[idx_var, idy_var],
color=colors[4],
linewidth=1.5,
zorder=0)
for iM in range(params['Mm']):
axes_eps[idy].scatter(iM,
epsilons[idx_var, idy_var][iM],
c=colors[iM],
s=3)
save_tuning_curve_fig(fig, data_flag)
def plot_activities(data_flags,
axes_to_plot=[0, 1],
projected_variable_components=dict()):
# Define the plot indices
assert len(data_flags) % 2 == 0, \
"Need command line arguments to be normalization_idxs*2, " \
"alternating Weber law and non-Weber law."
# Ready the plotting window; colormaps; colors; signals to plot
cmaps = [cm.Reds, cm.Blues]
cmaps_r = [cm.Reds_r, cm.Blues_r]
# Plot success error figures
for data_flag_idx, data_flag in enumerate(data_flags):
# Blue or red depends on this index
Weber_idx = data_flag_idx % 2
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
iter_plot_var = iter_vars.keys()[axes_to_plot[0]]
x_axis_var = iter_vars.keys()[axes_to_plot[1]]
data = load_signal_decoding_weber_law(data_flag)
activities = data['Yys']
for iter_var_idx in range(len(iter_vars[iter_plot_var])):
if iter_var_idx == 0:
bins = sp.linspace(-4, 1.05, 20000)
activities_data = sp.zeros(
(len(iter_vars[iter_plot_var]), len(bins) - 1))
# Histogram takes all activities for all stimuli choices, for
# this particular background mean. Plot absolute value of dYy
hist, bin_edges = sp.histogram(
sp.log(abs(activities[iter_var_idx, :, :]))\
/sp.log(10), bins=200)
# Interpolate to identical scale for all columns.
interp_hist = sp.interp(bins, bin_edges[:-1], hist)[:-1]
activities_data[iter_var_idx, :] = interp_hist
normed_activities = activities_data.T / sp.amax(activities_data.T,
axis=0)
fig = activities_subfigures()
plt.pcolormesh(iter_vars[iter_plot_var],
10.**bins,
normed_activities,
cmap=cmaps_r[Weber_idx],
rasterized=True,
vmin=0,
vmax=1.05)
save_activities_fig(fig, data_flag)
def est_VA(data_flag, init_seed):
# Load specifications from file; pass to single_cell_FRET object
list_dict = read_specs_file(data_flag)
vars_to_pass = compile_all_run_vars(list_dict)
scF = single_cell_FRET(**vars_to_pass)
# If stim and meas were not imported, then data was saved as data_flag
if scF.stim_file is None:
scF.stim_file = data_flag
if scF.meas_file is None:
scF.meas_file = data_flag
scF.set_stim()
scF.set_meas_data()
# Initalize estimation; set the estimation and prediction windows
scF.init_seed = init_seed
scF.set_init_est()
scF.set_est_pred_windows()
# Initalize annealer class
annealer = va_ode.Annealer()
annealer.set_model(scF.df_estimation, scF.nD)
annealer.set_data(scF.meas_data[scF.est_wind_idxs, :],
stim=scF.stim[scF.est_wind_idxs],
t=scF.Tt[scF.est_wind_idxs])
# Set Rm as inverse covariance; all parameters measured for now
Rm = 1.0 / sp.asarray(scF.meas_noise)**2.0
P_idxs = sp.arange(scF.nP)
# Estimate
BFGS_options = {
'gtol': 1.0e-8,
'ftol': 1.0e-8,
'maxfun': 1000000,
'maxiter': 1000000
}
tstart = time.time()
annealer.anneal(scF.x_init[scF.est_wind_idxs],
scF.p_init,
scF.alpha,
scF.beta_array,
Rm,
scF.Rf0,
scF.L_idxs,
P_idxs,
dt_model=None,
init_to_data=True,
bounds=scF.bounds,
disc='trapezoid',
method='L-BFGS-B',
opt_args=BFGS_options,
adolcID=init_seed)
print("\nADOL-C annealing completed in %f s." % (time.time() - tstart))
save_estimates(scF, annealer, data_flag)
def plot_tuning_curves(data_flags):
# First entries are for mu_dSs, second are for Kk2 diversity
plot_vars = [[0, 9, 19], [8, 15, 19]]
cmaps = [[cm.Greys, cm.Purples, cm.Blues],
[cm.Greys, cm.Purples, cm.Blues]]
for data_idx, data_flag in enumerate(data_flags):
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
tuning_curve_data = load_tuning_curve(data_flag)
tuning_curve = tuning_curve_data['tuning_curve']
epsilons = tuning_curve_data['epsilons']
Kk2s = tuning_curve_data['Kk2s']
if data_idx == 0:
fig, plot_dims, axes_tuning, axes_Kk2, axes_signal = \
tuning_curve_plot_Kk2(plot_vars, iter_vars, params)
for idx, idx_var in enumerate(plot_vars[0]):
for idy, idy_var in enumerate(plot_vars[1]):
colors = cmaps[data_idx][idx](sp.linspace(
0.75, 0.3, params['Mm']))
for iM in range(params['Mm']):
axes_tuning[idx,
idy].plot(sp.arange(params['Nn'] / 2),
sp.sort(tuning_curve[idx_var,
idy_var, ::2,
iM]),
color=colors[iM],
linewidth=0.7,
zorder=params['Mm'] - iM)
axes_tuning[idx,
idy].plot(sp.arange(params['Nn'] / 2 - 1,
params['Nn'] - 1),
sp.sort(tuning_curve[idx_var,
idy_var, 1::2,
iM])[::-1],
color=colors[iM],
linewidth=0.7,
zorder=params['Mm'] - iM)
if idx == 0:
sorted_idxs = sp.argsort(
sp.std(Kk2s[0, idy_var, :, :], axis=1))
axes_Kk2[idy].imshow(Kk2s[0, idy_var, sorted_idxs, :].T,
aspect=0.3,
cmap='bone',
rasterized=True)
save_tuning_curve_fig(fig, data_flag)
def calculate_signal_discrimination_weber_law(data_flag,
nonzero_bounds=[0.5, 1.5],
zero_bound=1./10.,
threshold_pct_nonzero=75.0,
threshold_pct_zero=75.0):
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
print ('Loading object list...'),
CS_object_array = load_aggregated_object_list(iter_vars_dims, data_flag)
print ('...loaded.')
#Code not written for Kk_split = 0
assert CS_object_array[0, 0].Kk_split != 0, "Need nonzero Kk_split"
# Data structures
errors_zero = sp.zeros(iter_vars_dims)
errors_nonzero_2 = sp.zeros(iter_vars_dims)
errors_nonzero = sp.zeros(iter_vars_dims)
successes_2 = sp.zeros(iter_vars_dims)
successes = sp.zeros(iter_vars_dims)
# Calculate binary errors
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
while not it.finished:
errors = binary_errors_dual_odor(CS_object_array[it.multi_index],
nonzero_bounds=nonzero_bounds,
zero_bound=zero_bound)
errors_nonzero[it.multi_index] = errors['errors_nonzero']
errors_nonzero_2[it.multi_index] = errors['errors_nonzero_2']
errors_zero[it.multi_index] = errors['errors_zero']
it.iternext()
# Calculate success ratios from binary errors
it = sp.nditer(sp.zeros(iter_vars_dims), flags = ['multi_index'])
while not it.finished:
successes_2[it.multi_index] = binary_success(
errors_nonzero_2[it.multi_index],
errors_zero[it.multi_index],
threshold_pct_nonzero=threshold_pct_nonzero,
threshold_pct_zero=threshold_pct_zero)
successes[it.multi_index] = binary_success(
errors_nonzero[it.multi_index],
errors_zero[it.multi_index],
threshold_pct_nonzero=threshold_pct_nonzero,
threshold_pct_zero=threshold_pct_zero)
it.iternext()
save_signal_discrimination_weber_law(successes, successes_2, data_flag)
def calculate_signal_decoding_weber_law(data_flag,
nonzero_bounds=[0.5, 1.5],
zero_bound=1. / 10.,
threshold_pct_nonzero=85.0,
threshold_pct_zero=85.0):
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
print('Loading object list...'),
CS_object_array = load_aggregated_object_list(iter_vars_dims, data_flag)
print('...loaded.')
# Data structures
errors_nonzero = sp.zeros(iter_vars_dims)
errors_zero = sp.zeros(iter_vars_dims)
epsilons = sp.zeros((iter_vars_dims[0], iter_vars_dims[1], params['Mm']))
gains = sp.zeros(
(iter_vars_dims[0], iter_vars_dims[1], params['Mm'], params['Nn']))
successes = sp.zeros(iter_vars_dims)
# Calculate binary errors
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
while not it.finished:
errors = binary_errors(CS_object_array[it.multi_index],
nonzero_bounds=nonzero_bounds,
zero_bound=zero_bound)
errors_nonzero[it.multi_index] = errors['errors_nonzero']
errors_zero[it.multi_index] = errors['errors_zero']
it.iternext()
# Calculate success ratios from binary errors
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
while not it.finished:
successes[it.multi_index] = binary_success(
errors_nonzero[it.multi_index],
errors_zero[it.multi_index],
threshold_pct_nonzero=threshold_pct_nonzero,
threshold_pct_zero=threshold_pct_zero)
epsilons[it.multi_index] = CS_object_array[it.multi_index].eps
gains[it.multi_index] = CS_object_array[it.multi_index].Rr
it.iternext()
save_signal_decoding_weber_law(successes, gains, epsilons, data_flag)
def nn_run(data_flag, iter_var_idxs):
"""
Run a supervised learning classification for a single specs file.
Data is read from a specifications file in the data_dir/specs/
folder, with proper formatting given in read_specs_file.py. The
specs file indicates the full range of the iterated variable; this
script only produces output from one of those indices, so multiple
runs can be performed in parallel.
"""
# Aggregate all run specifications from the specs file; instantiate model
list_dict = read_specs_file(data_flag)
vars_to_pass = compile_all_run_vars(list_dict, iter_var_idxs)
obj = nn(**vars_to_pass)
# Need this to save tensor flow objects on iterations
obj.data_flag = data_flag
# Set the signals and free energy, depending if adaptive or not.
if 'run_type' in list(list_dict['run_specs'].keys()):
val = list_dict['run_specs']['run_type']
if val[0] == 'nn':
obj.init_nn_frontend()
elif val[0] == 'nn_adapted':
obj.init_nn_frontend_adapted()
else:
print('`%s` run type not accepted for '
'supervised learning calculation' % val[0])
quit()
else:
print ('No learning calculation run type specified, proceeding with' \
'unadapted learning calculation')
obj.init_nn_frontend()
# Set the network variables, learning algorithm
obj.set_AL_MB_connectome()
obj.set_ORN_response_array()
obj.set_PN_response_array()
obj.init_tf()
# Train and test performance
obj.set_tf_class_labels()
obj.train_and_test_tf()
# Delete tensorflow variables to allow saving
obj.del_tf_vars()
dump_objects(obj, iter_var_idxs, data_flag)
return obj
def calculate_tuning_curves(data_flag):
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
# Get the iterated variable dimensions
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
# Set up array to hold tuning curve curves
tuning_curve = sp.zeros(
(iter_vars_dims[0], iter_vars_dims[1], params['Nn'], params['Mm']))
# Set array to hold epsilons and Kk2
epsilons = sp.zeros((iter_vars_dims[0], iter_vars_dims[1], params['Mm']))
Kk2s = sp.zeros(
(iter_vars_dims[0], iter_vars_dims[1], params['Mm'], params['Nn']))
# Iterate tuning curve calculation over all iterable variables
while not it.finished:
iter_var_idxs = it.multi_index
vars_to_pass = dict()
vars_to_pass = parse_iterated_vars(iter_vars, iter_var_idxs,
vars_to_pass)
vars_to_pass = parse_relative_vars(rel_vars, iter_vars, vars_to_pass)
vars_to_pass = merge_two_dicts(vars_to_pass, fixed_vars)
vars_to_pass = merge_two_dicts(vars_to_pass, params)
# Calculate tuning curve
for iN in range(vars_to_pass['Nn']):
vars_to_pass['manual_dSs_idxs'] = sp.array([iN])
obj = single_encode_CS(vars_to_pass, run_specs)
tuning_curve[iter_var_idxs[0], iter_var_idxs[1], iN, :] = obj.dYy
epsilons[it.multi_index] = obj.eps
Kk2s[it.multi_index] = obj.Kk2
it.iternext()
save_tuning_curve(tuning_curve, epsilons, Kk2s, data_flag)
def gen_twin_data(data_flag):
# Load specifications from file; to be passed to single_cell_FRET object
list_dict = read_specs_file(data_flag)
vars_to_pass = compile_all_run_vars(list_dict)
scF = single_cell_FRET(**vars_to_pass)
assert scF.meas_file is None, "For generating twin data manually, cannot "\
"import a measurement file; remove meas_file var in specs file"
scF.set_stim()
scF.gen_true_states()
scF.set_meas_data()
# Save the newly generated data; don't save stimulus if imported
if scF.stim_file is None:
save_stim(scF, data_flag)
save_true_states(scF, data_flag)
save_meas_data(scF, data_flag)
def CS_run(data_flag, iter_var_idxs):
"""
Run a CS decoding run for one given index of a set of iterated
variables.
Data is read from a specifications file in the data_dir/specs/
folder, with proper formatting given in read_specs_file.py. The
specs file indicates the full range of the iterated variable; this
script only produces output from one of those indices, so multiple
runs can be performed in parallel.
"""
# Aggregate all run specifications from the specs file; instantiate model
list_dict = read_specs_file(data_flag)
vars_to_pass = compile_all_run_vars(list_dict, iter_var_idxs)
obj = four_state_receptor_CS(**vars_to_pass)
# Encode and decode
obj = single_encode_CS(obj, list_dict['run_specs'])
obj.decode()
dump_objects(obj, iter_var_idxs, data_flag)
def aggregate_objects(data_flags, skip_missing=False):
"""
Aggregate CS objects from separate .pklz files to a single .pklz file.
Args:
data_flags: Identifiers for saving and loading.
"""
if skip_missing == True:
print("Skipping missing files...will populate with `None`")
if isinstance(data_flags, str):
data_flags = [data_flags]
for data_flag in data_flags:
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
obj_list = []
while not it.finished:
sys.stdout.flush()
print(it.multi_index)
if skip_missing == False:
CS_obj = load_objects(list(it.multi_index), data_flag)
else:
try:
CS_obj = load_objects(list(it.multi_index), data_flag)
except (IOError, OSError):
print('Skipping item %s...' % list(it.multi_index))
CS_obj = None
obj_list.append(CS_obj)
it.iternext()
save_aggregated_object_list(obj_list, data_flag)
def plot_signal_decoding_weber_law(data_flags, axes_to_plot=[0, 1],
projected_variable_components=dict()):
data_idxs = len(data_flags)
assert data_idxs % 2 == 0, \
"Need even number of command line arguments, alternating" \
"Weber law and non-Weber law"
# Ready the plotting window
fig, ax = single_decoding_weber_law_plot(data_idxs=data_idxs)
cmaps = [cm.Reds, cm.Blues]
cmaps_r = [cm.Reds_r, cm.Blues_r]
color_cycle_errors = sp.linspace(0.25, 0.7, data_idxs/2)
linewidths_errors = sp.linspace(6.0, 3.0, data_idxs/2)
# Plot for each command line argument
for data_idx, data_flag in enumerate(data_flags):
data_flag = str(data_flag)
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
iter_plot_var = iter_vars.keys()[axes_to_plot[0]]
x_axis_var = iter_vars.keys()[axes_to_plot[1]]
Nn = list_dict['params']['Nn']
data = load_signal_decoding_weber_law(data_flag)
successes = data['successes']
epsilons = data['epsilons']
gains = data['gains']
nAxes = len(successes.shape)
if nAxes > 2:
successes = project_tensor(successes,
iter_vars, projected_variable_components,
axes_to_plot)
# Switch axes if necessary
if axes_to_plot[0] > axes_to_plot[1]:
successes = successes.T
# Plot average errors
average_successes = sp.average(successes, axis=1)*100.0
cmap = cmaps[data_idx % 2]
color = cmap(color_cycle_errors[data_idx / 2])
linewidth = linewidths_errors[data_idx / 2]
ax['successes'].plot(iter_vars[iter_plot_var], average_successes,
color=color, linewidth=linewidth)
# Plot gains, averaged over odorant, and binned over different signals
# and over receptors
if data_idx % 2 == 0:
for iter_var_idx in range(len(iter_vars[iter_plot_var])):
if iter_var_idx == 0:
min = -8.0
max = -1.0
bins = sp.linspace(min, max, 1000)
gains_data = sp.zeros((len(iter_vars[iter_plot_var]),
len(bins) - 1))
odorant_averaged_gains = sp.average(gains[iter_var_idx],
axis=-1)
hist, bin_edges = sp.histogram(
sp.log(odorant_averaged_gains.flatten()) \
/sp.log(10), bins=bins)
gains_data[iter_var_idx, :] = hist
ax['gains_%s' % data_idx].pcolormesh(iter_vars[iter_plot_var],
10.**bins, gains_data.T, cmap=cmaps_r[0],
rasterized=True)
elif data_idx % 2 == 1:
for iter_var_idx in range(len(iter_vars[iter_plot_var])):
if iter_var_idx == 0:
min = -2.0
max = 1.0
bins = sp.linspace(min, max, 200)
gains_data = sp.zeros((len(iter_vars[iter_plot_var]),
len(bins) - 1))
odorant_averaged_gains = sp.average(gains[iter_var_idx],
axis=-1)
hist, bin_edges = sp.histogram(
sp.log(odorant_averaged_gains.flatten()) \
/sp.log(10), bins=bins)
gains_data[iter_var_idx, :] = hist
ax['gains_%s' % data_idx].pcolormesh(iter_vars[iter_plot_var],
10.**bins, gains_data.T, cmap=cmaps_r[1],
rasterized=True)
save_signal_decoding_weber_law_fig(fig)
# Plot estimated signals
samples_to_plot = [0, 1]
bkgrnds_to_plot = [40, 76]
stimuli_to_plot = [1, 2]
for data_idx, data_flag_idx in enumerate(samples_to_plot):
data_flag = data_flags[data_flag_idx]
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
print ('Loading object list...'),
CS_object_array = load_aggregated_object_list(iter_vars_dims, data_flag)
print ('...loaded.')
cmap = cmaps[data_idx % 2]
color = cmap(color_cycle_errors[-1])
for bkgrnd_idx, bkgrnd_val in enumerate(bkgrnds_to_plot):
ax['est_%s' % bkgrnd_idx].bar(
sp.arange(Nn), CS_object_array[bkgrnd_val,
stimuli_to_plot[bkgrnd_idx]].dSs, edgecolor='black',
zorder=100, width=1.0, lw=1.0, fill=False)
ax['est_%s' % bkgrnd_idx].bar(
sp.arange(Nn), CS_object_array[bkgrnd_val,
stimuli_to_plot[bkgrnd_idx]].dSs_est, color=color,
zorder=2+data_idx, width=1.0)
save_signal_decoding_weber_law_fig(fig)
def temporal_CS_run(data_flag,
iter_var_idxs,
mu_dSs_offset=0,
mu_dSs_multiplier=1. / 3.,
sigma_dSs_offset=0,
sigma_dSs_multiplier=1. / 9.,
signal_window=None,
save_data=True,
decode=True):
"""
Run a CS decoding run for a full temporal signal trace.
Data is read from a specifications file in the data_dir/specs/
folder, with proper formatting given in read_specs_file.py. The
specs file indicates the full range of the iterated variable; this
script only produces output from one of those indices, so multiple
runs can be performed in parallel.
"""
assert mu_dSs_offset >= 0, "mu_dSs_offset kwarg must be >= 0"
assert sigma_dSs_offset >= 0, "sigma_dSs_offset kwarg must be >= 0"
# Aggregate all run specifications from the specs file; instantiate model
list_dict = read_specs_file(data_flag)
vars_to_pass = compile_all_run_vars(list_dict, iter_var_idxs)
obj = four_state_receptor_CS(**vars_to_pass)
# Set the temporal signal array from file; truncate to signal window
obj.set_signal_trace()
assert sp.sum(obj.signal_trace <= 0) == 0, \
"Signal contains negative values; increase signal_trace_offset"
if signal_window is not None:
obj.signal_trace_Tt = obj.signal_trace_Tt[signal_window[0]: \
signal_window[1]]
obj.signal_trace = obj.signal_trace[signal_window[0]:signal_window[1]]
# Load dual odor dSs from file (this is considered non-adapted fluctuation
# and should have a shorter timescale than the first odor). Can also use
# Kk_1 and Kk_2 for separate complexities of odor 1 and 2, respectively.
if (obj.Kk_1 is not None) and (obj.Kk_2 is not None):
obj.Kk = obj.Kk_1 + obj.Kk_2
obj.Kk_split = obj.Kk_2
if (obj.Kk_split is not None) and (obj.Kk_split != 0):
try:
obj.signal_trace_2
except AttributeError:
print('Need to assign signal_trace_2 if setting Kk_split or ' \
'Kk_1 and Kk_2 nonzero')
quit()
assert sp.sum(obj.signal_trace_2 <= 0) == 0, \
"Signal_2 contains neg values; increase signal_trace_offset_2"
if signal_window is not None:
obj.signal_trace_2 = obj.signal_trace_2[signal_window[0]: \
signal_window[1]]
obj_list = []
for iT, dt in enumerate(obj.signal_trace_Tt):
print('%s/%s' % (iT + 1, len(obj.signal_trace)), end=' ')
sys.stdout.flush()
# Set mu_Ss0 from signal trace, if desired
if obj.set_mu_Ss0_temporal_signal == True:
obj.mu_Ss0 = obj.signal_trace[iT]
# Set estimation dSs values from signal trace and kwargs
signal = obj.signal_trace[iT]
obj.mu_dSs = mu_dSs_offset + signal * mu_dSs_multiplier
obj.sigma_dSs = sigma_dSs_offset + signal * sigma_dSs_multiplier
# Set estimation dSs values for dual odor if needed
if (obj.Kk_split is not None) and (obj.Kk_split != 0):
signal_2 = obj.signal_trace_2[iT]
obj.mu_dSs_2 = mu_dSs_offset + signal_2 * mu_dSs_multiplier
obj.sigma_dSs_2 = sigma_dSs_offset + signal_2 * sigma_dSs_multiplier
# Encode / decode fully first time; then just update eps and responses
if iT == 0:
obj = single_encode_CS(obj, list_dict['run_specs'])
# Spread adaptation rates over the system
if obj.temporal_adaptation_rate_sigma != 0:
obj.set_ordered_temporal_adaptation_rate()
else:
obj.set_sparse_signals()
obj.set_temporal_adapted_epsilon()
obj.set_measured_activity()
obj.set_linearized_response()
# Estimate signal at point iT
if decode == True:
obj.decode()
# Deep copy to take all aspects of the object but not update it
obj_list.append(copy.deepcopy(obj))
if save_data == True:
dump_objects(obj_list, iter_var_idxs, data_flag)
return obj_list
def calculate_signal_decoding_weber_law(data_flags,
nonzero_bounds=[0.75, 1.25],
zero_bound=1. / 10.,
threshold_pct_nonzero=100.0,
threshold_pct_zero=100.0):
for data_flag in data_flags:
list_dict = read_specs_file(data_flag)
for key in list_dict:
exec("%s = list_dict[key]" % key)
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
print('Loading object list...'),
CS_object_array = load_aggregated_object_list(iter_vars_dims,
data_flag)
print('...loaded.')
# Data structures
data = dict()
errors_nonzero = sp.zeros(iter_vars_dims)
errors_zero = sp.zeros(iter_vars_dims)
Mm_shape = iter_vars_dims + [params['Mm']]
Mm_Nn_shape = iter_vars_dims + [params['Mm'], params['Nn']]
data['epsilons'] = sp.zeros(Mm_shape)
data['dYys'] = sp.zeros(Mm_shape)
data['Yys'] = sp.zeros(Mm_shape)
data['gains'] = sp.zeros(Mm_Nn_shape)
data['Kk2s'] = sp.zeros(Mm_Nn_shape)
data['successes'] = sp.zeros(iter_vars_dims)
# Calculate binary errors
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
while not it.finished:
errors = binary_errors(CS_object_array[it.multi_index],
nonzero_bounds=nonzero_bounds,
zero_bound=zero_bound)
errors_nonzero[it.multi_index] = errors['errors_nonzero']
errors_zero[it.multi_index] = errors['errors_zero']
it.iternext()
# Calculate success ratios from binary errors
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
while not it.finished:
data['successes'][it.multi_index] = binary_success(
errors_nonzero[it.multi_index],
errors_zero[it.multi_index],
threshold_pct_nonzero=threshold_pct_nonzero,
threshold_pct_zero=threshold_pct_zero)
data['epsilons'][it.multi_index] = CS_object_array[
it.multi_index].eps
data['gains'][it.multi_index] = CS_object_array[it.multi_index].Rr
data['dYys'][it.multi_index] = CS_object_array[it.multi_index].dYy
data['Yys'][it.multi_index] = CS_object_array[it.multi_index].Yy
data['Kk2s'][it.multi_index] = CS_object_array[it.multi_index].Kk2
it.iternext()
save_signal_decoding_weber_law(data, data_flag)
def temporal_entropy_run(data_flag, iter_var_idxs,
mu_dSs_offset=0, mu_dSs_multiplier=1./3.,
sigma_dSs_offset=0, sigma_dSs_multiplier=1./9.,
signal_window=None, save_data=True):
assert mu_dSs_offset >= 0, "mu_dSs_offset kwarg must be >= 0"
assert sigma_dSs_offset >= 0, "sigma_dSs_offset kwarg must be >= 0"
# Aggregate all run specifications from the specs file; instantiate model
list_dict = read_specs_file(data_flag)
if 'run_type' in list_dict['run_specs'].keys():
print ('!!\n\nrun_spec %s passed in specs file. run_specs are not '
'accepted for temporal entropy calculations at this time. '
'Ignoring...\n\n!!\n' % list_dict['run_specs']['run_type'])
vars_to_pass = compile_all_run_vars(list_dict, iter_var_idxs)
obj = response_entropy(**vars_to_pass)
obj.encode_power_Kk()
# Set the temporal signal array from file; truncate to signal window
obj.set_signal_trace()
assert sp.sum(obj.signal_trace <= 0) == 0, \
"Signal contains negative values; increase signal_trace_offset"
if signal_window is not None:
obj.signal_trace_Tt = obj.signal_trace_Tt[signal_window[0]: \
signal_window[1]]
obj.signal_trace = obj.signal_trace[signal_window[0]: signal_window[1]]
# Load dual odor dSs from file (this is considered non-adapted fluctuation
# and should have a shorter timescale than the first odor). Can also use
# Kk_1 and Kk_2 for separate complexities of odor 1 and 2, respectively.
if (obj.Kk_1 is not None) and (obj.Kk_2 is not None):
obj.Kk = obj.Kk_1 + obj.Kk_2
obj.Kk_split = obj.Kk_2
if (obj.Kk_split is not None) and (obj.Kk_split != 0):
try:
obj.signal_trace_2
except AttributeError:
print('Need to assign signal_trace_2 if setting Kk_split or ' \
'Kk_1 and Kk_2 nonzero')
quit()
assert sp.sum(obj.signal_trace_2 <= 0) == 0, \
"Signal_2 contains neg values; increase signal_trace_offset_2"
if signal_window is not None:
obj.signal_trace_2 = obj.signal_trace_2[signal_window[0]: \
signal_window[1]]
obj_list = []
for iT, dt in enumerate(obj.signal_trace_Tt):
print('%s/%s' % (iT + 1, len(obj.signal_trace)), end=' ')
sys.stdout.flush()
# Set mu_Ss0 from signal trace, if desired
if obj.set_mu_Ss0_temporal_signal == True:
obj.mu_Ss0 = obj.signal_trace[iT]
# Set estimation dSs values from signal trace and kwargs
signal = obj.signal_trace[iT]
obj.mu_dSs = mu_dSs_offset + signal*mu_dSs_multiplier
obj.sigma_dSs = sigma_dSs_offset + signal*sigma_dSs_multiplier
# Set estimation dSs values for dual odor if needed
if (obj.Kk_split is not None) and (obj.Kk_split != 0):
signal_2 = obj.signal_trace_2[iT]
obj.mu_dSs_2 = mu_dSs_offset + signal_2*mu_dSs_multiplier
obj.sigma_dSs_2 = sigma_dSs_offset + signal_2*sigma_dSs_multiplier
# Set the full signal array from the above signal parameters
obj.set_ordered_dual_signal_array()
# At first step, set energy; from then on it is dynamical.
if iT == 0:
obj.set_normal_free_energy()
# Spread adaptation rates over the system
if obj.temporal_adaptation_rate_sigma != 0:
obj.set_ordered_temporal_adaptation_rate()
else:
obj.set_temporal_adapted_epsilon()
# Calculate MI
obj.set_mean_response_array()
obj.set_ordered_dual_response_pdf()
obj.calc_MI_fore_only()
print (sp.mean(obj.entropy))
# Deep copy to take all aspects of the object but not update it
obj_list.append(copy.deepcopy(obj))
if save_data == True:
dump_objects(obj_list, iter_var_idxs, data_flag)
return obj_list
def plot_signal_estimation_weber_law(data_flags, axes_to_plot=[0, 1],
projected_variable_components=dict()):
# Define the plot indices
assert len(data_flags) == 2, \
"Need command line arguments to be two, alternating " \
"non-Weber law and Weber law."
cmaps = [cm.Blues, cm.Reds]
alphas = [1.0, 0.8]
mu_dSs_to_plot = sp.arange(0, 100, 5)
seed_Kk2_to_plot = sp.arange(0, 100, 5)
true_signal_lw = 1.0
true_signal_color = 'black'
CS_object_array = []
# Load both object arrays only once
for Weber_idx, data_flag in enumerate(data_flags):
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
Nn = list_dict['params']['Nn']
Kk = list_dict['params']['Kk']
data = load_signal_decoding_weber_law(data_flag)
# Load CS objects for single stimuli plotting
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
print ('Loading object list for single stimulus plot...'),
CS_object_array.append(load_aggregated_object_list(iter_vars_dims,
data_flag))
print ('...loaded.')
# Nonzero components
for dSs_idx in mu_dSs_to_plot:
for Kk2_idx in seed_Kk2_to_plot:
# Ready the plotting window; colormaps; colors; signals to plot
fig = signal_estimation_subfigures(nonzero=True)
for Weber_idx, data_flag in enumerate(data_flags):
# Blue for non-adapted; red for adapted
color = cmaps[Weber_idx](0.6)
# Plot the bar graphs for true signal and estimates, top and
# bottom; order by signal strength
true_signal = CS_object_array[Weber_idx][dSs_idx, Kk2_idx].dSs
est_signal = CS_object_array[Weber_idx][dSs_idx, Kk2_idx].dSs_est
sorted_idxs = sp.argsort(true_signal)[::-1]
plt.bar(sp.arange(Kk), true_signal[sorted_idxs][:Kk]*(-1)**Weber_idx,
lw=true_signal_lw, edgecolor=true_signal_color,
zorder=100, width=1.0, fill=False)
plt.bar(sp.arange(Kk), est_signal[sorted_idxs][:Kk]*(-1)**Weber_idx,
color=color, zorder=2, width=1.0)
for data_flag in data_flags:
save_signal_estimation_nonzeros_fig(fig, data_flag, dSs_idx, Kk2_idx)
plt.close()
# Zero components
for dSs_idx in mu_dSs_to_plot:
for Kk2_idx in seed_Kk2_to_plot:
# Ready the plotting window; colormaps; colors; signals to plot
fig = signal_estimation_subfigures(nonzero=False)
for Weber_idx, data_flag in enumerate(data_flags):
# Blue for non-adapted; red for adapted
color = cmaps[Weber_idx](0.6)
alpha = alphas[Weber_idx]
# Ordering here is actually not necessary
true_signal = CS_object_array[Weber_idx][dSs_idx, Kk2_idx].dSs
est_signal = CS_object_array[Weber_idx][dSs_idx, Kk2_idx].dSs_est
sorted_idxs = sp.argsort(true_signal)[::-1]
est_signal_nonzeros = est_signal[sorted_idxs][Kk:]
est_signal_sorted_idxs = sp.argsort(est_signal_nonzeros)
plt.fill_between(sp.arange(Nn - Kk), 0, est_signal_nonzeros\
[est_signal_sorted_idxs], color=color, alpha=alpha)
for data_flag in data_flags:
save_signal_estimation_zeros_fig(fig, data_flag, dSs_idx, Kk2_idx)
plt.close()
def plot_signal_discrimination_weber_law(data_flags,
axes_to_plot=[0, 1],
projected_variable_components=dict()):
# Function to plot signal and inset; odor 2 is overlaid in darker color.
def signal_plot(ax):
ax.bar(sp.arange(Nn),
CS_object_array[mu_dSs_to_plot,
seed_Kk2_to_plot[Kk_split_idx]].dSs *
(-1)**Weber_idx,
lw=true_signal_lw,
edgecolor=true_signal_color,
zorder=100,
width=1.0,
fill=False)
ax.bar(sp.arange(Nn),
CS_object_array[mu_dSs_to_plot,
seed_Kk2_to_plot[Kk_split_idx]].dSs_est *
(-1)**Weber_idx,
color=cmap(dual_odor_color_shades[0]),
zorder=2,
width=1.0)
# Generate just odor 2 signal and plot over first plot
signal_2 = sp.zeros(Nn)
idxs_2 = CS_object_array[mu_dSs_to_plot, \
seed_Kk2_to_plot[Kk_split_idx]].idxs_2
for idx_2 in idxs_2:
signal_2[idx_2] = CS_object_array[
mu_dSs_to_plot, seed_Kk2_to_plot[Kk_split_idx]].dSs_est[idx_2]
ax.bar(sp.arange(Nn),
signal_2 * (-1)**Weber_idx,
color=cmap(dual_odor_color_shades[1]),
zorder=3,
width=1.0)
return ax
# Define the plot indices
Kk_split_idxs = len(data_flags) / 2
Weber_idxs = 2
assert len(data_flags) % 2 == 0, \
"Need command line arguments to be Kk_split*2, alternating " \
"Weber law and non-Weber law."
# Ready the plotting window; colormaps; colors; signals to plot
fig, ax = signal_discrimination_weber_law_plot(Kk_split_idxs=Kk_split_idxs)
cmaps = [cm.Reds, cm.Blues]
cmaps_r = [cm.Reds_r, cm.Blues_r]
dual_odor_color_shades = [0.7, 0.3]
success_plots_linewidths = [4.0, 6.0]
true_signal_color = 'black'
true_signal_lw = 1.0
mu_dSs_to_plot = 27
seed_Kk2_to_plot = [9, 64, 25]
# Plot
for data_idx, data_flag in enumerate(data_flags):
Weber_idx = data_idx % Weber_idxs
Kk_split_idx = data_idx / Weber_idxs
cmap = cmaps[Weber_idx]
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
Nn = list_dict['params']['Nn']
iter_plot_var = iter_vars.keys()[axes_to_plot[0]]
x_axis_var = iter_vars.keys()[axes_to_plot[1]]
data = load_signal_discrimination_weber_law(data_flag)
successes = data['successes']
successes_2 = data['successes_2']
nAxes = len(successes.shape)
if nAxes > 2:
successes = project_tensor(successes, iter_vars,
projected_variable_components,
axes_to_plot)
successes_2 = project_tensor(successes_2, iter_vars,
projected_variable_components,
axes_to_plot)
# Switch axes if necessary
if axes_to_plot[0] > axes_to_plot[1]:
successes = successes.T
successes_2 = successes_2.T
# Plot successes, averaged over second axis of successes array
avg_successes = sp.average(successes, axis=1) * 100.0
avg_successes_2 = sp.average(successes_2, axis=1) * 100.0
ax['successes_%s' % Kk_split_idx].plot(iter_vars[iter_plot_var],
avg_successes,
color=cmap(
dual_odor_color_shades[0]),
zorder=2,
lw=success_plots_linewidths[0])
ax['successes_%s' % Kk_split_idx].plot(iter_vars[iter_plot_var],
avg_successes_2,
color=cmap(
dual_odor_color_shades[1]),
zorder=1,
lw=success_plots_linewidths[1])
# Load CS objects for single stimuli plotting
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
print('Loading object list for single stimulus plot...'),
CS_object_array = load_aggregated_object_list(iter_vars_dims,
data_flag)
print('...loaded.')
# Plot signal and inset
ax['signal_%s' % Kk_split_idx] = \
signal_plot(ax['signal_%s' % Kk_split_idx])
ax['signal_insert_%s' % Kk_split_idx] = \
signal_plot(ax['signal_insert_%s' % Kk_split_idx])
if Weber_idx == 1:
mark_inset(ax['signal_%s' % Kk_split_idx],
ax['signal_insert_%s' % Kk_split_idx],
loc1=3,
loc2=4,
fc="none",
ec="0.5")
save_signal_discrimination_weber_law_fig(fig)
def plot_signal_decoding_weber_law(data_flags,
axes_to_plot=[0, 1],
projected_variable_components=dict()):
# Define the plot indices
diversity_idxs = len(data_flags) / 2
assert len(data_flags) % 2 == 0, \
"Need command line arguments to be diversity_idxs*2, alternating " \
"Weber law and non-Weber law."
# Ready the plotting window; colormaps; colors; signals to plot
cmaps = [cm.Reds, cm.Blues]
shades = sp.linspace(0.7, 0.3, diversity_idxs)
success_plot_lws = sp.linspace(4.0, 3.0, diversity_idxs)
# Decoding accuracy subfigures
fig = decoding_accuracy_subfigures()
# Plot success error figures
for diversity_idx in range(diversity_idxs):
shade = shades[diversity_idx]
lw = success_plot_lws[diversity_idx]
for Weber_idx in range(2):
data_flag_idx = Weber_idx + diversity_idx * 2
data_flag = data_flags[data_flag_idx]
# Blue for non-adapted; red for adapted
cmap = cmaps[Weber_idx]
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
Nn = list_dict['params']['Nn']
iter_plot_var = iter_vars.keys()[axes_to_plot[0]]
x_axis_var = iter_vars.keys()[axes_to_plot[1]]
data = load_signal_decoding_weber_law(data_flag)
successes = data['successes']
nAxes = len(successes.shape)
if nAxes > 2:
successes = project_tensor(successes, iter_vars,
projected_variable_components,
axes_to_plot)
# Switch axes if necessary
if axes_to_plot[0] > axes_to_plot[1]:
successes = successes.T
# Plot successes, averaged over second axis of successes array
avg_successes = sp.average(successes, axis=1) * 100.0
plt.plot(iter_vars[iter_plot_var],
avg_successes,
color=cmap(shade),
zorder=diversity_idx,
lw=lw)
# Save same plot in both Weber Law and non-Weber Law folders
for Weber_idx in range(2):
data_flag = data_flags[Weber_idx + diversity_idx * 2]
save_decoding_accuracy_fig(fig, data_flag)
plt.close()
# Plot Kk2 of index [0, 0], sorted
for data_flag in data_flags:
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
data = load_signal_decoding_weber_law(data_flag)
Kk2s = data['Kk2s']
reshape_idxs = sp.hstack((-1, Kk2s.shape[-2:]))
Kk2 = Kk2s.reshape(reshape_idxs)[0]
means = sp.average(Kk2, axis=1)
stdevs = sp.std(Kk2, axis=1)
sorted_idxs = sp.argsort(means)
sorted_Kk2 = Kk2[sorted_idxs, :]
fig = Kk2_subfigures()
plt.imshow(sp.log(sorted_Kk2.T) / sp.log(10),
interpolation='nearest',
cmap=plt.cm.inferno,
vmin=-1.51,
vmax=0.01)
cbar = plt.colorbar()
cbar.ax.tick_params(labelsize=14)
save_Kk2_fig(fig, data_flag)
def pred_plot(data_flag):
# Load specs file data and object
list_dict = read_specs_file(data_flag)
vars_to_pass = compile_all_run_vars(list_dict)
scF = single_cell_FRET(**vars_to_pass)
# If stim and meas were not imported, then data was saved as data_flag
if scF.stim_file is None:
scF.stim_file = data_flag
if scF.meas_file is None:
scF.meas_file = data_flag
scF.set_stim()
scF.set_meas_data()
# Initalize estimation; set the estimation and prediction windows
scF.set_est_pred_windows()
# Load all of the prediction data and estimation object and dicts
pred_dict = load_pred_data(data_flag)
opt_IC = sp.nanargmin(pred_dict['errors'])
opt_pred_path = pred_dict['pred_path'][:, :, opt_IC]
est_path = pred_dict['est_path'][:, :, opt_IC]
est_params = pred_dict['params'][:, opt_IC]
est_range = scF.est_wind_idxs
pred_range = scF.pred_wind_idxs
full_range = sp.arange(scF.est_wind_idxs[0], scF.pred_wind_idxs[-1])
est_Tt = scF.Tt[est_range]
pred_Tt = scF.Tt[pred_range]
full_Tt = scF.Tt[full_range]
# Load true data if using synthetic data
true_states = None
try:
true_states = load_true_file(data_flag)[:, 1:]
except:
pass
num_plots = scF.nD + 1
# Plot the stimulus
plt.subplot(num_plots, 1, 1)
plt.plot(full_Tt, scF.stim[full_range], color='r', lw=2)
plt.xlim(full_Tt[0], full_Tt[-1])
plt.ylim(80, 160)
# Plot the estimates
iL_idx = 0
for iD in range(scF.nD):
plt.subplot(num_plots, 1, iD + 2)
plt.xlim(full_Tt[0], full_Tt[-1])
if iD in scF.L_idxs:
# Plot measured data
plt.plot(est_Tt,
scF.meas_data[scF.est_wind_idxs, iL_idx],
color='g')
plt.plot(pred_Tt,
scF.meas_data[scF.pred_wind_idxs, iL_idx],
color='g')
# Plot estimation and prediction
plt.plot(est_Tt, est_path[:, iD], color='r', lw=3)
plt.plot(pred_Tt, opt_pred_path[:, iD], color='r', lw=3)
# Plot true states if this uses fake data
if true_states is not None:
plt.plot(scF.Tt, true_states[:, iD], color='k')
iL_idx += 1
else:
plt.plot(est_Tt, est_path[:, iD], color='r', lw=3)
plt.plot(pred_Tt, opt_pred_path[:, iD], color='r', lw=3)
if true_states is not None:
plt.plot(scF.Tt, true_states[:, iD], color='k')
save_opt_pred_plots(data_flag)
plt.show()
# Save all the optimal predictions, measurement and stimuli to txt files
stim_to_save = sp.vstack((full_Tt.T, scF.stim[full_range].T)).T
meas_to_save = sp.vstack((full_Tt.T, scF.meas_data[full_range].T)).T
est_to_save = sp.vstack((est_Tt.T, est_path.T)).T
pred_to_save = sp.vstack((pred_Tt.T, opt_pred_path.T)).T
params_to_save = sp.vstack((scF.model.param_names, est_params)).T
save_opt_pred_data(data_flag, stim_to_save, meas_to_save, est_to_save,
pred_to_save, params_to_save)
def aggregate_temporal_entropy_objects(data_flags):
"""
Aggregate CS objects from separate .pklz files of temporal runs to a single
.pklz object.
Args:
data_flags: Identifiers for saving and loading.
"""
temporal_structs_to_save = ['entropy']
if isinstance(data_flags, str):
data_flags = [data_flags]
for data_flag in data_flags:
list_dict = read_specs_file(data_flag)
iter_vars = list_dict['iter_vars']
iter_vars_dims = []
for iter_var in iter_vars:
iter_vars_dims.append(len(iter_vars[iter_var]))
it = sp.nditer(sp.zeros(iter_vars_dims), flags=['multi_index'])
CS_init_array = load_objects(list(it.multi_index), data_flag)
# Dictionary to save all object at time 0; this will contain all
# non-temporal info for each iterated variable.
data = dict()
data['init_objs'] = []
nT = len(CS_init_array[0].signal_trace_Tt)
# Assign data structures of appropriate shape for the temporal variable
structs = dict()
for struct_name in temporal_structs_to_save:
try:
tmp_str = 'structs[struct_name] = CS_init_array[0].%s' \
% struct_name
exec(tmp_str)
except:
print('%s not an attribute of the CS object' % struct_name)
continue
# shape is (num timesteps, iterated var ranges, variable shape);
# if a float or integer, shape is just time and iter vars.
struct_shape = (nT, ) + tuple(iter_vars_dims)
if hasattr(structs[struct_name], 'shape'):
struct_shape += (structs[struct_name].shape)
data['%s' % struct_name] = sp.zeros(struct_shape)
# Iterate over all objects to be aggregated
structs = dict()
while not it.finished:
print('Loading index:', it.multi_index)
temporal_CS_array = load_objects(list(it.multi_index), data_flag)
# Save full object at time 0, contains non-temporal data.
data['init_objs'].append(temporal_CS_array[0])
# Grab all the temporal structures, timepoint-by-timepoint
for iT in range(nT):
full_idx = (iT, ) + it.multi_index
for struct_name in temporal_structs_to_save:
tmp_str = 'structs[struct_name] = temporal_CS_array[iT].%s' \
% struct_name
exec(tmp_str)
data[struct_name][full_idx] = structs[struct_name]
it.iternext()
save_aggregated_temporal_objects(data, data_flag)