def simulation(dt, N, output_n):
start_time = time.time()
dur = 0.01
steps = int(np.round(dur / dt))
G = create_graph(N)
print("Creating graph completed in {} seconds.".format(time.time() -
start_time))
start_time = time.time()
#comp_dict, conns = LPU.graph_to_dicts(G, remove_edge_id=False)
fl_input_processor = StepInputProcessor(
'I', ['neuron_{}'.format(i) for i in range(N)], 20.0, 0.0, dur)
#fl_output_processor = [FileOutputProcessor([('V', None), ('g', ['synapse_neuron_{}_to_neuron_1'.format(i) for i in range(N)])],# ('spike_state', None), ('g', None), ('E', None)],
# 'neurodriver_output_{}.h5'.format(output_n), sample_interval=10, cache_length=2000)]
fl_output_processor = [] # temporarily suppress generating output
#fl_output_processor = [OutputRecorder([('spike_state', None), ('V', None), ('g', None), ('E', None)], dur, dt, sample_interval = 1)]
lpu = LPU(dt,
'obj',
G,
device=args.gpu_dev,
id='ge',
input_processors=[fl_input_processor],
output_processors=fl_output_processor,
debug=args.debug,
manager=False,
print_timing=False,
time_sync=False,
extra_comps=[])
print("Instantiating LPU completed in {} seconds.".format(time.time() -
start_time))
start_time1 = time.time()
# LPU.run includes pre_run, run_steps and post_run
lpu.run(steps=steps)
execution_time = time.time() - start_time1
compile_and_execute_time = time.time() - start_time
print("LPUs Compilation and Execution Completed in {} seconds.".format(
compile_and_execute_time))
return compile_and_execute_time, execution_time
port_data = get_random_port()
port_ctrl = get_random_port()
else:
port_data = args.port_data
port_ctrl = args.port_ctrl
man = core.Manager(port_data, port_ctrl)
man.add_brok()
# Load configurations for lamina, medulla and antennal lobe models:
(n_dict_al, s_dict_al) = LPU.lpu_parser('./data/antennallobe.gexf.gz')
lpu_al = LPU(dt,
n_dict_al,
s_dict_al,
input_file='./data/olfactory_input.h5',
output_file='antennallobe_output.h5',
port_ctrl=man.port_ctrl,
port_data=man.port_data,
device=args.al_dev,
id='antennallobe')
man.add_mod(lpu_al)
(n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz')
lpu_lam = LPU(dt,
n_dict_lam,
s_dict_lam,
input_file='./data/vision_input.h5',
output_file='lamina_output.h5',
port_ctrl=man.port_ctrl,
port_data=man.port_data,
device=args.lam_dev,
if args.log.lower() in ['screen', 'both']:
screen = True
logger = base.setup_logger(file_name, screen)
if args.port_data is None and args.port_ctrl is None:
port_data = get_random_port()
port_ctrl = get_random_port()
else:
port_data = args.port_data
port_ctrl = args.port_ctrl
man = core.Manager(port_data, port_ctrl)
man.add_brok()
(n_dict, s_dict) = LPU.lpu_parser('./data/generic_lpu.gexf.gz')
ge = LPU(dt,
n_dict,
s_dict,
input_file='./data/generic_input.h5',
output_file='generic_output.h5',
port_ctrl=port_ctrl,
port_data=port_data,
device=args.gpu_dev,
id='ge',
debug=args.debug)
man.add_mod(ge)
man.start(steps=args.steps)
man.stop()
file_name = 'neurokernel.log'
if args.log.lower() in ['screen', 'both']:
screen = True
logger = base.setup_logger(file_name, screen)
if args.port_data is None and args.port_ctrl is None:
port_data = get_random_port()
port_ctrl = get_random_port()
else:
port_data = args.port_data
port_ctrl = args.port_ctrl
man = core.Manager(port_data, port_ctrl)
man.add_brok()
(n_dict, s_dict) = LPU.lpu_parser('./data/olfactory_lpu.gexf.gz')
olf = LPU(dt,
n_dict,
s_dict,
input_file='./data/olfactory_input.h5',
output_file='olfactory_output.h5',
port_ctrl=port_ctrl,
port_data=port_data,
device=args.gpu_dev,
id='olf',
debug=args.debug)
man.add_mod(olf)
man.start(steps=args.steps)
man.stop()
args = parser.parse_args()
file_name = None
screen = False
if args.log.lower() in ['file', 'both']:
file_name = 'neurokernel.log'
if args.log.lower() in ['screen', 'both']:
screen = True
logger = base.setup_logger(file_name=file_name, screen=screen)
if args.port_data is None and args.port_ctrl is None:
port_data = get_random_port()
port_ctrl = get_random_port()
else:
port_data = args.port_data
port_ctrl = args.port_ctrl
man = core.Manager(port_data, port_ctrl)
man.add_brok()
(n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz')
lpu_lam = LPU(dt, n_dict_lam, s_dict_lam,
input_file='./data/vision_input.h5',
output_file='lamina_output.h5', port_ctrl=port_ctrl,
port_data=port_data, device=args.lam_dev, id='lamina')
man.add_mod(lpu_lam)
man.start(steps=args.steps)
man.stop()
if args.timeit:
ptime = lambda t, s: print_time(t, s)
else:
ptime = lambda t, s: print_time(t)
man = core.Manager(port_data, port_ctrl, port_time)
man.add_brok()
tic = time()
# Load configurations for lamina, medulla and antennal lobe models:
(n_dict_al, s_dict_al) = LPU.lpu_parser( './data/antennallobe.gexf.gz')
lpu_al = LPU(dt, n_dict_al, s_dict_al,
input_file='./data/olfactory_input.h5',
output_file='antennallobe_output.h5',
port_ctrl=port_ctrl, port_data=port_data, port_time=port_time,
device=args.al_dev, id='antennallobe', time_sync=args.time_sync)
man.add_mod(lpu_al)
tic = ptime(tic, 'Load AL LPU time')
(n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz')
lpu_lam = LPU(dt, n_dict_lam, s_dict_lam,
input_file='./data/vision_input.h5',
output_file='lamina_output.h5',
port_ctrl=port_ctrl, port_data=port_data, port_time=port_time,
device=args.al_dev, id='lamina', time_sync=args.time_sync)
man.add_mod(lpu_lam)
tic = ptime(tic, 'Load LAM LPU time')
(n_dict_med, s_dict_med) = LPU.lpu_parser('./data/medulla.gexf.gz')
else:
port_data = args.port_data
port_ctrl = args.port_ctrl
if not args.suppress:
man = core.Manager(port_data, port_ctrl)
man.add_brok()
print('Parsing retina lpu data')
n_dict_ret, s_dict_ret = LPU.lpu_parser(RET_GEXF_FILE)
print('Initializing retina LPU')
lpu_ret = LPU(dt,
n_dict_ret,
s_dict_ret,
input_file=INPUT_FILE,
output_file=RET_OUTPUT_FILE,
port_ctrl=port_ctrl,
port_data=port_data,
device=args.ret_dev,
id='retina',
debug=True)
man.add_mod(lpu_ret)
if not args.retina_only:
print('Parsing lamina lpu data')
n_dict_lam, s_dict_lam = LPU.lpu_parser(LAM_GEXF_FILE)
print('Initializing lamina LPU')
lpu_lam = LPU(dt,
n_dict_lam,
s_dict_lam,
input_file=None,
output_file=LAM_OUTPUT_FILE,
port_ctrl = get_random_port()
else:
port_data = args.port_data
port_ctrl = args.port_ctrl
man = core.Manager(port_data, port_ctrl)
man.add_brok()
print('Parsing lpu data')
n_dict_ret, s_dict_ret = LPU.lpu_parser(GEXF_FILE)
print('Initializing LPU')
lpu_ret = LPU(dt,
n_dict_ret,
s_dict_ret,
input_file=INPUT_FILE,
output_file=OUTPUT_FILE,
port_ctrl=port_ctrl,
port_data=port_data,
device=0,
id='retina',
debug=False)
man.add_mod(lpu_ret)
print('Starting simulation')
start_time = time.time()
man.start(steps=args.steps)
man.stop()
print('Simulation complete: Duration {} seconds'.format(time.time() -
start_time))
if i == 0:
in_file_name = in_file_name_0
else:
in_file_name = None
lpu_file_name = 'generic_lpu_%s.gexf.gz' % i
out_file_name = 'generic_output_%s.h5' % i
g.create_lpu(lpu_file_name, *neu_num)
(n_dict, s_dict) = LPU.lpu_parser(lpu_file_name)
id = 'lpu_%s' % i
lpu = LPU(dt,
n_dict,
s_dict,
input_file=in_file_name,
output_file=out_file_name,
port_ctrl=port_ctrl,
port_data=port_data,
device=i,
id=id,
debug=args.debug)
lpu_entry['lpu_file_name'] = lpu_file_name
lpu_entry['in_file_name'] = in_file_name
lpu_entry['out_file_name'] = out_file_name
lpu_entry['lpu'] = lpu
lpu_entry['id'] = id
lpu_dict[i] = lpu_entry
syn_params = {
'AlphaSynapse':
'uids': [uid],
'data': {
'time': spike_times,
'index': np.array([0] * spike_times.shape[0], np.int32)
}
}
})
output_processor = OutputRecorder([('g', [uid])], dur, dt)
lpu = LPU(dt,
'obj', {
'graph': G,
'kwargs': {
'class_key': 'model'
}
},
device=0,
id='test',
input_processors=[input_processor],
output_processors=[output_processor],
debug=True,
manager=False,
print_timing=False,
extra_comps=[ArrayInputProcessor])
lpu.run(steps=steps)
s = np.zeros(steps, np.double)
t = np.arange(0, dur, dt)
for tk in spike_times:
s += (scale / (ar - ad) *
(np.exp(-ad *
(t - tk) * 1000) - np.exp(-ar *
def run(connected):
if args.port_data is None and args.port_ctrl is None:
port_data = get_random_port()
port_ctrl = get_random_port()
else:
port_data = args.port_data
port_ctrl = args.port_ctrl
out_name = 'un' if not connected else 'co'
man = core.Manager(port_data, port_ctrl)
man.add_brok()
lpu_file_0 = './data/generic_lpu_0.gexf.gz'
lpu_file_1 = './data/generic_lpu_1.gexf.gz'
(n_dict_0, s_dict_0) = LPU.lpu_parser(lpu_file_0)
(n_dict_1, s_dict_1) = LPU.lpu_parser(lpu_file_1)
ge_0_id = 'ge_0'
ge_0 = LPU(dt,
n_dict_0,
s_dict_0,
input_file='./data/generic_input_0.h5',
output_file='generic_output_0_%s.h5' % out_name,
port_ctrl=port_ctrl,
port_data=port_data,
device=args.gpu_dev[0],
id=ge_0_id,
debug=args.debug)
man.add_mod(ge_0)
ge_1_id = 'ge_1'
ge_1 = LPU(dt,
n_dict_1,
s_dict_1,
input_file='./data/generic_input_1.h5',
output_file='generic_output_1_%s.h5' % out_name,
port_ctrl=port_ctrl,
port_data=port_data,
device=args.gpu_dev[1],
id=ge_1_id,
debug=args.debug)
man.add_mod(ge_1)
# Connect the public neurons in the two LPUs:
df_neu_0, df_syn_0 = neurokernel.tools.graph.graph_to_df(
nx.read_gexf(lpu_file_0))
df_neu_1, df_syn_1 = neurokernel.tools.graph.graph_to_df(
nx.read_gexf(lpu_file_1))
# Number of public neurons in each LPU:
N_spike_0 = len(df_neu_0[(df_neu_0['spiking'] == True)
& (df_neu_0['public'] == True)])
N_gpot_0 = len(df_neu_0[(df_neu_0['spiking'] == False)
& (df_neu_0['public'] == True)])
N_spike_1 = len(df_neu_1[(df_neu_1['spiking'] == True)
& (df_neu_1['public'] == True)])
N_gpot_1 = len(df_neu_1[(df_neu_1['spiking'] == False)
& (df_neu_1['public'] == True)])
# Alpha function synaptic parameters:
alphasynapse_type_params = {
'AlphaSynapse':
['ad', 'ar', 'gmax', 'id', 'class', 'conductance', 'reverse']
}
if connected:
conn = core.Connectivity(N_gpot_0, N_spike_0, N_gpot_1, N_spike_1, 1,
ge_0.id, ge_1.id, alphasynapse_type_params)
for id, (i, j) in enumerate(
itertools.product(xrange(N_spike_0), xrange(N_spike_1))):
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j] = 1
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0,
'name'] = 'int_0to1_%s_%s' % (i, j)
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0,
'model'] = 'AlphaSynapse'
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0,
'ad'] = 0.19 * 1000
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0, 'ar'] = 1.1 * 100
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0, 'class'] = 0
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0,
'conductance'] = True
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0, 'gmax'] = 0.003
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0, 'id'] = id
conn[ge_0_id, 'spike', i, ge_1_id, 'spike', j, 0,
'reverse'] = 0.065
man.connect(ge_0, ge_1, conn)
man.start(steps=args.steps)
man.stop()
port_data = args.port_data
port_ctrl = args.port_ctrl
if not args.suppress:
man = core.Manager(port_data, port_ctrl)
man.add_brok()
if 'r' in args.model:
print('Parsing retina LPU data')
n_dict_ret, s_dict_ret = LPU.lpu_parser(RET_GEXF_FILE)
print('Initializing retina LPU')
lpu_ret = LPU(dt,
n_dict_ret,
s_dict_ret,
input_file=RET_INPUT,
output_file=RET_OUTPUT_FILE,
port_ctrl=port_ctrl,
port_data=port_data,
device=args.ret_dev,
id='retina',
debug=True)
man.add_mod(lpu_ret)
if 'l' in args.model:
print('Parsing lamina LPU data')
n_dict_lam, s_dict_lam = LPU.lpu_parser(LAM_GEXF_FILE)
print('Initializing lamina LPU')
lpu_lam = LPU(dt,
n_dict_lam,
s_dict_lam,
input_file=LAM_INPUT,
output_file=LAM_OUTPUT_FILE,
def run(connected):
if args.port_data is None:
port_data = get_random_port()
else:
port_data = args.port_data
if args.port_ctrl is None:
port_ctrl = get_random_port()
else:
port_ctrl = args.port_ctrl
if args.port_time is None:
port_time = get_random_port()
else:
port_time = args.port_time
out_name = 'un' if not connected else 'co'
man = core.Manager(port_data, port_ctrl, port_time)
man.add_brok()
lpu_file_0 = './data/generic_lpu_0.gexf.gz'
lpu_file_1 = './data/generic_lpu_1.gexf.gz'
(n_dict_0, s_dict_0) = LPU.lpu_parser(lpu_file_0)
(n_dict_1, s_dict_1) = LPU.lpu_parser(lpu_file_1)
lpu_0_id = 'lpu_0'
lpu_0 = LPU(dt, n_dict_0, s_dict_0,
input_file='./data/generic_lpu_0_input.h5',
output_file='generic_lpu_0_%s_output.h5' % out_name,
port_ctrl=port_ctrl, port_data=port_data,
port_time=port_time,
device=args.gpu_dev[0], id=lpu_0_id,
debug=args.debug, time_sync=args.time_sync)
man.add_mod(lpu_0)
lpu_1_id = 'lpu_1'
lpu_1 = LPU(dt, n_dict_1, s_dict_1,
input_file='./data/generic_lpu_1_input.h5',
output_file='generic_lpu_1_%s_output.h5' % out_name,
port_ctrl=port_ctrl, port_data=port_data,
port_time=port_time,
device=args.gpu_dev[1], id=lpu_1_id,
debug=args.debug, time_sync=args.time_sync)
man.add_mod(lpu_1)
# Create random connections between the input and output ports if the LPUs
# are to be connected:
if connected:
# Find all output and input port selectors in each LPU:
out_ports_0 = lpu_0.interface.out_ports().to_selectors()
out_ports_1 = lpu_1.interface.out_ports().to_selectors()
in_ports_0 = lpu_0.interface.in_ports().to_selectors()
in_ports_1 = lpu_1.interface.in_ports().to_selectors()
out_ports_spk_0 = lpu_0.interface.out_ports().spike_ports().to_selectors()
out_ports_gpot_0 = lpu_0.interface.out_ports().gpot_ports().to_selectors()
out_ports_spk_1 = lpu_1.interface.out_ports().spike_ports().to_selectors()
out_ports_gpot_1 = lpu_1.interface.out_ports().gpot_ports().to_selectors()
in_ports_spk_0 = lpu_0.interface.in_ports().spike_ports().to_selectors()
in_ports_gpot_0 = lpu_0.interface.in_ports().gpot_ports().to_selectors()
in_ports_spk_1 = lpu_1.interface.in_ports().spike_ports().to_selectors()
in_ports_gpot_1 = lpu_1.interface.in_ports().gpot_ports().to_selectors()
# Initialize a connectivity pattern between the two sets of port
# selectors:
pat = pattern.Pattern(','.join(out_ports_0+in_ports_0),
','.join(out_ports_1+in_ports_1))
# Create connections from the ports with identifiers matching the output
# ports of one LPU to the ports with identifiers matching the input
# ports of the other LPU:
N_conn_spk_0_1 = min(len(out_ports_spk_0), len(in_ports_spk_1))
N_conn_gpot_0_1 = min(len(out_ports_gpot_0), len(in_ports_gpot_1))
for src, dest in zip(random.sample(out_ports_spk_0, N_conn_spk_0_1),
random.sample(in_ports_spk_1, N_conn_spk_0_1)):
pat[src, dest] = 1
pat.interface[src, 'type'] = 'spike'
pat.interface[dest, 'type'] = 'spike'
for src, dest in zip(random.sample(out_ports_gpot_0, N_conn_gpot_0_1),
random.sample(in_ports_gpot_1, N_conn_gpot_0_1)):
pat[src, dest] = 1
pat.interface[src, 'type'] = 'gpot'
pat.interface[dest, 'type'] = 'gpot'
man.connect(lpu_0, lpu_1, pat, 0, 1)
man.start(steps=args.steps)
man.stop()
port_ctrl = args.port_ctrl
if args.port_time is None:
port_time = get_random_port()
else:
port_time = args.port_time
man = core.Manager(port_data, port_ctrl, port_time)
man.add_brok()
(n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz')
lpu_lam = LPU(dt,
n_dict_lam,
s_dict_lam,
input_file='./data/vision_input.h5',
output_file='lamina_output.h5',
port_ctrl=port_ctrl,
port_data=port_data,
port_time=port_time,
device=args.lam_dev,
id='lamina',
time_sync=args.time_sync)
man.add_mod(lpu_lam)
(n_dict_med, s_dict_med) = LPU.lpu_parser('./data/medulla.gexf.gz')
lpu_med = LPU(dt,
n_dict_med,
s_dict_med,
output_file='medulla_output.h5',
port_ctrl=port_ctrl,
port_data=port_data,
port_time=port_time,
