def worker_gs(self, *args, **kwargs):
# get parameters
kwargs_tmp = deepcopy(kwargs)
conditions = kwargs_tmp.pop('conditions')
param_grid = kwargs_tmp.pop('param_grid')
param_scalings = kwargs_tmp.pop('param_scalings')
T = kwargs_tmp['simulation_time']
dt = kwargs_tmp['step_size']
# simulate autonomous behavior in different conditions
results, gene_ids = [], param_grid.index
for c_dict in deepcopy(conditions):
for key in param_grid:
if key in c_dict:
c_dict[key] = deepcopy(param_grid[key]) * c_dict[key]
elif key in param_grid:
c_dict[key] = deepcopy(param_grid[key])
for key, key_tmp, power in param_scalings:
c_dict[key] = c_dict[key] * c_dict[key_tmp]**power
param_grid_tmp = DataFrame.from_dict(c_dict)
r, self.result_map, sim_time = grid_search(
*args, param_grid=param_grid_tmp, **deepcopy(kwargs_tmp))
r = r.droplevel(2, axis=1)
results.append(r)
# simulate behavior under extrinsic forcing
sim_steps = int(np.round(T / dt))
stim_offset = int(np.round(T * 0.5 / dt))
stim_dur = int(np.round(1.0 / dt))
stim_delayed = int(np.round((T * 0.5 + 14.0) / dt))
stim_amp = 9.0
stim_var = 100.0
ctx = np.zeros((sim_steps, 1))
ctx[stim_offset:stim_offset + stim_dur, 0] = stim_amp
ctx = gaussian_filter1d(ctx, stim_var, axis=0)
stria = np.zeros((sim_steps, 1))
stria[stim_delayed:stim_delayed + stim_dur, 0] = stim_amp
stria = gaussian_filter1d(stria, stim_var * 10.0, axis=0)
for key, key_tmp, power in param_scalings:
param_grid[key] = np.asarray(param_grid[key]) * np.asarray(
param_grid[key_tmp])**power
kwargs_tmp.pop('inputs')
r, self.result_map, sim_time = grid_search(*args,
param_grid=param_grid,
inputs={
'stn/stn_op/ctx': ctx,
'str/str_dummy_op/I':
stria
},
**kwargs_tmp)
results.append(r)
self.results = results
return sim_time
def worker_gs(self, *args, **kwargs):
kwargs_tmp = deepcopy(kwargs)
conditions = kwargs_tmp.pop('conditions')
param_grid = kwargs_tmp.pop('param_grid')
results, gene_ids = [], param_grid.index
for i, c_dict in enumerate(conditions):
for key in param_grid:
if '_pd' not in key:
if i < 6 or f"{key}_pd" not in param_grid:
param = param_grid[key]
else:
param = param_grid[key] + param_grid[f"{key}_pd"]
if key in c_dict:
c_dict[key] = param * c_dict[key]
else:
c_dict[key] = param
param_grid_tmp = DataFrame.from_dict(c_dict)
kwargs_gs = deepcopy(kwargs_tmp)
if i > 5:
kwargs_gs['simulation_time'] *= 3.0
r, self.result_map, sim_time = grid_search(
*args, param_grid=param_grid_tmp, **kwargs_gs)
r = r.droplevel(2, axis=1)
results.append(r)
self.results = results
return sim_time
def worker_gs(self, *args, **kwargs):
# get parameters
kwargs_tmp = deepcopy(kwargs)
conditions = kwargs_tmp.pop('conditions')
param_grid = kwargs_tmp.pop('param_grid')
param_scalings = kwargs_tmp.pop('param_scalings')
# simulate autonomous behavior in different conditions
results, gene_ids = [], param_grid.index
for c_dict in deepcopy(conditions):
for key in param_grid:
if key in c_dict:
c_dict[key] = deepcopy(param_grid[key]) * c_dict[key]
elif key in param_grid:
c_dict[key] = deepcopy(param_grid[key])
for key, key_tmp, power in param_scalings:
c_dict[key] = c_dict[key] * c_dict[key_tmp]**power
param_grid_tmp = DataFrame.from_dict(c_dict)
r, self.result_map, sim_time = grid_search(*args, param_grid=param_grid_tmp, **deepcopy(kwargs_tmp))
r = r.droplevel(2, axis=1)
results.append(r)
self.results = results
return sim_time
def worker_gs(self, *args, **kwargs):
kwargs_tmp = deepcopy(kwargs)
param_grid = kwargs_tmp.pop('param_grid')
r, self.result_map, sim_time = grid_search(*args,
param_grid=param_grid,
**kwargs_tmp)
r = r.droplevel(2, axis=1)
self.results = r
return sim_time
def simulate(self, process_id, matlab_engine=None):
T = 10.
dt = 1e-3
dts = 1e-2
ext_input = np.random.uniform(3., 5., (int(T / dt), 1))
# sys.stdout = io.StringIO()
# run PyRates with parameter combinations
results, result_map = grid_search(circuit_template=f'{os.path.dirname(__file__)}/PyRates_model_template/JRC',
param_grid={'w_ep': self.p['w_ein_pc'], 'w_ip': self.p['w_iin_pc']},
param_map={'w_ep': {'vars': ['weight'],
'edges': [('EIN', 'PC')]},
'w_ip': {'vars': ['weight'],
'edges': [('IIN', 'PC')]}},
simulation_time=T, dt=dt, sampling_step_size=dts,
inputs={'PC/Op_exc_syn/I_ext': ext_input},
outputs={'r': 'PC/Op_exc_syn/r'},
init_kwargs={'vectorization': True},
permute_grid=False,
backend="numpy", # "tensorflow"
decorator=njit)
y = np.zeros((len(self.p['w_ein_pc']), 1))
# extract QOI
for idx, (we, wi) in enumerate(zip(self.p['w_ein_pc'], self.p['w_iin_pc'])):
res_idx = result_map.loc[(result_map == (we, wi)).all(1), :].index
# plot_psd
# plot_psd(results[we][wi], tmin=30.0, show=False)
# p = plt.gca().get_lines()[-1].get_ydata()
# f = plt.gca().get_lines()[-1].get_xdata()
# max_idx = np.argmax(p)
# y[idx, 0] = f[max_idx]
# # y[idx, 1] = p[max_idx]
# plt.close(plt.gcf())
# welch
# f, p = psd(data=results[we][wi], nperseg=4096, tmin=30.0)
# max_idx = np.argmax(p)
# y[idx, 0] = f[max_idx]
# y[idx, 1] = p[max_idx]
# fft
# f, p = psd(data=results[res_idx], nperseg=4096, tmin=30.0)
f, p = get_psd(data=results[res_idx], tmin=30.0)
p = p[:int(len(p) / 2)]
f = f[np.argmax(np.abs(p))]
y[idx, 0] = f
# y[idx, 1] = p
sys.stdout = sys.__stdout__
return y
def worker_gs(self, *args, **kwargs):
kwargs_tmp = deepcopy(kwargs)
conditions = kwargs_tmp.pop('conditions')
model_vars = kwargs_tmp.pop('model_vars')
param_grid = kwargs_tmp.pop('param_grid')
results, gene_ids = [], param_grid.index
for c_dict in conditions:
for key in model_vars:
if key in c_dict and type(c_dict[key]) is float:
c_dict[key] = np.zeros(
(param_grid.shape[0], )) + c_dict[key]
elif key in param_grid:
c_dict[key] = param_grid[key]
param_grid_tmp = DataFrame.from_dict(c_dict)
f = terminate_at_threshold
f.terminal = True
r, self.result_map, sim_time = grid_search(
*args,
param_grid=param_grid_tmp,
events=f,
**deepcopy(kwargs_tmp))
r = r.droplevel(2, axis=1)
if any(r.values[-1, :] > 10.0):
invalid_genes = []
for id in param_grid.index:
if r.loc[r.index[-1], ('r_e', f'circuit_{id}')] > 10.0 or \
r.loc[r.index[-1], ('r_i', f'circuit_{id}')] > 10.0:
invalid_genes.append(id)
param_grid.drop(index=id, inplace=True)
kwargs['param_grid'] = param_grid
sim_time = self.worker_gs(*args, **kwargs)
for r in self.results:
for id in invalid_genes:
r[('r_e', f'circuit_{id}')] = np.zeros(
(r.shape[0], )) + 1e6
r[('r_i', f'circuit_{id}')] = np.zeros(
(r.shape[0], )) + 1e6
return sim_time
else:
results.append(r)
self.results = results
return sim_time
# define simulation parameters
dt = 1e-2
T = 3000.0
dts = 1e-1
# perform simulation
results, result_map = grid_search(
circuit_template="config/stn_gpe/stn_gpe_basic",
param_grid=param_grid,
param_map=param_map,
simulation_time=T,
step_size=dt,
sampling_step_size=dts,
permute_grid=False,
inputs={},
outputs={
'R_e': 'stn/stn_op/R_e',
'R_i': 'gpe/gpe_proto_op/R_i'
},
init_kwargs={
'backend': 'numpy',
'solver': 'scipy',
'step_size': dt
},
)
results = results * 1e3
for i, id in enumerate(result_map.index):
r_e = results['R_e'][id]
r_i = results['R_i'][id]
plt.plot(r_e)
# param_grid[key] = val * n_infreqs
for key, key_tmp, power in param_scalings:
param_grid[key] = np.asarray(param_grid[key]) * np.asarray(param_grid[key_tmp]) ** power
# simulations
#############
results, result_map = grid_search(
circuit_template="config/stn_gpe/gpe_2pop_driver",
param_grid=param_grid,
param_map=param_map,
simulation_time=T,
step_size=dt,
permute_grid=True,
sampling_step_size=dts,
inputs={},
outputs={'r_i': 'gpe_p/gpe_proto_syns_op/R_i',
#'r_a': 'gpe_a/gpe_arky_syns_op/R_a',
'd': 'driver/sl_op/Z2'
},
init_kwargs={
'backend': 'numpy', 'solver': 'scipy', 'step_size': dt, 'matrix_sparseness': 1.0},
method='RK45'
)
results_dict = {}
for key in result_map.index:
data1, data2 = results.loc[:, ('d', key)].values, results.loc[:, ('r_i', key)].values
results_dict[key] = {"omega": result_map.loc[key, 'omega'], 'alpha': result_map.loc[key, 'alpha'],
"data": np.asarray([data1, data2])}
scio.savemat('bs_data.mat', mdict=results_dict, long_field_names=True)
for key, key_tmp, power in param_scalings:
param_grid[key] = param_grid[key] * param_grid[key_tmp] ** power
#for key, val in param_grid.items():
# if len(val) == 1:
# param_grid[key] = np.asarray(list(val)*len(etas))
results, result_map = grid_search(
circuit_template="config/stn_gpe/stn_syns_pop",
param_grid=param_grid,
param_map=param_map,
simulation_time=T,
step_size=dt,
permute_grid=True,
sampling_step_size=dts,
inputs={},
outputs={
'r_e': 'stn/stn_syns_op/R_e'
},
init_kwargs={'backend': 'numpy', 'solver': 'scipy', 'step_size': dt},
method='RK45'
)
results = results * 1e3
# post-processing
#################
inputs, outputs = [], []
cutoff = 100.0
for i in range(len(etas)):
'tau_i': {
'var': [('Op_e.0', 'tau_i'), ('Op_i.0', 'tau_i')],
'nodes': ['PC.0', 'IIN.0']
},
'tau': {
'var': [('Op_e.0', 'tau'), ('Op_i.0', 'tau')],
'nodes': ['PC.0', 'IIN.0']
}
}
# perform simulation
results = grid_search(circuit_template="EI_circuit.Net",
param_grid=params,
param_map=param_map,
inputs={("PC", "Op_e.0", "i_in"): inp},
outputs={"r": ("PC", "Op_e.0", "r")},
dt=dt,
simulation_time=T,
permute_grid=False,
sampling_step_size=1e-3)
# plotting
cut_off = 1.
max_freq = np.zeros((len(tau_e_scaling), len(ei_ratio)))
freq_pow = np.zeros_like(max_freq)
for t_e, t_i, t_tmp in zip(params['tau_e'], params['tau_i'],
params['tau']):
if not results[t_e][t_i][t_tmp].isnull().any().any():
_ = plot_psd(results[t_e][t_i][t_tmp], tmin=cut_off, show=False)
pow = plt.gca().get_lines()[-1].get_ydata()
freqs = plt.gca().get_lines()[-1].get_xdata()
def simulate(self, process_id):
T = 500.
dt = 1e-3
dts = 1e-2
ext_input = np.random.uniform(3., 5., (int(T / dt), 1))
sys.stdout = io.StringIO()
# run PyRates with parameter combinations
results = grid_search(
deepcopy(self.jrc_template),
param_grid={
'w_ep': self.p['w_ein_pc'],
'w_ip': self.p['w_iin_pc']
},
param_map={
'w_ep': {
'var': [(None, 'weight')],
'edges': [('EINs.0', 'PCs.0', 0)]
},
'w_ip': {
'var': [(None, 'weight')],
'edges': [('IINs.0', 'PCs.0', 0)]
}
},
simulation_time=T,
dt=dt,
sampling_step_size=dts,
inputs={('PCs.0', 'Op_exc_syn.0', 'I_ext'): ext_input},
outputs={'r': ('PCs.0', 'Op_exc_syn.0', 'r')},
init_kwargs={
'vectorization': 'nodes',
'build_in_place': False
},
permute_grid=False,
backend="numpy", # "tensorflow"
decorator=njit)
y = np.zeros((len(self.p['w_ein_pc']), 1))
# extract QOI
for idx, (we,
wi) in enumerate(zip(self.p['w_ein_pc'],
self.p['w_iin_pc'])):
# plot_psd
# plot_psd(results[we][wi], tmin=30.0, show=False)
# p = plt.gca().get_lines()[-1].get_ydata()
# f = plt.gca().get_lines()[-1].get_xdata()
# max_idx = np.argmax(p)
# y[idx, 0] = f[max_idx]
# # y[idx, 1] = p[max_idx]
# plt.close(plt.gcf())
# welch
# f, p = psd(data=results[we][wi], nperseg=4096, tmin=30.0)
# max_idx = np.argmax(p)
# y[idx, 0] = f[max_idx]
# y[idx, 1] = p[max_idx]
# fft
f, p = get_psd(results[we][wi], tmin=30.0)
p = p[:int(len(p) / 2)]
f = f[np.argmax(np.abs(p))]
y[idx, 0] = f
# y[idx, 1] = p
sys.stdout = sys.__stdout__
return y
# grid-search
#############
for key, key_tmp, power in param_scalings:
param_grid[key] = np.asarray(param_grid[key]) * np.asarray(
param_grid[key_tmp])**power
results, result_map = grid_search(circuit_template="config/stn_gpe/stn_gpe",
param_grid=param_grid,
param_map=param_map,
simulation_time=T,
step_size=dt,
permute=True,
sampling_step_size=dts,
inputs={
'stn/stn_op/ctx': ctx,
'str/str_dummy_op/I': stria
},
outputs={
'r_i': 'gpe_p/gpe_proto_op/R_i',
'r_e': 'stn/stn_op/R_e'
},
init_kwargs={
'backend': 'numpy',
'solver': 'scipy',
'step_size': dt
})
results = results * 1e3
results = results.loc[0.5 * T:, :]
results.plot()
plt.show()
# post-processing
n += 1
params = {'J_ee': J_ee, 'J_ii': J_ii, 'J_ie': J_ie, 'J_ei': J_ei}
param_map = {'J_ee': {'var': [('Op_e_adapt.0', 'J')],
'nodes': ['E.0']},
'J_ii': {'var': [('Op_i_adapt.0', 'J')],
'nodes': ['I.0']},
'J_ei': {'var': [(None, 'weight')],
'edges': [('I.0', 'E.0', 0)]},
'J_ie': {'var': [(None, 'weight')],
'edges': [('E.0', 'I.0', 0)]}
}
# perform simulation
results = grid_search(circuit_template="../config/cmc_templates.EI_adapt",
param_grid=params, param_map=param_map,
inputs={}, outputs={"r_e": ("E.0", "Op_e_adapt.0", "r")},
dt=dt, simulation_time=T, permute_grid=False, sampling_step_size=dts)
# plotting
max_freq = np.zeros((len(ei_ratio), len(io_ratio)))
freq_pow = np.zeros_like(max_freq)
for j_ee, j_ii, j_ie, j_ei in zip(params['J_ee'], params['J_ii'], params['J_ie'], params['J_ei']):
data = results[j_ee][j_ii][j_ie][j_ei].values[cut_off:, 0]
peaks, _ = find_peaks(data, distance=int(1./dts))
r, c = np.argmin(np.abs(ei_ratio - j_ee/j_ii)), np.argmin(np.abs(io_ratio - j_ee/j_ie))
if len(peaks) > 0:
max_freq[r, c] = T/len(peaks)
freq_pow[r, c] = np.mean(data[peaks])
cm1 = cubehelix_palette(n_colors=int(len(ei_ratio)*len(io_ratio)), as_cmap=True, start=2.5, rot=-0.1)
cm2 = cubehelix_palette(n_colors=int(len(ei_ratio)*len(io_ratio)), as_cmap=True, start=-2.0, rot=-0.1)
def eval_fitness(self, target: list, **kwargs):
# define simulation conditions
param_grid = self.pop.drop(['fitness', 'sigma', 'results'], axis=1)
results = []
models_vars = [
'k_ie', 'k_ii', 'k_ei', 'k_ee', 'eta_e', 'eta_i', 'eta_str',
'eta_tha', 'alpha', 'delta_e', 'delta_i'
]
freq_targets = [0.0, 0.0, 0.0, 0.0, 60.0, 0.0, 13.0]
param_grid, invalid_params = eval_params(param_grid)
zero_vec = [0.0 for _ in range(param_grid.shape[0])]
conditions = [
{}, # healthy control
{
'k_ie': zero_vec
}, # STN blockade
{
'k_ii': zero_vec,
'eta_str': zero_vec
}, # GABAA blockade in GPe
{
'k_ie': zero_vec,
'k_ii': zero_vec,
'eta_str': zero_vec
}, # STN blockade and GABAA blockade in GPe
{
'k_ie': zero_vec,
'eta_tha': zero_vec
}, # AMPA + NMDA blocker in GPe
{
'k_ei': zero_vec
}, # GABAA antagonist in STN
{
'k_ei': param_grid['k_ei'] + param_grid['k_ei_pd'],
'k_ie': param_grid['k_ie'] + param_grid['k_ie_pd'],
'k_ee': param_grid['k_ee'] + param_grid['k_ee_pd'],
'k_ii': param_grid['k_ii'] + param_grid['k_ii_pd'],
'eta_e': param_grid['eta_e'] + param_grid['eta_e_pd'],
'eta_i': param_grid['eta_i'] + param_grid['eta_i_pd'],
'eta_str': param_grid['eta_str'] + param_grid['eta_str_pd'],
'eta_tha': param_grid['eta_tha'] + param_grid['eta_tha_pd'],
'delta_e': param_grid['delta_e'] + param_grid['delta_e_pd'],
'delta_i': param_grid['delta_i'] + param_grid['delta_i_pd'],
} # parkinsonian condition
]
# perform simulations
if len(param_grid) > 0:
for c_dict in conditions:
param_grid_tmp = {key: param_grid[key]
for key in models_vars}.copy()
param_grid_tmp.update(DataFrame(c_dict,
index=param_grid.index))
r = grid_search(
circuit_template=self.gs_config['circuit_template'],
param_grid=param_grid_tmp,
param_map=self.gs_config['param_map'],
simulation_time=self.gs_config['simulation_time'],
step_size=self.gs_config['step_size'],
sampling_step_size=self.gs_config['sampling_step_size'],
permute_grid=False,
inputs=self.gs_config['inputs'],
outputs=self.gs_config['outputs'].copy(),
init_kwargs=self.gs_config['init_kwargs'],
**kwargs)[0]
r.index = r.index * 1e-3
r = r * 1e3
results.append(r)
# calculate fitness
for gene_id in param_grid.index:
outputs, freq, pow = [], [], []
for i, r in enumerate(results):
outputs.append([
np.mean(r['r_e'][f'circuit_{gene_id}'].loc[0.1:]),
np.mean(r['r_i'][f'circuit_{gene_id}'].loc[0.1:])
])
tmin = 0.0 if i == 4 else 0.1
psds, freqs = welch(r['r_i'][f'circuit_{gene_id}'],
tmin=tmin,
fmin=5.0,
fmax=100.0)
freq.append(freqs)
pow.append(psds[0, :])
dist1 = self.fitness_measure(outputs, target,
**self.fitness_kwargs)
dist2 = analyze_oscillations(freq_targets, freq, pow)
self.pop.at[gene_id, 'fitness'] = 1.0 / (dist1 + dist2)
self.pop.at[gene_id, 'results'] = outputs
# set fitness of invalid parametrizations
for gene_id in invalid_params.index:
self.pop.at[gene_id, 'fitness'] = 0.0
k_l3l5_e[n] = C * r1 * r2
k_l3l5_i[n] = C * r2
n += 1
params = {'k_l3l5_e': k_l3l5_e, 'k_l3l5_i': k_l3l5_i, 'k_l5l3_i': k_l5l3_i}
param_map = {'k_l3l5_e': {'var': [(None, 'weight')],
'edges': [('L3/PC.0', 'L5/PC.0', 0)]},
'k_l3l5_i': {'var': [(None, 'weight')],
'edges': [('L3/PC.0', 'L5/IIN.0', 0)]},
'k_l5l3_i': {'var': [(None, 'weight')],
'edges': [('L5/PC.0', 'L3/IIN.0', 0)]},
}
# perform simulation
results = grid_search(circuit_template="../config/cmc_templates.CMC",
param_grid=params, param_map=param_map,
inputs={("L3/PC.0", "Op_e.0", "i_in"): inp}, outputs={"r": ("L3/PC.0", "Op_e.0", "r")},
dt=dt, simulation_time=T, permute_grid=False, sampling_step_size=1e-3)
# plotting
cut_off = 1.
max_freq = np.zeros((len(ei_ratio), len(l3l5_ratio)))
freq_pow = np.zeros_like(max_freq)
for k1, k2, k3 in zip(params['k_l3l5_e'], params['k_l3l5_i'], params['k_l5l3_i']):
if not results[k1][k2][k3].isnull().any().any():
_ = plot_psd(results[k1][k2][k3], tmin=cut_off, show=False)
pow = plt.gca().get_lines()[-1].get_ydata()
freqs = plt.gca().get_lines()[-1].get_xdata()
r, c = np.argmin(np.abs(ei_ratio - k1/k2)), np.argmin(np.abs(l3l5_ratio - k2/k3))
max_freq[r, c] = freqs[np.argmax(pow)]
freq_pow[r, c] = np.max(pow)
plt.close(plt.gcf())
'k': [1.6, 1.8, 2.0, 2.2],
'eta_str': [-50.0, -100.0],
}
# define simulation parameters
dt = 1e-2
T = 21000.0
dts = 1e-1
# perform simulation
results, result_map = grid_search(circuit_template="config/stn_gpe/net_stn_gpe",
param_grid=param_grid,
param_map=param_map,
simulation_time=T,
step_size=dt,
sampling_step_size=dts,
permute_grid=True,
inputs={},
outputs={'Ie': 'stn_gpe/qif_full/I_ee',
'Ii': 'stn_gpe/qif_full/I_ei'},
init_kwargs={'backend': 'numpy', 'solver': 'scipy', 'step_size': dt},
)
results = results * 1e3
#fig = plt.figure(figsize=(12, 10), tight_layout=True)
#grid = gs.GridSpec(6, 2)
#results.plot()
# codim 1
# for i, k in enumerate(param_grid['k']):
# r, c = i % 6, i // 6
# ax_tmp = fig.add_subplot(grid[r, c])
# idx = result_map.index[result_map.loc[:, 'k'] == k]
