def simulate_filtering_fun(freq, params_msn_d1, params_msn_d2, params_stn,
synapse_models, sim_time, seed, I_e_add, threads,
start_rec, model_params):
mean = []
for f, se in zip(freq, seed):
params_msn_d1.update({'base_rates': [f]})
params_msn_d2.update({'focus': False, 'skip': 1})
layer_dic = simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=sim_time,
seed=se,
I_e_add=I_e_add,
threads=threads,
start_rec=start_rec,
model_params=model_params)
layer_dic['SNR'].get_signal('s', start=start_rec, stop=sim_time)
signal = layer_dic['SNR'].signals['spikes']
spk_mean = numpy.mean(signal.spike_histogram(time_bin=1,
normalized=True),
axis=0)
mean.append(numpy.mean(spk_mean))
return mean
def simulate_1500(params_msn_d1, params_msn_d2, params_stn, synapse_models,
sim_time, seed, I_e_add, threads, start_rec):
N_MSN = 1500
model_params = {
'misc': {
'N_MSN': N_MSN
},
'conns': {
'MSN_D2_GPE': {
'lines': False
},
'GPE_STN': {
'lesion': False
}
},
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
},
'MSN_D1_bg': {
'n': 0
},
'MSN_D2_bg': {
'n': 0
},
'GPE': {
'paused': False
}
}
}
layer_dic = simulate_network(params_msn_d1, params_msn_d2, params_stn,
synapse_models, sim_time, seed, I_e_add,
threads, start_rec, model_params)
mr = []
signal = layer_dic['SNR'].signals['spikes']
m_hist = numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0)
mr.append(numpy.mean(m_hist, axis=0))
signal = layer_dic['GPE'].signals['spikes']
m_hist = numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0)
mr.append(numpy.mean(m_hist, axis=0))
signal = layer_dic['STN'].signals['spikes']
m_hist = numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0)
mr.append(numpy.mean(m_hist, axis=0))
return layer_dic, mr
def simulate(load,
save_at,
n_exp,
res,
params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time,
seed,
start_rec,
I_e_add,
threads,
model_params,
dis_conn_GPE_STN=False):
if not load:
r = []
for i in range(n_exp):
seed = i
p = numpy.random.randint(1)
start_rec += p
sim_time += p
layer_dic = simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time,
seed,
I_e_add,
threads,
start_rec,
model_params,
dis_conn_GPE_STN=dis_conn_GPE_STN)
layer_dic['SNR'].get_signal('s', start=start_rec, stop=sim_time)
signal = layer_dic['SNR'].signals['spikes']
r.append(
numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0))
numpy.array(r)
misc.pickle_save(r, save_at)
else:
r = misc.pickle_load(save_at)
r = numpy.array(r)
r = misc.convolve(r, res, 'triangle', single=False)
mr = numpy.mean(r, axis=0)
mstd = numpy.std(r, axis=0)
d = [mr, mstd]
return d
def simulate_filterting_burst_fun(mod,
freq,
base_rates,
params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=2000.,
seed=1,
I_e_add={},
threads=4,
start_rec=0,
model_params={}):
mr = []
for f, m, se, br in zip(freq, mod, seed, base_rates):
params_msn_d1.update({
'mod_rates': [0.1, f, 0.1],
'mod_times': [1, 1000, 1000 + 500],
'n_mod': int(m)
})
params_msn_d1.update({
'base_rates': [0.1, br, 0.1],
'base_times': [1, 1000, 1000 + 500]
})
params_msn_d2.update({'focus': False, 'skip': 1})
layer_dic = simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=sim_time,
seed=se,
I_e_add=I_e_add,
threads=4,
start_rec=start_rec,
model_params=model_params)
layer_dic['SNR'].get_signal('s', start=start_rec, stop=sim_time)
signal = layer_dic['SNR'].signals['spikes']
mr.append(
numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0))
return numpy.array(mr)
#synapse_models=['MSN_SNR_gaba_p1', 'GPE_SNR_gaba_p_stoc']
synapse_models_mod = ['MSN_SNR_gaba_p1']
save_result_at = OUTPUT_PATH + '/simulate_network_example_robust_pause.plk'
if 0:
layer_dics = []
for model, seed in zip(synapse_models_mod, [1]):
synapse_models = [model, 'GPE_SNR_gaba_p']
layer_dics.append(
simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=sim_time,
seed=seed,
I_e_add={
'SNR': 300,
'STN': 0,
'GPE': 30
},
threads=4,
start_rec=500.))
misc.pickle_save(layer_dics, save_result_at)
else:
layer_dics = misc.pickle_load(save_result_at)
params_msn_d1 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [0.1, 20, 0.1, 20, 0.1],
'mod_times': [1, 1000, 1000 + 500],
def simulate_non_diffuse(load, save_at, n_exp, mod, skip, res=100):
#synapse_models=['MSN_SNR_gaba_p1', 'GPE_SNR_gaba_p_stoc']
synapse_models_mod = ['GPE_SNR_gaba_s_ref', 'GPE_SNR_gaba_p']
model_params = {
'misc': {
'N_MSN': N_MSN
},
'conns': {
'MSN_D2_GPE': {
'lines': True
}
},
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
}
}
}
params_msn_d2 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [0.1, 20.0, 0.1],
'mod_times': [1, 1500, 1500 + 500],
'n_mod': mod,
'focus': False,
'skip': skip
}
if not load:
d = {}
for model, seed in zip(synapse_models_mod, [1, 1]):
synapse_models = ['MSN_SNR_gaba_p1', model]
spk_mean = []
for i in range(n_exp):
seed = i
layer_dic = simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=sim_time,
seed=seed,
I_e_add={},
threads=4,
start_rec=start_rec,
model_params=model_params)
signal = layer_dic['SNR'].signals['spikes']
spk_mean.append(
numpy.mean(signal.spike_histogram(time_bin=1,
normalized=True),
axis=0))
signal = layer_dic['GPE'].signals['spikes']
hist = signal.spike_histogram(time_bin=1, normalized=True)
spk_mean.append(numpy.mean(hist, axis=0))
down, up = [], []
for i in range(hist.shape[0]):
if numpy.mean(hist[i, 1000:1500]) < numpy.mean(
hist[i, 0:1000]):
down.append(hist[i, :])
else:
up.append(hist[i, :])
spk_mean.append(numpy.mean(numpy.array(down), axis=0))
spk_mean.append(numpy.mean(numpy.array(up), axis=0))
d[model] = spk_mean
misc.pickle_save(d, save_at)
else:
d = misc.pickle_load(save_at)
d_SNR, d_GPE = [], []
for r in d.values():
r = numpy.array(r)
r = misc.convolve(r, res, 'triangle', single=False)
d_SNR.append(
[numpy.mean(r[0::4, :], axis=0),
numpy.std(r[0::4, :], axis=0)]) # SNR
d_GPE.append(
[numpy.mean(r[1::4, :], axis=0),
numpy.std(r[1::4, :], axis=0)]) # GPE
d_GPE.append(
[numpy.mean(r[2::4, :], axis=0),
numpy.std(r[2::4, :], axis=0)]) # GPE down
d_GPE.append(
[numpy.mean(r[3::4, :], axis=0),
numpy.std(r[3::4, :], axis=0)]) # GPE up
return d, d_SNR, d_GPE
'mod_times': [1, 2000, 2000 + 500],
'n_mod': mod1,
'focus': False,
'skip': 1
}
save_result_at = OUTPUT_PATH + '/simulate_network_example_indirect' + str(
N_MSN) + '.plk'
if 0:
synapse_models = ['MSN_SNR_gaba_p1', 'GPE_SNR_gaba_p']
layer = simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=sim_time,
seed=1,
I_e_add={},
threads=4,
start_rec=1500.,
model_params=model_params)
misc.pickle_save(layer, save_result_at)
else:
layer = misc.pickle_load(save_result_at)
#Inspect results
plot_settings.set_mode(pylab,
mode='by_fontsize',
w=1100.0,
h=450.0 + 275.0,
fontsize=16)
font_size_text = 14
def simluate(load, save_at, n_exp, synapse_models_mod, mod, res=100.):
model_params = {
'misc': {
'N_MSN': N_MSN
},
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
}
}
}
params_msn_d1 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [0.1, 20, 0.1],
'mod_times': [1, 1500, 1500 + 500],
'n_mod': mod
}
if not load:
d = {}
for model in synapse_models_mod:
synapse_models = [model, 'GPE_SNR_gaba_p']
spk_mean = []
for i in range(n_exp):
seed = i
layer_dic = simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=sim_time,
seed=seed,
I_e_add={},
threads=4,
start_rec=start_rec,
model_params=model_params)
layer_dic['SNR'].get_signal('s',
start=start_rec,
stop=sim_time)
signal = layer_dic['SNR'].signals['spikes']
spk_mean.append(
numpy.mean(signal.spike_histogram(time_bin=1,
normalized=True),
axis=0))
d[model] = spk_mean
misc.pickle_save(d, save_at)
else:
d = misc.pickle_load(save_at)
d_SNR, d_GPE = [], []
for r in d.values():
r = numpy.array(r)
r = misc.convolve(r, res, 'triangle', single=False)
d_SNR.append(
[numpy.mean(r[0::1, :], axis=0),
numpy.std(r[0::1, :], axis=0)]) # SNR
return d, d_SNR
def simulate_filtering(load,
save_at,
interval,
syn_STN,
params_msn_d1,
params_msn_d2,
params_stn,
synapse_model,
sim_time=2000.,
seed=1,
threads=4,
start_rec=0):
freq_filter = numpy.linspace(0.1, 4.0, 15)
paused = numpy.zeros(len(freq_filter))
seed = range(len(freq_filter))
model_params = {
'misc': {
'N_MSN': N_MSN
},
'conns': {
'MSN_D2_GPE': {
'lines': False
},
'STN_SNR': {
'syn': syn_STN
}
},
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
},
'GPE': {
'paused': 0
}
}
}
if not load:
mr = []
for f, pa, se in zip(freq_filter, paused, seed):
params_msn_d2.update({'base_rates': [f]})
params_msn_d2.update({'focus': False, 'skip': 1})
model_params['neurons']['GPE']['paused'] = pa
layer_dic = simulate_network(params_msn_d1,
params_msn_d2,
params_stn,
synapse_models,
sim_time=sim_time,
seed=se,
I_e_add={},
threads=threads,
start_rec=start_rec,
model_params=model_params)
signal = layer_dic['SNR'].signals['spikes']
spk_mean = numpy.mean(signal.spike_histogram(time_bin=1,
normalized=True),
axis=0)
mr.append(numpy.mean(spk_mean[interval[0]:interval[1]]))
signal = layer_dic['GPE'].signals['spikes']
spk_mean = numpy.mean(signal.spike_histogram(time_bin=1,
normalized=True),
axis=0)
mr.append(numpy.mean(spk_mean[interval[0]:interval[1]]))
signal = layer_dic['STN'].signals['spikes']
spk_mean = numpy.mean(signal.spike_histogram(time_bin=1,
normalized=True),
axis=0)
mr.append(numpy.mean(spk_mean[interval[0]:interval[1]]))
mr = numpy.array(mr)
misc.pickle_save(mr, save_at)
else:
mr = misc.pickle_load(save_at)
mr_SNR = mr[0::3]
mr_GPE = mr[1::3]
mr_STN = mr[2::3]
d = numpy.array([freq_filter, mr_SNR, mr_GPE, mr_STN])
return d
def simulate_filtering(load, save_at, interval, syn_STN, freq, params_msn_d1,
params_msn_d2, params_stn, synapse_models, sim_time,
threads, start_rec, N_MSN):
mr = []
seed = range(len(freq))
model_params = {
'misc': {
'N_MSN': N_MSN
},
'conns': {
'MSN_D2_GPE': {
'lines': False
},
'STN_SNR': {
'syn': syn_STN
}
},
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
},
'GPE': {
'paused': 0
}
}
}
if not load:
for f, se in zip(freq, seed):
params_stn.update({
'rate': 250.,
'mod': True,
'mod_rate': f,
'mod_times': [1., sim_time]
})
layer_dic = simulate_network(params_msn_d1, params_msn_d2,
params_stn, synapse_models, sim_time,
seed, {}, threads, start_rec,
model_params)
signal = layer_dic['SNR'].signals['spikes']
r = numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0)
mr.append(numpy.mean(r[interval[0]:interval[1]]))
signal = layer_dic['GPE'].signals['spikes']
r = numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0)
mr.append(numpy.mean(r[interval[0]:interval[1]]))
signal = layer_dic['STN'].signals['spikes']
r = numpy.mean(signal.spike_histogram(time_bin=1, normalized=True),
axis=0)
mr.append(numpy.mean(r[interval[0]:interval[1]]))
mr = numpy.array(mr)
misc.pickle_save(mr, save_at)
else:
mr = misc.pickle_load(save_at)
mr_SNR = mr[0::3]
mr_GPE = mr[1::3]
mr_STN = mr[2::3]
d = numpy.array([freq, mr_SNR, mr_GPE, mr_STN])
return d
