def test_csa_one_to_one_connector():
unittest_setup()
connector = CSAConnector(csa.oneToOne)
weight = 1.0
delay = 2.0
synapse_info = SynapseInformation(connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(
10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
receptor_type=None,
is_virtual_machine=False,
synapse_type_from_dynamics=False,
weights=weight,
delays=delay)
connector.set_projection_information(synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice],
[post_vertex_slice],
pre_vertex_slice,
post_vertex_slice, 0, synapse_info)
assert (len(block) > 0)
assert (all(item["source"] == item["target"] for item in block))
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
def test_setting_state_variables():
unittest_setup()
@defaults
class _AClass(object):
@default_parameters({"param_1"})
def __init__(self, param_1=1, param_2=2, param_3=3):
pass
@defaults
class _AnotherClass(object):
@default_initial_values({"param_1"})
def __init__(self, param_1=1, param_2=2, param_3=3):
pass
with LogCapture() as lc:
_AClass(param_1=1)
_check_warnings(lc, [], ["param_1", "param_2", "param_3"])
with LogCapture() as lc:
_AClass(param_2=2)
_check_warnings(lc, ["param_2"], ["param_1", "param_3"])
with LogCapture() as lc:
_AClass(param_3=3)
_check_warnings(lc, ["param_3"], ["param_1", "param_2"])
with LogCapture() as lc:
_AnotherClass(param_1=1)
_check_warnings(lc, ["param_1"], ["param_2", "param_3"])
with LogCapture() as lc:
_AnotherClass(param_2=2)
_check_warnings(lc, [], ["param_1", "param_2", "param_3"])
with LogCapture() as lc:
_check_warnings(lc, [], ["param_1", "param_2", "param_3"])
_AnotherClass(param_3=3)
def test_csa_random_connector():
unittest_setup()
connector = CSAConnector(csa.random(0.05))
weight = 1.0
delay = 2.0
mock_synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weight,
delays=delay)
connector.set_projection_information(mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice],
[post_vertex_slice],
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) >= 0)
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
def test_get_max_synapses():
unittest_setup()
spynnaker8.setup()
d = SynapseDynamicsSTDP(timing_dependence=TimingDependenceSpikePair(),
weight_dependence=WeightDependenceAdditive(),
pad_to_length=258)
assert d.get_max_synapses(256) <= 256
def test_init_bad():
unittest_setup()
neuron = MockNeuron()
with pytest.raises(KeyError):
neuron.get_initial_value("badvariable")
with pytest.raises(KeyError):
assert 1 == neuron.initialize("anotherbad", "junk")
def test_abstract():
unittest_setup()
class BaseClass(object, metaclass=AbstractBase):
@abstractproperty
@staticmethod
def default_parameters():
pass
@abstractproperty
@staticmethod
def default_initial_values():
pass
@defaults
class _AClass(BaseClass):
default_parameters = None
default_initial_values = None
def __init__(self, param="test"):
pass
assert (_AClass.default_parameters == {"param": "test"})
assert (_AClass.default_initial_values == {})
_AClass()
def test_csa_from_list_connector():
unittest_setup()
conn_list = [(i, i + 1 % 10) for i in range(10)]
connector = CSAConnector(conn_list)
weight = 1.0
delay = 2.0
mock_synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weight,
delays=delay)
connector.set_projection_information(mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice],
[post_vertex_slice],
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) > 0)
assert (all(item["source"] == conn[0]
for item, conn in zip(block, conn_list)))
assert (all(item["target"] == conn[1]
for item, conn in zip(block, conn_list)))
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
def test_initial_values():
unittest_setup()
neuron = MockNeuron()
initial_values = neuron.initial_values
assert "foo" in initial_values
assert "bar" in initial_values
initial_values = neuron.get_initial_values(selector=3)
assert {"foo": [1], "bar": [11]} == initial_values
def test_initializable():
unittest_setup()
neuron = MockNeuron()
assert [1, 1, 1, 1, 1] == neuron.get_initial_value("foo")
neuron.initialize("foo", 2)
assert [2, 2, 2, 2, 2] == neuron.get_initial_value("foo_init")
assert [11, 11, 11, 11, 11] == neuron.get_initial_value("bar_init")
assert [11, 11, 11, 11, 11] == neuron.get_initial_value("bar")
def test_max_atoms_per_core():
unittest_setup()
_MyPyNNModelImpl.set_model_max_atoms_per_core(100)
_MyNeuronModelImpl.set_model_max_atoms_per_core(20)
_MyOtherNeuronModel.set_model_max_atoms_per_core(50)
assert (_MyPyNNModelImpl.get_max_atoms_per_core() == 100)
assert (_MyNeuronModelImpl.get_max_atoms_per_core() == 20)
assert (_MyOtherNeuronModel.get_max_atoms_per_core() == 50)
def test_connector_split():
unittest_setup()
n_sources = 1000
n_targets = 1000
n_connections = 10000
pre_neurons_per_core = 57
post_neurons_per_core = 59
sources = numpy.random.randint(0, n_sources, n_connections)
targets = numpy.random.randint(0, n_targets, n_connections)
pre_slices = [
Slice(i, i + pre_neurons_per_core - 1)
for i in range(0, n_sources, pre_neurons_per_core)
]
post_slices = [
Slice(i, i + post_neurons_per_core - 1)
for i in range(0, n_targets, post_neurons_per_core)
]
connection_list = numpy.dstack((sources, targets))[0]
connector = MockFromListConnector(connection_list)
weight = 1.0
delay = 1.0
synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(n_sources, "Pre"),
post_population=MockPopulation(n_targets, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weight,
delays=delay)
has_block = set()
try:
# Check each connection is in the right place
for pre_slice in pre_slices:
for post_slice in post_slices:
block = connector.create_synaptic_block(
pre_slices, post_slices, pre_slice, post_slice, 1,
synapse_info)
for source in block["source"]:
assert (pre_slice.lo_atom <= source <= pre_slice.hi_atom)
for target in block["target"]:
assert (post_slice.lo_atom <= target <= post_slice.hi_atom)
for item in block:
has_block.add((item["source"], item["target"]))
# Check each connection has a place
for source, target in zip(sources, targets):
assert (source, target) in has_block
# Check the split only happens once
assert connector._split_count == 1
except AssertionError as e:
print(connection_list)
raise e
def test_reset_max_atoms_per_core():
unittest_setup()
_MyNeuronModelImpl.set_model_max_atoms_per_core(20)
_MyNeuronModelImpl.set_model_max_atoms_per_core()
_MyPyNNModelImpl.set_model_max_atoms_per_core(100)
_MyPyNNModelImpl.set_model_max_atoms_per_core()
assert (_MyNeuronModelImpl.get_max_atoms_per_core() ==
DEFAULT_MAX_ATOMS_PER_CORE)
assert (_MyPyNNModelImpl.get_max_atoms_per_core() == sys.maxsize)
def test_connection_holder_matrix_multiple_items():
unittest_setup()
data_items = ["source", "target", "delay", "weight"]
connection_holder = ConnectionHolder(data_items_to_return=data_items,
as_list=False,
n_pre_atoms=2,
n_post_atoms=2)
connections = numpy.array([(0, 0, 1, 10), (0, 0, 2, 20), (0, 1, 3, 30)],
AbstractSynapseDynamics.NUMPY_CONNECTORS_DTYPE)
connection_holder.add_connections(connections)
def test_init_by_in():
unittest_setup()
neuron = MockNeuron()
assert [1, 1, 1, 1, 1] == neuron.get_initial_value("foo")
neuron.initialize(variable="foo", value=11, selector=1)
assert [1, 11, 1, 1, 1] == neuron.get_initial_value("foo")
neuron.initialize(variable="foo", value=12, selector=2)
assert [1, 11, 12, 1, 1] == neuron.get_initial_value("foo")
assert [11] == neuron.get_initial_value("bar", selector=1)
assert [12] == neuron.get_initial_value("foo", selector=2)
def test_state_variables():
unittest_setup()
@defaults
class _AClass(object):
@default_initial_values({"param_1"})
def __init__(self, param_1=1, param_2=2, param_3=3):
pass
assert (_AClass.default_initial_values == {"param_1": 1})
assert (_AClass.default_parameters == {"param_2": 2, "param_3": 3})
def test_nothing():
unittest_setup()
@defaults
class _AClass(object):
def __init__(self, param_1=1, param_2=2, param_3=3):
pass
assert (_AClass.default_parameters == {
"param_1": 1,
"param_2": 2,
"param_3": 3
})
assert (_AClass.default_initial_values == {})
def test_recording_variables():
unittest_setup()
recordables = ["v", "gsyn_exc", "gsyn_inh"]
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
nr = NeuronRecorder(recordables, data_types, [], 100, [], [], [], [])
assert([] == nr.recording_variables)
nr.set_recording("v", True)
nr.set_recording("gsyn_inh", True)
assert(["v", "gsyn_inh"] == nr.recording_variables)
assert([0, 2] == nr.recorded_region_ids)
def test_simple_record():
unittest_setup()
recordables = ["v", "gsyn_exc", "gsyn_inh"]
data_types = {
"v": DataType.S1615,
"gsyn_exc": DataType.S1615,
"gsyn_inh": DataType.S1615
}
nr = NeuronRecorder(recordables, data_types, [], 100, [], [], [], [])
assert(frozenset(["v", "gsyn_exc", "gsyn_inh"]) ==
frozenset(nr.get_recordable_variables()))
assert([] == nr.recording_variables)
nr.set_recording("v", True)
assert(["v"] == nr.recording_variables)
def test_could_connect():
unittest_setup()
connector = FromListConnector([[0, 0], [1, 2], [2, 0], [3, 3], [2, 6],
[1, 8], [4, 1], [5, 0], [6, 2], [4, 8]])
pre_slices = [Slice(0, 3), Slice(4, 6), Slice(7, 9)]
post_slices = [Slice(0, 2), Slice(3, 5), Slice(6, 9)]
for pre_slice in pre_slices:
pre_vertex = MockMachineVertex(pre_slice, pre_slices)
for post_slice in post_slices:
post_vertex = MockMachineVertex(post_slice, post_slices)
count = connector.get_n_connections(pre_slices, post_slices,
pre_slice.hi_atom,
post_slice.hi_atom)
if count:
assert (connector.could_connect(None, pre_vertex, post_vertex))
else:
assert (not connector.could_connect(None, pre_vertex,
post_vertex))
def test_slices():
unittest_setup()
app_edge = ProjectionApplicationEdge(None, None, None)
mv0_2 = SimpleMachineVertex(None, None, None, None, Slice(0, 1))
mv2_4 = SimpleMachineVertex(None, None, None, None, Slice(2, 3))
mv4_6 = SimpleMachineVertex(None, None, None, None, Slice(4, 5))
app_edge.remember_associated_machine_edge(MachineEdge(mv0_2, mv2_4))
app_edge.remember_associated_machine_edge(MachineEdge(mv4_6, mv0_2))
app_edge.remember_associated_machine_edge(MachineEdge(mv0_2, mv2_4))
assert app_edge.pre_slices == [Slice(0, 1), Slice(4, 5)]
post1 = app_edge.post_slices
assert post1 == [Slice(0, 1), Slice(2, 3)]
app_edge.remember_associated_machine_edge(MachineEdge(mv0_2, mv0_2))
app_edge.remember_associated_machine_edge(MachineEdge(mv2_4, mv2_4))
assert app_edge.pre_slices == [Slice(0, 1), Slice(2, 3), Slice(4, 5)]
post2 = app_edge.post_slices
assert post1 == post2
assert id(post1) != id(post2)
def test_connector(clist, column_names, weights, delays, expected_clist,
expected_weights, expected_delays,
expected_extra_parameters, expected_extra_parameter_names):
unittest_setup()
connector = FromListConnector(clist, column_names=column_names)
if expected_clist is not None:
assert (numpy.array_equal(connector.conn_list, expected_clist))
else:
assert (numpy.array_equal(connector.conn_list, clist))
# Check extra parameters are as expected
extra_params = connector.get_extra_parameters()
extra_param_names = connector.get_extra_parameter_names()
assert (numpy.array_equal(extra_params, expected_extra_parameters))
assert (numpy.array_equal(extra_param_names,
expected_extra_parameter_names))
if extra_params is not None:
assert (len(extra_params.shape) == 2)
assert (extra_params.shape[1] == len(extra_param_names))
for i in range(len(extra_param_names)):
assert (extra_params[:, i].shape == (len(clist), ))
# Check weights and delays are used or ignored as expected
pre_slice = Slice(0, 10)
post_slice = Slice(0, 10)
synapse_info = SynapseInformation(connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(
10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
is_virtual_machine=False,
weights=weights,
delays=delays)
block = connector.create_synaptic_block([pre_slice], [post_slice],
pre_slice, post_slice, 1,
synapse_info)
assert (numpy.array_equal(block["weight"], numpy.array(expected_weights)))
assert (numpy.array_equal(block["delay"], numpy.array(expected_delays)))
def test_csa_block_connector():
unittest_setup()
try:
# This creates a block of size (2, 5) with a probability of 0.5; then
# within the block an individual connection has a probability of 0.3
connector = CSAConnector(
csa.block(2, 5) * csa.random(0.5) * csa.random(0.3))
weight = 1.0
delay = 2.0
mock_synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(10, "Pre"),
post_population=MockPopulation(10, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
receptor_type=None,
is_virtual_machine=False,
synapse_type_from_dynamics=False,
weights=weight,
delays=delay)
connector.set_projection_information(mock_synapse_info)
pre_vertex_slice = Slice(0, 10)
post_vertex_slice = Slice(0, 10)
block = connector.create_synaptic_block([pre_vertex_slice], 0,
[post_vertex_slice], 0,
pre_vertex_slice,
post_vertex_slice, 0,
mock_synapse_info)
assert (len(block) >= 0)
assert (all(item["weight"] == 1.0 for item in block))
assert (all(item["delay"] == 2.0 for item in block))
except TypeError as e:
raise SkipTest("https://github.com/INCF/csa/issues/17") from e
except RuntimeError as e:
if sys.version_info >= (3, 7):
raise SkipTest("https://github.com/INCF/csa/issues/16") from e
raise e
def test_both():
unittest_setup()
@defaults
class _AClass(object):
@default_parameters({"param_1"})
@default_initial_values({"param_2"})
def __init__(self, param_1=1, param_2=2, param_3=3):
pass
@defaults
class _AnotherClass(object):
@default_initial_values({"param_1"})
@default_parameters({"param_2"})
def __init__(self, param_1=1, param_2=2, param_3=3):
pass
assert (_AClass.default_parameters == {"param_1": 1})
assert (_AClass.default_initial_values == {"param_2": 2})
assert (_AnotherClass.default_parameters == {"param_2": 2})
assert (_AnotherClass.default_initial_values == {"param_1": 1})
def test_defaults():
unittest_setup()
assert (_MyPyNNModelImpl.default_initial_values == {"svar": 2.0})
assert (_MyPyNNModelImpl.default_parameters == {"param": 1.0})
assert (_MyPyNNModelImpl.default_initial_values == {"svar": 2.0})
assert (_MyPyNNModelImpl.default_parameters == {"param": 1.0})
def test_connection_holder(data_items, fixed_values, as_list):
unittest_setup()
all_values = None
n_items = 0
if data_items is not None or fixed_values is not None:
all_values = list()
elif as_list:
n_items = 4
if data_items is not None:
all_values.extend(data_items)
n_items += len(data_items)
if fixed_values is not None:
all_values.extend([item[0] for item in fixed_values])
n_items += len(fixed_values)
test_data_items = data_items
if test_data_items is None and fixed_values is None:
test_data_items = ["source", "target", "weight", "delay"]
connection_holder = ConnectionHolder(data_items_to_return=all_values,
as_list=as_list,
n_pre_atoms=2,
n_post_atoms=2,
fixed_values=fixed_values)
connections = numpy.array([(0, 0, 1, 10), (0, 0, 2, 20), (0, 1, 3, 30)],
AbstractSynapseDynamics.NUMPY_CONNECTORS_DTYPE)
connection_holder.add_connections(connections)
if as_list:
# Just a list so should be the same length as connections
assert len(connection_holder) == len(connections)
# Check that the selected item values are correct
for i in range(len(connections)):
# Go through each of the selected fields
p = 0
if test_data_items is not None:
p = len(test_data_items)
for j, item in enumerate(test_data_items):
item_index = connections.dtype.names.index(item)
# Check that the value matches with the correct field value
if n_items == 1:
assert connection_holder[i] == \
connections[i][item_index]
else:
assert connection_holder[i][j] == \
connections[i][item_index]
if fixed_values is not None:
for j, item in enumerate(fixed_values):
if n_items == 1:
assert connection_holder[i] == item[1]
else:
assert connection_holder[i][p + j] == item[1]
else:
if n_items == 0:
assert len(connection_holder) == 0
else:
# Should have n_items matrices returned, each of which is a 2x2
# matrix
if n_items == 1:
assert len(connection_holder) == 2
assert len(connection_holder[0]) == 2
assert len(connection_holder[1]) == 2
else:
assert len(connection_holder) == n_items
for matrix in connection_holder:
assert len(matrix) == 2
assert len(matrix[0]) == 2
assert len(matrix[1]) == 2
# Should have the values in the appropriate places
# Go through each of the selected fields
p = 0
if test_data_items is not None:
p = len(test_data_items)
for j, item in enumerate(test_data_items):
# Check that the value matches with the correct field value
item_index = connections.dtype.names.index(item)
if n_items == 1:
matrix = connection_holder
else:
matrix = connection_holder[j]
assert matrix[0, 0] == connections[1][item_index]
assert matrix[0, 1] == connections[2][item_index]
assert math.isnan(matrix[1, 0])
assert math.isnan(matrix[1, 1])
if fixed_values is not None:
for j, item in enumerate(fixed_values):
if n_items == 1:
matrix = connection_holder
else:
matrix = connection_holder[j + p]
assert matrix[0, 0] == item[1]
assert matrix[0, 1] == item[1]
assert math.isnan(matrix[1, 0])
assert math.isnan(matrix[1, 1])
def test_single_value():
unittest_setup()
run_spec_check(single_value)
def test_real_list():
unittest_setup()
run_spec_check(real_list)
def test_range_list_as_list():
unittest_setup()
run_spec_check(range_list_as_list)
def setUp(self):
unittest_setup()
def test_connectors(n_pre, n_post, n_in_slice, create_connector, weight,
delay):
unittest_setup()
max_target = 0
max_source = 0
max_row_length = None
max_col_length = None
for seed in range(10):
numpy.random.seed(random.randint(0, 1000))
connector = create_connector()
synapse_info = SynapseInformation(
connector=None,
pre_population=MockPopulation(n_pre, "Pre"),
post_population=MockPopulation(n_post, "Post"),
prepop_is_view=False,
postpop_is_view=False,
rng=None,
synapse_dynamics=None,
synapse_type=None,
receptor_type=None,
is_virtual_machine=False,
synapse_type_from_dynamics=False,
weights=weight,
delays=delay)
connector.set_projection_information(synapse_info=synapse_info)
pre_slices = [
Slice(i, i + n_in_slice - 1) for i in range(0, n_pre, n_in_slice)
]
post_slices = [
Slice(i, i + n_in_slice - 1) for i in range(0, n_post, n_in_slice)
]
pre_slice_index = 0
post_slice_index = 0
pre_vertex_slice = pre_slices[pre_slice_index]
post_vertex_slice = post_slices[post_slice_index]
synapse_type = 0
pre_slice = pre_slices[pre_slice_index]
post_slice = post_slices[post_slice_index]
pre_range = numpy.arange(pre_slice.lo_atom, pre_slice.hi_atom + 2)
post_range = numpy.arange(post_slice.lo_atom, post_slice.hi_atom + 2)
max_delay = connector.get_delay_maximum(synapse_info)
max_weight = connector.get_weight_maximum(synapse_info)
if max_row_length is None:
max_row_length = connector.\
get_n_connections_from_pre_vertex_maximum(
post_vertex_slice, synapse_info)
else:
assert (max_row_length ==
connector.get_n_connections_from_pre_vertex_maximum(
post_vertex_slice, synapse_info))
if max_col_length is None:
max_col_length = connector.\
get_n_connections_to_post_vertex_maximum(synapse_info)
else:
assert (max_col_length == connector.
get_n_connections_to_post_vertex_maximum(synapse_info))
synaptic_block = connector.create_synaptic_block(
pre_slices, post_slices, pre_vertex_slice, post_vertex_slice,
synapse_type, synapse_info)
source_histogram = numpy.histogram(synaptic_block["source"],
pre_range)[0]
target_histogram = numpy.histogram(synaptic_block["target"],
post_range)[0]
matrix_max_weight = (max(synaptic_block["weight"])
if len(synaptic_block) > 0 else 0)
matrix_max_delay = (max(synaptic_block["delay"])
if len(synaptic_block) > 0 else 0)
max_source = max((max(source_histogram), max_source))
max_target = max((max(target_histogram), max_target))
if len(post_slices) > post_slice_index + 1:
test_post_slice = post_slices[post_slice_index + 1]
test_synaptic_block = connector.create_synaptic_block(
pre_slices, post_slices, pre_vertex_slice, test_post_slice,
synapse_type, synapse_info)
if len(test_synaptic_block) > 0:
assert not numpy.array_equal(test_synaptic_block,
synaptic_block)
if len(pre_slices) > pre_slice_index + 1:
test_pre_slice = pre_slices[pre_slice_index + 1]
test_synaptic_block = connector.create_synaptic_block(
pre_slices, post_slices, test_pre_slice, post_vertex_slice,
synapse_type, synapse_info)
if len(test_synaptic_block) > 0:
assert not numpy.array_equal(test_synaptic_block,
synaptic_block)
try:
assert max(source_histogram) <= max_row_length
assert max(target_histogram) <= max_col_length
assert matrix_max_weight <= max_weight
assert matrix_max_delay <= max_delay
except Exception:
print(connector, n_pre, n_post, n_in_slice)
print(max_row_length, max(source_histogram), source_histogram)
print(max_col_length, max(target_histogram), target_histogram)
print(max_weight, matrix_max_weight, synaptic_block["weight"])
print(max_delay, matrix_max_delay, synaptic_block["delay"])
print(connector, n_pre, n_post, n_in_slice, max_row_length, max_source,
max_col_length, max_target)
