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):
# Create a simple deep network (2 input nodes, 3 network nodes, 3 output nodes)
self.ni, self.nc, self.no, self.weight = 2, 5, 3, 10
# Set edges
self.l_edges = [('input_0', 'core_0'), ('core_0', 'core_1'), ('core_0', 'core_2'),
('core_1', 'output_0'), ('core_2', 'output_1')] + \
[('input_0', 'core_3'), ('core_3', 'core_2')] + \
[('input_1', 'core_4'), ('core_4', 'output_2')] + \
[('input_1', 'core_2')]
self.l_edges_2 = [('input_0', 'core_0'), ('core_0', 'core_1'), ('core_0', 'core_2'),
('core_1', 'output_0'), ('core_2', 'output_1')] + \
[('input_1', 'core_3'), ('core_3', 'core_2')]
# Set levels
self.ax_levels = np.array([1, 1, 1, 1, 1])
self.ax_levels_2 = np.array([1, 1, 2, 1])
# Set input and expected output of propagation through firing graph
self.sax_i = csc_matrix(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]))
self.sax_o = csc_matrix(np.array([[0, 0], [0, 0], [1, 0], [1, 1]]))
# Disable edge update
self.mask_vertice_drain = {'I': np.zeros(self.ni), 'C': np.zeros(self.nc), 'O': np.zeros(self.no)}
self.mask_vertice_drain_2 = {'I': np.zeros(self.ni), 'C': np.zeros(self.nc - 1), 'O': np.zeros(self.no - 1)}
# Get matrices for building test
self.sax_I, self.sax_C, self.sax_O = mat_from_tuples(self.ni, self.no, self.nc, self.l_edges, self.weight)
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 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