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]