def __init__(self, network, theory_spec):
self.params = copy(theory_params)
check_custom_params(theory_spec, self.params)
self.custom_params = theory_spec
nested_update(self.params, self.custom_params)
self.network = network
E_L = self.params['neuron_params']['single_neuron_dict']['E_L']
self.NP = {
'theta':
self.params['neuron_params']['single_neuron_dict']['V_th'] - E_L,
'V_reset':
self.params['neuron_params']['single_neuron_dict']['V_reset'] -
E_L,
'tau_m':
self.params['neuron_params']['single_neuron_dict']['tau_m'],
# assumes that tau_syn_ex = tau_syn_in in LIF neuron
'tau_syn':
self.params['neuron_params']['single_neuron_dict']['tau_syn_ex'],
't_ref':
self.params['neuron_params']['single_neuron_dict']['t_ref'],
'tau':
1.
}
self.label = dicthash.generate_hash_from_dict({
'params':
self.params,
'network_label':
self.network.label
})
def __init__(self, network, sim_spec):
"""
Simulation class.
An instance of the simulation class with the given parameters.
Can be created as a member class of a multiarea_model instance
or standalone.
Parameters
----------
network : multiarea_model
An instance of the multiarea_model class that specifies
the network to be simulated.
params : dict
custom simulation parameters that overwrite the
default parameters defined in default_params.py
"""
self.params = deepcopy(sim_params)
if isinstance(sim_spec, dict):
check_custom_params(sim_spec, self.params)
self.custom_params = sim_spec
else:
fn = os.path.join(data_path, sim_spec, '_'.join(
('custom_params', sim_spec)))
with open(fn, 'r') as f:
self.custom_params = json.load(f)['sim_params']
nested_update(self.params, self.custom_params)
self.network = network
self.label = dicthash.generate_hash_from_dict({
'params':
self.params,
'network_label':
self.network.label
})
print("Simulation label: {}".format(self.label))
self.data_dir = os.path.join(data_path, self.label)
try:
os.mkdir(self.data_dir)
os.mkdir(os.path.join(self.data_dir, 'recordings'))
except OSError:
pass
self.copy_files()
print("Copied files.")
d = {
'sim_params': self.custom_params,
'network_params': self.network.custom_params,
'network_label': self.network.label
}
with open(
os.path.join(self.data_dir, '_'.join(
('custom_params', self.label))), 'w') as f:
json.dump(d, f)
print("Initialized simulation class.")
self.areas_simulated = self.params['areas_simulated']
self.areas_recorded = self.params['recording_dict']['areas_recorded']
self.T = self.params['t_sim']
self.extra_global_param_bytes = 0
def __init__(self,
network_spec,
theory=False,
simulation=False,
analysis=False,
*args,
**keywords):
"""
Multiarea model class.
An instance of the multiarea model with the given parameters.
Parameters
----------
network_spec : dict or str
Specify the network. If it is of type dict, the parameters defined
in the dictionary overwrite the default parameters defined in
default_params.py.
If it is of type str, the string defines the label of a previously
initialized model instance that is now loaded.
theory : bool
whether to create an instance of the theory class as member.
simulation : bool
whether to create an instance of the simulation class as member.
analysis : bool
whether to create an instance of the analysis class as member.
"""
self.params = deepcopy(network_params)
if isinstance(network_spec, dict):
print("Initializing network from dictionary.")
check_custom_params(network_spec, self.params)
self.custom_params = network_spec
p_ = 'multiarea_model/data_multiarea/custom_data_files'
# Draw random integer label for data script to avoid clashes with
# parallelly created class instances
rand_data_label = np.random.randint(10000)
print("RAND_DATA_LABEL", rand_data_label)
tmp_parameter_fn = os.path.join(
base_path, p_,
'custom_{}_parameter_dict.json'.format(rand_data_label))
tmp_data_fn = os.path.join(
base_path, p_,
'custom_Data_Model_{}.json'.format(rand_data_label))
with open(tmp_parameter_fn, 'w') as f:
json.dump(self.custom_params, f)
# Execute Data script
compute_Model_params(out_label=str(rand_data_label), mode='custom')
else:
print("Initializing network from label.")
parameter_fn = os.path.join(base_path, 'config_files',
'{}_config'.format(network_spec))
tmp_data_fn = os.path.join(
base_path, 'config_files',
'custom_Data_Model_{}.json'.format(network_spec))
with open(parameter_fn, 'r') as f:
self.custom_params = json.load(f)
nested_update(self.params, self.custom_params)
with open(tmp_data_fn, 'r') as f:
dat = json.load(f)
self.structure = OrderedDict()
for area in dat['area_list']:
self.structure[area] = dat['structure'][area]
self.N = dat['neuron_numbers']
self.synapses = dat['synapses']
self.W = dat['synapse_weights_mean']
self.W_sd = dat['synapse_weights_sd']
self.area_list = complete_area_list
self.distances = dat['distances']
ind, inda, out, outa = load_degree_data(tmp_data_fn)
# If K_stable is specified in the params, load the stabilized matrix
# TODO: Extend this by calling the stabilization method
if self.params['connection_params']['K_stable'] is None:
self.K = ind
else:
if not isinstance(self.params['connection_params']['K_stable'],
str):
raise TypeError("Not supported. Please store the "
"matrix in a binary numpy file and define "
"the path to the file as the parameter value.")
# Assume that the parameter defines a filename containing the matrix
K_stable = np.load(self.params['connection_params']['K_stable'])
ext = {
area: {
pop: ind[area][pop]['external']
for pop in self.structure['V1']
}
for area in self.area_list
}
self.K = matrix_to_dict(K_stable,
self.area_list,
self.structure,
external=ext)
self.synapses = indegree_to_synapse_numbers(self.K, self.N)
self.vectorize()
if self.params['K_scaling'] != 1. or self.params['N_scaling'] != 1.:
if self.params['fullscale_rates'] is None:
raise KeyError('For downscaling, you have to define a file'
' with fullscale rates.')
self.scale_network()
self.K_areas = area_level_dict(self.K, self.N)
self.label = dicthash.generate_hash_from_dict(
{
'params': self.params,
'K': self.K,
'N': self.N,
'structure': self.structure
},
blacklist=[('params', 'fullscale_rates'),
('params', 'connection_params', 'K_stable'),
('params', 'connection_params',
'replace_cc_input_source')])
if isinstance(network_spec, dict):
parameter_fn = os.path.join(base_path, 'config_files',
'{}_config'.format(self.label))
data_fn = os.path.join(
base_path, 'config_files',
'custom_Data_Model_{}.json'.format(self.label))
shutil.move(tmp_parameter_fn, parameter_fn)
shutil.move(tmp_data_fn, data_fn)
elif isinstance(network_spec, str):
assert (network_spec == self.label)
# Initialize member classes
if theory:
if 'theory_spec' not in keywords:
theory_spec = {}
else:
theory_spec = keywords['theory_spec']
self.init_theory(theory_spec)
if simulation:
if 'sim_spec' not in keywords:
sim_spec = {}
else:
sim_spec = keywords['sim_spec']
self.init_simulation(sim_spec)
if analysis:
assert (getattr(self, 'simulation'))
if 'ana_spec' not in keywords:
ana_spec = {}
else:
ana_spec = keywords['ana_spec']
self.init_analysis(ana_spec)
