def setUp(self):
# Create a simple deep network (2 input vertices, 3 network vertices,, 2 output vertices)
self.ni, self.nc, self.no, self.depth, self.weight, self.p, self.r, self.batch_size = 2, 3, 2, 2, 10, 3, 2, 4
self.ax_p, self.ax_r = np.ones(self.no) * self.p, np.ones(self.no) * self.r
l_edges = [('input_0', 'core_0'), ('core_0', 'output_0')] + \
[('input_0', 'core_1'), ('core_1', 'output_0')] + \
[('input_1', 'core_1')] + \
[('input_1', 'core_2'), ('core_2', 'output_1')]
self.levels = np.array([1, 2, 1], dtype=int)
self.sax_I, self.sax_C, self.sax_O = mat_from_tuples(self.ni, self.no, self.nc, l_edges, self.weight)
self.mask_vertice_drain_a = {'I': np.ones(self.ni), 'C': np.ones(self.nc)}
self.mask_vertice_drain_b = {'I': np.ones(self.ni), 'C': np.zeros(self.nc)}
self.mask_vertice_drain_c = {'I': np.zeros(self.ni), 'C': np.ones(self.nc)}
# Create firing graphs
self.fga = FiringGraph.from_matrices(
self.sax_I, self.sax_C, self.sax_O, self.levels, mask_vertices=self.mask_vertice_drain_a
)
self.fgb = FiringGraph.from_matrices(
self.sax_I, self.sax_C, self.sax_O, self.levels, mask_vertices=self.mask_vertice_drain_b
)
self.fgc = FiringGraph.from_matrices(
self.sax_I, self.sax_C, self.sax_O, self.levels, mask_vertices=self.mask_vertice_drain_c
)
# Create test signals
self.input = csc_matrix([[0, 0], [1, 0], [0, 1], [1, 1]])
self.output = csc_matrix([[0, 0], [0, 0], [0, 1], [1, 1]])
def setUp(self):
# enable, disable visual inspection of graph
self.visual = False
# Create And pattern of depth 2 /!\ Do not change those parameter for the test /!\
self.n, self.ni, self.no, self.w0, self.t_mask = 100, 10, 2, 10, 5
self.ap2 = ap2(self.ni, self.no, w=self.w0, seed=1234)
self.ap2_fg = self.ap2.build_graph_pattern_init()
# Create And pattern of depth 3
self.ni, self.no, self.n_selected = 15, 2, 3
self.ap3 = ap3(self.ni,
self.no,
n_selected=self.n_selected,
w=self.w0,
seed=1234)
self.ap3_fg = self.ap3.build_graph_pattern_init()
# Create simple pattern to test multi output
self.sax_forward = vstack([csc_matrix(np.eye(4)) for _ in range(10)])
self.sax_backward = lil_matrix(self.sax_forward.shape)
self.sax_backward[:, :2] = 1
self.p, self.r = np.array([1, 1, 2, 1]), np.array([1, 2, 1, 1])
self.weight = 100
# Create patterns to test functionality of forward and backward patterns in server
d_matrices = create_empty_matrices(self.sax_forward.shape[1],
self.sax_backward.shape[1], 4)
for i in range(4):
d_matrices['Iw'][i, i], d_matrices['Ow'][
i, i], d_matrices['Im'][:, :] = self.weight, 1, True
self.fg = FiringGraph('test_server', np.ones(4), d_matrices, depth=2)
def build_graph_pattern_init(self):
# Build edges
l_edges = []
for i in range(self.no):
l_edges += [(self.input_vertices[i][j], self.core_vertices[i])
for j in range(self.ni)]
l_edges += zip(self.core_vertices, self.output_vertices)
# Build Firing graph
sax_I, sax_C, sax_O = mat_from_tuples(self.ni * self.no,
self.no,
self.no,
l_edges,
weights=self.w)
self.firing_graph = FiringGraph.from_matrices(
sax_I,
sax_C,
sax_O,
np.ones(self.no),
mask_vertices=self.mask_vertice_drain,
depth=self.depth,
project='AndPat2')
return self.firing_graph
def setUp(self):
# Create input and output signal
self.sax_forward = csc_matrix([
[1, 0, 0, 0, 0, 1],
[1, 0, 1, 1, 1, 1],
[0, 1, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1],
[1, 1, 1, 0, 0, 1],
[1, 1, 0, 0, 1, 0],
[1, 1, 0, 1, 0, 1],
[1, 1, 0, 1, 1, 1],
])
self.sax_backward = csc_matrix([[0], [0], [0], [0], [1], [1], [1],
[1]])
self.sax_test = csc_matrix([[1], [0], [1], [0], [1], [1], [1], [0]])
# Create patterns to test functionality of forward and backward patterns in server
d_matrices = create_empty_matrices(self.sax_forward.shape[1],
self.sax_backward.shape[1], 1)
d_matrices['Iw'][3, 0], d_matrices['Ow'][0, 0] = 1, 1
self.pattern = FiringGraph('test_server',
np.ones(1),
d_matrices,
depth=2)
# Create server
self.server = ArrayServer(self.sax_forward,
self.sax_backward,
dtype_forward=int,
dtype_backward=int,
pattern_mask=self.pattern.copy())
self.sax_expected = np.array([-1, 0, -1, 0, 1, 1, 1, 0])
self.sax_expected_mask = np.array([-1, 0, 0, 0, 1, 1, 0, 0])
def test_propagate(self):
"""
Test basic graph building
python -m unittest tests.unit.firing_graph.test_builder.TestBuilder.test_propagate
"""
sax_I, sax_C, sax_O = mat_from_tuples(self.ni, self.no - 1, self.nc -1, self.l_edges_2, self.weight)
firing_graph = FiringGraph.from_matrices(
sax_I, sax_C, sax_O, self.ax_levels_2, mask_vertices=self.mask_vertice_drain_2, depth=3
)
sax_o = firing_graph.propagate(self.sax_i)
# Assert result is as expected
self.assertTrue((sax_o.toarray() == self.sax_o.toarray()).all())
def build_graph_pattern_init(self):
# Build edges
l_edges, ax_levels = [], np.ones(self.nc * self.no)
for i in range(self.no):
l_edges += [(self.input_vertices[i][j], self.core_vertices[i][0])
for j in range(self.ni)
if self.ni * i + j in self.target_selected[i]]
ax_levels[i * self.nc] = len(self.target_selected[i])
for i in range(self.no):
l_edges += [(self.input_vertices[i][j], self.core_vertices[i][1])
for j in range(self.ni)
if self.ni * i + j not in self.target_selected[i]]
for i in range(self.no):
l_edges += [
(self.core_vertices[i][0], self.core_vertices[i][self.nc - 1]),
(self.core_vertices[i][1], self.core_vertices[i][self.nc - 1]),
(self.core_vertices[i][self.nc - 1], self.output_vertices[i])
]
ax_levels[i * self.nc + self.nc - 1] = self.nc - 1
# Build Firing graph
sax_I, sax_C, sax_O = mat_from_tuples(self.ni * self.no,
self.no,
self.no * self.nc,
l_edges,
weights=self.w)
self.firing_graph = FiringGraph.from_matrices(
sax_I,
sax_C,
sax_O,
ax_levels,
mask_vertices=self.mask_vertice_drain,
depth=self.depth,
project='AndPatInit3')
return self.firing_graph
def test_building_graph(self):
"""
Test basic graph building
python -m unittest tests.unit.firing_graph.test_builder.TestBuilder.test_building_graph
"""
# Update mask vertice drainer
self.mask_vertice_drain['I'][0] = 1
self.mask_vertice_drain['C'][3] = 1
self.mask_vertice_drain['C'][2] = 1
firing_graph = FiringGraph.from_matrices(
self.sax_I, self.sax_C, self.sax_O, self.ax_levels, mask_vertices=self.mask_vertice_drain, depth=3
)
# Assert matrices dtypes and format are correct
self.assertTrue(isinstance(firing_graph.Iw, csc_matrix) and firing_graph.Iw.dtype.type == np.int32)
self.assertTrue(isinstance(firing_graph.Cw, csc_matrix) and firing_graph.Cw.dtype.type == np.int32)
self.assertTrue(isinstance(firing_graph.Ow, csc_matrix) and firing_graph.Ow.dtype.type == np.int32)
self.assertTrue(isinstance(firing_graph.Im, csc_matrix) and firing_graph.Im.dtype.type == np.bool_)
self.assertTrue(isinstance(firing_graph.Cm, csc_matrix) and firing_graph.Cm.dtype.type == np.bool_)
self.assertTrue(isinstance(firing_graph.Om, csc_matrix) and firing_graph.Om.dtype.type == np.bool_)
# Assert tracking dtypes and format are correct
self.assertTrue(isinstance(firing_graph.backward_firing['i'], csc_matrix))
self.assertTrue(isinstance(firing_graph.backward_firing['c'], csc_matrix))
self.assertTrue(isinstance(firing_graph.backward_firing['o'], csc_matrix))
self.assertTrue(all([sax_bf.dtype.type == np.uint32 for sax_bf in firing_graph.backward_firing.values()]))
# Assert adjacency matrices are correct
self.assertTrue(firing_graph.I[0, 3] and firing_graph.Iw[0, 3] == self.weight)
self.assertTrue(firing_graph.C[3, 2] and firing_graph.Cw[3, 2] == self.weight)
self.assertTrue(firing_graph.O[4, 2] and firing_graph.Ow[4, 2] == self.weight)
# Assert mask for drainer are correct
self.assertTrue(firing_graph.Im[1, :].nnz == 0 and firing_graph.Im[0, :].nnz == firing_graph.I[0, :].nnz)
self.assertTrue(firing_graph.Cm[[0, 1, 2, 4], :].nnz == 0 and firing_graph.Cm[3, :].nnz == firing_graph.C[3, :].nnz)
self.assertTrue(firing_graph.Om[[0, 1, 3, 4], :].nnz == 0 and firing_graph.Om[2, :].nnz == firing_graph.O[2, :].nnz)
class TestServer(unittest.TestCase):
def setUp(self):
# Create input and output signal
self.sax_forward = csc_matrix([
[1, 0, 0, 0, 0, 1],
[1, 0, 1, 1, 1, 1],
[0, 1, 0, 1, 1, 0],
[0, 1, 0, 0, 1, 1],
[1, 1, 1, 0, 0, 1],
[1, 1, 0, 0, 1, 0],
[1, 1, 0, 1, 0, 1],
[1, 1, 0, 1, 1, 1],
])
self.sax_backward = csc_matrix([[0], [0], [0], [0], [1], [1], [1],
[1]])
self.sax_test = csc_matrix([[1], [0], [1], [0], [1], [1], [1], [0]])
# Create patterns to test functionality of forward and backward patterns in server
d_matrices = create_empty_matrices(self.sax_forward.shape[1],
self.sax_backward.shape[1], 1)
d_matrices['Iw'][3, 0], d_matrices['Ow'][0, 0] = 1, 1
self.pattern = FiringGraph('test_server',
np.ones(1),
d_matrices,
depth=2)
# Create server
self.server = ArrayServer(self.sax_forward,
self.sax_backward,
dtype_forward=int,
dtype_backward=int,
pattern_mask=self.pattern.copy())
self.sax_expected = np.array([-1, 0, -1, 0, 1, 1, 1, 0])
self.sax_expected_mask = np.array([-1, 0, 0, 0, 1, 1, 0, 0])
def test_server_no_mask(self):
"""
python -m unittest tests.unit.firing_graph.test_server.TestServer.test_server_no_mask
"""
# stream once
self.server.pattern_mask = None
sax_i = self.server.next_forward(5).sax_data_forward
# Assert correct behaviour
self.assertEqual(sax_i.shape, (5, self.sax_forward.shape[1]))
self.assertTrue(
(sax_i.toarray() == self.sax_forward.toarray()[:5, :]).all())
self.assertEqual(self.server.step_forward, 5)
# Stream another time
sax_i = self.server.next_forward(5).sax_data_forward
# Assert correct behaviour
self.assertEqual(sax_i.shape, (5, self.sax_forward.shape[1]))
self.assertTrue(
(sax_i.toarray()[0, :] == self.sax_forward.toarray()[5, :]).all())
self.assertTrue((sax_i.toarray()[-1, :] == self.sax_forward.toarray()[
9 % self.sax_forward.shape[0], :]).all())
self.assertEqual(self.server.step_forward, 2)
# Stream feedback signal
self.server.stream_features()
# Assert correct behaviour
sax_ob = fpo(self.sax_test, self.server, self.sax_forward.shape[0],
np.ones(1), np.ones(1))
self.assertTrue((sax_ob.toarray()[0] == self.sax_expected).all())
def test_server_mask_pattern(self):
"""
python -m unittest tests.unit.firing_graph.test_server.TestServer.test_server_mask_pattern
"""
# Stream feedback signal with soft orthogonality settings
self.server.stream_features()
# Assert correct behaviour
sax_ob = fpo(self.sax_test, self.server, self.sax_forward.shape[0],
np.ones(1), np.ones(1))
self.assertTrue((sax_ob.toarray() == self.sax_expected_mask).all())