def test_src_idx_dest_type(self):
p = Pattern('/[aaa,bbb][0:3]', '/[xxx,yyy][0:3]')
p['/aaa[0]', '/yyy[0]'] = 1
p['/aaa[0]', '/yyy[1]'] = 1
p['/aaa[0]', '/yyy[2]'] = 1
p['/xxx[0]', '/bbb[0]'] = 1
p['/xxx[1]', '/bbb[1]'] = 1
p['/xxx[2]', '/bbb[2]'] = 1
p.interface['/aaa[0:3]', 'type'] = 'spike'
p.interface['/yyy[0:3]', 'type'] = 'spike'
self.assertItemsEqual(p.src_idx(0, 1, dest_type='spike'),
[('aaa', 0)])
self.assertItemsEqual(p.src_idx(0, 1, dest_type='gpot'), [])
def test_connected_port_pairs(self):
p = Pattern('/aaa[0:3]', '/bbb[0:3]')
p['/aaa[0]', '/bbb[2]'] = 1
p['/aaa[1]', '/bbb[0]'] = 1
p['/aaa[2]', '/bbb[1]'] = 1
self.assertSequenceEqual(p.connected_port_pairs(),
[(('aaa', 0), ('bbb', 2)),
(('aaa', 1), ('bbb', 0)),
(('aaa', 2), ('bbb', 1))])
self.assertSequenceEqual(p.connected_port_pairs(True),
[('/aaa/0', '/bbb/2'),
('/aaa/1', '/bbb/0'),
('/aaa/2', '/bbb/1')])
def test_src_idx_dest_type(self):
p = Pattern('/[aaa,bbb][0:3]', '/[xxx,yyy][0:3]')
p['/aaa[0]', '/yyy[0]'] = 1
p['/aaa[0]', '/yyy[1]'] = 1
p['/aaa[0]', '/yyy[2]'] = 1
p['/xxx[0]', '/bbb[0]'] = 1
p['/xxx[1]', '/bbb[1]'] = 1
p['/xxx[2]', '/bbb[2]'] = 1
p.interface['/aaa[0:3]', 'type'] = 'spike'
p.interface['/yyy[0:3]', 'type'] = 'spike'
self.assertItemsEqual(p.src_idx(0, 1, dest_type='spike'), [('aaa', 0)])
self.assertItemsEqual(p.src_idx(0, 1, dest_type='gpot'), [])
q = Pattern('/[aaa,bbb,ccc]', '/[www,xxx,yyy,zzz]')
q['/aaa', '/www'] = 1
q['/aaa', '/xxx'] = 1
q['/yyy', '/bbb'] = 1
q['/zzz', '/ccc'] = 1
q.interface['/aaa'] = [0, 'in', 'spike']
q.interface['/[www,xxx]'] = [1, 'out', 'spike']
self.assertItemsEqual(q.src_idx(0, 1, dest_type='spike'), [('aaa', )])
self.assertItemsEqual(q.src_idx(0, 1, dest_type='gpot'), [])
def test_get_conns(self):
p = Pattern('/aaa[0:3]', '/bbb[0:3]')
p['/aaa[0]', '/bbb[2]'] = 1
p['/aaa[1]', '/bbb[0]'] = 1
p['/aaa[2]', '/bbb[1]'] = 1
self.assertSequenceEqual(p.get_conns(),
[(('aaa', 0), ('bbb', 2)),
(('aaa', 1), ('bbb', 0)),
(('aaa', 2), ('bbb', 1))])
self.assertSequenceEqual(p.get_conns(True),
[('/aaa[0]', '/bbb[2]'),
('/aaa[1]', '/bbb[0]'),
('/aaa[2]', '/bbb[1]')])
def test_create(self):
p = Pattern('/foo[0:5]', '/bar[0:5]')
p['/foo[0]', '/bar[0]'] = 1
p['/foo[1]', '/bar[1]'] = 1
p['/foo[1]', '/bar[2]'] = 1
p['/bar[3]', '/foo[2]'] = 1
p['/bar[3]', '/foo[3]'] = 1
p['/bar[4]', '/foo[4]'] = 1
assert_frame_equal(p.data, self.df_p)
p.interface['/foo[0:2]', 'type'] = 'spike'
p.interface['/bar[0:2]', 'type'] = 'spike'
p.interface['/foo[2:5]', 'type'] = 'gpot'
p.interface['/bar[3:5]', 'type'] = 'gpot'
assert_frame_equal(p.interface.data, self.df_i)
def test_interface_ports(self):
p = Pattern('/foo[0:3]', '/bar[0:3]')
p.interface['/foo[0]', 'io', 'type'] = ['in', 'spike']
p.interface['/foo[1:3]', 'io', 'type'] = ['out', 'gpot']
p.interface['/bar[0:2]', 'io', 'type'] = ['out', 'spike']
p.interface['/bar[2]', 'io', 'type'] = ['in', 'gpot']
self.assertItemsEqual(p.interface_ports(0).to_tuples(),
[('foo', 0),
('foo', 1),
('foo', 2)])
self.assertItemsEqual(p.interface_ports(1).to_tuples(),
[('bar', 0),
('bar', 1),
('bar', 2)])
def test_dest_idx_src_type(self):
p = Pattern('/[aaa,bbb][0:3]', '/[xxx,yyy][0:3]')
p['/aaa[0]', '/yyy[0]'] = 1
p['/aaa[0]', '/yyy[1]'] = 1
p['/aaa[0]', '/yyy[2]'] = 1
p['/xxx[0]', '/bbb[0]'] = 1
p['/xxx[1]', '/bbb[1]'] = 1
p['/xxx[2]', '/bbb[2]'] = 1
p.interface['/aaa[0:3]'] = [0, 'in', 'spike']
p.interface['/yyy[0:3]'] = [1, 'out', 'spike']
self.assertItemsEqual(p.dest_idx(0, 1, src_type='spike'),
[('yyy', 0),
('yyy', 1),
('yyy', 2)])
self.assertItemsEqual(p.src_idx(0, 1, src_type='gpot'), [])
def test_connected_ports(self):
p = Pattern('/foo[0:3]', '/bar[0:3]')
p['/foo[0]', '/bar[0]'] = 1
p['/foo[1]', '/bar[1]'] = 1
self.assertItemsEqual(p.connected_ports(tuples=True),
[('bar', 0),
('bar', 1),
('foo', 0),
('foo', 1)])
self.assertItemsEqual(p.connected_ports(0, True),
[('foo', 0),
('foo', 1)])
self.assertItemsEqual(p.connected_ports(1, True),
[('bar', 0),
('bar', 1)])
def test_to_graph(self):
p = Pattern('/foo[0:4]', '/bar[0:4]')
p['/foo[0]', '/bar[0]'] = 1
p['/foo[0]', '/bar[1]'] = 1
p['/foo[1]', '/bar[2]'] = 1
p['/bar[3]', '/foo[2]'] = 1
p['/bar[3]', '/foo[3]'] = 1
g = p.to_graph()
self.assertItemsEqual(g.nodes(data=True), [('/bar/0', {
'interface': 1,
'io': 'out',
'type': ''
}), ('/bar/1', {
'interface': 1,
'io': 'out',
'type': ''
}), ('/bar/2', {
'interface': 1,
'io': 'out',
'type': ''
}), ('/bar/3', {
'interface': 1,
'io': 'in',
'type': ''
}), ('/foo/0', {
'interface': 0,
'io': 'in',
'type': ''
}), ('/foo/1', {
'interface': 0,
'io': 'in',
'type': ''
}), ('/foo/2', {
'interface': 0,
'io': 'out',
'type': ''
}), ('/foo/3', {
'interface': 0,
'io': 'out',
'type': ''
})])
self.assertItemsEqual(g.edges(data=True), [('/foo/0', '/bar/0', {}),
('/foo/0', '/bar/1', {}),
('/foo/1', '/bar/2', {}),
('/bar/3', '/foo/2', {}),
('/bar/3', '/foo/3', {})])
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 test_from_df(self):
p = Pattern('/[aaa,bbb]/0', '/[ccc,ddd]/0')
p['/aaa/0', '/ccc/0'] = 1
p['/aaa/0', '/ddd/0'] = 1
df_int = pd.DataFrame(data=[(0, 'in', np.nan), (0, np.nan, np.nan),
(1, 'out', np.nan), (1, 'out', np.nan)],
index=pd.MultiIndex(
levels=[['aaa', 'bbb', 'ccc', 'ddd'], [0]],
labels=[[0, 1, 2, 3], [0, 0, 0, 0]],
names=['0', '1']),
columns=['interface', 'io', 'type'],
dtype=object)
df_pat = pd.DataFrame(data=[(1, ), (1, )],
index=pd.MultiIndex(
levels=[['aaa'], [0], ['ccc', 'ddd'], [0]],
labels=[[0, 0], [0, 0], [0, 1], [0, 0]],
names=['from_0', 'from_1', 'to_0', 'to_1']),
columns=['conn'],
dtype=object)
q = Pattern.from_df(df_int, df_pat)
assert_frame_equal(p.data, q.data)
assert_frame_equal(p.interface.data, q.interface.data)
def run_test(m0_sel_in_gpot, m0_sel_in_spike, m0_sel_out_gpot,
m0_sel_out_spike, m1_sel_in_gpot, m1_sel_in_spike,
m1_sel_out_gpot, m1_sel_out_spike):
# Create test module classes with a queue installed in the destination
# module to check that data was correctly propagated:
class TestModule0(TestModule):
def __init__(self, *args, **kwargs):
super(TestModule0, self).__init__(*args, **kwargs)
self.q = Queue()
def run_step(self):
self.log_info('saving data to queue before run step')
if self.steps > 0:
self.q.put(
(self.pm['gpot'][self._out_port_dict['gpot']['m1']].copy(),
self.pm['spike'][self._out_port_dict['spike']
['m1']].copy()))
super(TestModule0, self).run_step()
class TestModule1(TestModule):
def __init__(self, *args, **kwargs):
super(TestModule1, self).__init__(*args, **kwargs)
self.q = Queue()
def run_step(self):
super(TestModule1, self).run_step()
self.log_info('saving data to queue after run step')
if self.steps > 0:
self.q.put(
(self.pm['gpot'][self._in_port_dict['gpot']['m0']].copy(),
self.pm['spike'][self._in_port_dict['spike']
['m0']].copy()))
m0_sel_gpot = m0_sel_in_gpot + m0_sel_out_gpot
m0_sel_spike = m0_sel_in_spike + m0_sel_out_spike
m0_sel = m0_sel_in_gpot + m0_sel_in_spike + m0_sel_out_gpot + m0_sel_out_spike
m0_data_gpot = np.ones(len(m0_sel_gpot), np.double)
m0_data_spike = np.ones(len(m0_sel_spike), np.int32)
m1_sel_gpot = m1_sel_in_gpot + m1_sel_out_gpot
m1_sel_spike = m1_sel_in_spike + m1_sel_out_spike
m1_sel = m1_sel_in_gpot + m1_sel_in_spike + m1_sel_out_gpot + m1_sel_out_spike
m1_data_gpot = np.zeros(len(m1_sel_gpot), np.double)
m1_data_spike = np.zeros(len(m1_sel_spike), np.int32)
# Instantiate manager and broker:
man = Manager(get_random_port(), get_random_port(), get_random_port())
man.add_brok()
# Add modules:
m0 = TestModule0(m0_sel,
m0_sel_in_gpot,
m0_sel_in_spike,
m0_sel_out_gpot,
m0_sel_out_spike,
m0_data_gpot,
m0_data_spike,
man.port_data,
man.port_ctrl,
man.port_time,
id='m0')
man.add_mod(m0)
m1 = TestModule1(m1_sel,
m1_sel_in_gpot,
m1_sel_in_spike,
m1_sel_out_gpot,
m1_sel_out_spike,
m1_data_gpot,
m1_data_spike,
man.port_data,
man.port_ctrl,
man.port_time,
id='m1')
man.add_mod(m1)
# Connect the modules:
pat = Pattern(m0_sel, m1_sel)
pat.interface[m0_sel_in_gpot] = [0, 'in', 'gpot']
pat.interface[m0_sel_out_gpot] = [0, 'out', 'gpot']
pat.interface[m0_sel_in_spike] = [0, 'in', 'spike']
pat.interface[m0_sel_out_spike] = [0, 'out', 'spike']
pat.interface[m1_sel_in_gpot] = [1, 'in', 'gpot']
pat.interface[m1_sel_out_gpot] = [1, 'out', 'gpot']
pat.interface[m1_sel_in_spike] = [1, 'in', 'spike']
pat.interface[m1_sel_out_spike] = [1, 'out', 'spike']
for sel_from, sel_to in zip(m0_sel_out_gpot, m1_sel_in_gpot):
if not (sel_from == ((), ) or sel_to == ((), )):
pat[sel_from, sel_to] = 1
for sel_from, sel_to in zip(m0_sel_out_spike, m1_sel_in_spike):
if not (sel_from == ((), ) or sel_to == ((), )):
pat[sel_from, sel_to] = 1
man.connect(m0, m1, pat, 0, 1)
# Execute exactly two steps; m0 transmits data during the first step, which
# should be received by m1 during the second step:
man.start(steps=2)
man.stop()
# Forcibly terminate all processes that are still alive:
if m0.is_alive():
m0.terminate()
if m1.is_alive():
m1.terminate()
for b in man.brokers.values():
if b.is_alive():
b.terminate()
# Check that data was propagated correctly:
m0_data_gpot_after, m0_data_spike_after = m0.q.get()
m1_data_gpot_after, m1_data_spike_after = m1.q.get()
assert all(m0_data_gpot_after == m1_data_gpot_after)
assert all(m0_data_spike_after == m1_data_spike_after)
m1_id = 'm1 '
man.add(MyModule, m1_id, m1_sel, m1_sel_in, m1_sel_out,
m1_sel_gpot, m1_sel_spike,
np.zeros(N1_gpot, dtype=np.double),
np.zeros(N1_spike, dtype=int),
device=0, time_sync=True)
m2_id = 'm2 '
man.add(MyModule, m2_id, m2_sel, m2_sel_in, m2_sel_out,
m2_sel_gpot, m2_sel_spike,
np.zeros(N2_gpot, dtype=np.double),
np.zeros(N2_spike, dtype=int),
device=1, time_sync=True)
# Make sure that all ports in the patterns' interfaces are set so
# that they match those of the modules:
pat12 = Pattern(m1_sel, m2_sel)
pat12.interface[m1_sel_out_gpot] = [0, 'in', 'gpot']
pat12.interface[m1_sel_in_gpot] = [0, 'out', 'gpot']
pat12.interface[m1_sel_out_spike] = [0, 'in', 'spike']
pat12.interface[m1_sel_in_spike] = [0, 'out', 'spike']
pat12.interface[m2_sel_in_gpot] = [1, 'out', 'gpot']
pat12.interface[m2_sel_out_gpot] = [1, 'in', 'gpot']
pat12.interface[m2_sel_in_spike] = [1, 'out', 'spike']
pat12.interface[m2_sel_out_spike] = [1, 'in', 'spike']
pat12['/a/out/gpot[0]', '/b/in/gpot[0]'] = 1
pat12['/a/out/gpot[1]', '/b/in/gpot[1]'] = 1
pat12['/b/out/gpot[0]', '/a/in/gpot[0]'] = 1
pat12['/b/out/gpot[1]', '/a/in/gpot[1]'] = 1
pat12['/a/out/spike[0]', '/b/in/spike[0]'] = 1
pat12['/a/out/spike[1]', '/b/in/spike[1]'] = 1
pat12['/b/out/spike[0]', '/a/in/spike[0]'] = 1
def test_create_unequal_levels(self):
p = Pattern('/x[0:3]/y', '/z[0:3]')
p['/x[0]/y', '/z[0]'] = 1
q = Pattern('/x[0:3]', '/z[0:3]/a')
q['/x[0]', '/z[0]/a'] = 1
def test_is_connected_single_level(self):
p = Pattern('/[aaa,bbb]', '/[ccc,ddd]')
p['/aaa', '/ccc'] = 1
assert p.is_connected(0, 1) == True
assert p.is_connected(1, 0) == False
def test_transmit_spikes_one_to_many(self):
m1_sel_in_gpot = Selector('')
m1_sel_out_gpot = Selector('')
m1_sel_in_spike = Selector('')
m1_sel_out_spike = Selector('/m1/out/spike[0:4]')
m1_sel, m1_sel_in, m1_sel_out, m1_sel_gpot, m1_sel_spike = \
make_sels(m1_sel_in_gpot, m1_sel_out_gpot, m1_sel_in_spike, m1_sel_out_spike)
N1_gpot = SelectorMethods.count_ports(m1_sel_gpot)
N1_spike = SelectorMethods.count_ports(m1_sel_spike)
m2_sel_in_gpot = Selector('')
m2_sel_out_gpot = Selector('')
m2_sel_in_spike = Selector('/m2/in/spike[0:4]')
m2_sel_out_spike = Selector('')
m2_sel, m2_sel_in, m2_sel_out, m2_sel_gpot, m2_sel_spike = \
make_sels(m2_sel_in_gpot, m2_sel_out_gpot, m2_sel_in_spike, m2_sel_out_spike)
N2_gpot = SelectorMethods.count_ports(m2_sel_gpot)
N2_spike = SelectorMethods.count_ports(m2_sel_spike)
m1_id = 'm1'
self.man.add(MyModule1,
m1_id,
m1_sel,
m1_sel_in,
m1_sel_out,
m1_sel_gpot,
m1_sel_spike,
np.zeros(N1_gpot, dtype=np.double),
np.zeros(N1_spike, dtype=int),
device=0,
debug=debug,
out_spike_data=[1, 0, 0, 0])
f, out_file_name = tempfile.mkstemp()
os.close(f)
m2_id = 'm2'
self.man.add(MyModule2,
m2_id,
m2_sel,
m2_sel_in,
m2_sel_out,
m2_sel_gpot,
m2_sel_spike,
np.zeros(N2_gpot, dtype=np.double),
np.zeros(N2_spike, dtype=int),
device=1,
debug=debug,
out_file_name=out_file_name)
pat12 = Pattern(m1_sel, m2_sel)
pat12.interface[m1_sel_out_gpot] = [0, 'in', 'gpot']
pat12.interface[m1_sel_in_gpot] = [0, 'out', 'gpot']
pat12.interface[m1_sel_out_spike] = [0, 'in', 'spike']
pat12.interface[m1_sel_in_spike] = [0, 'out', 'spike']
pat12.interface[m2_sel_in_gpot] = [1, 'out', 'gpot']
pat12.interface[m2_sel_out_gpot] = [1, 'in', 'gpot']
pat12.interface[m2_sel_in_spike] = [1, 'out', 'spike']
pat12.interface[m2_sel_out_spike] = [1, 'in', 'spike']
pat12['/m1/out/spike[0]', '/m2/in/spike[0]'] = 1
pat12['/m1/out/spike[0]', '/m2/in/spike[1]'] = 1
pat12['/m1/out/spike[0]', '/m2/in/spike[2]'] = 1
pat12['/m1/out/spike[0]', '/m2/in/spike[3]'] = 1
self.man.connect(m1_id, m2_id, pat12, 0, 1)
# Run emulation for 2 steps:
self.man.spawn()
self.man.start(2)
self.man.wait()
# Get output of m2:
with open(out_file_name, 'r') as f:
output = pickle.load(f)
os.remove(out_file_name)
self.assertSequenceEqual(list(output), [1, 1, 1, 1])
def test_is_connected_multi_level(self):
p = Pattern('/aaa[0:3]', '/bbb[0:3]')
p['/aaa[0]', '/bbb[2]'] = 1
assert p.is_connected(0, 1) == True
assert p.is_connected(1, 0) == False