def build_injective_inputs(target_net):
print('Building External Network')
input_network_model = {
'external': {
'N': len(target_net.nodes()
), # Need one virtual node for every LIF_network node
'ei': 'e',
'pop_name': 'input_network',
'model_type': 'virtual'
}
}
inputNetwork = NetworkBuilder("external")
inputNetwork.add_nodes(**input_network_model['external'])
inputNetwork.add_edges(
target=target_net.nodes(pop_name='LIF_exc'),
connection_rule=injective_connections,
iterator='all_to_one', # will make building a little faster
syn_weight=200,
delay=D,
dynamics_params='ExcToExc.json',
model_template='static_synapse')
inputNetwork.add_edges(target=target_net.nodes(pop_name='LIF_inh'),
connection_rule=injective_connections,
iterator='all_to_one',
syn_weight=100,
delay=D,
dynamics_params='ExcToExc.json',
model_template='static_synapse')
inputNetwork.build()
inputNetwork.save(output_dir='network')
model_template='exp2syn')
net.add_edges(source=backgroundPV.nodes(),
target=net.nodes(pop_name='PV'),
connection_rule=BG_to_PV,
syn_weight=1,
target_sections=['somatic'],
delay=0.1,
distance_range=[0.0, 300.0],
dynamics_params='AMPA_ExcToInh.json',
model_template='exp2syn')
# Build and save our networks
net.build()
net.save(output_dir='network')
tone.build()
tone.save_nodes(output_dir='network')
shock.build()
shock.save_nodes(output_dir='network')
backgroundPN.build()
backgroundPN.save_nodes(output_dir='network')
backgroundPV.build()
backgroundPV.save_nodes(output_dir='network')
backgroundOLM.build()
backgroundOLM.save_nodes(output_dir='network')
return sec_ids, sec_xs, coords[0][0], coords[0][1], coords[0][2], dist[0], swctype[0]
# Feedfoward excitatory virtual cells
exc_net = NetworkBuilder('excvirt')
exc_net.add_nodes(N=10, model_type='virtual', ei='e')
cm = exc_net.add_edges(target=cortex.nodes(), source=exc_net.nodes(ei='e'),
connection_rule=lambda *_: np.random.randint(4, 12),
dynamics_params='AMPA_ExcToExc.json',
model_template='Exp2Syn',
delay=2.0)
cm.add_properties('syn_weight', rule=3.4e-4, dtypes=np.float)
cm.add_properties(['sec_id', 'sec_x', 'pos_x', 'pos_y', 'pos_z', 'dist', 'type'],
rule=build_edges,
dtypes=[np.int32, np.float, np.float, np.float, np.float, np.float, np.uint8])
exc_net.build()
exc_net.save(output_dir='network')
if not os.path.exists('inputs/exc_spike_trains.h5'):
# Build spike-trains for excitatory virtual cells
if not os.path.exists('inputs'):
os.mkdir('inputs')
psg = PoissonSpikesGenerator(range(10), 10.0, tstop=3000.0)
psg.to_hdf5('inputs/exc_spike_trains.h5')
# Inhibitory connections, build this as a separate network so we can test simulation with only excitatory input and
# with mixed excitatory/inhibitory input.
inh_net = NetworkBuilder('inhvirt')
inh_net.add_nodes(N=10, model_type='virtual', ei='i')
cm = inh_net.add_edges(target=cortex.nodes(), source=inh_net.nodes(ei='i'),
connection_rule=np.random.randint(0, 8),
model_template='static_synapse',
syn_weight=3.0,
delay=2.0)
internal.add_edges(source={'ei': 'i'},
target={'orig_model': 'intfire'},
connection_rule=n_connections,
dynamics_params='instanteneousInh.json',
model_template='static_synapse',
syn_weight=-4.0,
delay=2.0)
# Build and save internal network
internal.build()
print('Saving internal network')
internal.save(output_dir='network')
# Build a network of 100 virtual cells that will connect to and drive the simulation of the internal network
print('Building external connections')
external = NetworkBuilder("external")
external.add_nodes(N=100, model_type='virtual', ei='e')
# Targets all glif excitatory cells
external.add_edges(target=internal.nodes(ei='e', orig_model='glif'),
source=external.nodes(),
connection_rule=lambda *_: np.random.randint(0, 5),
dynamics_params='LGN_to_GLIF.json',
model_template='static_synapse',
delay=2.0,
syn_weight=11.0)
ycoords += [p[1] for p in positions]
# Get spatial filter size of cells
filter_sizes = get_filter_spatial_size(params['N'], X_grids, Y_grids,
params['size_range'])
LGN.add_nodes(
N=total_N,
ei=params['ei'],
model_type=params['model_type'],
model_template=params['model_template'],
x=positions[:, 0],
y=positions[:, 1],
dynamics_params=params['dynamics_params'],
# TODO: Come up with better name than non-dominate parameters (spatial-params?)
non_dom_params=params.get('non_dom_params', None),
# TODO: See if it's possible to calculate spatial sizes during simulation.
spatial_size=filter_sizes,
# NOTE: If tuning angle is not defined, then it will be randomly generated during the simulation. But
# when evaluating a large network many times it will be more efficent to store it in the nodes file.
tuning_angle=np.random.uniform(0.0, 360.0, total_N),
# TODO: Can sf-sperator be stored in the params json file.
sf_sep=params.get('sf_sep', None))
LGN.build()
LGN.save(output_dir='network')
x=pos_x, y=pos_y,
dynamics_params='472363762_point.json')
def recurrent_connections(src_cells, trg_cell, n_syns):
# Increasing numbers of synapses per target cell...
#print(trg_cell)
#print(dir(trg_cell))
#print('--- %s'%trg_cell._node_params)
synapses = [20 * n_syns* (trg_cell.node_id-per_pop)] *len(src_cells)
return synapses
net.add_edges(source={'ei': 'e'}, target={'ei': 'i', 'model_type': 'point_process'},
iterator='all_to_one',
connection_rule=recurrent_connections,
connection_params={'n_syns': 1},
syn_weight=10,
weight_function='wmax',
delay=2.0,
dynamics_params='ExcToInh.json',
model_template='static_synapse')
net.build()
net.save(output_dir='../input/network')
print 'Built: %s'%net.name
positions = [(radius*np.cos(i*dx), radius*np.sin(i*dx), 0.0)] # place cells in wheel around origin
bio_net.add_nodes(model_type='biophysical', model_processing='aibs_perisomatic', positions=positions,
**model_props)
bio_net.build()
bio_net.save_nodes(output_dir='network')
if build_virtual_net:
# Build a separate network of virtual cells to synapse onto the biophysical network
virt_net = NetworkBuilder('virt')
virt_net.add_nodes(N=10, model_type='virtual', ei='e') # 10 excitatory virtual cells
virt_net.add_edges(target=bio_net.nodes(), # Connect every virt cells onto every bio cell
connection_rule=lambda *_: np.random.randint(4, 12), # 4 to 12 synapses per source/target
dynamics_params='AMPA_ExcToExc.json',
model_template='Exp2Syn',
syn_weight=3.4e-4,
delay=2.0,
target_sections=['soma', 'basal', 'apical'], # target soma and all dendritic sections
distance_range=[0.0, 1.0e20])
virt_net.build()
virt_net.save(output_dir='network')
# Create spike trains to use for our virtual cells
if not os.path.exists('inputs'):
os.mkdir('inputs')
psg = PoissonSpikesGenerator(range(10), 10.0, tstop=4000.0)
psg.to_hdf5('inputs/exc_spike_trains.h5')
def build_edges(source_node_id, target_node_id):
sonata_file = sonata.File(
data_files=[
'/data/work_files/V1_network_update/Biophysical_network/network_fixed_synapses/v1_nodes.h5',
'/data/work_files/V1_network_update/Biophysical_network/network_fixed_synapses/v1_v1_edges.h5'
],
data_type_files=[
'/data/work_files/V1_network_update/Biophysical_network/network_fixed_synapses/v1_node_types.csv',
'/data/work_files/V1_network_update/Biophysical_network/network_fixed_synapses/v1_v1_edge_types.csv'
])
v1_edges = sonata_file.edges['v1_to_v1']
v1_nodes = sonata_file.nodes['v1']
l4_node = v1_nodes.get_node_id(source_node_id)
l4_node_morphology_path = os.path.join('biophys_components/morphologies',
l4_node['morphology'])
l4_node_props = l4_node.node_type_properties
l4_node_props.update({str(k): [v] for k, v in l4_node.group_props.items()})
l4_node_props['rotation_angle_zaxis'] *= -1
l2_node = v1_nodes.get_node_id(target_node_id)
l2_node_morphology_path = os.path.join('biophys_components/morphologies',
l2_node['morphology'])
l2_node_props = l2_node.node_type_properties
l2_node_props.update({str(k): [v] for k, v in l2_node.group_props.items()})
l2_node_props['rotation_angle_zaxis'] *= -1
swc_parsers = {
source_node_id: SWCParser(l4_node_morphology_path),
target_node_id: SWCParser(l2_node_morphology_path)
}
v1 = NetworkBuilder('v1')
v1.add_nodes(**l4_node_props)
v1.add_nodes(**l2_node_props)
def query_str2dict(qry_str):
qry_dict = {}
for cond in qry_str.split('&'):
k, v = cond.split('==')
v = v.strip("\'")
try:
v = int(v)
except ValueError:
pass
qry_dict[k] = v
return qry_dict
for src_id, trg_id in permutations([source_node_id, target_node_id]):
sec_ids = []
sec_xs = []
syn_weights = []
edge_props = {}
trg_swc = swc_parsers[trg_id]
trg_swc_ids = []
trg_swc_dists = []
for e in v1_edges.get_source(src_id):
if e.target_node_id == trg_id:
sec_id = e._group_props['sec_id']
sec_x = e._group_props['sec_x']
swc_id, swc_dist = trg_swc.get_swc_id(sec_id, sec_x)
trg_swc_ids.append(swc_id)
trg_swc_dists.append(swc_dist)
edge_props[
e._edge_type_props['edge_type_id']] = e._edge_type_props
sec_ids.append(sec_id)
sec_xs.append(sec_x)
syn_weights.append(e._group_props['syn_weight'])
for edge_type_id, edge_type_props in edge_props.items():
trg_query = query_str2dict(edge_type_props['target_query'])
del edge_type_props['target_query']
src_query = query_str2dict(edge_type_props['source_query'])
del edge_type_props['source_query']
cm = v1.add_edges(source=src_query,
target=trg_query,
connection_rule=len(syn_weights),
**edge_type_props)
# cm.add_properties('syn_weight', rule=lambda *_: np.random.uniform(0.0, 100.0), dtypes=np.float)
cm.add_properties('afferent_section_id',
rule=sec_ids,
dtypes=np.int)
cm.add_properties('afferent_section_pos',
rule=sec_xs,
dtypes=np.float)
cm.add_properties('syn_weight', rule=syn_weights, dtypes=np.float)
cm.add_properties('afferent_swc_id',
rule=trg_swc_ids,
dtypes=np.int)
cm.add_properties('afferent_swc_pos',
rule=trg_swc_dists,
dtypes=np.float)
v1.build()
v1.save(output_dir='network')
def build_lif_network():
### Define all the cell models in a dictionary.
print('Building Internal Network')
LIF_models = {
'LIF_exc': {
'N': N_LIF_exc,
'ei': 'e',
'pop_name': 'LIF_exc',
'model_type': 'point_process',
'model_template': 'nest:iaf_psc_exp',
'dynamics_params': 'excitatory.json'
},
'LIF_inh': {
'N': N_LIF_inh,
'ei': 'i',
'pop_name': 'LIF_inh',
'model_type': 'point_process',
'model_template': 'nest:iaf_psc_exp',
'dynamics_params': 'inhibitory.json'
}
}
net = NetworkBuilder('internal')
for model in LIF_models:
params = LIF_models[model].copy()
positions = positions_columinar(N=LIF_models[model]['N'],
center=[0, 10.0, 0],
max_radius=50.0,
height=200.0)
net.add_nodes(x=positions[:, 0],
y=positions[:, 1],
z=positions[:, 2],
**params)
net.add_edges(source={'ei': 'e'},
target={'ei': 'e'},
connection_rule=random_connections,
connection_params={'p': eps},
syn_weight=200,
delay=D,
dynamics_params='ExcToExc.json',
model_template='static_synapse')
net.add_edges(source={'ei': 'e'},
target={'ei': 'i'},
connection_rule=random_connections,
connection_params={'p': eps},
syn_weight=300,
delay=D,
dynamics_params='ExcToInh.json',
model_template='static_synapse')
net.add_edges(source={'ei': 'i'},
target={'ei': 'e'},
connection_rule=random_connections,
connection_params={'p': eps},
syn_weight=-550,
delay=D,
dynamics_params='InhToExc.json',
model_template='static_synapse')
net.add_edges(source={'ei': 'i'},
target={'ei': 'i'},
connection_rule=random_connections,
connection_params={'p': eps},
syn_weight=-300,
delay=D,
dynamics_params='InhToInh.json',
model_template='static_synapse')
net.build()
net.save(output_dir='network')
# net.save_edges(edges_file_name='edges.h5', edge_types_file_name='edge_types.csv', output_dir='network')
# net.save_nodes(nodes_file_name='nodes.h5', node_types_file_name='node_types.csv', output_dir='network')
return net
thalamus = NetworkBuilder('mthalamus')
thalamus.add_nodes(N=1, pop_name='tON', potential='exc', model_type='virtual')
thalamus.add_edges(source={'pop_name': 'tON'},
target=net.nodes(pop_name=['Int']),
connection_rule=1,
syn_weight=1,
delay=2.0,
weight_function=None,
target_sections=['somatic'],
distance_range=[0.0, 150.0],
dynamics_params='AMPA_ExcToExc.json',
model_template='exp2syn')
net.build()
net.save(output_dir='network')
thalamus.build()
thalamus.save(output_dir='network')
psg = PoissonSpikeGenerator(population='mthalamus')
psg.add(
node_ids=1, # Have 5 nodes to match mthalamus
firing_rate=8, # 2 Hz
times=(0.0, 1)) # time is in seconds for some reason
psg.to_sonata('virtual_spikes.h5')
print('Number of background spikes: {}'.format(psg.n_spikes()))
from bmtk.utils.sim_setup import build_env_bionet
build_env_bionet(
base_dir='../',
network_dir='./network',
def build_model():
if os.path.isdir('network'):
shutil.rmtree('network')
if os.path.isdir('2_cell_inputs'):
shutil.rmtree('2_cell_inputs')
seed = 967
random.seed(seed)
np.random.seed(seed)
load()
syn = syn_params_dicts()
# Initialize our network
net = NetworkBuilder("biophysical")
num_inh = [1]
num_exc = [1]
##################################################################################
###################################BIOPHY#########################################
# PN
net.add_nodes(N=1,
pop_name='PyrC',
mem_potential='e',
model_type='biophysical',
model_template='hoc:Cell_C',
morphology=None)
# PV
net.add_nodes(N=1,
pop_name="PV",
mem_potential='e',
model_type='biophysical',
model_template='hoc:basket',
morphology=None)
backgroundPN_C = NetworkBuilder('bg_pn_c')
backgroundPN_C.add_nodes(N=1,
pop_name='tON',
potential='exc',
model_type='virtual')
backgroundPV = NetworkBuilder('bg_pv')
backgroundPV.add_nodes(N=2,
pop_name='tON',
potential='exc',
model_type='virtual')
# if neuron is sufficiently depolorized enough post synaptic calcium then synaptiic weight goes up
# pyr->pyr & pyr->PV
# PV->pyr PV->PV
def one_to_all(source, target):
sid = source.node_id
tid = target.node_id
print("connecting bio cell {} to bio cell {}".format(sid, tid))
return 1
def BG_to_PN_C(source, target):
sid = source.node_id
tid = target.node_id
if sid == tid:
print("connecting BG {} to PN_C{}".format(sid, tid))
return 1
else:
return 0
def BG_to_PV(source, target):
sid = source.node_id
tid = target.node_id
sid = sid + 1
if sid == tid:
print("connecting BG {} to PV{}".format(sid, tid))
return 1
else:
return 0
conn = net.add_edges(source=net.nodes(pop_name='PyrC'),
target=net.nodes(pop_name="PV"),
connection_rule=one_to_all,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='PN2PV.json',
model_template=syn['PN2PV.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(1, 0.9),
dtypes=[np.int32, np.float])
conn = net.add_edges(source=net.nodes(pop_name='PV'),
target=net.nodes(pop_name="PyrC"),
connection_rule=one_to_all,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='PV2PN.json',
model_template=syn['PV2PN.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(1, 0.9),
dtypes=[np.int32, np.float])
conn = net.add_edges(source=backgroundPN_C.nodes(),
target=net.nodes(pop_name='PyrC'),
connection_rule=BG_to_PN_C,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='BG2PNC.json',
model_template=syn['BG2PNC.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(2, 0.9),
dtypes=[np.int32,
np.float]) # places syn on apic at 0.9
conn = net.add_edges(source=backgroundPV.nodes(),
target=net.nodes(pop_name='PV'),
connection_rule=BG_to_PV,
syn_weight=1.0,
delay=0.1,
distance_range=[-10000, 10000],
dynamics_params='BG2PV.json',
model_template=syn['BG2PV.json']['level_of_detail'])
conn.add_properties(['sec_id', 'sec_x'],
rule=(1, 0.9),
dtypes=[np.int32, np.float])
backgroundPN_C.build()
backgroundPN_C.save_nodes(output_dir='network')
backgroundPV.build()
backgroundPV.save_nodes(output_dir='network')
net.build()
net.save(output_dir='network')
# SPIKE TRAINS
t_sim = 40000
# build_env_bionet(base_dir='./',
# network_dir='./network',
# tstop=t_sim, dt=0.1,
# report_vars=['v'],
# components_dir='biophys_components',
# config_file='config.json',
# spikes_inputs=[('bg_pn_c', '2_cell_inputs/bg_pn_c_spikes.h5'),
# ('bg_pv', '2_cell_inputs/bg_pv_spikes.h5')],
# compile_mechanisms=False)
psg = PoissonSpikeGenerator(population='bg_pn_c')
psg.add(
node_ids=range(1), # need same number as cells
firing_rate=6, # 1 spike every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('2_cell_inputs/bg_pn_c_spikes.h5')
print('Number of background spikes for PN_C: {}'.format(psg.n_spikes()))
psg = PoissonSpikeGenerator(population='bg_pv')
psg.add(
node_ids=range(1), # need same number as cells
firing_rate=7.7, # 8 spikes every 1 second Hz
times=(0.0, t_sim / 1000)) # time is in seconds for some reason
psg.to_sonata('2_cell_inputs/bg_pv_spikes.h5')
print('Number of background spikes for PV: {}'.format(psg.n_spikes()))
# connection_params={'prob': 0.2},
# syn_weight=6.0e-05,
connection_rule=tunning_angle,
connection_params={'max_syns': 5},
syn_weight=3.0e-05,
delay=2.0,
dynamics_params='ExcToExc.json',
model_template='Exp2Syn',
target_sections=['basal', 'apical'],
distance_range=[30.0, 150.0],
weight_function='set_syn_weight')
# Build and save internal network
v1.build()
print('Saving V1')
v1.save(output_dir='network')
# Build a network of 100 virtual cells that will connect to and drive the simulation of the internal network
print('Building external "LGN" connections')
lgn = NetworkBuilder("LGN")
lgn.add_nodes(N=50,
model_type='virtual',
ei='e',
model_template='lgnmodel:sOFF_TF8',
x=np.random.uniform(0.0, 240.0, 50),
y=np.random.uniform(0.0, 120.0, 50),
spatial_size=1.0,
dynamics_params='sOFF_TF8.json')
lgn.add_nodes(N=50,
