def test_arbitrary_neuron_sink(self, source):
"""Test that standard connections to neurons return an appropriate
sink.
We have no plan to support arbitrary connections to neurons, but we
allow them at this stage because they may later become global
inhibition connections when we optimise out passthrough Nodes.
"""
with nengo.Network():
a = nengo.Ensemble(100, 2)
b = nengo.Ensemble(100, 4)
if source == "neurons":
a_b = nengo.Connection(a.neurons,
b.neurons,
transform=np.eye(100))
else:
a_b = nengo.Connection(a,
b.neurons,
transform=[[1.0, 0.5]] * 99 +
[[0.5, 1.0]])
# Create a model with the Ensemble for b in it
model = builder.Model()
b_ens = operators.EnsembleLIF(b)
model.object_operators[b] = b_ens
# Get the sink, check that an appropriate target is return
sink = ensemble.get_neurons_sink(model, a_b)
assert sink.target.obj is b_ens
assert sink.target.port is ensemble.EnsembleInputPort.neurons
def test_normal_source(self):
# Create a network and standard model
with nengo.Network():
a = nengo.Ensemble(100, 2)
b = nengo.Ensemble(200, 4)
a_b = nengo.Connection(a, b[1:3])
# Create a model with the Ensemble for b in it
model = builder.Model()
a_ens = operators.EnsembleLIF(a)
model.object_operators[a] = a_ens
source = ensemble.get_ensemble_source(model, a_b)
assert source.target.obj is a_ens
assert source.target.port is OutputPort.standard
def test_neurons_source():
"""Test that neurons sources are sane."""
with nengo.Network():
a = nengo.Ensemble(100, 2)
b = nengo.Ensemble(100, 4)
a_b = nengo.Connection(a.neurons, b.neurons, transform=np.eye(100))
# Create a model with the Ensemble for a in it
model = builder.Model()
a_ens = operators.EnsembleLIF(a)
model.object_operators[a] = a_ens
# Get the source, check that an appropriate target is return
source = ensemble.get_neurons_source(model, a_b)
assert source.target.obj is a_ens
assert source.target.port is ensemble.EnsembleOutputPort.neurons
def test_encoder_learnt_sink(self):
# Create a network and standard model
with nengo.Network():
a = nengo.Ensemble(100, 2)
b = nengo.Ensemble(100, 2)
a_b = nengo.Connection(a, b)
a_b.learning_rule_type = nengo.Voja()
# Create a model with the Ensemble for b in it
model = builder.Model()
b_ens = operators.EnsembleLIF(b)
model.object_operators[b] = b_ens
sink = ensemble.get_ensemble_sink(model, a_b)
assert sink.target.obj is b_ens
assert sink.target.port is ensemble.EnsembleInputPort.learnt
def test_constant_node_sink_with_slice(self):
"""Test that connections from constant valued Nodes to Ensembles are
optimised out correctly.
"""
# Create a network and standard model
with nengo.Network():
a = nengo.Node([0.5, 1.0])
b = nengo.Ensemble(200, 2)
a_b = nengo.Connection(a[0], b[1])
# Create a model with the Ensemble for b in it
model = builder.Model()
b_ens = operators.EnsembleLIF(b)
model.object_operators[b] = b_ens
# Check that no sink is created but that the direct input is modified
assert np.all(b_ens.direct_input == np.zeros(2))
assert ensemble.get_ensemble_sink(model, a_b) is None
assert np.all(b_ens.direct_input == [0.0, 0.5])
def test_normal_sink_for_process_node(self):
"""Test that sinks for most connections into Ensembles do nothing
special.
"""
# Create a network and standard model
with nengo.Network():
a = nengo.Node(nengo.processes.WhiteNoise(), size_out=4)
b = nengo.Ensemble(200, 4)
a_b = nengo.Connection(a, b)
# Create a model with the Ensemble for b in it
model = builder.Model()
b_ens = operators.EnsembleLIF(b)
model.object_operators[b] = b_ens
# Get the sink, check that an appropriate target is return
sink = ensemble.get_ensemble_sink(model, a_b)
assert sink.target.obj is b_ens
assert sink.target.port is InputPort.standard
def test_decoder_learnt_source(self):
# Create a network and standard model
with nengo.Network():
a = nengo.Ensemble(100, 2)
b = nengo.Ensemble(100, 2)
e = nengo.Ensemble(100, 2)
a_b = nengo.Connection(a, b)
a_b.learning_rule_type = nengo.PES()
e_l = nengo.Connection(e, a_b.learning_rule)
# Create a model with the Ensemble for b in it
model = builder.Model()
a_ens = operators.EnsembleLIF(a)
model.object_operators[a] = a_ens
source = ensemble.get_ensemble_source(model, a_b)
assert source.target.obj is a_ens
assert source.target.port is ensemble.EnsembleOutputPort.learnt
def test_global_inhibition_sink(self):
"""Test that sinks are correctly determined for connections which are
global inhibition connections.
"""
# Create a model with a global inhibition connection
with nengo.Network():
a = nengo.Ensemble(100, 2)
b = nengo.Ensemble(200, 4)
a_b = nengo.Connection(a, b.neurons, transform=[[1.0, 0.5]] * 200)
# Create a model with the Ensemble for b in it
model = builder.Model()
b_ens = operators.EnsembleLIF(b)
model.object_operators[b] = b_ens
decs = mock.Mock()
evals = mock.Mock()
si = mock.Mock()
# Get the sink, check that an appropriate target is return
sink = ensemble.get_neurons_sink(model, a_b)
assert sink.target.obj is b_ens
assert sink.target.port is ensemble.EnsembleInputPort.global_inhibition
def test_encoder_learning_rule_sink(self):
"""Test that sinks for most connections into Ensembles do nothing
special.
"""
# Create a network and standard model
with nengo.Network():
a = nengo.Ensemble(100, 2)
b = nengo.Ensemble(100, 2)
e = nengo.Ensemble(100, 1)
a_b = nengo.Connection(a, b)
a_b.learning_rule_type = nengo.Voja()
e_l = nengo.Connection(e, a_b.learning_rule)
# Create a model with the Ensemble for b in it
model = builder.Model()
b_ens = operators.EnsembleLIF(b)
model.object_operators[b] = b_ens
# Get the sink, check that an appropriate target is return
sink = ensemble.get_learning_rule_sink(model, e_l)
assert sink.target.obj is b_ens
assert sink.target.port is a_b.learning_rule
