def build_network(logger):
"""Builds the network including setting of simulation and neuron
parameters, creation of neurons and connections
Requires an instance of Logger as argument
"""
tic = time.time() # start timer on construction
# unpack a few variables for convenience
NE = brunel_params['NE']
NI = brunel_params['NI']
model_params = brunel_params['model_params']
stdp_params = brunel_params['stdp_params']
# set global kernel parameters
nest.SetKernelStatus({
'total_num_virtual_procs': params['nvp'],
'resolution': params['dt'],
'overwrite_files': True})
nest.SetDefaults('iaf_psc_alpha', model_params)
nest.message(M_INFO, 'build_network', 'Creating excitatory population.')
E_neurons = nest.Create('iaf_psc_alpha', NE)
nest.message(M_INFO, 'build_network', 'Creating inhibitory population.')
I_neurons = nest.Create('iaf_psc_alpha', NI)
if brunel_params['randomize_Vm']:
nest.message(M_INFO, 'build_network',
'Randomzing membrane potentials.')
random_vm = nest.random.normal(brunel_params['mean_potential'],
brunel_params['sigma_potential'])
nest.GetLocalNodeCollection(E_neurons).V_m = random_vm
nest.GetLocalNodeCollection(I_neurons).V_m = random_vm
# number of incoming excitatory connections
CE = int(1. * NE / params['scale'])
# number of incomining inhibitory connections
CI = int(1. * NI / params['scale'])
nest.message(M_INFO, 'build_network',
'Creating excitatory stimulus generator.')
# Convert synapse weight from mV to pA
conversion_factor = convert_synapse_weight(
model_params['tau_m'], model_params['tau_syn_ex'], model_params['C_m'])
JE_pA = conversion_factor * brunel_params['JE']
nu_thresh = model_params['V_th'] / (
CE * model_params['tau_m'] / model_params['C_m'] *
JE_pA * np.exp(1.) * tau_syn)
nu_ext = nu_thresh * brunel_params['eta']
E_stimulus = nest.Create('poisson_generator', 1, {
'rate': nu_ext * CE * 1000.})
nest.message(M_INFO, 'build_network',
'Creating excitatory spike recorder.')
if params['record_spikes']:
recorder_label = os.path.join(
brunel_params['filestem'],
'alpha_' + str(stdp_params['alpha']) + '_spikes')
E_recorder = nest.Create('spike_recorder', params={
'record_to': 'ascii',
'label': recorder_label
})
BuildNodeTime = time.time() - tic
logger.log(str(BuildNodeTime) + ' # build_time_nodes')
logger.log(str(memory_thisjob()) + ' # virt_mem_after_nodes')
tic = time.time()
nest.SetDefaults('static_synapse_hpc', {'delay': brunel_params['delay']})
nest.CopyModel('static_synapse_hpc', 'syn_std')
nest.CopyModel('static_synapse_hpc', 'syn_ex',
{'weight': JE_pA})
nest.CopyModel('static_synapse_hpc', 'syn_in',
{'weight': brunel_params['g'] * JE_pA})
stdp_params['weight'] = JE_pA
nest.SetDefaults('stdp_pl_synapse_hom_hpc', stdp_params)
nest.message(M_INFO, 'build_network', 'Connecting stimulus generators.')
# Connect Poisson generator to neuron
nest.Connect(E_stimulus, E_neurons, {'rule': 'all_to_all'},
{'synapse_model': 'syn_ex'})
nest.Connect(E_stimulus, I_neurons, {'rule': 'all_to_all'},
{'synapse_model': 'syn_ex'})
nest.message(M_INFO, 'build_network',
'Connecting excitatory -> excitatory population.')
nest.Connect(E_neurons, E_neurons,
{'rule': 'fixed_indegree', 'indegree': CE,
'allow_autapses': False, 'allow_multapses': True},
{'synapse_model': 'stdp_pl_synapse_hom_hpc'})
nest.message(M_INFO, 'build_network',
'Connecting inhibitory -> excitatory population.')
nest.Connect(I_neurons, E_neurons,
{'rule': 'fixed_indegree', 'indegree': CI,
'allow_autapses': False, 'allow_multapses': True},
{'synapse_model': 'syn_in'})
nest.message(M_INFO, 'build_network',
'Connecting excitatory -> inhibitory population.')
nest.Connect(E_neurons, I_neurons,
{'rule': 'fixed_indegree', 'indegree': CE,
'allow_autapses': False, 'allow_multapses': True},
{'synapse_model': 'syn_ex'})
nest.message(M_INFO, 'build_network',
'Connecting inhibitory -> inhibitory population.')
nest.Connect(I_neurons, I_neurons,
{'rule': 'fixed_indegree', 'indegree': CI,
'allow_autapses': False, 'allow_multapses': True},
{'synapse_model': 'syn_in'})
if params['record_spikes']:
if params['nvp'] != 1:
local_neurons = nest.GetLocalNodeCollection(E_neurons)
# GetLocalNodeCollection returns a stepped composite NodeCollection, which
# cannot be sliced. In order to allow slicing it later on, we're creating a
# new regular NodeCollection from the plain node IDs.
local_neurons = nest.NodeCollection(local_neurons.tolist())
else:
local_neurons = E_neurons
if len(local_neurons) < brunel_params['Nrec']:
nest.message(
M_ERROR, 'build_network',
"""Spikes can only be recorded from local neurons, but the
number of local neurons is smaller than the number of neurons
spikes should be recorded from. Aborting the simulation!""")
exit(1)
nest.message(M_INFO, 'build_network', 'Connecting spike recorders.')
nest.Connect(local_neurons[:brunel_params['Nrec']], E_recorder,
'all_to_all', 'static_synapse_hpc')
# read out time used for building
BuildEdgeTime = time.time() - tic
logger.log(str(BuildEdgeTime) + ' # build_edge_time')
logger.log(str(memory_thisjob()) + ' # virt_mem_after_edges')
return E_recorder if params['record_spikes'] else None
def build_network(logger):
'''Builds the network including setting of simulation and neuron
parameters, creation of neurons and connections
Requires an instance of Logger as argument
'''
tic = time.time() # start timer on construction
# unpack a few variables for convenience
NE = brunel_params['NE']
NI = brunel_params['NI']
model_params = brunel_params['model_params']
stdp_params = brunel_params['stdp_params']
# set global kernel parameters
nest.SetKernelStatus({
'total_num_virtual_procs': params['nvp'],
'resolution': params['dt'],
'overwrite_files': True})
nest.SetDefaults('iaf_psc_alpha', model_params)
nest.message(M_INFO, 'build_network', 'Creating excitatory population.')
E_neurons = nest.Create('iaf_psc_alpha', NE)
nest.message(M_INFO, 'build_network', 'Creating inhibitory population.')
I_neurons = nest.Create('iaf_psc_alpha', NI)
if brunel_params['randomize_Vm']:
nest.message(M_INFO, 'build_network',
'Randomzing membrane potentials.')
seed = nest.GetKernelStatus(
'rng_seeds')[-1] + 1 + nest.GetStatus([0], 'vp')[0]
rng = np.random.RandomState(seed=seed)
for node in get_local_nodes(E_neurons):
nest.SetStatus([node],
{'V_m': rng.normal(
brunel_params['mean_potential'],
brunel_params['sigma_potential'])})
for node in get_local_nodes(I_neurons):
nest.SetStatus([node],
{'V_m': rng.normal(
brunel_params['mean_potential'],
brunel_params['sigma_potential'])})
# number of incoming excitatory connections
CE = int(1. * NE / params['scale'])
# number of incomining inhibitory connections
CI = int(1. * NI / params['scale'])
nest.message(M_INFO, 'build_network',
'Creating excitatory stimulus generator.')
# Convert synapse weight from mV to pA
conversion_factor = convert_synapse_weight(
model_params['tau_m'], model_params['tau_syn_ex'], model_params['C_m'])
JE_pA = conversion_factor * brunel_params['JE']
nu_thresh = model_params['V_th'] / (
CE * model_params['tau_m'] / model_params['C_m'] *
JE_pA * np.exp(1.) * tau_syn)
nu_ext = nu_thresh * brunel_params['eta']
E_stimulus = nest.Create('poisson_generator', 1, {
'rate': nu_ext * CE * 1000.})
nest.message(M_INFO, 'build_network',
'Creating excitatory spike detector.')
if params['record_spikes']:
detector_label = os.path.join(
brunel_params['filestem'],
'alpha_' + str(stdp_params['alpha']) + '_spikes')
E_detector = nest.Create('spike_detector', 1, {
'withtime': True, 'to_file': True, 'label': detector_label})
BuildNodeTime = time.time() - tic
logger.log(str(BuildNodeTime) + ' # build_time_nodes')
logger.log(str(memory_thisjob()) + ' # virt_mem_after_nodes')
tic = time.time()
nest.SetDefaults('static_synapse_hpc', {'delay': brunel_params['delay']})
nest.CopyModel('static_synapse_hpc', 'syn_std')
nest.CopyModel('static_synapse_hpc', 'syn_ex',
{'weight': JE_pA})
nest.CopyModel('static_synapse_hpc', 'syn_in',
{'weight': brunel_params['g'] * JE_pA})
stdp_params['weight'] = JE_pA
nest.SetDefaults('stdp_pl_synapse_hom_hpc', stdp_params)
nest.message(M_INFO, 'build_network', 'Connecting stimulus generators.')
# Connect Poisson generator to neuron
nest.Connect(E_stimulus, E_neurons, {'rule': 'all_to_all'},
{'model': 'syn_ex'})
nest.Connect(E_stimulus, I_neurons, {'rule': 'all_to_all'},
{'model': 'syn_ex'})
nest.message(M_INFO, 'build_network',
'Connecting excitatory -> excitatory population.')
nest.Connect(E_neurons, E_neurons,
{'rule': 'fixed_indegree', 'indegree': CE,
'autapses': False, 'multapses': True},
{'model': 'stdp_pl_synapse_hom_hpc'})
nest.message(M_INFO, 'build_network',
'Connecting inhibitory -> excitatory population.')
nest.Connect(I_neurons, E_neurons,
{'rule': 'fixed_indegree', 'indegree': CI,
'autapses': False, 'multapses': True},
{'model': 'syn_in'})
nest.message(M_INFO, 'build_network',
'Connecting excitatory -> inhibitory population.')
nest.Connect(E_neurons, I_neurons,
{'rule': 'fixed_indegree', 'indegree': CE,
'autapses': False, 'multapses': True},
{'model': 'syn_ex'})
nest.message(M_INFO, 'build_network',
'Connecting inhibitory -> inhibitory population.')
nest.Connect(I_neurons, I_neurons,
{'rule': 'fixed_indegree', 'indegree': CI,
'autapses': False, 'multapses': True},
{'model': 'syn_in'})
if params['record_spikes']:
local_neurons = list(get_local_nodes(E_neurons))
if len(local_neurons) < brunel_params['Nrec']:
nest.message(
M_ERROR, 'build_network',
'''Spikes can only be recorded from local neurons, but the
number of local neurons is smaller than the number of neurons
spikes should be recorded from. Aborting the simulation!''')
exit(1)
nest.message(M_INFO, 'build_network', 'Connecting spike detectors.')
nest.Connect(local_neurons[:brunel_params['Nrec']], E_detector,
'all_to_all', 'static_synapse_hpc')
# read out time used for building
BuildEdgeTime = time.time() - tic
logger.log(str(BuildEdgeTime) + ' # build_edge_time')
logger.log(str(memory_thisjob()) + ' # virt_mem_after_edges')
return E_detector if params['record_spikes'] else None
def BuildNetwork(logger):
tic = time.time() # start timer on construction
# set global kernel parameters
nest.SetKernelStatus({
'total_num_virtual_procs': params['nvp'],
'resolution': params['dt']
})
master_seed = 101
n_vp = nest.GetKernelStatus(['total_num_virtual_procs'])[0]
nest.ll_api.sli_run(
'0 << /grng rngdict/MT19937 :: 101 CreateRNG >> SetStatus')
rng_seeds = list(
range(master_seed + 1 + n_vp, master_seed + 1 + (2 * n_vp)))
grng_seed = master_seed + n_vp
kernel_dict = {'grng_seed': grng_seed, 'rng_seeds': rng_seeds}
nest.SetKernelStatus(kernel_dict)
nest.SetDefaults('iaf_psc_alpha', brunel_params['model_params'])
# ------------------------- Build nodes ------------------------------------
nest.message(M_INFO, 'build_network', 'Creating populations.')
population_list = []
for _ in range(brunel_params['num_pop']):
pop = nest.Create('iaf_psc_alpha', brunel_params['num_neurons'])
population_list.append([pop[0], pop[-1]])
logger_params['num_nodes'] += len(pop)
BuildNodeTime = time.time() - tic
logger.log('{} # build_time_nodes'.format(BuildNodeTime))
logger.log('{} # virt_mem_after_nodes'.format(memory_thisjob()))
#-------------------------- Connection -------------------------------------
tic = time.time() # start timer for selecting targets
nest.message(M_INFO, 'build_network', 'Finding target populations.')
targets = [
random.sample(population_list, brunel_params['num_pop_connections'])
for _ in range(brunel_params['num_pop'])
]
FindTargetsTime = time.time() - tic
logger.log('{} # find_targets_time'.format(FindTargetsTime))
tic = time.time() # Start timer for connection time
conn_degree = 50 # number of connections per neuron
conn_dict = {'autapses': False, 'multapses': True}
if params['rule'] == 'in':
conn_dict.update({'rule': 'fixed_indegree', 'indegree': conn_degree})
elif params['rule'] == 'out':
conn_dict.update({'rule': 'fixed_outdegree', 'outdegree': conn_degree})
elif params['rule'] == 'tot':
conn_dict.update({
'rule': 'fixed_total_number',
'N': conn_degree * brunel_params['num_neurons']
})
elif params['rule'] == 'bern':
conn_dict.update({
'rule': 'pairwise_bernoulli',
'p': conn_degree / brunel_params['num_neurons']
})
elif params['rule'] == 'all':
conn_dict.update({'rule': 'all_to_all'})
# Create custom synapse types with appropriate values for our connections
nest.SetDefaults('static_synapse_hpc', {'delay': brunel_params['delay']})
if params['plastic']:
brunel_params['stdp_params'].update({'weight': 1.})
nest.CopyModel('stdp_pl_synapse_hom_hpc', 'syn_ex_ex',
brunel_params['stdp_params'])
else:
nest.CopyModel('static_synapse_hpc', 'syn_ex_ex', {'weight': 1.})
nest.message(M_INFO, 'build_network', 'Connecting populations.')
if params['d_min'] != params['d_max']:
delays = {'distribution': 'uniform', 'low': d_min, 'high': d_max}
else:
delays = params['d_min']
for source, target_vec in zip(population_list, targets):
for target in target_vec:
nest.Connect(list(range(source[0], source[1] + 1)),
list(range(target[0], target[1] + 1)), conn_dict,
{'model': 'syn_ex_ex'})
# read out time used for building
BuildEdgeTime = time.time() - tic
logger.log('{} # build_edge_time'.format(BuildEdgeTime))
logger.log('{} # virt_mem_after_edges'.format(memory_thisjob()))
def build_network(logger):
'''Builds the network including setting of simulation and neuron
parameters, creation of neurons and connections
Requires an instance of Logger as argument
'''
tic = time.time() # start timer on construction
# unpack a few variables for convenience
NE = brunel_params['NE']
NI = brunel_params['NI']
model_params = brunel_params['model_params']
stdp_params = brunel_params['stdp_params']
# set global kernel parameters
nest.SetKernelStatus({
'total_num_virtual_procs': params['nvp'],
'resolution': params['dt'],
'overwrite_files': True
})
nest.SetDefaults('iaf_psc_alpha', model_params)
nest.message(M_INFO, 'build_network', 'Creating excitatory population.')
E_neurons = nest.Create('iaf_psc_alpha', NE)
nest.message(M_INFO, 'build_network', 'Creating inhibitory population.')
I_neurons = nest.Create('iaf_psc_alpha', NI)
if brunel_params['randomize_Vm']:
nest.message(M_INFO, 'build_network',
'Randomzing membrane potentials.')
seed = nest.GetKernelStatus('rng_seeds')[-1] + 1 + nest.GetStatus(
[0], 'vp')[0]
rng = np.random.RandomState(seed=seed)
for node in get_local_nodes(E_neurons):
nest.SetStatus(
[node], {
'V_m':
rng.normal(brunel_params['mean_potential'],
brunel_params['sigma_potential'])
})
for node in get_local_nodes(I_neurons):
nest.SetStatus(
[node], {
'V_m':
rng.normal(brunel_params['mean_potential'],
brunel_params['sigma_potential'])
})
# number of incoming excitatory connections
CE = int(1. * NE / params['scale'])
# number of incomining inhibitory connections
CI = int(1. * NI / params['scale'])
nest.message(M_INFO, 'build_network',
'Creating excitatory stimulus generator.')
# Convert synapse weight from mV to pA
conversion_factor = convert_synapse_weight(model_params['tau_m'],
model_params['tau_syn_ex'],
model_params['C_m'])
JE_pA = conversion_factor * brunel_params['JE']
nu_thresh = model_params['V_th'] / (CE * model_params['tau_m'] /
model_params['C_m'] * JE_pA *
np.exp(1.) * tau_syn)
nu_ext = nu_thresh * brunel_params['eta']
E_stimulus = nest.Create('poisson_generator', 1,
{'rate': nu_ext * CE * 1000.})
nest.message(M_INFO, 'build_network',
'Creating excitatory spike detector.')
if params['record_spikes']:
detector_label = os.path.join(
brunel_params['filestem'],
'alpha_' + str(stdp_params['alpha']) + '_spikes')
E_detector = nest.Create('spike_detector', 1, {
'withtime': True,
'to_file': True,
'label': detector_label
})
BuildNodeTime = time.time() - tic
logger.log(str(BuildNodeTime) + ' # build_time_nodes')
logger.log(str(memory_thisjob()) + ' # virt_mem_after_nodes')
tic = time.time()
nest.SetDefaults('static_synapse_hpc', {'delay': brunel_params['delay']})
nest.CopyModel('static_synapse_hpc', 'syn_std')
nest.CopyModel('static_synapse_hpc', 'syn_ex', {'weight': JE_pA})
nest.CopyModel('static_synapse_hpc', 'syn_in',
{'weight': brunel_params['g'] * JE_pA})
stdp_params['weight'] = JE_pA
nest.SetDefaults('stdp_pl_synapse_hom_hpc', stdp_params)
nest.message(M_INFO, 'build_network', 'Connecting stimulus generators.')
# Connect Poisson generator to neuron
nest.Connect(E_stimulus, E_neurons, {'rule': 'all_to_all'},
{'model': 'syn_ex'})
nest.Connect(E_stimulus, I_neurons, {'rule': 'all_to_all'},
{'model': 'syn_ex'})
nest.message(M_INFO, 'build_network',
'Connecting excitatory -> excitatory population.')
nest.Connect(
E_neurons, E_neurons, {
'rule': 'fixed_indegree',
'indegree': CE,
'autapses': False,
'multapses': True
}, {'model': 'stdp_pl_synapse_hom_hpc'})
nest.message(M_INFO, 'build_network',
'Connecting inhibitory -> excitatory population.')
nest.Connect(
I_neurons, E_neurons, {
'rule': 'fixed_indegree',
'indegree': CI,
'autapses': False,
'multapses': True
}, {'model': 'syn_in'})
nest.message(M_INFO, 'build_network',
'Connecting excitatory -> inhibitory population.')
nest.Connect(
E_neurons, I_neurons, {
'rule': 'fixed_indegree',
'indegree': CE,
'autapses': False,
'multapses': True
}, {'model': 'syn_ex'})
nest.message(M_INFO, 'build_network',
'Connecting inhibitory -> inhibitory population.')
nest.Connect(
I_neurons, I_neurons, {
'rule': 'fixed_indegree',
'indegree': CI,
'autapses': False,
'multapses': True
}, {'model': 'syn_in'})
if params['record_spikes']:
local_neurons = list(get_local_nodes(E_neurons))
if len(local_neurons) < brunel_params['Nrec']:
nest.message(
M_ERROR, 'build_network',
'''Spikes can only be recorded from local neurons, but the
number of local neurons is smaller than the number of neurons
spikes should be recorded from. Aborting the simulation!''')
exit(1)
nest.message(M_INFO, 'build_network', 'Connecting spike detectors.')
nest.Connect(local_neurons[:brunel_params['Nrec']], E_detector,
'all_to_all', 'static_synapse_hpc')
# read out time used for building
BuildEdgeTime = time.time() - tic
logger.log(str(BuildEdgeTime) + ' # build_edge_time')
logger.log(str(memory_thisjob()) + ' # virt_mem_after_edges')
return E_detector if params['record_spikes'] else None
