def plot_example_firing_rate(ax, layer, name, color='b', ylim=[]):
time_bin = 20
signal = layer.signals['spikes']
#signal.my_firing_rate(bin=time_bin, display=ax,
# kwargs={'color':color})
print name, 'CV:', numpy.mean(signal.cv_isi())
print name, 'mean:', signal.mean_rate()
print name, 'std:', signal.mean_rate_std()
hist = signal.spike_histogram(time_bin=1, normalized=True)
spk_mean = numpy.mean(hist, axis=0)
spk_mean = misc.convolve(spk_mean, 100, 'triangle', single=True)[0]
print spk_mean.shape
time = numpy.arange(1, len(spk_mean) + 1)
ax.plot(time, spk_mean)
if layer.id_mod:
print numpy.array(layer.id_mod) - layer.ids[0] - 1
spk_mean = numpy.mean(hist[numpy.array(layer.id_mod) -
layer.ids[0], :],
axis=0)
spk_mean = misc.convolve(spk_mean, 100, 'triangle', single=True)[0]
print spk_mean.shape
time = numpy.arange(1, len(spk_mean) + 1)
ax.plot(time, spk_mean, 'r')
ax.set_ylabel('Firing rate ' + name + ' (spikes/s)')
ax.set_xlabel('Time (ms)')
ax.my_set_no_ticks(yticks=6, xticks=8)
ax.set_ylim(ylim)
def plot_example_firing_rate_MSN(ax, layer, name, color='b', ylim=[]):
time_bin = 20
signal = layer.signals['spikes']
#signal.my_firing_rate(bin=time_bin, display=ax,
# kwargs={'color':color})
print name, 'CV:', numpy.mean(signal.cv_isi())
print name, 'mean:', signal.mean_rate()
print name, 'std:', signal.mean_rate_std()
hist = signal.spike_histogram(time_bin=1, normalized=True)
spk_mean = numpy.mean(hist, axis=0)
spk_mean = misc.convolve(spk_mean, 100, 'triangle', single=True)[0]
print spk_mean.shape
time = numpy.arange(1, len(spk_mean) + 1)
ax.plot(time, spk_mean)
shift = 0
if layer.id_mod:
print numpy.array(layer.id_mod) - layer.ids[0] - 1
spk_mean = numpy.mean(
hist[numpy.array(layer.id_mod) - layer.ids[0], :] - shift, axis=0)
spk_mean = misc.convolve(spk_mean, 50, 'triangle', single=True)[0]
print spk_mean.shape
time = numpy.arange(1, len(spk_mean) + 1)
ax.plot(time, spk_mean, 'r')
pylab.setp(ax.lines,
linewidth=2.0) # Need to pu ti before generating legend
ax.set_ylabel('Rate ' + name + ' (spikes/s)')
ax.set_xlabel('Time (ms)')
ax.my_set_no_ticks(yticks=6, xticks=5)
ax.set_xlim(misc.adjust_limit([0, 1500]))
ax.set_ylim(misc.adjust_limit(ylim))
ax.text(0.05,
0.65,
'Bursting \n$MSN_{D1}$',
backgroundcolor='w',
transform=ax.transAxes,
fontsize=font_size_text,
**{'color': 'r'})
ax.text(0.05,
0.85,
'Average \nover all',
backgroundcolor='w',
transform=ax.transAxes,
fontsize=font_size_text,
**{'color': 'b'})
for line in ax.lines:
line.set_xdata(line.get_xdata() - 500)
def plot_example_3x_freq(ax, times, spk_mean, hzs=[10, 20, 40]):
spk_mean = spk_mean
colors = misc.make_N_colors('YlOrBr', 5)[2:]
labels = ['%i Hz' % hzs[0], '%i Hz' % hzs[1], '%i Hz' % hzs[2]]
coords = [[0.4, 0.52], [0.05, 0.22], [0.1, 0.74]]
for i, col in enumerate(colors):
ax.plot(times,
misc.convolve(spk_mean[i, :], 50, 'triangle', single=True)[0],
color=col)
#ax.plot(times, spk_mean[i,:], col)
lines = ax.lines
for line in lines:
line.set_xdata(line.get_xdata() - ADJUST_XDATA_MS)
misc.slice_line(line, xlim=[0, 1490])
#ax.set_ylim([0,40])
for label, coord, color in zip(labels, coords, colors):
ax.text(coord[0],
coord[1],
label,
transform=ax.transAxes,
fontsize=font_size_text,
**{'color': color})
ax.set_ylabel('Rate SNr (spikes/s)')
ax.set_xlabel('Time (ms)')
ax.my_set_no_ticks(yticks=6, xticks=8)
ax.set_xlim(misc.adjust_limit([0, 1500]))
ax.set_ylim(misc.adjust_limit([0, 40]))
def plot_example_firing_rate(ax, groups, name, color='b', ylim=[], ylabel=True, xlabel=False):
time_bin=20
colors=misc.make_N_colors('gist_rainbow', len(groups))
#signal.my_firing_rate(bin=time_bin, display=ax,
# kwargs={'color':color})
for group, col in zip(groups, colors):
signal=group.signals['spikes']
print name, 'CV:', numpy.mean(signal.cv_isi())
print name, 'mean:', signal.mean_rate()
print name, 'std:', signal.mean_rate_std()
hist=signal.spike_histogram(time_bin=1, normalized=True)
spk_mean=numpy.mean(hist, axis=0)
spk_mean=misc.convolve(spk_mean, 100, 'triangle',single=True)[0]
print spk_mean.shape
time=numpy.arange(1,len(spk_mean)+1)
ax.plot(time,spk_mean, **{'color':col})
ax.set_ylabel('Firing rate '+name+'\n (spikes/s)', fontsize=12.,multialignment='center')
ax.set_xlabel('Time (ms)')
ax.my_set_no_ticks( yticks=6, xticks = 8 )
ax.set_ylim(ylim)
ax.set_xlim([time[0],time[-1]])
ax.my_remove_axis( xaxis=not xlabel, yaxis=not ylabel )
def conv_data(raw_r,
conv_r,
mean_conv_r,
std_conv_r,
bin=100,
kernel='rectangle'):
conv_r.append(misc.convolve(raw_r[-1], bin, kernel, single=False))
mean_conv_r.append(numpy.mean(conv_r[-1], axis=0))
std_conv_r.append(numpy.std(conv_r[-1], axis=0))
return conv_r, mean_conv_r, std_conv_r
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 plot_example_snr(ax, SNR):
time_bin = 20
signal = SNR.signals['spikes']
colors = ['k']
sim_time = 2500
hist = signal.spike_histogram(time_bin=1, normalized=True)
spk_mean = numpy.mean(hist, axis=0)
spk_mean = misc.convolve(spk_mean, 100, 'triangle', single=True)[0]
time = numpy.arange(1, len(spk_mean) + 1)
ax.plot(time, spk_mean, 'k')
ax.my_set_no_ticks(yticks=6, xticks=7)
lines = ax.lines
lines = ax.lines
for line in lines:
misc.slice_line(line, xlim=[50, 2450])
ax.plot([0, sim_time], [SELECTION_THR] * len([0, sim_time]), **{
'color': [0.6, 0.6, 0.6],
'label': '',
'linewidth': 1,
'linestyle': '--'
})
ax.text(0.9,
0.14,
'Thr',
transform=ax.transAxes,
**{'color': [0.6, 0.6, 0.6]})
misc.slice_line(lines[0], xlim=[0, sim_time])
ax.plot([1000, 1500], [39, 39], color='k', marker='|')
ax.text(0.47, 0.84, 'stop', transform=ax.transAxes, **{'color': 'k'})
ax.plot([500, 700], [30, 30], color='k', marker='|')
ax.text(0.23, 0.67, '1st', transform=ax.transAxes, **{'color': 'k'})
ax.plot([1500, 1700], [30, 30], color='k', marker='|')
ax.text(0.60, 0.67, '2nd', transform=ax.transAxes, **{'color': 'k'})
ax.set_xlim(misc.adjust_limit([0, sim_time]))
ax.set_ylim(misc.adjust_limit([0, 45]))
ax.set_ylabel('Firing rate SNr (spikes/s)')
def plot_example_firing_rate(ax, spk, name, color=['b', 'g', 'r'], ylim=[]):
for col, sp in zip(color, spk):
time = numpy.arange(1, len(sp) + 1)
sp = misc.convolve(sp, 100, 'triangle', single=True)[0]
ax.plot(time, sp, **{'color': col})
#spk_rate=misc.convolve(spk_mean[i,:], 50, 'triangle',single=True)[0]
#plot()
#meanRate=round(layer.signals['spikes'].mean_rate(1000,sim_time),1)
#spk=SNR.signals['spikes'].time_slice(1000,sim_time).raw_data()
#CV=numpy.std(numpy.diff(spk[:,0],axis=0))/numpy.mean(numpy.diff(spk[:,0],axis=0))
ax.set_ylabel('Firing rate ' + name + ' (spikes/s)')
ax.set_xlabel('Time (ms)')
ax.my_set_no_ticks(yticks=6, xticks=8)
ax.set_ylim(ylim)
def simulate_direct_vs_indirect(load,
N_MSN,
burst_rate,
save_at,
threads,
resolution=10,
flag_bg=False):
params_msn_d1 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [0.1, burst_rate, 0.1],
'mod_times': [1, 1000, 1000 + 500],
'n_mod': 0,
'bg_rate': 0
}
params_msn_d2 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [0.1, burst_rate, 0.1],
'mod_times': [1, 1000, 1000 + 500],
'n_mod': 0,
'focus': False,
'skip': 1,
'bg_rate': 0
}
params_stn = {
'rate': 250.,
'mod': False,
'mod_rate': 0.,
'mod_times': [1000., 1000. + 500.]
}
model_params = {
'conns': {
'MSN_D2_GPE': {
'lines': False
}
},
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
}
}
}
synapse_models = ['MSN_SNR_gaba_p1', 'GPE_SNR_gaba_p']
if flag_bg: save_at = save_at + '_bg'
sim_time = 2000.
n_exp = 2
proportions_d1 = numpy.linspace(0.01, 0.15,
resolution) #arange(1,7,1)*150.
proportions_d2 = numpy.linspace(0.01, 0.15,
resolution) #arange(1,7,1)*150.
mods_d1 = proportions_d1 * N_MSN
mods_d2 = proportions_d2 * N_MSN
raw_r = []
conv_r = []
mean_conv_r = []
std_conv_r = []
inputs = []
i = 0
if not load:
for m_d1 in mods_d1:
for m_d2 in mods_d2:
tmp_rates = []
for e in range(n_exp):
seed = i
rates_SNR, rates_GPE = simulate_network_direct_indirect_onoff_vs_rate(
m_d1,
m_d1,
params_msn_d1,
params_msn_d2,
params_stn,
synapse_models, {
'SNR': 280,
'STN': 0,
'GPE': 20
},
sim_time=sim_time,
seed=seed,
threads=threads,
start_rec=500.,
model_params=model_params,
flag_bg=flag_bg)
tmp_rates.append(list(rates_SNR))
i += 1
raw_r.append(numpy.array(tmp_rates))
conv_r.append(
misc.convolve(raw_r[-1], 100, 'rectangle', single=False))
mean_conv_r.append(numpy.mean(conv_r[-1], axis=0))
std_conv_r.append(numpy.std(conv_r[-1], axis=0))
inputs.append((m_d1, m_d2))
misc.pickle_save(
[raw_r, conv_r, mean_conv_r, std_conv_r, inputs], save_at)
else:
raw_r, conv_r, mean_conv_r, std_conv_r, inputs = misc.pickle_load(
save_at)
data, data_split, slopes = get_data_and_slopes(inputs, mean_conv_r,
std_conv_r, resolution,
N_MSN)
return data, data_split, slopes, burst_rate, proportions_d1, proportions_d2
def simulate_indirect(load,
N_MSN,
save_at,
threads,
resolution=10,
max_prop=1.1,
flag_bg=False,
skip=1,
lines=False):
params_msn_d1 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [],
'mod_times': [],
'n_mod': 0,
'bg_rate': 0
}
params_msn_d2 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [],
'mod_times': [],
'n_mod': 0,
'focus': False,
'skip': skip,
'bg_rate': 0
}
params_stn = {
'rate': 250.,
'mod': False,
'mod_rate': 0.,
'mod_times': [1000., 1000. + 500.]
}
synapse_models = ['MSN_SNR_gaba_p1', 'GPE_SNR_gaba_p']
model_params = {
'misc': {
'N_MSN': N_MSN
},
'conns': {
'MSN_D2_GPE': {
'lines': lines
}
},
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
}
}
}
if flag_bg: save_at = save_at + '_bg'
sim_time = 2000.
n_exp = 5
burst_rate = numpy.linspace(15, 50, resolution)
proportions = numpy.linspace(0.01, max_prop,
resolution) #arange(1,7,1)*150.
mods = proportions * N_MSN
raw_r, conv_r, mean_conv_r, std_conv_r, inputs = [], [], [], [], []
i = 0
if not load:
for m in mods:
for r in burst_rate:
tmp_rates = []
for e in range(n_exp):
seed = i
rates_SNR, rates_GPE = simulate_indirect_fun(
m,
r,
params_msn_d1,
params_msn_d2,
params_stn,
synapse_models, {
'SNR': 280,
'STN': 0,
'GPE': 20
},
sim_time=sim_time,
seed=seed,
threads=threads,
start_rec=500.,
model_params=model_params,
flag_bg=flag_bg,
max_mod=max(mods))
tmp_rates.append(list(rates_SNR))
i += 1
raw_r.append(numpy.array(tmp_rates))
conv_r.append(
misc.convolve(raw_r[-1], 100, 'rectangle', single=False))
mean_conv_r.append(numpy.mean(conv_r[-1], axis=0))
std_conv_r.append(numpy.std(conv_r[-1], axis=0))
inputs.append((m, r))
misc.pickle_save(
[raw_r, conv_r, mean_conv_r, std_conv_r, inputs], save_at)
else:
raw_r, conv_r, mean_conv_r, std_conv_r, inputs = misc.pickle_load(
save_at)
data, data_split, slopes = get_data_and_slopes(inputs, mean_conv_r,
std_conv_r, resolution,
N_MSN)
return data, data_split, slopes, burst_rate, proportions
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
save_result_at = OUTPUT_PATH + '/main_mutual_information_prob.pkl'
if RUN is False:
c_prob = []
c_sum = []
for i in sorted(list(count_dic.keys())):
c_prob.append([])
c_sum.append([])
for j, hz in enumerate(sorted(list(count_dic[i].keys()))):
c_prob[i].append([])
c_sum[i].append([])
for N in sorted(list(count_dic[i][hz].keys())):
c = count_dic[i][hz][N][2::3, :] # Pick out results for SNr
c_conv = misc.convolve(c,
bin_extent=100,
kernel_type='rectangle')
c_prob[i][j].append(
numpy.sum(c_conv < 1, axis=0) / float(c_conv.shape[0]))
c_sum[i][j].append(numpy.sum(c, axis=0))
c_prob = numpy.array(c_prob)
c_sum = numpy.array(c_sum)
misc.pickle_save([c_prob, c_sum, time], save_result_at)
else:
c_prob, c_sum, time = misc.pickle_load(save_result_at)
from numpy import *
import pylab as p
#import matplotlib.axes3d as p3
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_hyperdirect(load,
N_MSN,
save_at,
type,
burst_time,
burst_rate,
n_exp,
res,
threads,
stn_syn='STN_SNR_ampa_s',
gpe_syn='GPE_SNR_gaba_p',
flag_bg=False):
ra = random.random() * 200.
start_rec = 950 + ra #Hundred ms before burst
delay = 10.0
params_msn_d1 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [],
'mod_times': [],
'n_mod': 0.,
'bg_rate': 0
}
params_msn_d2 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [],
'mod_times': [],
'n_mod': 0,
'focus': False,
'skip': 1,
'bg_rate': 0
}
params_stn = {
'rate': 219.,
'mod': True,
'mod_rate': burst_rate,
'mod_times': [1000. + ra, 1000. + ra + burst_time]
}
synapse_models = ['MSN_SNR_gaba_p1', gpe_syn]
model_params = {
'misc': {
'N_MSN': N_MSN
},
'conns': {
'MSN_D2_GPE': {
'lines': False
},
'STN_SNR': {
'syn': stn_syn
}
},
'neurons': {
'MSN_D1': {
'n': 0
},
'MSN_D2': {
'n': 0
}
}
}
if type == 'normal':
pass
if type == 'no STN-GPE':
model_params['conns'] = {'STN_GPE': {'lesion': True}}
if type == 'no GPE-STN':
model_params['conns'] = {'GPE_STN': {'lesion': True}}
if type == 'no STN-SNR':
model_params['conns'] = {'STN_SNR': {'lesion': True}}
if type == 'no GPE-SNR':
model_params['conns'] = {'GPE_SNR': {'lesion': True}}
if flag_bg: save_at = save_at + '_bg'
sim_time = 1300. + burst_time
raw_r = []
conv_r = []
mean_conv_r = []
std_conv_r = []
inputs = []
i = 0
if not load:
mr = []
for i in range(n_exp):
seed = i
mr_tmp = simulate_hyperdirect_fun(params_msn_d1, params_msn_d2,
params_stn, synapse_models, {},
sim_time, seed, threads,
start_rec, model_params, flag_bg)
mr.append(mr_tmp)
misc.pickle_save(mr, save_at)
else:
mr = misc.pickle_load(save_at)
r_new = [[], [], []]
for r in mr:
r = numpy.array(r)
for i in range(3):
r_new[i].append(r[i::4, :]) #
mr_new = []
std_new = []
for r in r_new:
r = numpy.array(r)
r = misc.convolve(r[:, 0, :], res, 'triangle', single=False)
mr_new.append(numpy.mean(r, axis=0))
std_new.append(numpy.std(r, axis=0))
#print mr_new
return mr_new, std_new
synapse_models = {
'MSN': 'MSN_SNR_gaba_p1',
'GPE': 'GPE_SNR_gaba_p',
'STN': 'STN_SNR_ampa_s'
}
#times, spk_binned =_simulate_model([params_msn, params_gpe,params_gpe, 'SNR_izh',
# synapse_models, sim_time, 0])
t = ttime.time()
times, spk_binned = simulate_model(params_msn,
params_gpe,
params_stn,
'SNR_izh',
synapse_models,
sim_time,
n_exp=n_exp,
threads=4)
print 'Time:', ttime.time() - t
spk_mean = numpy.sum(spk_binned, axis=0)
#spk_std=numpy.std(spk_binned,axis=0)
#pylab.plot(times, spk_mean*1000/n_exp)
pylab.plot(
times,
misc.convolve(spk_mean, 50, 'triangle', single=True)[0] * 1000 / n_exp,
col)
pylab.ylim([0, 40])
pylab.show()
def simulate_direct(load, N_MSN, save_at, threads, points=[550, 650, 950]):
params_msn_d1 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [0.1, 20, 0.1],
'mod_times': [1, 1000, 1000 + 500],
'n_mod': 0
}
params_msn_d2 = {
'base_rates': [0.1],
'base_times': [1],
'mod_rates': [0.1, 20, 0.1],
'mod_times': [1, 1000, 1000 + 500],
'n_mod': 0,
'focus': False,
'skip': 1
}
params_stn = {
'rate': 300.,
'mod': False,
'mod_rate': 0.,
'mod_times': [1000., 1000. + 500.]
}
model_params = {
'neurons': {
'MSN_D1': {
'n': N_MSN
},
'MSN_D2': {
'n': N_MSN
}
}
}
synapse_models = ['MSN_SNR_gaba_p1', 'GPE_SNR_gaba_p']
sim_time = 2000.
resolution = 2
n_exp = 2
burst_rate = numpy.linspace(15, 50, resolution)
proportions = numpy.linspace(0.01, 0.07, resolution) #arange(1,7,1)*150.
mods = proportions * N_MSN
pop_raw_rates = []
pop_conv_rates = []
mean_pop_conv_rates = []
std_pop_conv_rates = []
inputs = []
i = 0
if not load:
for m in mods:
for r in burst_rate:
tmp_rates = []
for e in range(n_exp):
seed = i
rates = simulate_network_direct_onoff_vs_rate(
m,
r,
params_msn_d1,
params_msn_d2,
params_stn,
synapse_models, {
'SNR': 280,
'STN': 0,
'GPE': 20
},
sim_time=sim_time,
seed=seed,
threads=threads,
start_rec=500.,
model_params=model_params)
tmp_rates.append(list(rates))
i += 1
tmp_rates = numpy.array(tmp_rates)
pop_raw_rates.append(tmp_rates)
pop_conv_rates.append(
misc.convolve(tmp_rates, 100, 'rectangle', single=False))
inputs.append((m, r))
mean_pop_conv_rates.append(
numpy.mean(pop_conv_rates[-1], axis=0))
std_pop_conv_rates.append(numpy.std(pop_conv_rates[-1],
axis=0))
# mean=mean_pop_conv_rates[-1]
# std=std_pop_conv_rates[-1]
#
# for i in range(n_exp):
# pylab.plot(pop_conv_rates[-1][i,:])
# pylab.plot(mean,'k')
# pylab.plot(mean-std,'--k')
# pylab.plot(mean+std,'--k')
# pylab.show()
misc.pickle_save([
pop_raw_rates, pop_conv_rates, mean_pop_conv_rates,
std_pop_conv_rates, inputs
], save_result_at)
else:
pop_raw_rates, pop_conv_rates, mean_pop_conv_rates, std_pop_conv_rates, inputs = misc.pickle_load(
save_result_at)
data = {}
for p in points:
x = []
y = []
z_mean = []
z_std = []
for i, m, s in zip(inputs, mean_pop_conv_rates, std_pop_conv_rates):
x.append(i[0])
y.append(i[1])
z_mean.append(m[p])
z_std.append(s[p])
data[p] = numpy.array([x, y, z_mean, z_std])
spl = numpy.split(data[p], 2, axis=1)
#
# for a in spl:
# pylab.plot(a[1,:],a[2,:])
# pylab.plot(a[1,:],a[2,:]+a[3,:],'--k')
# pylab.plot(a[1,:],a[2,:]-a[3,:],'--k')
#
# pylab.show()
return data
