def add_LPU(config, manager): config_photor = config['Photoreceptor'] gexf_file = config_photor['gexf_file'] input_file = config_photor['input_file'] output_file = config_photor['output_file'] G = generate_gexf(config_photor, gexf_file) LPU.graph_to_dicts(G) comp_dict, conns = LPU.graph_to_dicts(G) LPU_id = 'photoreceptor' debug = config_photor['debug'] dt = config['General']['dt'] extra_comps = [PhotoreceptorModel] input_processor = StepInputProcessor('photon', G.nodes(), 10000, 0.2, 1) output_processor = FileOutputProcessor([('V', G.nodes())], output_file, sample_interval=1) manager.add(LPU, LPU_id, dt, comp_dict, conns, device=0, input_processors=[input_processor], output_processors=[output_processor], debug=debug, time_sync=False, extra_comps=extra_comps)
def add_worker_LPU(config, retina_index, retina, manager): gexf_filename = config['Retina']['gexf_file'] suffix = config['General']['file_suffix'] dt = config['General']['dt'] debug = config['Retina']['debug'] time_sync = config['Retina']['time_sync'] worker_num = config['Retina']['worker_num'] gexf_file = '{}{}_{}{}.gexf.gz'.format(gexf_filename, 0, retina_index, suffix) G = retina.get_worker_graph(retina_index + 1, worker_num) #G = nx.convert_node_labels_to_integers(G) nx.write_gexf(G, gexf_file) worker_dev = retina_index (comp_dict, conns) = LPU.lpu_parser(gexf_file) worker_id = get_worker_id(retina_index) extra_comps = [Photoreceptor] manager.add(LPU, worker_id, dt, comp_dict, conns, device=worker_dev, debug=debug, time_sync=time_sync, extra_comps=extra_comps)
def main(): import neurokernel.mpi_relaunch logger = setup_logger(file_name=None, screen=True) parser = argparse.ArgumentParser() parser.add_argument( "-l", "--layers", dest="num_layers", type=int, default=16, help="number of layers of ommatidia on circle" ) parser.add_argument("-i", "--input", action="store_true", help="generates input if set") parser.add_argument("-g", "--gexf", action="store_true", help="generates gexf of LPU if set") parser.add_argument("--steps", default=100, type=int, help="simulation steps") args = parser.parse_args() dt = 1e-4 GEXF_FILE = "retina.gexf.gz" INPUT_FILE = "vision_input.h5" IMAGE_FILE = "image1.mat" OUTPUT_FILE = "retina_output.h5" if args.input: print("Generating input of model from image file") generate_input(INPUT_FILE, IMAGE_FILE, args.num_layers) if args.gexf: print("Writing retina lpu") n = args.num_layers photoreceptor_num = 6 * (3 * n * (n + 1) + 1) generate_gexf(GEXF_FILE, photoreceptor_num) man = core_gpu.Manager() print("Parsing lpu data") n_dict_ret, s_dict_ret = LPU.lpu_parser(GEXF_FILE) print("Initializing LPU") man.add( LPU, "retina", dt, n_dict_ret, s_dict_ret, input_file=INPUT_FILE, output_file=OUTPUT_FILE, device=0, debug=True, time_sync=False, ) man.spawn() print("Starting simulation") start_time = time.time() man.start(steps=args.steps) man.wait() print("Simulation complete: Duration {} seconds".format(time.time() - start_time))
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
def add_retina_LPU(config, retina_index, retina, manager): ''' This method adds Retina LPU and its parameters to the manager so that it can be initialized later. Depending on configuration input can either be created in advance and read from file or generated during simulation by a generator object. -- config: configuration dictionary like object i: identifier of eye in case more than one is used retina: retina array object required for the generation of graph. manager: manager object to which LPU will be added generator: generator object or None ''' dt = config['General']['dt'] debug = config['Retina']['debug'] time_sync = config['Retina']['time_sync'] input_filename = config['Retina']['input_file'] output_filename = config['Retina']['output_file'] gexf_filename = config['Retina']['gexf_file'] suffix = config['General']['file_suffix'] output_file = '{}{}{}.h5'.format(output_filename, retina_index, suffix) gexf_file = '{}{}{}.gexf.gz'.format(gexf_filename, retina_index, suffix) inputmethod = config['Retina']['inputmethod'] if inputmethod == 'read': print('Generating input files') with Timer('input generation'): input_processor = RetinaFileInputProcessor(config, retina) else: print('Using input generating function') input_processor = RetinaInputProcessor(config, retina) output_processor = FileOutputProcessor([('V',None),('spike_state',None)], output_file, sample_interval=1) # retina also allows a subset of its graph to be taken # in case it is needed later to split the retina model to more # GPUs G = retina.get_worker_nomaster_graph() nx.write_gexf(G, gexf_file) (comp_dict, conns) = LPU.graph_to_dicts(G) retina_id = get_retina_id(retina_index) extra_comps = [LeakyIAF, BufferPhoton] manager.add(LPU, retina_id, dt, comp_dict, conns, device = retina_index, input_processors = [input_processor], output_processors = [output_processor], debug=debug, time_sync=time_sync, extra_comps = extra_comps)
def create_pattern(n_dict_1, n_dict_2, save_as=None): """ If `save_as` is not None, save the pattern in GEXF format as the specified file name. """ lpu1_sel_in_gpot = plsel.Selector(LPU.extract_in_gpot(n_dict_1)) lpu1_sel_out_gpot = plsel.Selector(LPU.extract_out_gpot(n_dict_1)) lpu2_sel_in_gpot = plsel.Selector(LPU.extract_in_gpot(n_dict_2)) lpu2_sel_out_gpot = plsel.Selector(LPU.extract_out_gpot(n_dict_2)) lpu1_sel_in_spike = plsel.Selector(LPU.extract_in_spk(n_dict_1)) lpu1_sel_out_spike = plsel.Selector(LPU.extract_out_spk(n_dict_1)) lpu2_sel_in_spike = plsel.Selector(LPU.extract_in_spk(n_dict_2)) lpu2_sel_out_spike = plsel.Selector(LPU.extract_out_spk(n_dict_2)) lpu1_sel_out = plsel.Selector.union(lpu1_sel_out_gpot, lpu1_sel_out_spike) lpu2_sel_out = plsel.Selector.union(lpu2_sel_out_gpot, lpu2_sel_out_spike) lpu1_sel_in = plsel.Selector.union(lpu1_sel_in_gpot, lpu1_sel_in_spike) lpu2_sel_in = plsel.Selector.union(lpu2_sel_in_gpot, lpu2_sel_in_spike) lpu1_sel = plsel.Selector.union(lpu1_sel_out, lpu1_sel_in) lpu2_sel = plsel.Selector.union(lpu2_sel_out, lpu2_sel_in) Neuron_list_12 = ["L1", "L2", "L3", "L4", "L5", "T1"] Neuron_list_21 = ["C2", "C3"] gpot_sel = plsel.Selector.union(lpu1_sel_out_gpot, lpu1_sel_in_gpot, lpu2_sel_out_gpot, lpu2_sel_in_gpot) spike_sel = plsel.Selector.union(lpu1_sel_out_spike, lpu1_sel_in_spike, lpu2_sel_out_spike, lpu2_sel_in_spike) Neuron_str_12 = "[" + ",".join(Neuron_list_12) + "]" Neuron_str_21 = "[" + ",".join(Neuron_list_21) + "]" cart_str = "[" + ",".join(["cart%i" % i for i in range(768)]) + "]" from_sel_12 = "/lamina" + cart_str + Neuron_str_12 to_sel_12 = "/medulla" + cart_str + Neuron_str_12 from_sel_21 = "/medulla" + cart_str + Neuron_str_21 to_sel_21 = "/lamina" + cart_str + Neuron_str_21 from_sel = from_sel_12 + "," + from_sel_21 to_sel = to_sel_12 + "," + to_sel_21 pat = Pattern.from_concat( lpu1_sel, lpu2_sel, from_sel=from_sel, to_sel=to_sel, gpot_sel=gpot_sel, spike_sel=spike_sel, data=1 ) if save_as: nx.write_gexf(pat.to_graph(), save_as, prettyprint=True) return pat
def add_master_LPU(config, retina_index, retina, manager): dt = config['General']['dt'] debug = config['Retina']['debug'] time_sync = config['Retina']['time_sync'] input_filename = config['Retina']['input_file'] output_filename = config['Retina']['output_file'] gexf_filename = config['Retina']['gexf_file'] suffix = config['General']['file_suffix'] output_file = '{}{}{}.h5'.format(output_filename, retina_index, suffix) gexf_file = '{}{}{}.gexf.gz'.format(gexf_filename, retina_index, suffix) inputmethod = config['Retina']['inputmethod'] if inputmethod == 'read': print('Generating input files') with Timer('input generation'): input_processor = RetinaFileInputProcessor(config, retina) else: print('Using input generating function') input_processor = RetinaInputProcessor(config, retina) input_processor = get_input_gen(config, retina) uids_to_record = [ 'ret_{}_{}'.format(name, i) for i in range(retina.num_elements) for name in ['R1', 'R2', 'R3', 'R4', 'R5', 'R6'] ] output_processor = FileOutputProcessor([('V', uids_to_record)], output_file, sample_interval=1) G = retina.get_master_graph() nx.write_gexf(G, gexf_file) (comp_dict, conns) = LPU.lpu_parser(gexf_file) master_id = get_master_id(retina_index) extra_comps = [BufferPhoton, BufferVoltage] manager.add(LPU, master_id, dt, comp_dict, conns, device=retina_index, input_processors=[input_processor], output_processors=[output_processor], debug=debug, time_sync=time_sync, extra_comps=extra_comps)
def create_pattern(n_dict_1, n_dict_2, save_as=None): """ If `save_as` is not None, save the pattern as the specified file name. """ lpu1_sel_in_gpot = plsel.Selector(LPU.extract_in_gpot(n_dict_1)) lpu1_sel_out_gpot = plsel.Selector(LPU.extract_out_gpot(n_dict_1)) lpu2_sel_in_gpot = plsel.Selector(LPU.extract_in_gpot(n_dict_2)) lpu2_sel_out_gpot = plsel.Selector(LPU.extract_out_gpot(n_dict_2)) lpu1_sel_in_spike = plsel.Selector(LPU.extract_in_spk(n_dict_1)) lpu1_sel_out_spike = plsel.Selector(LPU.extract_out_spk(n_dict_1)) lpu2_sel_in_spike = plsel.Selector(LPU.extract_in_spk(n_dict_2)) lpu2_sel_out_spike = plsel.Selector(LPU.extract_out_spk(n_dict_2)) lpu1_sel_out = plsel.Selector.union(lpu1_sel_out_gpot, lpu1_sel_out_spike) lpu2_sel_out = plsel.Selector.union(lpu2_sel_out_gpot, lpu2_sel_out_spike) lpu1_sel_in = plsel.Selector.union(lpu1_sel_in_gpot, lpu1_sel_in_spike) lpu2_sel_in = plsel.Selector.union(lpu2_sel_in_gpot, lpu2_sel_in_spike) lpu1_sel = plsel.Selector.union(lpu1_sel_out, lpu1_sel_in) lpu2_sel = plsel.Selector.union(lpu2_sel_out, lpu2_sel_in) pat = Pattern(lpu1_sel, lpu2_sel) pat.interface[lpu1_sel_in_gpot, 'io', 'type'] = ['in', 'gpot'] pat.interface[lpu1_sel_out_gpot, 'io', 'type'] = ['out', 'gpot'] pat.interface[lpu2_sel_in_gpot, 'io', 'type'] = ['in', 'gpot'] pat.interface[lpu2_sel_out_gpot, 'io', 'type'] = ['out', 'gpot'] pat.interface[lpu1_sel_in_spike, 'io', 'type'] = ['in', 'spike'] pat.interface[lpu1_sel_out_spike, 'io', 'type'] = ['out', 'spike'] pat.interface[lpu2_sel_in_spike, 'io', 'type'] = ['in', 'spike'] pat.interface[lpu2_sel_out_spike, 'io', 'type'] = ['out', 'spike'] Neuron_list_12 = ['L1', 'L2', 'L3', 'L4', 'L5', 'T1'] Neuron_list_21 = ['C2', 'C3'] for i in range(768): for neuron in Neuron_list_12: pat['/lamina/cart'+str(i)+'/'+neuron, '/medulla/cart'+str(i)+'/'+neuron] = 1 for neuron in Neuron_list_21: pat['/medulla/cart'+str(i)+'/'+neuron, '/lamina/cart'+str(i)+'/'+neuron] = 1 if save_as: with open(save_as, 'wb') as pat_file: pickle.dump(pat, pat_file) return pat
def cx_component(graph): #lpu lists lpu_name_list = ['BU', 'bu', 'EB', 'FB', 'PB'] lpu_name_to_node = {} # LPU name -> pyorient LPU node lpu_name_to_g_na = {} # LPU name -> NeuroArch-compatible graph lpu_name_to_g_nk_orig = {} # LPU name -> Neurokernel-compatible graph lpu_name_to_g_nk = {} # LPU name -> Neurokernel-compatible graph with int IDs #lpu_name_to_n_dict = {} # LPU name -> n_dict data struct #lpu_name_to_s_dict = {} # LPU name -> s_dict data struct lpu_name_to_comp_dict = {} # LPU name -> comp_dict data struct lpu_name_to_conn_list = {} # LPU name -> conn_list data struct for name in lpu_name_list: lpu_name_to_node[name] = graph.LPUs.query(name=name).one() lpu_name_to_g_na[name] = lpu_name_to_node[name].traverse_owns(max_levels = 2).get_as('nx') lpu_name_to_g_nk_orig[name] = nk.na_lpu_to_nk_new(lpu_name_to_g_na[name]) lpu_name_to_g_nk[name] = nx.convert_node_labels_to_integers(lpu_name_to_g_nk_orig[name], ordering = 'sorted') lpu_name_to_g_nk[name] = \ partly_relabel_by_sorted_attr(lpu_name_to_g_nk[name], 'model', ['LeakyIAF'], 'name') #lpu_name_to_n_dict[name], lpu_name_to_s_dict[name] = LPU.graph_to_dicts(lpu_name_to_g_nk[name]) lpu_name_to_comp_dict[name], lpu_name_to_conn_list[name] = LPU.graph_to_dicts(lpu_name_to_g_nk[name]) nx.write_gexf(lpu_name_to_g_nk[name], name+'.gexf.gz') # Patterns: pat_name_list = [n.name for n in graph.Patterns.query().all()] pat_name_to_node = {} # LPU pair -> pyorient Pattern node pat_name_to_g_na = {} # LPU pair -> NeuroArch-compatible graph pat_name_to_g_nk = {} # LPU pair -> Neurokernel-compatible graph pat_name_to_pat = {} # LPU pair -> Pattern class instance for name in pat_name_list: pat_name_to_node[name] = graph.Patterns.query(name=name).one() pat_name_to_g_na[name] = pat_name_to_node[name].traverse_owns(max_levels = 2).get_as('nx') pat_name_to_g_nk[name] = nk.na_pat_to_nk(pat_name_to_g_na[name]) pat_name_to_pat[name] = Pattern.Pattern.from_graph(nx.DiGraph(pat_name_to_g_nk[name])) return lpu_name_to_comp_dict, lpu_name_to_conn_list, pat_name_list, pat_name_to_pat
def add_lamina_LPU(config, lamina_index, lamina, manager): ''' This method adds Lamina LPU and its parameters to the manager so that it can be initialized later. -- config: configuration dictionary like object i: identifier of eye in case more than one is used lamina: lamina array object required for the generation of graph. manager: manager object to which LPU will be added generator: generator object or None ''' output_filename = config['Lamina']['output_file'] gexf_filename = config['Lamina']['gexf_file'] suffix = config['General']['file_suffix'] dt = config['General']['dt'] debug = config['Lamina']['debug'] time_sync = config['Lamina']['time_sync'] output_file = '{}{}{}.h5'.format(output_filename, lamina_index, suffix) gexf_file = '{}{}{}.gexf.gz'.format(gexf_filename, lamina_index, suffix) G = lamina.get_graph() nx.write_gexf(G, gexf_file) (comp_dict, conns) = LPU.graph_to_dicts(G) lamina_id = get_lamina_id(lamina_index) extra_comps = [BufferVoltage] output_processor = FileOutputProcessor( [('V', None)], output_file, sample_interval=1) manager.add(LPU, lamina_id, dt, comp_dict, conns, output_processors = [output_processor], device=lamina_index+1, debug=debug, time_sync=time_sync, extra_comps = extra_comps)
else: port_data = args.port_data port_ctrl = args.port_ctrl for i, neu_num in neu_dict.iteritems(): lpu_entry = {} 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
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()
# Set up several LPUs: man = core.Manager() for i, neu_num in neu_dict.iteritems(): lpu_entry = {} 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_lpu_%s_output.h5' % i id = 'lpu_%s' % i g.create_lpu(lpu_file_name, id, *neu_num) (n_dict, s_dict) = LPU.lpu_parser(lpu_file_name) man.add(LPU, id, dt, n_dict, s_dict, input_file=in_file_name, output_file=out_file_name, device=i, debug=args.debug, time_sync=args.time_sync) lpu_entry['lpu_file_name'] = lpu_file_name lpu_entry['in_file_name'] = in_file_name lpu_entry['out_file_name'] = out_file_name
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/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()
import numpy as np from neurokernel.LPU.LPU import LPU import vision_configuration as vc np.random.seed(10000) lamina = vc.Lamina(24, 32, 'neuron_types_lamina.csv', 'synapse_lamina.csv', None) lamina.create_cartridges() lamina.connect_cartridges() lamina.create_non_columnar_neurons() lamina.connect_composition_II() lamina.connect_composition_I() lamina.add_selectors() g_lam = lamina.export_to_gexf('lamina.gexf.gz') n_dict_lam, s_dict_lam = LPU.graph_to_dicts(g_lam) medulla = vc.Medulla(24, 32, 'neuron_types_medulla.csv', 'synapse_medulla.csv', 'synapse_medulla_other.csv') medulla.create_cartridges() medulla.connect_cartridges() medulla.create_non_columnar_neurons() medulla.connect_composition_I() medulla.connect_composition_II() medulla.connect_composition_III() medulla.add_selectors() g_med = medulla.export_to_gexf('medulla.gexf.gz') n_dict_med, s_dict_med = LPU.graph_to_dicts(g_med) vc.create_pattern(n_dict_lam, n_dict_med, 'lam_med.gexf.gz')
man = core.Manager() G = nx.MultiDiGraph() G.add_node( 'neuron0', { 'class': 'LeakyIAF', 'name': 'LeakyIAF', 'resting_potential': -70.0, 'threshold': -45.0, 'capacitance': 0.07, # in mS 'resistance': 0.2, # in Ohm }) comp_dict, conns = LPU.graph_to_dicts(G) fl_input_processor = StepInputProcessor('I', ['neuron0'], 40, 0.2, 0.8) fl_output_processor = FileOutputProcessor([('spike_state', None), ('V', None)], 'new_output.h5', sample_interval=1) man.add(LPU, 'ge', dt, comp_dict, conns, device=args.gpu_dev, input_processors=[fl_input_processor], output_processors=[fl_output_processor],
help='Number of steps [default: %s]' % steps) parser.add_argument('-g', '--gpu_dev', default=0, type=int, help='GPU device number [default: 0]') 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 = setup_logger(file_name=file_name, screen=screen) man = core.Manager() (comp_dict, conns) = LPU.lpu_parser('./data/generic_lpu.gexf.gz') #st_input_processor = StepInputProcessor('I', ['73','74','75','76','77'] , 10, 0.1,0.4) fl_input_processor = FileInputProcessor('./data/generic_input.h5') fl_output_processor = FileOutputProcessor([('V',None),('spike_state',None)], 'new_output.h5', sample_interval=1) ''' a = LPU(dt, comp_dict, conns, device=args.gpu_dev, input_processors = [st_input_processor], id='ge') ''' man.add(LPU, 'ge', dt, comp_dict, conns, device=args.gpu_dev, input_processors = [fl_input_processor], output_processors = [fl_output_processor], debug=args.debug) man.spawn() man.start(steps=args.steps) man.wait()
# Set up several LPUs: man = core.Manager() for i, neu_num in neu_dict.iteritems(): lpu_entry = {} 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_lpu_%s_output.h5' % i id = 'lpu_%s' % i g.create_lpu(lpu_file_name, id, *neu_num) (n_dict, s_dict) = LPU.lpu_parser(lpu_file_name) man.add(LPU, id, dt, n_dict, s_dict, input_file=in_file_name, output_file=out_file_name, device=i, debug=args.debug, time_sync=args.time_sync) 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['n_dict'] = n_dict lpu_entry['s_dict'] = s_dict lpu_dict[id] = lpu_entry
G.node[nn] = { 'model': 'Photoreceptor', 'name' : 'neuron_0' , 'extern' : True, 'public' : False, 'spiking' : False, 'Vinit' : -0.07, 'SA' : 0.6982, 'SI' : 0.000066517, 'DRA' : 0.2285, 'DRI' : 0.00012048 } nx.write_gexf(G, 'simple_lpu.gexf.gz') (n_dict, s_dict) = LPU.lpu_parser('simple_lpu.gexf.gz') t = np.arange(0, dt*Nt, dt) I = np.zeros((Nt, 1), dtype=np.double) I[np.logical_and(t>start, t<stop)] = I_max with h5py.File('simple_input.h5', 'w') as f: f.create_dataset('array', (Nt,1), dtype=np.double, data=I) port_data = get_random_port() port_ctrl = get_random_port() lpu = LPU_retina(dt, n_dict, s_dict, input_file='retina_inputs.h5', output_file='retina_output.h5', port_ctrl=port_ctrl, port_data=port_data, device=0, id='simple', debug=False) man = Manager(port_data, port_ctrl) man.add_brok() man.add_mod(lpu)
print('Writing lamina lpu') eyemodel.write_lamina(LAM_GEXF_FILE) 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 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=port_ctrl,
def launch(self, user_id, task): neuron_uid_list = [str(a) for a in task['neuron_list']] conf_obj = get_config_obj() config = conf_obj.conf if config['Retina']['intype'] == 'Natural': coord_file = config['InputType']['Natural']['coord_file'] tmp = os.path.splitext(coord_file) config['InputType']['Natural']['coord_file'] = '{}_{}{}'.format( tmp[0], user_id, tmp[1]) setup_logger(file_name='neurokernel_' + user_id + '.log', screen=True) manager = core.Manager() lpus = {} patterns = {} G = task['data'] with open('G.pickle', 'wb') as f: pickle.dump(G, f, protocol=pickle.HIGHEST_PROTOCOL) print(G) print(G.keys()) print(G['LPU']) print(G['LPU'].keys()) # get graph and output_uid_list for each LPU for k, lpu in G['LPU'].items(): lpus[k] = {} g_lpu_na = create_graph_from_database_returned(lpu) lpu_nk_graph = nk.na_lpu_to_nk_new(g_lpu_na) lpus[k]['graph'] = lpu_nk_graph lpus[k]['output_uid_list'] = list( set(lpu_nk_graph.nodes()).intersection(set(neuron_uid_list))) lpus[k]['output_file'] = '{}_output_{}.h5'.format(k, user_id) for kkey, lpu in lpus.items(): graph = lpu['graph'] for uid, comp in graph.node.items(): if 'attr_dict' in comp: print('Found attr_dict; fixing...') nx.set_node_attributes(graph, {uid: comp['attr_dict']}) # print('changed',uid) graph.nodes[uid].pop('attr_dict') for i, j, k, v in graph.edges(keys=True, data=True): if 'attr_dict' in v: for key in v['attr_dict']: nx.set_edge_attributes( graph, {(i, j, k): { key: v['attr_dict'][key] }}) graph.edges[(i, j, k)].pop('attr_dict') lpus[kkey]['graph'] = graph # get graph for each Pattern for k, pat in G['Pattern'].items(): l1, l2 = k.split('-') if l1 in lpus and l2 in lpus: g_pattern_na = create_graph_from_database_returned(pat) pattern_nk = nk.na_pat_to_nk(g_pattern_na) print(lpus[l1]['graph'].nodes(data=True)) lpu_ports = [node[1]['selector'] \ for node in lpus[l1]['graph'].nodes(data=True) \ if node[1]['class']=='Port'] + \ [node[1]['selector'] \ for node in lpus[l2]['graph'].nodes(data=True) \ if node[1]['class']=='Port'] pattern_ports = pattern_nk.nodes() patterns[k] = {} patterns[k]['graph'] = pattern_nk.subgraph( list(set(lpu_ports).intersection(set(pattern_ports)))) dt = config['General']['dt'] if 'dt' in task: dt = task['dt'] print(dt) # add LPUs to manager for k, lpu in lpus.items(): lpu_name = k graph = lpu['graph'] for uid, comp in graph.node.items(): if 'attr_dict' in comp: nx.set_node_attributes(graph, {uid: comp['attr_dict']}) # print('changed',uid) graph.nodes[uid].pop('attr_dict') for i, j, ko, v in graph.edges(keys=True, data=True): if 'attr_dict' in v: for key in v['attr_dict']: nx.set_edge_attributes( graph, {(i, j, ko): { key: v['attr_dict'][key] }}) graph.edges[(i, j, ko)].pop('attr_dict') nx.write_gexf(graph, 'name.gexf') with open(lpu_name + '.pickle', 'wb') as f: pickle.dump(graph, f, protocol=pickle.HIGHEST_PROTOCOL) comps = graph.node.items() #for uid, comp in comps: # if 'attr_dict' in comp: # nx.set_node_attributes(graph, {uid: comp['attr_dict']}) # print('changed',uid) # if 'class' in comp: if k == 'retina': prs = [node for node in graph.nodes(data=True) \ if node[1]['class'] == 'PhotoreceptorModel'] for pr in prs: graph.node[pr[0]]['num_microvilli'] = 3000 input_processors = [ RetinaInputIndividual(config, prs, user_id) ] extra_comps = [PhotoreceptorModel] retina_input_uids = [a[0] for a in prs] elif k == 'EB': input_processor = StepInputProcessor('I', [node[0] for node in graph.nodes(data=True) \ if node[1]['class'] == 'LeakyIAF'], 40.0, 0.0, 1.0) input_processors = [input_processor] extra_comps = [BufferVoltage] else: input_processors = [] extra_comps = [BufferVoltage] if 'inputProcessors' in task: input_processors = loadExperimentSettings( task['inputProcessors']) output_processor = FileOutputProcessor( [('V', lpu['output_uid_list'])], lpu['output_file'], sample_interval=10) (comp_dict, conns) = LPU.graph_to_dicts(graph) # print(comp_dict) # print(conns) print(k) manager.add(LPU, k, dt, comp_dict, conns, device=0, input_processors=input_processors, output_processors=[output_processor], extra_comps=extra_comps, debug=True) # connect LPUs by Patterns for k, pattern in patterns.items(): l1, l2 = k.split('-') if l1 in lpus and l2 in lpus: print('Connecting {} and {}'.format(l1, l2)) pat, key_order = Pattern.from_graph(nx.DiGraph( pattern['graph']), return_key_order=True) print(l1, l2) print(key_order) with Timer('update of connections in Manager'): manager.connect(l1, l2, pat, int_0=key_order.index(l1), int_1=key_order.index(l2)) # start simulation steps = config['General']['steps'] ignored_steps = config['General']['ignored_steps'] if 'steps' in task: steps = task['steps'] if 'ignored_steps' in task: ignored_steps = task['ignored_steps'] # ignored_steps = 0 # steps = 100 manager.spawn() manager.start(steps=steps) manager.wait() time.sleep(5) print(task) # post-processing inputs (hard coded, can be better organized) inputs = { u'ydomain': 1.0, u'xdomain': dt * (steps - ignored_steps), u'dt': dt * 10, u'data': {} } if 'retina' in lpus: input_array = si.read_array('{}_{}.h5'.format( config['Retina']['input_file'], user_id)) inputs[u'ydomain'] = input_array.max() for i, item in enumerate(retina_input_uids): inputs['data'][item] = np.hstack( (np.arange(int((steps - ignored_steps) / 10)).reshape( (-1, 1)) * dt * 10, input_array[ignored_steps::10, i:i + 1])).tolist() del input_array # post-processing outputs from all LPUs and combine them into one dictionary result = { u'ydomain': 1, u'xdomain': dt * (steps - ignored_steps), u'dt': dt * 10, u'data': {} } for k, lpu in lpus.items(): with h5py.File(lpu['output_file']) as output_file: uids = output_file['V']['uids'][:] output_array = output_file['V']['data'][:] for i, item in enumerate(uids): output = output_array[int(ignored_steps / 10):, i:i + 1] # tmp = output.max()-output.min() # if tmp <= 0.01: #mV # output = (output - output.min()) + 0.5 # else: # output = (output - output.min())/tmp*0.9+0.1 result['data'][item] = np.hstack( (np.arange(int((steps - ignored_steps) / 10)).reshape( (-1, 1)) * dt * 10, output)).tolist() return inputs, result
def main(): import neurokernel.mpi_relaunch logger = setup_logger(file_name=None, screen=True) parser = argparse.ArgumentParser() parser.add_argument('-l', '--layers', dest='num_layers', type=int, default=16, help='number of layers of ommatidia on circle') parser.add_argument('-i', '--input', action="store_true", help='generates input if set') parser.add_argument('-g', '--gexf', action="store_true", help='generates gexf of LPU if set') parser.add_argument('--steps', default=100, type=int, help='simulation steps') args = parser.parse_args() dt = 1e-4 GEXF_FILE = 'retina.gexf.gz' INPUT_FILE = 'vision_input.h5' IMAGE_FILE = 'image1.mat' OUTPUT_FILE = 'retina_output.h5' if args.input: print('Generating input of model from image file') generate_input(INPUT_FILE, IMAGE_FILE, args.num_layers) if args.gexf: print('Writing retina lpu') n = args.num_layers photoreceptor_num = 6 * (3 * n * (n + 1) + 1) generate_gexf(GEXF_FILE, photoreceptor_num) man = core_gpu.Manager() print('Parsing lpu data') n_dict_ret, s_dict_ret = LPU.lpu_parser(GEXF_FILE) print('Initializing LPU') man.add(LPU, 'retina', dt, n_dict_ret, s_dict_ret, input_file=INPUT_FILE, output_file=OUTPUT_FILE, device=0, debug=True, time_sync=False) man.spawn() print('Starting simulation') start_time = time.time() man.start(steps=args.steps) man.wait() print('Simulation complete: Duration {} seconds'.format(time.time() - start_time))
def test_graph_to_dicts(self): self.maxDiff = 2048 g = nx.MultiDiGraph() g.add_node('0', {'model': 'LeakyIAF', 'spiking': True, 'extern': True, 'public': True, 'selector': '/lif0', 'C': 1.0, 'R': 1.0, 'V': -1.0, 'Vr': -0.1, 'Vt': -0.1, 'name': 'lif0'}) g.add_node('1', {'model': 'LeakyIAF', 'spiking': True, 'extern': True, 'public': True, 'selector': '/lif1', 'C': 2.0, 'R': 2.0, 'V': -2.0, 'Vr': -0.2, 'Vt': -0.2, 'name': 'lif1'}) g.add_node('2', {'model': 'MorrisLecar', 'spiking': False, 'extern': False, 'public': False, 'selector': '/ml0', 'V1': 0.03, 'V2': 0.3, 'V3': 0.2, 'V4': 0.1, 'initV': -0.1, 'initn': 0.1, 'offset': 0, 'phi': 0.01, 'name': 'ml0'}) g.add_node('3', {'model': 'MorrisLecar', 'spiking': False, 'extern': False, 'public': False, 'selector': '/ml1', 'V1': 0.04, 'V2': 0.4, 'V3': 0.3, 'V4': 0.2, 'initV': -0.2, 'initn': 0.2, 'offset': 0, 'phi': 0.02, 'name': 'ml1'}) g.add_edge('0', '1', attr_dict={'class': 0, 'model': 'AlphaSynapse', 'conductance': True, 'name': 'lif0-lif1', 'reverse': 0.01, 'ad': 0.01, 'gr': 1.0, 'gmax': 0.001}) g.add_edge('1', '0', attr_dict={'class': 0, 'model': 'AlphaSynapse', 'conductance': True, 'name': 'lif1-lif0', 'reverse': 0.02, 'ad': 0.02, 'gr': 2.0, 'gmax': 0.002}) n_dict, s_dict = LPU.graph_to_dicts(g) self.assertDictEqual(n_dict, {'LeakyIAF': {'C': [1.0, 2.0], 'name': ['lif0', 'lif1'], 'id': [0, 1], 'selector': ['/lif0', '/lif1'], 'Vr': [-0.1, -0.2], 'R': [1.0, 2.0], 'Vt': [-0.1, -0.2], 'V': [-1.0, -2.0], 'extern': [True, True], 'spiking': [True, True], 'public': [True, True]}, 'MorrisLecar': { 'V1': [0.03,0.04], 'V2': [0.3, 0.4], 'V3': [0.2, 0.3], 'V4': [0.1, 0.2], 'initV': [-0.1, -0.2], 'initn': [0.1, 0.2], 'offset': [0, 0], 'phi': [0.01, 0.02], 'selector': ['/ml0','/ml1'], 'name': ['ml0','ml1'], 'id': [2, 3], 'extern': [False, False], 'spiking': [False, False], 'public': [False, False]}}) self.assertDictEqual(s_dict, {'AlphaSynapse': {'pre': ['1', '0'], 'reverse': [0.02, 0.01], 'gmax': [0.002, 0.001], 'post': ['0', '1'], 'class': [0, 0], 'conductance': [True, True], 'ad': [0.02, 0.01], 'gr': [2.0, 1.0], 'id': [0, 1], 'name': ['lif1-lif0', 'lif0-lif1']}})
help='GPU for integration [default:3]') args = parser.parse_args() dt = 1e-4 dur = 1.4 Nt = args.steps or int(dur/dt) file_name = 'neurokernel.log' if args.log.lower() in ['file', 'both'] else None screen = True if args.log.lower() in ['screen', 'both'] else False logger = setup_logger(file_name=file_name, screen=screen) man = core.Manager() # Load configurations for lamina, medulla and antennal lobe models: al_id = 'antennallobe' (n_dict_al, s_dict_al) = LPU.lpu_parser( './data/antennallobe.gexf.gz') man.add(LPU, al_id, dt, n_dict_al, s_dict_al, input_file='./data/olfactory_input.h5', output_file='antennallobe_output.h5', device=args.al_dev, time_sync=args.time_sync) lam_id = 'lamina' (n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz') man.add(LPU, lam_id, dt, n_dict_lam, s_dict_lam, input_file='./data/vision_input.h5', output_file='lamina_output.h5', device=args.al_dev, time_sync=args.time_sync) med_id = 'medulla' (n_dict_med, s_dict_med) = LPU.lpu_parser('./data/medulla.gexf.gz') man.add(LPU, med_id, dt, n_dict_med, s_dict_med,
def run(connected): """ Set `connected` to True to connect the LPUs. """ import neurokernel.mpi_relaunch out_name = 'un' if not connected else 'co' man = core.Manager() lpu_file_0 = './data/generic_lpu_0.gexf.gz' lpu_file_1 = './data/generic_lpu_1.gexf.gz' comp_dict_0, conns_0 = LPU.lpu_parser(lpu_file_0) comp_dict_1, conns_1 = LPU.lpu_parser(lpu_file_1) fl_input_processor_0 = FileInputProcessor( './data/generic_lpu_0_input.h5') fl_output_processor_0 = FileOutputProcessor( [('V', None), ('spike_state', None)], 'generic_lpu_0_%s_output.h5' % out_name, sample_interval=1) lpu_0_id = 'lpu_0' man.add(LPU, lpu_0_id, dt, comp_dict_0, conns_0, input_processors=[fl_input_processor_0], output_processors=[fl_output_processor_0], device=args.gpu_dev[0], debug=args.debug, time_sync=args.time_sync) fl_input_processor_1 = FileInputProcessor( './data/generic_lpu_1_input.h5') fl_output_processor_1 = FileOutputProcessor( [('V', None), ('spike_state', None)], 'generic_lpu_1_%s_output.h5' % out_name, sample_interval=1) lpu_1_id = 'lpu_1' man.add(LPU, lpu_1_id, dt, comp_dict_1, conns_1, input_processors=[fl_input_processor_1], output_processors=[fl_output_processor_1], device=args.gpu_dev[1], debug=args.debug, time_sync=args.time_sync) # 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_spk_0 = plsel.Selector(','.join( LPU.extract_out_spk(comp_dict_0, 'id')[0])) out_ports_gpot_0 = plsel.Selector(','.join( LPU.extract_out_gpot(comp_dict_0, 'id')[0])) out_ports_spk_1 = plsel.Selector(','.join( LPU.extract_out_spk(comp_dict_1, 'id')[0])) out_ports_gpot_1 = plsel.Selector(','.join( LPU.extract_out_gpot(comp_dict_1, 'id')[0])) in_ports_spk_0 = plsel.Selector(','.join( LPU.extract_in_spk(comp_dict_0, 'id')[0])) in_ports_gpot_0 = plsel.Selector(','.join( LPU.extract_in_gpot(comp_dict_0, 'id')[0])) in_ports_spk_1 = plsel.Selector(','.join( LPU.extract_in_spk(comp_dict_1, 'id')[0])) in_ports_gpot_1 = plsel.Selector(','.join( LPU.extract_in_gpot(comp_dict_1, 'id')[0])) out_ports_0 = plsel.Selector.union(out_ports_spk_0, out_ports_gpot_0) out_ports_1 = plsel.Selector.union(out_ports_spk_1, out_ports_gpot_1) in_ports_0 = plsel.Selector.union(in_ports_spk_0, in_ports_gpot_0) in_ports_1 = plsel.Selector.union(in_ports_spk_1, in_ports_gpot_1) # Initialize a connectivity pattern between the two sets of port # selectors: pat = pattern.Pattern( plsel.Selector.union(out_ports_0, in_ports_0), plsel.Selector.union(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.identifiers, N_conn_spk_0_1), random.sample(in_ports_spk_1.identifiers, 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.identifiers, N_conn_gpot_0_1), random.sample(in_ports_gpot_1.identifiers, N_conn_gpot_0_1)): pat[src, dest] = 1 pat.interface[src, 'type'] = 'gpot' pat.interface[dest, 'type'] = 'gpot' man.connect(lpu_0_id, lpu_1_id, pat, 0, 1) man.spawn() man.start(steps=args.steps) man.wait()
'--al_dev', default=0, type=int, help='GPU for antennal lobe [default:0]') 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 = setup_logger(file_name=file_name, screen=screen) man = core.Manager() (n_dict, s_dict) = LPU.lpu_parser('./data/antennallobe.gexf.gz') man.add(LPU, 'al', dt, n_dict, s_dict, input_file='./data/olfactory_input.h5', output_file='olfactory_output.h5', debug=args.debug) man.spawn() man.start(steps=args.steps) man.wait()
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()
help='GPU for medulla [default: 1]') 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 = setup_logger(file_name=file_name, screen=screen) man = core.Manager() lam_id = 'lamina' (n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz') man.add(LPU, lam_id, dt, n_dict_lam, s_dict_lam, input_file='./data/vision_input.h5', output_file='lamina_output.h5', device=args.lam_dev, time_sync=args.time_sync) med_id = 'medulla' (n_dict_med, s_dict_med) = LPU.lpu_parser('./data/medulla.gexf.gz') man.add(LPU, med_id, dt,
def test_graph_to_dicts(self): self.maxDiff = 2048 g = nx.MultiDiGraph() g.add_node( '0', { 'model': 'LeakyIAF', 'spiking': True, 'extern': True, 'public': True, 'selector': '/lif0', 'C': 1.0, 'R': 1.0, 'V': -1.0, 'Vr': -0.1, 'Vt': -0.1, 'name': 'lif0' }) g.add_node( '1', { 'model': 'LeakyIAF', 'spiking': True, 'extern': True, 'public': True, 'selector': '/lif1', 'C': 2.0, 'R': 2.0, 'V': -2.0, 'Vr': -0.2, 'Vt': -0.2, 'name': 'lif1' }) g.add_node( '2', { 'model': 'MorrisLecar', 'spiking': False, 'extern': False, 'public': False, 'selector': '/ml0', 'V1': 0.03, 'V2': 0.3, 'V3': 0.2, 'V4': 0.1, 'initV': -0.1, 'initn': 0.1, 'offset': 0, 'phi': 0.01, 'name': 'ml0' }) g.add_node( '3', { 'model': 'MorrisLecar', 'spiking': False, 'extern': False, 'public': False, 'selector': '/ml1', 'V1': 0.04, 'V2': 0.4, 'V3': 0.3, 'V4': 0.2, 'initV': -0.2, 'initn': 0.2, 'offset': 0, 'phi': 0.02, 'name': 'ml1' }) g.add_edge('0', '1', attr_dict={ 'class': 0, 'model': 'AlphaSynapse', 'conductance': True, 'name': 'lif0-lif1', 'reverse': 0.01, 'ad': 0.01, 'gr': 1.0, 'gmax': 0.001 }) g.add_edge('1', '0', attr_dict={ 'class': 0, 'model': 'AlphaSynapse', 'conductance': True, 'name': 'lif1-lif0', 'reverse': 0.02, 'ad': 0.02, 'gr': 2.0, 'gmax': 0.002 }) n_dict, s_dict = LPU.graph_to_dicts(g) self.assertDictEqual( n_dict, { 'LeakyIAF': { 'C': [1.0, 2.0], 'name': ['lif0', 'lif1'], 'id': [0, 1], 'selector': ['/lif0', '/lif1'], 'Vr': [-0.1, -0.2], 'R': [1.0, 2.0], 'Vt': [-0.1, -0.2], 'V': [-1.0, -2.0], 'extern': [True, True], 'spiking': [True, True], 'public': [True, True] }, 'MorrisLecar': { 'V1': [0.03, 0.04], 'V2': [0.3, 0.4], 'V3': [0.2, 0.3], 'V4': [0.1, 0.2], 'initV': [-0.1, -0.2], 'initn': [0.1, 0.2], 'offset': [0, 0], 'phi': [0.01, 0.02], 'selector': ['/ml0', '/ml1'], 'name': ['ml0', 'ml1'], 'id': [2, 3], 'extern': [False, False], 'spiking': [False, False], 'public': [False, False] } }) self.assertDictEqual( s_dict, { 'AlphaSynapse': { 'pre': ['1', '0'], 'reverse': [0.02, 0.01], 'gmax': [0.002, 0.001], 'post': ['0', '1'], 'class': [0, 0], 'conductance': [True, True], 'ad': [0.02, 0.01], 'gr': [2.0, 1.0], 'id': [0, 1], 'name': ['lif1-lif0', 'lif0-lif1'] } })
port_time = get_random_port() else: port_time = args.port_time 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)
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/antennallobe.gexf.gz') al = 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.al_dev, id='al', debug=args.debug) man.add_mod(al) man.start(steps=args.steps) man.stop()
help='GPU for medulla [default: 1]') 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 = setup_logger(file_name=file_name, screen=screen) man = core.Manager() lam_id = 'lamina' (n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz') man.add(LPU, lam_id, dt, n_dict_lam, s_dict_lam, input_file='./data/vision_input.h5', output_file='lamina_output.h5', device=args.lam_dev, time_sync=args.time_sync) med_id = 'medulla' (n_dict_med, s_dict_med) = LPU.lpu_parser('./data/medulla.gexf.gz') man.add(LPU, med_id, dt, n_dict_med, s_dict_med, output_file='medulla_output.h5', device=args.med_dev, time_sync=args.time_sync) pat = pattern.Pattern.from_graph(nx.read_gexf('./data/lam_med.gexf.gz')) man.connect(lam_id, med_id, pat, 0, 1) man.spawn()
def launch(self, user_id, task): neuron_uid_list = [str(a) for a in task['neuron_list']] conf_obj = get_config_obj() config = conf_obj.conf if config['Retina']['intype'] == 'Natural': coord_file = config['InputType']['Natural']['coord_file'] tmp = os.path.splitext(coord_file) config['InputType']['Natural']['coord_file'] = '{}_{}{}'.format( tmp[0], user_id, tmp[1]) setup_logger(file_name='neurokernel_' + user_id + '.log', screen=False) manager = core.Manager() lpus = {} patterns = {} G = task['success']['data'] # get graph and output_uid_list for each LPU for k, lpu in G['LPU'].iteritems(): lpus[k] = {} g_lpu_na = create_graph_from_database_returned(lpu) lpu_nk_graph = nk.na_lpu_to_nk_new(g_lpu_na) lpus[k]['graph'] = lpu_nk_graph lpus[k]['output_uid_list'] = list( set(lpu_nk_graph.nodes()).intersection(set(neuron_uid_list))) lpus[k]['output_file'] = '{}_output_{}.h5'.format(k, user_id) # get graph for each Pattern for k, pat in G['Pattern'].iteritems(): l1, l2 = k.split('-') if l1 in lpus and l2 in lpus: g_pattern_na = create_graph_from_database_returned(pat) pattern_nk = nk.na_pat_to_nk(g_pattern_na) lpu_ports = [node[1]['selector'] \ for node in lpus[l1]['graph'].nodes(data=True) \ if node[1]['class']=='Port'] + \ [node[1]['selector'] \ for node in lpus[l2]['graph'].nodes(data=True) \ if node[1]['class']=='Port'] pattern_ports = pattern_nk.nodes() patterns[k] = {} patterns[k]['graph'] = pattern_nk.subgraph( list(set(lpu_ports).intersection(set(pattern_ports)))) dt = config['General']['dt'] # add LPUs to manager for k, lpu in lpus.iteritems(): graph = lpu['graph'] if k == 'retina': prs = [node for node in graph.nodes(data=True) \ if node[1]['class'] == 'PhotoreceptorModel'] for pr in prs: graph.node[pr[0]]['num_microvilli'] = 3000 input_processors = [ RetinaInputIndividual(config, prs, user_id) ] extra_comps = [PhotoreceptorModel] retina_input_uids = [a[0] for a in prs] else: input_processors = [] extra_comps = [BufferVoltage] output_processor = FileOutputProcessor( [('V', lpu['output_uid_list'])], lpu['output_file'], sample_interval=10) (comp_dict, conns) = LPU.graph_to_dicts(graph) manager.add(LPU, k, dt, comp_dict, conns, device=0, input_processors=input_processors, output_processors=[output_processor], extra_comps=extra_comps) # connect LPUs by Patterns for k, pattern in patterns.iteritems(): l1, l2 = k.split('-') if l1 in lpus and l2 in lpus: print('Connecting {} and {}'.format(l1, l2)) pat, key_order = Pattern.from_graph( nx.DiGraph(pattern['graph'])) with Timer('update of connections in Manager'): manager.connect(l1, l2, pat, int_0=key_order.index(l1), int_1=key_order.index(l2)) # start simulation steps = config['General']['steps'] ignored_steps = config['General']['ignored_steps'] manager.spawn() manager.start(steps=steps) manager.wait() time.sleep(5) # post-processing inputs (hard coded, can be better organized) inputs = { u'ydomain': 1.0, u'xdomain': dt * (steps - ignored_steps), u'dt': dt * 10, u'data': {} } if 'retina' in lpus: input_array = si.read_array('{}_{}.h5'.format( config['Retina']['input_file'], user_id)) inputs[u'ydomain'] = input_array.max() for i, item in enumerate(retina_input_uids): inputs['data'][item] = np.hstack( (np.arange(int((steps - ignored_steps) / 10)).reshape( (-1, 1)) * dt * 10, input_array[ignored_steps::10, i:i + 1])).tolist() del input_array # post-processing outputs from all LPUs and combine them into one dictionary result = { u'ydomain': 1, u'xdomain': dt * (steps - ignored_steps), u'dt': dt * 10, u'data': {} } for k, lpu in lpus.iteritems(): with h5py.File(lpu['output_file']) as output_file: uids = output_file['V']['uids'][:] output_array = output_file['V']['data'][:] for i, item in enumerate(uids): output = output_array[int(ignored_steps / 10):, i:i + 1] tmp = output.max() - output.min() if tmp <= 0.01: #mV output = (output - output.min()) + 0.5 else: output = (output - output.min()) / tmp * 0.9 + 0.1 result['data'][item] = np.hstack( (np.arange(int((steps - ignored_steps) / 10)).reshape( (-1, 1)) * dt * 10, output)).tolist() return inputs, result
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 = setup_logger(file_name=file_name, screen=screen) man = core.Manager() np.random.seed(0) lpu_name = 'neurodriver' g = create_lpu_graph(lpu_name, *args.n) n_dict, s_dict = LPU.graph_to_dicts(g) total_neurons = \ len([d for n, d in g.nodes(data=True) if d['model'] == 'LeakyIAF']) total_synapses = \ len([d for f, t, d in g.edges(data=True) if d['model'] == 'AlphaSynapse']) output_file = None man.add(MyLPU, lpu_name, dt, n_dict, s_dict, I_const=0.6, output_file=output_file, device=args.gpu_dev, debug=args.debug, time_sync=True) man.spawn() start = time.time() man.start(steps=args.steps)
#lpu_name_to_s_dict = {} # LPU name -> s_dict data struct lpu_name_to_comp_dict = {} # LPU name -> comp_dict data struct lpu_name_to_conn_list = {} # LPU name -> conn_list data struct for name in lpu_name_list: lpu_name_to_node[name] = graph.LPUs.query(name=name).one() lpu_name_to_g_na[name] = lpu_name_to_node[name].traverse_owns( max_levels=2).get_as('nx') lpu_name_to_g_nk_orig[name] = nk.na_lpu_to_nk_new(lpu_name_to_g_na[name]) lpu_name_to_g_nk[name] = nx.convert_node_labels_to_integers( lpu_name_to_g_nk_orig[name], ordering='sorted') lpu_name_to_g_nk[name] = \ partly_relabel_by_sorted_attr(lpu_name_to_g_nk[name], 'model', ['LeakyIAF'], 'name') #lpu_name_to_n_dict[name], lpu_name_to_s_dict[name] = LPU.graph_to_dicts(lpu_name_to_g_nk[name]) lpu_name_to_comp_dict[name], lpu_name_to_conn_list[ name] = LPU.graph_to_dicts(lpu_name_to_g_nk[name]) # Patterns: pat_name_list = [n.name for n in graph.Patterns.query().all()] pat_name_to_node = {} # LPU pair -> pyorient Pattern node pat_name_to_g_na = {} # LPU pair -> NeuroArch-compatible graph pat_name_to_g_nk = {} # LPU pair -> Neurokernel-compatible graph pat_name_to_pat = {} # LPU pair -> Pattern class instance for name in pat_name_list: pat_name_to_node[name] = graph.Patterns.query(name=name).one() pat_name_to_g_na[name] = pat_name_to_node[name].traverse_owns( max_levels=2).get_as('nx') pat_name_to_g_nk[name] = nk.na_pat_to_nk(pat_name_to_g_na[name]) pat_name_to_pat[name] = pattern.Pattern.from_graph(
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, 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()
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 port_time = get_random_port() man = core.Manager(port_data, port_ctrl, port_time) man.add_brok() (n_dict, s_dict) = LPU.lpu_parser('./data/antennallobe.gexf.gz') al = 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.al_dev, id='al', debug=args.debug) man.add_mod(al) man.start(steps=args.steps) man.stop()
help='GPU for integration [default:3]') args = parser.parse_args() dt = 1e-4 dur = 1.4 Nt = args.steps or int(dur / dt) file_name = 'neurokernel.log' if args.log.lower() in ['file', 'both'] else None screen = True if args.log.lower() in ['screen', 'both'] else False logger = setup_logger(file_name=file_name, screen=screen) man = core.Manager() # Load configurations for lamina, medulla and antennal lobe models: al_id = 'antennallobe' (n_dict_al, s_dict_al) = LPU.lpu_parser('./data/antennallobe.gexf.gz') man.add(LPU, al_id, dt, n_dict_al, s_dict_al, input_file='./data/olfactory_input.h5', output_file='antennallobe_output.h5', device=args.al_dev, time_sync=args.time_sync) lam_id = 'lamina' (n_dict_lam, s_dict_lam) = LPU.lpu_parser('./data/lamina.gexf.gz') man.add(LPU, lam_id, dt,
if args.log.lower() in ['file', 'both']: file_name = 'neurokernel.log' if args.log.lower() in ['screen', 'both']: screen = True logger = setup_logger(file_name=file_name, screen=screen) man = core.Manager() G = nx.MultiDiGraph() G.add_node('neuron0', **{ 'class': 'ConnorStevens', 'name': 'ConnorStevens', }) comp_dict, conns = LPU.graph_to_dicts(G) fl_input_processor = StepInputProcessor('I', ['neuron0'], 40, 0.15, 0.25) fl_output_processor = FileOutputProcessor([('spike_state', None),('V', None)], 'new_output.h5', sample_interval=1) man.add(LPU, 'ge', dt, comp_dict, conns, device=args.gpu_dev, input_processors = [fl_input_processor], output_processors = [fl_output_processor], debug=args.debug) man.spawn() man.start(steps=args.steps) man.wait() # plot the result import h5py import matplotlib
n = args.num_layers photoreceptor_num = 6*(3*n*(n+1)+1) generate_gexf(GEXF_FILE, photoreceptor_num) 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() 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=args.ret_dev, 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))
else: port_data = args.port_data port_ctrl = args.port_ctrl for i, neu_num in neu_dict.iteritems(): lpu_entry = {} 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
import h5py import networkx as nx import argparse import itertools import random import pickle import neurokernel.mpi_relaunch import neurokernel.core_gpu as core from neurokernel.LPU.InputProcessors.StepInputProcessor import StepInputProcessor from neurokernel.LPU.InputProcessors.FileInputProcessor import FileInputProcessor from neurokernel.tools.logging import setup_logger from neurokernel.LPU.LPU import LPU (comp_dict, conns) = LPU.lpu_parser('neuroballad_temp_model.gexf.gz') with open('run_parameters.pickle', 'rb') as f: run_parameters = pickle.load(f) with open('record_parameters.pickle', 'rb') as f: record_parameters = pickle.load(f) dur = 1.0 dt = 1e-4 dur = run_parameters[0] dt = run_parameters[1] fl_input_processor = FileInputProcessor('neuroballad_temp_model_input.h5') from neurokernel.LPU.OutputProcessors.FileOutputProcessor import FileOutputProcessor output_processor = FileOutputProcessor(record_parameters, 'neuroballad_temp_model_output.h5', sample_interval=1)
help='Write connectivity structures and inter-LPU routed data in debug folder') parser.add_argument('-l', '--log', default='none', type=str, help='Log output to screen [file, screen, both, or none; default:none]') parser.add_argument('-s', '--steps', default=steps, type=int, help='Number of steps [default: %s]' % steps) parser.add_argument('-g', '--gpu_dev', default=0, type=int, help='GPU device number [default: 0]') 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 = setup_logger(file_name=file_name, screen=screen) man = core.Manager() (n_dict, s_dict) = LPU.lpu_parser('./data/generic_lpu.gexf.gz') man.add(LPU, 'ge', dt, n_dict, s_dict, input_file='./data/generic_input.h5', output_file='generic_output.h5', device=args.gpu_dev, debug=args.debug) man.spawn() man.start(steps=args.steps) man.wait()
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() # 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,
n = args.num_layers photoreceptor_num = 6 * (3 * n * (n + 1) + 1) generate_gexf(GEXF_FILE, photoreceptor_num) 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() 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')
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()
def run(connected): """ Set `connected` to True to connect the LPUs. """ import neurokernel.mpi_relaunch out_name = 'un' if not connected else 'co' man = core.Manager() lpu_file_0 = './data/generic_lpu_0.gexf.gz' lpu_file_1 = './data/generic_lpu_1.gexf.gz' comp_dict_0, conns_0 = LPU.lpu_parser(lpu_file_0) comp_dict_1, conns_1 = LPU.lpu_parser(lpu_file_1) fl_input_processor_0 = FileInputProcessor('./data/generic_lpu_0_input.h5') fl_output_processor_0 = FileOutputProcessor( [('V',None),('spike_state',None)], 'generic_lpu_0_%s_output.h5' % out_name, sample_interval=1) lpu_0_id = 'lpu_0' man.add(LPU, lpu_0_id, dt, comp_dict_0, conns_0, input_processors = [fl_input_processor_0], output_processors = [fl_output_processor_0], device=args.gpu_dev[0], debug=args.debug, time_sync=args.time_sync) fl_input_processor_1 = FileInputProcessor('./data/generic_lpu_1_input.h5') fl_output_processor_1 = FileOutputProcessor( [('V',None),('spike_state',None)], 'generic_lpu_1_%s_output.h5' % out_name, sample_interval=1) lpu_1_id = 'lpu_1' man.add(LPU, lpu_1_id, dt, comp_dict_1, conns_1, input_processors = [fl_input_processor_1], output_processors = [fl_output_processor_1], device=args.gpu_dev[1], debug=args.debug, time_sync=args.time_sync) # 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_spk_0 = plsel.Selector( ','.join(LPU.extract_out_spk(comp_dict_0, 'id')[0])) out_ports_gpot_0 = plsel.Selector( ','.join(LPU.extract_out_gpot(comp_dict_0, 'id')[0])) out_ports_spk_1 = plsel.Selector( ','.join(LPU.extract_out_spk(comp_dict_1, 'id')[0])) out_ports_gpot_1 = plsel.Selector( ','.join(LPU.extract_out_gpot(comp_dict_1, 'id')[0])) in_ports_spk_0 = plsel.Selector( ','.join(LPU.extract_in_spk(comp_dict_0, 'id')[0])) in_ports_gpot_0 = plsel.Selector( ','.join(LPU.extract_in_gpot(comp_dict_0, 'id')[0])) in_ports_spk_1 = plsel.Selector( ','.join(LPU.extract_in_spk(comp_dict_1, 'id')[0])) in_ports_gpot_1 = plsel.Selector( ','.join(LPU.extract_in_gpot(comp_dict_1, 'id')[0])) out_ports_0 = plsel.Selector.union(out_ports_spk_0, out_ports_gpot_0) out_ports_1 = plsel.Selector.union(out_ports_spk_1, out_ports_gpot_1) in_ports_0 = plsel.Selector.union(in_ports_spk_0, in_ports_gpot_0) in_ports_1 = plsel.Selector.union(in_ports_spk_1, in_ports_gpot_1) # Initialize a connectivity pattern between the two sets of port # selectors: pat = pattern.Pattern(plsel.Selector.union(out_ports_0, in_ports_0), plsel.Selector.union(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.identifiers, N_conn_spk_0_1), random.sample(in_ports_spk_1.identifiers, 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.identifiers, N_conn_gpot_0_1), random.sample(in_ports_gpot_1.identifiers, N_conn_gpot_0_1)): pat[src, dest] = 1 pat.interface[src, 'type'] = 'gpot' pat.interface[dest, 'type'] = 'gpot' man.connect(lpu_0_id, lpu_1_id, pat, 0, 1) man.spawn() man.start(steps=args.steps) man.wait()
#lpu_name_to_n_dict = {} # LPU name -> n_dict data struct #lpu_name_to_s_dict = {} # LPU name -> s_dict data struct lpu_name_to_comp_dict = {} # LPU name -> comp_dict data struct lpu_name_to_conn_list = {} # LPU name -> conn_list data struct for name in lpu_name_list: lpu_name_to_node[name] = graph.LPUs.query(name=name).one() lpu_name_to_g_na[name] = lpu_name_to_node[name].traverse_owns( max_levels=2).get_as('nx') lpu_name_to_g_nk_orig[name] = nk.na_lpu_to_nk_new(lpu_name_to_g_na[name]) lpu_name_to_g_nk[name] = nx.convert_node_labels_to_integers( lpu_name_to_g_nk_orig[name], ordering='sorted') lpu_name_to_g_nk[name] = \ partly_relabel_by_sorted_attr(lpu_name_to_g_nk[name], 'model', ['LeakyIAF'], 'name') lpu_name_to_comp_dict[name], lpu_name_to_conn_list[ name] = LPU.graph_to_dicts(lpu_name_to_g_nk[name]) # Select spiking projection neurons: lpu_name_to_neurons = {} ''' for name in lpu_name_list: lpu_name_to_neurons[name] = \ sorted([int(k) for k, n in lpu_name_to_g_nk[name].node.items() if \ n['class'] != 'port_in_spk' and \ n['spiking']]) ''' ##### Pick 80 Neurons and sort them for visualization ###### sort_list = {} lpu_region_to_vision_region = lpu_region_to_number() for name in ['BU', 'bu']:
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, 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()
print('Writing lamina lpu') eyemodel.write_lamina(LAM_GEXF_FILE) 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 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')