def simulate(from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50,20) ):
setup=Setup(50,20)
file_name = kw.get('file_name', dr.HOME_DATA+'/'+script_name)
file_name_figs = kw.get('file_name_figs', dr.HOME_DATA+'/fig/'+script_name)
sd=get_storage_list([net], file_name, '')[0]
d={}
if from_disk==0:
print net
dd={net:simulate_network(**kw)}
dd=compute_attrs(dd, net, setup)
save(sd, dd)
if from_disk==1:
filt= [net]+['gi','st', 'gi_st']+['spike_signal']
dd = load(sd, *filt)
pp(dd)
dd=compute_attrs(dd, net, setup)
save(sd, dd)
elif from_disk==2:
filt = [net]+['gi','st', 'gi_st']+['firing_rate', 'phases_diff_with_cohere']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
def simulate(from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50, 20)):
setup = Setup(50, 20)
file_name = kw.get('file_name', dr.HOME_DATA + '/' + script_name)
file_name_figs = kw.get('file_name_figs',
dr.HOME_DATA + '/fig/' + script_name)
sd = get_storage_list([net], file_name, '')[0]
d = {}
if from_disk == 0:
print net
dd = {net: simulate_network(**kw)}
dd = compute_attrs(dd, net, setup)
save(sd, dd)
if from_disk == 1:
filt = [net] + ['gi', 'st', 'gi_st'] + ['spike_signal']
dd = load(sd, *filt)
pp(dd)
dd = compute_attrs(dd, net, setup)
save(sd, dd)
elif from_disk == 2:
filt = [net] + ['gi', 'st', 'gi_st'
] + ['firing_rate', 'phases_diff_with_cohere']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
def main(*args, **kwargs):
setup=kwargs.get( 'setup')#, Setup())
script_name=kwargs.get('script_name')#,__file__.split('/')[-1][0:-3])
builder=kwargs.get('builder')
info, nets, _ = get_networks(builder,
setup.builder(),
setup.director(),
setup.engine(),
setup.default_params())
perturbation_list=kwargs.get('perturbation_list')#,op.get()[0])
perturbation_list+=pl(setup.par(), '=', **{'name':setup.tp_name})
print perturbation_list
for p in sorted(perturbation_list.list):
print p
add_perturbations(perturbation_list, nets)
key=nets.keys()[0]
file_name = get_file_name(script_name, nets[key].par)
path_nest=get_path_nest(script_name, nets.keys(), nets[key].par)
print nets.keys()
for net in nets.values():
net.set_path_nest(path_nest)
net.set_opt(setup.opt[net.name])
# Adding nets no file name
sd_list=get_storage_list(nets.keys(), file_name, info)
for net, sd in zip(nets, sd_list):
nl=Network_list(nets.values())
#nd.add(name, **kwargs)
kwargs={'model':nl,
'call_get_x0':'get_x0',
'call_get_error':'sim_optimization',
'verbose':True,}
f=Fmin('GA_GI_ST_opt', **kwargs)
h=f.fmin()
dd={setup.tp_name.split('_')[0]:{net:{'opt':h}}}
save(sd, dd)
def main_loop_conn(from_disk, attr, models, sets, nets, kwargs_dic, sd):
d = {}
from_disks = [from_disk] * len(nets.keys())
for net, fd in zip(nets.values(), from_disks):
if fd == 0:
net.do_connect()
dd = get_conn_matricies(net, models, attr)
save(sd, dd)
elif fd == 1:
pass
elif fd == 2:
filt = [net.get_name()] + sets + models + attr
dd = load(sd, *filt)
return from_disks, d
def main():
k = get_kwargs_builder()
from os.path import expanduser
home = expanduser("~")
attr = ['firing_rate', 'mean_rates', 'spike_statistic']
kwargs_dic = {
'mean_rates': {
't_start': k['start_rec']
},
'spike_statistic': {
't_start': k['start_rec']
},
}
file_name = (home + '/results/papers/inhibition/network/' +
__file__.split('/')[-1][0:-3])
models = ['M1', 'M2', 'FS', 'GI', 'GA', 'ST', 'SN']
info, nets, _ = get_networks()
sd = Storage_dic.load(file_name)
sd.add_info(info)
sd.garbage_collect()
d = {}
for net, from_disk in zip(nets, [1] * 2):
if not from_disk:
dd = run(net)
dd = compute(dd, models, attr, **kwargs_dic)
save(sd, dd)
elif from_disk:
filt = [net.get_name()] + models + attr
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
figs = []
figs.append(show_fr(d, models))
figs.append(show_hr(d, models))
sd.save_figs(figs)
if DISPLAY: pylab.show()
pylab.show()
def _run(storage_dic, d, net, from_disk, attr, **kwargs):
model = net.get_single_unit()
kwargs_dic = {attr: kwargs}
if not from_disk:
dd = {net.get_name(): net.simulation_loop()}
dd = compute(dd, [model], [attr], **kwargs_dic)
save(storage_dic, dd)
elif from_disk:
# filt = [net.get_name()] + [model] + ['spike_signal']
# dd = load(storage_dic, *filt)
# dd = compute(dd, [model], [attr], **kwargs_dic)
# save(storage_dic, dd)
filt = [net.get_name()] + [model] + [attr]
dd = load(storage_dic, *filt)
dd = reduce_levels(dd, [model] + [attr])
d = misc.dict_update(d, dd)
return d
def main(**kwargs):
exclude=kwargs.get('exclude',[])
models=['GP_GP', 'GA_GA', 'GI_GA', 'GI_GI']
models=[m for m in models if not ( m in exclude)]
nets=['Net_0', 'Net_1']
attrs=['mean_coherence', 'phases_diff_with_cohere']
from_disk=kwargs.get('from_diks',0)
path=('/home/mikael/results/papers/inhibition/network/'
+'supermicro/simulate_slow_wave_ZZZ_dop_effect_perturb/')
path=kwargs.get('data_path', path)
script_name=kwargs.get('script_name', (__file__.split('/')[-1][0:-3]
+'/data'))
file_name = get_file_name(script_name)
sd = get_storage(file_name, '')
d={}
if not from_disk:
# d['raw']=gather(path, nets, models, attrs)
d['raw']=gather2(path, nets, models, attrs)
d['data']=extract_data(d['raw'], nets, models, attrs)
d['performance']=compute_performance(d['data'], nets, models, attrs)
d['bar_obj'], d['labels']=generate_plot_data(d['performance'],
models,
attrs)
save(sd, d)
else:
filt=['bar_obj']+models+['labels']
d = sd.load_dic(*filt)
figs=[]
figs.append(plot_coher(d, d['labels'], title_name=kwargs.get('title')))
save_figures(figs, script_name)
pylab.show()
def simulate(
from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50, 20),
):
file_name = kw.get('file_name', dr.HOME_DATA + '/' + script_name)
file_name_figs = kw.get('file_name_figs',
dr.HOME_DATA + '/fig/' + script_name)
sd = get_storage_list([net], file_name, '')[0]
d = {}
if from_disk == 0:
print net
dd = {}
for call in kw.get('calls', [
simulate_irregular_firing,
simulate_ahp,
simulate_IV,
simulate_IF,
get_nullcline,
simulate_rebound_spike,
]):
misc.dict_update(dd, {net: call(**kw)})
save(sd, dd)
elif from_disk == 1:
filt = kw.get('filter', [net] + ['IV', 'IF', 'ahp', 'nullcline'] +
['rs_scatter'] +
['rs_voltage_{0}'.format(i) for i in range(6)] +
['irf_voltage_{0}'.format(i) for i in range(3)])
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
def main(**kwargs):
exclude = kwargs.get('exclude', [])
models = ['GP_GP', 'GA_GA', 'GI_GA', 'GI_GI']
models = [m for m in models if not (m in exclude)]
nets = ['Net_0', 'Net_1']
attrs = ['mean_coherence', 'phases_diff_with_cohere']
from_disk = kwargs.get('from_diks', 0)
path = ('/home/mikael/results/papers/inhibition/network/' +
'supermicro/simulate_slow_wave_ZZZ_dop_effect_perturb/')
path = kwargs.get('data_path', path)
script_name = kwargs.get('script_name',
(__file__.split('/')[-1][0:-3] + '/data'))
file_name = get_file_name(script_name)
sd = get_storage(file_name, '')
d = {}
if not from_disk:
# d['raw']=gather(path, nets, models, attrs)
d['raw'] = gather2(path, nets, models, attrs)
d['data'] = extract_data(d['raw'], nets, models, attrs)
d['performance'] = compute_performance(d['data'], nets, models, attrs)
d['bar_obj'], d['labels'] = generate_plot_data(d['performance'],
models, attrs)
save(sd, d)
else:
filt = ['bar_obj'] + models + ['labels']
d = sd.load_dic(*filt)
figs = []
figs.append(plot_coher(d, d['labels'], title_name=kwargs.get('title')))
save_figures(figs, script_name)
pylab.show()
def main_loop(from_disk, attr, models, sets, nets, kwargs_dic, sd_list,
**kwargs):
run_method = kwargs.get('run', run)
compute_method = kwargs.get('compute', compute)
d = {}
from_disks = [from_disk] * len(nets.keys())
if type(sd_list) == list:
iterator = [nets.values(), from_disks, sd_list]
else:
iterator = [nets.values(), from_disks]
for vals in zip(*iterator):
if type(sd_list) == list:
net, fd, sd = vals
else:
net, fd = vals
if fd == 0:
dd = run_method(net)
save(sd, dd)
elif fd == 1:
filt = [net.get_name()] + models + ['spike_signal']
dd = load(sd, *filt)
dd = compute_method(dd, models, attr, **kwargs_dic)
save(sd, dd)
elif fd == 2:
print 'Loading data'
filt = ([net.get_name()] + sets + models + attr +
kwargs.get('attrs_load', []))
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return from_disks, d
def _run_XX(flag, storage_dic, stim, d, net, from_disk):
model = net.get_single_unit()
inp = net.get_single_unit_input()
if flag == 'IV':
attr = 'IV_curve'
stim_name = 'node.' + model + '.nest_params.I_e'
call = getattr(net, 'sim_IV_curve')
if flag == 'IF':
attr = 'IF_curve'
stim_name = 'node.' + model + '.nest_params.I_e'
call = getattr(net, 'sim_IF_curve')
if flag == 'FF':
attr = 'FF_curve'
stim_name = 'node.' + inp + '.rate'
call = getattr(net, 'sim_FF_curve')
if not from_disk:
k = {
'stim': stim,
'stim_name': stim_name,
'stim_time': net.get_sim_time(),
'model': model
}
dd = {net.get_name(): call(**k)}
dd = compute(dd, [model], [attr])
save(storage_dic, dd)
elif from_disk:
filt = [net.get_name()] + [model] + [attr]
dd = load(storage_dic, *filt)
pp(dd)
dd = reduce_levels(dd, [model] + [attr])
d = misc.dict_update(d, dd)
return d
def _optimize(flag, net, storage_dic, d, from_disk, **kwargs):
model = net.get_single_unit()
inp = net.get_single_unit_input()
attr = 'fmin'
f = [model]
if flag == 'opt_rate':
x = ['node.' + inp + '.rate']
if flag == 'opt_curr':
x = ['node.' + model + '.nest_params.I_e']
x0 = kwargs.get('x0', 900.)
opt = {'netw': {'optimization': {'f': f, 'x': x, 'x0': x0}}}
net.par.update_dic_rep(opt)
kwargs_fmin = {
'model': net,
'call_get_x0': 'get_x0',
'call_get_error': 'sim_optimization',
'verbose': kwargs.get('verbose', True)
}
if not from_disk:
f = Fmin(net.name, **kwargs_fmin)
dd = {net.get_name(): {model: {attr: f.fmin()}}}
print dd
save(storage_dic, dd)
elif from_disk:
filt = [net.get_name()] + [model] + [attr]
dd = load(storage_dic, *filt)
dd = reduce_levels(dd, [model] + [attr])
d = misc.dict_update(d, dd)
return d
def simulate(from_disk=0,
kw={},
net='Net_0',
script_name=__file__.split('/')[-1][0:-3],
setup=Setup(50,20),
):
file_name = kw.get('file_name', dr.HOME_DATA+'/'+script_name)
file_name_figs = kw.get('file_name_figs', dr.HOME_DATA+'/fig/'+script_name)
sd=get_storage_list([net], file_name, '')[0]
d={}
if from_disk==0:
print net
dd={}
for call in kw.get('calls',[simulate_irregular_firing,
simulate_ahp,
simulate_IV,
simulate_IF,
get_nullcline,
simulate_rebound_spike,]):
misc.dict_update(dd,{net:call(**kw)})
save(sd, dd)
elif from_disk==1:
filt = kw.get('filter', [net]+['IV', 'IF', 'ahp', 'nullcline']
+['rs_scatter']+['rs_voltage_{0}'.format(i) for i in range(6)]
+['irf_voltage_{0}'.format(i) for i in range(3)])
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
return d, file_name_figs
+'milner/simulate_beta_new_beginning_slow4/')
paths.append('/home/mikael/results/papers/inhibition/network/'
+'milner/simulate_slow_wave_new_beginning_slow4/')
script_name=(__file__.split('/')[-1][0:-3]+'/data')
file_name = get_file_name(script_name)
sd = Storage_dic.load(file_name, **{'force_update':False})
if from_disk==0:
d={}
for path, create_name in zip(paths, [ create_name_beta,create_name_sw]):
d_tmp=effect_conns.gather(path, nets, models, attrs, **{'name_maker':create_name})
misc.dict_update(d, d_tmp)
save(sd, d)
pp(d)
elif from_disk==1:
d = sd.load_dic(*(nets+models+['spike_statistic']),
**{'star':[0]})
pp(d)
pp(sorted(d.keys()))
dd=postprocess(d)
misc.dict_update(d, dd)
save(sd, d)
elif from_disk==2:
keys_iterator=[]
for key in ['mean_rates', 'xlabels', 'ylabels']:
keys_iterator+=[['beta', 'Net_0', key],
def main(*args, **kwargs):
setup=kwargs.get('setup')#, Setup())
script_name=kwargs.get('script_name')#,__file__.split('/')[-1][0:-3])
builder=kwargs.get('builder')
info, nets, _ = get_networks(builder,
setup.builder(),
setup.director(),
setup.engine(),
setup.default_params())
perturbation_list=kwargs.get('perturbation_list')
perturbation_list+=pl(target_perturbations()[setup.tp_name], '=', **{'name':setup.tp_name})
perturbation_list+=pl(setup.par(), '=', **{'name':setup.tp_name})
add_perturbations(perturbation_list, nets)
key=nets.keys()[0]
file_name = get_file_name(script_name, nets[key].par)
path_nest=get_path_nest(script_name, nets.keys(), nets[key].par)
for val in nets.values():
for key in sorted(val.par['nest'].keys()):
val2=val.par['nest'][key]
if 'weight' in val2.keys():
print key, val2['weight']
for key in sorted(val.par['node'].keys()):
val2=val.par['node'][key]
if 'spike_setup' in val2.keys():
print key, val2['spike_setup']
if 'rate' in val2.keys():
print key, val2['rate']
print setup.tp_name, nets.keys()
pp(nets['Net_1'].par['nest']['GA_GA_gaba']['weight'])
for net in nets.values():
net.set_path_nest(path_nest)
pp(nets['Net_1'].par['nest']['GA_GA_gaba']['weight'])
net.set_opt(setup.opt[net.name])
pp(nets['Net_1'].par['nest']['GA_GA_gaba']['weight'])
# vt=net.voltage_trace()
# import pylab
# ax=pylab.subplot(111)
# vt.plot_voltage_trace(ax)
# pylab.show()
sd_list=get_storage_list(nets.keys(), file_name, info)
for net, sd in zip(nets.values(), sd_list):
nl=Network_list([net])
# pp(net.par.dic['node']['STp'])
kwargs={'model':nl,
'call_get_x0':'get_x0',
'call_get_error':'sim_optimization',
'verbose':True,}
kwargs_fmin={'maxiter':100,
'maxfun':100,
'full_output':1,
'retall':1,
'xtol':.0001,
'ftol':.0001,
'disp':0}
kwargs_fmin={}
kwargs['kwargs_fmin']=kwargs_fmin
f=Fmin('GA_opt', **kwargs)
h=f.fmin()
dd={setup.tp_name.split('_')[0]:{net.name:{'opt':h}}}
save(sd, dd)
'st_amp': 0,
'st_n': 200
}
kw_list.append(kw)
nets = ['Net_{0:0>2}'.format(i) for i in range(len(kw_list))]
sd_list = get_storage_list(nets, path, '')
d = {}
for net, sd, kw in zip(nets, sd_list, kw_list):
if from_disk == 0: # and net=='Net_05':
print net
dd = {net: simulate_network(**kw)}
dd = compute_attrs(dd, net)
save(sd, dd)
if from_disk == 1:
filt = [net] + ['gi', 'st', 'gi_st'] + ['spike_signal']
dd = load(sd, *filt)
pp(dd)
dd = compute_attrs(dd, net)
save(sd, dd)
elif from_disk == 2:
filt = [net] + ['gi', 'st', 'gi_st'
] + ['firing_rate', 'phases_diff_with_cohere']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
d={}
for net, sd, kw in zip(nets, sd_list, kw_list):
if from_disk==0:# and net=='Net_05':
print net
dd={}
for call in [
simulate_IV,
simulate_IF,
get_nullcline,
simulate_rebound_spike,
]:
misc.dict_update(dd,{net:call(**kw)})
save(sd, dd)
# if from_disk==1:
# filt= [net]+['gi','st', 'gi_st']+['spike_signal']
# dd = load(sd, *filt)
# pp(dd)
# dd=compute_attrs(dd, net)
# save(sd, dd)
elif from_disk==1:
filt = [net]+['IV', 'IF', 'nullcline'] +['rs_scatter']
dd = load(sd, *filt)
d = misc.dict_update(d, dd)
pp(d)
def main(*args, **kwargs):
setup = kwargs.get('setup') #, Setup())
script_name = kwargs.get('script_name') #,__file__.split('/')[-1][0:-3])
builder = kwargs.get('builder')
info, nets, _ = get_networks(builder, setup.builder(), setup.director(),
setup.engine(), setup.default_params())
perturbation_list = kwargs.get('perturbation_list')
perturbation_list += pl(target_perturbations()[setup.tp_name], '=',
**{'name': setup.tp_name})
perturbation_list += pl(setup.par(), '=', **{'name': setup.tp_name})
add_perturbations(perturbation_list, nets)
key = nets.keys()[0]
file_name = get_file_name(script_name, nets[key].par)
path_nest = get_path_nest(script_name, nets.keys(), nets[key].par)
for val in nets.values():
for key in sorted(val.par['nest'].keys()):
val2 = val.par['nest'][key]
if 'weight' in val2.keys():
print key, val2['weight']
for key in sorted(val.par['node'].keys()):
val2 = val.par['node'][key]
if 'spike_setup' in val2.keys():
print key, val2['spike_setup']
if 'rate' in val2.keys():
print key, val2['rate']
print setup.tp_name, nets.keys()
pp(nets['Net_1'].par['nest']['GA_GA_gaba']['weight'])
for net in nets.values():
net.set_path_nest(path_nest)
pp(nets['Net_1'].par['nest']['GA_GA_gaba']['weight'])
net.set_opt(setup.opt[net.name])
pp(nets['Net_1'].par['nest']['GA_GA_gaba']['weight'])
# vt=net.voltage_trace()
# import pylab
# ax=pylab.subplot(111)
# vt.plot_voltage_trace(ax)
# pylab.show()
sd_list = get_storage_list(nets.keys(), file_name, info)
for net, sd in zip(nets.values(), sd_list):
nl = Network_list([net])
# pp(net.par.dic['node']['STp'])
kwargs = {
'model': nl,
'call_get_x0': 'get_x0',
'call_get_error': 'sim_optimization',
'verbose': True,
}
kwargs_fmin = {
'maxiter': 100,
'maxfun': 100,
'full_output': 1,
'retall': 1,
'xtol': .0001,
'ftol': .0001,
'disp': 0
}
kwargs_fmin = {}
kwargs['kwargs_fmin'] = kwargs_fmin
f = Fmin('GA_opt', **kwargs)
h = f.fmin()
dd = {setup.tp_name.split('_')[0]: {net.name: {'opt': h}}}
save(sd, dd)