def test_contains():
class A:
pass
cfg = nengo.Config(A)
with pytest.raises(TypeError):
A in cfg
def test_instance_fallthrough():
"""If the class default is set, instances should use that."""
class A:
pass
inst1 = A()
inst2 = A()
config = nengo.Config(A)
config[A].set_param("amount", Parameter("amount", default=1))
assert config[A].amount == 1
assert config[inst1].amount == 1
assert config[inst2].amount == 1
# Value can change for instance
config[inst1].amount = 2
assert config[A].amount == 1
assert config[inst1].amount == 2
assert config[inst2].amount == 1
# If value to A is changed, unset instances should also change
config[A].amount = 3
assert config[A].amount == 3
assert config[inst1].amount == 2
assert config[inst2].amount == 3
# If class default is deleted, unset instances go back
del config[A].amount
assert config[A].amount == 1
assert config[inst1].amount == 2
assert config[inst2].amount == 1
def test_direct_mode_with_single_neuron(Simulator, plt, seed):
radius = 2
dim = 5
config = nengo.Config(nengo.Ensemble)
config[nengo.Ensemble].neuron_type = nengo.Direct()
with config:
product = nengo_extras.networks.Product(
1, dim, radius, net=nengo.Network(seed=seed))
func_A = lambda t: np.sqrt(radius)*np.sin(np.arange(1, dim+1)*2*np.pi*t)
func_B = lambda t: np.sqrt(radius)*np.sin(np.arange(dim, 0, -1)*2*np.pi*t)
with product:
input_A = nengo.Node(func_A)
input_B = nengo.Node(func_B)
nengo.Connection(input_A, product.A)
nengo.Connection(input_B, product.B)
p = nengo.Probe(product.output, synapse=0.005)
with Simulator(product) as sim:
sim.run(1.0)
t = sim.trange()
AB = np.asarray(list(map(func_A, t))) * np.asarray(list(map(func_B, t)))
delay = 0.013
offset = np.where(t >= delay)[0]
for i in range(dim):
plt.subplot(dim+1, 1, i+1)
plt.plot(t + delay, AB[:, i])
plt.plot(t, sim.data[p][:, i])
plt.xlim(right=t[-1])
plt.yticks((-2, 0, 2))
assert rmse(AB[:len(offset), :], sim.data[p][offset, :]) < 0.2
def __init__(self, vocab=Default, neurons_per_dimension=Default, **kwargs):
super(Compare, self).__init__(**kwargs)
self.vocab = vocab
self.neurons_per_dimension = neurons_per_dimension
with self:
with nengo.Config(nengo.Ensemble) as cfg:
cfg[nengo.Ensemble].eval_points = nengo.dists.CosineSimilarity(
self.vocab.dimensions + 2)
cfg[nengo.Ensemble].intercepts = nengo.dists.CosineSimilarity(
self.vocab.dimensions + 2)
self.product = nengo.networks.Product(
self.neurons_per_dimension, self.vocab.dimensions)
self.output = nengo.Node(size_in=1, label="output")
nengo.Connection(
self.product.output,
self.output,
transform=np.ones((1, self.vocab.dimensions)),
)
self.input_a = self.product.input_a
self.input_b = self.product.input_b
self.declare_input(self.input_a, self.vocab)
self.declare_input(self.input_b, self.vocab)
self.declare_output(self.output, None)
def Product_2D_ens(n_neurons,
dimensions,
input_magnitude=1,
config=None,
net=None):
"""Computes the element-wise product of two equally sized vectors."""
if net is None:
net = nengo.Network(label="Product")
if config is None:
config = nengo.Config(nengo.Ensemble)
config[nengo.Ensemble].encoders = Choice([[1, 1], [1, -1], [-1, 1],
[-1, -1]])
with net, config:
net.A = nengo.Node(size_in=dimensions, label="A")
net.B = nengo.Node(size_in=dimensions, label="B")
net.output = nengo.Node(size_in=dimensions, label="output")
net.product = EnsembleArray(n_neurons,
n_ensembles=dimensions,
ens_dimensions=2,
radius=input_magnitude * np.sqrt(2))
nengo.Connection(net.A, net.product.input[::2], synapse=None)
nengo.Connection(net.B, net.product.input[1::2], synapse=None)
net.output = net.product.add_output('product', lambda x: x[0] * x[1])
return net
def test_matrix_mult(Simulator, rng, nl, plt):
shape_left = (2, 2)
shape_right = (2, 2)
left_mat = rng.rand(*shape_left)
right_mat = rng.rand(*shape_right)
with nengo.Network("Matrix multiplication test") as model:
node_left = nengo.Node(left_mat.ravel())
node_right = nengo.Node(right_mat.ravel())
with nengo.Config(nengo.Ensemble) as cfg:
cfg[nengo.Ensemble].neuron_type = nl()
mult_net = nengo_extras.networks.MatrixMult(
100, shape_left, shape_right)
p = nengo.Probe(mult_net.output, synapse=0.01)
nengo.Connection(node_left, mult_net.input_left)
nengo.Connection(node_right, mult_net.input_right)
dt = 0.001
sim = Simulator(model, dt=dt)
sim.run(1)
t = sim.trange()
plt.plot(t, sim.data[p])
for d in np.dot(left_mat, right_mat).flatten():
plt.axhline(d, color='k')
atol, rtol = .2, .01
ideal = np.dot(left_mat, right_mat).ravel()
assert np.allclose(sim.data[p][-1], ideal, atol=atol, rtol=rtol)
def test_matrix_mult(Simulator, seed, rng, AnyNeuronType, plt, allclose):
shape_left = (2, 2)
shape_right = (2, 2)
left_mat = rng.uniform(-1, 1, size=shape_left)
right_mat = rng.uniform(-1, 1, size=shape_right)
with nengo.Network("Matrix multiplication test", seed=seed) as model:
node_left = nengo.Node(left_mat.ravel())
node_right = nengo.Node(right_mat.ravel())
with nengo.Config(nengo.Ensemble) as cfg:
cfg[nengo.Ensemble].neuron_type = AnyNeuronType()
mult_net = nengo_extras.networks.MatrixMult(
200, shape_left, shape_right)
p = nengo.Probe(mult_net.output, synapse=0.01)
nengo.Connection(node_left, mult_net.input_left)
nengo.Connection(node_right, mult_net.input_right)
dt = 0.001
with Simulator(model, dt=dt) as sim:
sim.run(1)
t = sim.trange()
plt.plot(t, sim.data[p])
for d in np.dot(left_mat, right_mat).flatten():
plt.axhline(d, color="k")
atol, rtol = 0.15, 0.01
if AnyNeuronType.__name__ == "SpikingTanh":
atol = 0.2
ideal = np.dot(left_mat, right_mat).ravel()
assert allclose(sim.data[p][-1], ideal, atol=atol, rtol=rtol)
def config_with_default_synapse(config, synapse):
if config is None:
config = nengo.Config(nengo.Connection)
config[nengo.Connection].synapse = synapse
override = "synapse" not in config[nengo.Connection]
if override:
config[nengo.Connection].synapse = synapse
return config, override
def __init__(self):
self.config = nengo.Config(nengo.Ensemble, nengo.Connection,
nengo.Probe)
self.mfcc = MFCCParams()
self.periphery = PeripheryParams()
self.cepstra = CepstraParams()
self.derivatives = []
# Set dummy audio so that pickling doesn't fail
self.audio = np.zeros(1)
def generate(net=None, n_neurons=200, alpha=1000.0, beta=1000.0/4.0,
dt=0.001, analog=False):
tau = 0.1 # synaptic time constant
synapse = nengo.Lowpass(tau)
# the A matrix for our point attractor
A = np.array([[0.0, 1.0],
[-alpha*beta, -alpha]])
# the B matrix for our point attractor
B = np.array([[0.0], [alpha*beta]])
# if you have the nengolib library you can do it this way
# from nengolib.synapses import ss2sim
# C = np.eye(2)
# D = np.zeros((2, 2))
# linsys = ss2sim((A, B, C, D), synapse=synapse, dt=None if analog else dt)
# A = linsys.A
# B = linsys.B
if analog:
# account for continuous lowpass filter
A = tau * A + np.eye(2)
B = tau * B
else:
# discretize state matrices
Ad = expm(A*dt)
Bd = np.dot(np.linalg.inv(A), np.dot((Ad - np.eye(2)), B))
# account for discrete lowpass filter
a = np.exp(-dt/tau)
A = 1.0 / (1.0 - a) * (Ad - a * np.eye(2))
B = 1.0 / (1.0 - a) * Bd
if net is None:
net = nengo.Network(label='Point Attractor')
config = nengo.Config(nengo.Connection, nengo.Ensemble)
config[nengo.Connection].synapse = nengo.Lowpass(tau)
with config, net:
net.ydy = nengo.Ensemble(n_neurons=n_neurons, dimensions=2,
# set it up so neurons are tuned to one dimensions only
encoders=nengo.dists.Choice([[1, 0], [-1, 0], [0, 1], [0, -1]]))
# set up Ax part of point attractor
nengo.Connection(net.ydy, net.ydy, transform=A)
# hook up input
net.input = nengo.Node(size_in=1, size_out=1)
# set up Bu part of point attractor
nengo.Connection(net.input, net.ydy, transform=B)
# hook up output
net.output = nengo.Node(size_in=1, size_out=1)
# add in forcing function
nengo.Connection(net.ydy[0], net.output, synapse=None)
return net
def __init__(self):
self.config = nengo.Config(nengo.Ensemble, nengo.Connection,
nengo.Probe)
self.syllable = RecogSyllableParams()
self.syllables = []
self.syllable_dict = {}
self.cleanup = CleanupParams()
self.memory = MemoryParams()
self.classifier = ClassifierParams()
self.trial = RecognitionTrialParams()
def __init__(self):
self.config = nengo.Config(nengo.Ensemble, nengo.Connection,
nengo.Probe)
self.sequence = SyllableSequenceParams()
self.sequencer = SequencerParams()
self.syllable = ProdSyllableParams()
self.syllables = []
self.syllable_dict = {}
self.production_info = ProductionInfoParams()
self.trial = ProductionTrialParams()
def thresh_ens_config(self):
cfg = nengo.Config(nengo.Ensemble)
cfg[nengo.Ensemble].update({
'radius': 1,
'intercepts': Uniform(0.5, 1.0),
'encoders': Choice([[1]]),
'eval_points': Uniform(0.75, 1.1),
'n_eval_points': self.n_eval_points,
})
return cfg
def __init__( self, seed=1, label="KerNengo", cats=None ):
"""
build the nengo network
there will be as many input and Keras node objects as the categories to be searched
in the image. The categories can be given in a list as cats argoments, otherwise the
global categories is used
"""
self.probes = {}
self.nodes = {}
self.states = {}
self.prob = {}
self.v_dim = list(lg.n_coords.values())[ 0 ][ 0 ]
self.voc = spa.Vocabulary( self.v_dim )
self.dl = nengo.Network( seed=seed, label='DL'+label )
self.spa = spa.Network( seed=seed+1, label='SPA'+label )
if cats is None:
self.categories = lg.categories
else:
self.categories = cats
# initialize probabilities
for c in self.categories:
self.prob[ c ] = numpy.zeros( ( self.v_dim, ) )
"""
this is the part intended for using a vocabolary, but I have found no ways to use it
(see NOTE in state())
n_cat = len( self.categories )
parse_str = (n_cat - 1 ) * "WHERE{}; " + "WHERE{}"
spointers = parse_str.format( *self.categories )
self.voc.populate( spointers )
"""
with self.dl:
net = 'dl'
for c in self.categories:
inp = "input_" + c
self.inode( c, net=net )
self.knode( c )
nengo.Connection( self.get_node( inp, net=net ), self.get_node( c, net=net ), synapse=None )
self.probe( self.get_node( c, net=net ), c, net=net )
with self.spa:
net = 'spa'
cfg = nengo.Config( nengo.Ensemble )
cfg[ nengo.Ensemble ].neuron_type = nengo.Direct()
with cfg:
for c in self.categories:
inp = "input_" + c
self.inode( c, net=net )
where = c + "_where"
self.state( c )
nengo.Connection( self.get_node( inp, net=net ), self.states[ c ].input )
self.probe( self.states[ c ].output, where, net=net )
def default_ens_config(self):
"""(Config) Defaults for other ensemble creation."""
cfg = nengo.Config(nengo.Ensemble)
cfg[nengo.Ensemble].update({
'radius': 1,
'intercepts': Exponential(self.exp_scale, 0.0, 1.0),
'encoders': Choice([[1]]),
'eval_points': Uniform(0.0, 1.0),
'n_eval_points': self.n_eval_points,
})
return cfg
def thresh_ens_config(self):
"""(Config) Defaults for threshold ensemble creation."""
cfg = nengo.Config(nengo.Ensemble)
cfg[nengo.Ensemble].update({
"radius": 1,
"intercepts": Uniform(0.5, 1.0),
"encoders": Choice([[1]]),
"eval_points": Uniform(0.75, 1.1),
"n_eval_points": self.n_eval_points,
})
return cfg
def am_ens_config(self):
"""(Config) Defaults for associative memory ensemble creation."""
cfg = nengo.Config(nengo.Ensemble, nengo.Connection)
cfg[nengo.Ensemble].update({
'radius': 1,
'intercepts': Exponential(self.exp_scale, 0.0, 1.0),
'encoders': Choice([[1]]),
'eval_points': Uniform(0.0, 1.0),
'n_eval_points': self.n_eval_points,
})
cfg[nengo.Connection].synapse = None
return cfg
def generate(
net=None, # define PMC, M1, CB, S1 inside net
probes_on=False): # set True to record data
""" Connect up the PMC, M1, CB, and S1 sub-networks up for
the REACH model.
"""
config = nengo.Config(nengo.Connection, nengo.Ensemble)
with net, config:
dim = net.dim # the number of DOF of the arm
net.probes_on = probes_on
relay = nengo.Node(size_in=dim, label='relay')
# connect the control signal summed from M1 and CB to the arm
nengo.Connection(relay, net.arm_node[:2])
# send in (x, y) of target for plotting
nengo.Connection(net.xy, net.arm_node[2:])
if getattr(net, "M1", False):
# project control signal into output relay
nengo.Connection(net.M1.output, relay)
# send in x_des signal to M1
nengo.Connection(net.error[:dim], net.M1.input[dim:])
if getattr(net, "S1", False):
nengo.Connection(net.arm_node, net.S1.input)
if getattr(net, "M1", False):
# connect up sensory feedback
nengo.Connection(net.S1.output[:dim], net.M1.input[:dim])
if getattr(net, "CB", False):
# connect up sensory feedback
nengo.Connection(net.arm_node[:dim * 2], net.CB.input[:dim * 2])
# send in target for context
nengo.Connection(net.PMC.output, net.CB.input[dim * 2 + 2:])
# send in training signal
nengo.Connection(relay, net.CB.input[dim * 2:dim * 2 + 2])
# project dynamics compensation term into relay
# to be included in the training signal for u_adapt
nengo.Connection(net.CB.output[:dim], relay)
# send u_adapt output directly to arm
nengo.Connection(net.CB.output[dim:], net.arm_node[:2])
if probes_on:
net.probe_S1 = nengo.Probe(net.S1.output)
net.probe_M1 = nengo.Probe(net.M1.output)
net.probe_CB = nengo.Probe(net.CB.output)
return net
def generate(net=None,
n_neurons=200,
alpha=1000.0,
beta=1000.0 / 4.0,
dt=0.001,
analog=False):
tau = 0.1 # synaptic time constant
# the A matrix for our point attractor
A = np.array([[0.0, 1.0], [-alpha * beta, -alpha]])
# the B matrix for our point attractor
B = np.array([[0.0, 0.0], [alpha * beta, 1.0]])
# discretize
Ad = expm(A * dt)
Bd = np.dot(np.linalg.inv(A), np.dot((Ad - np.eye(2)), B))
# account for discrete lowpass filter
a = np.exp(-dt / tau)
if analog:
A = tau * A + np.eye(2)
B = tau * B
else:
A = 1.0 / (1.0 - a) * (Ad - a * np.eye(2))
B = 1.0 / (1.0 - a) * Bd
if net is None:
net = nengo.Network(label='Point Attractor')
config = nengo.Config(nengo.Connection, nengo.Ensemble)
config[nengo.Connection].synapse = nengo.Lowpass(tau)
# config[nengo.Ensemble].neuron_type = nengo.Direct()
with config, net:
net.ydy = nengo.Ensemble(
n_neurons=n_neurons,
dimensions=2,
# set it up so neurons are tuned to one dimensions only
encoders=nengo.dists.Choice([[1, 0], [-1, 0], [0, 1], [0, -1]]))
# set up Ax part of point attractor
nengo.Connection(net.ydy, net.ydy, transform=A)
# hook up input
net.input = nengo.Node(size_in=2)
# set up Bu part of point attractor
nengo.Connection(net.input, net.ydy, transform=B)
# hook up output
net.output = nengo.Node(size_in=1)
# add in forcing function
nengo.Connection(net.ydy[0], net.output, synapse=None)
return net
def rsvr_ens_config(self):
"""(Config) Defaults for reservoir ensemble creation."""
cfg = nengo.Config(nengo.Ensemble, nengo.Connection)
cfg[nengo.Ensemble].update({
"radius":
1,
"intercepts":
nengo.dists.Choice([0] * self.dimensions),
"n_eval_points":
self.n_eval_points,
})
cfg[nengo.Connection].synapse = None
return cfg
def test_configstack():
"""Test that setting defaults with bare configs works."""
with nengo.Network() as net:
net.config[nengo.Connection].transform = -1
e1 = nengo.Ensemble(5, dimensions=1)
e2 = nengo.Ensemble(6, dimensions=1)
excite = nengo.Connection(e1, e2)
with nengo.Config(nengo.Connection) as inhib:
inhib[nengo.Connection].synapse = nengo.synapses.Lowpass(0.00848)
inhibit = nengo.Connection(e1, e2)
assert excite.synapse == nengo.Connection.synapse.default
assert excite.transform.init == -1
assert inhibit.synapse == inhib[nengo.Connection].synapse
assert inhibit.transform.init == -1
def Integrator(n_neurons, dimensions, recurrent_config=None, net=None):
if net is None:
net = nengo.Network()
if recurrent_config is None:
recurrent_config = nengo.Config(nengo.Connection)
recurrent_config[nengo.Connection].synapse = nengo.Lowpass(0.1)
with net:
net.input = nengo.Node(size_in=dimensions)
net.ensemble = nengo.Ensemble(n_neurons, dimensions=dimensions)
with recurrent_config:
nengo.Connection(net.ensemble, net.ensemble)
tau = nengo.Config.default(nengo.Connection, 'synapse').tau
nengo.Connection(net.input, net.ensemble, synapse=None, transform=tau)
return net
def pulvinar(size_in, net=None):
""""""
if net is None:
net = nengo.Network()
with net:
S_input = nengo.Node(size_in=size_in, label='S_input')
# Ensemble with 100 LIF neurons which represents a 2-dimensional signal
pulv = nengo.Ensemble(100,
dimensions=size_in,
max_rates=Uniform(100, 200))
pulv = nengo.Ensemble(n_neurons=size_in, label='pulvinar')
nengo.Config(S_input, pulv.neurons, transform=np.ones())
def test_contains():
class A:
pass
cfg = nengo.Config(A)
with pytest.raises(TypeError, match="Cannot check if .* is in a config"):
A in cfg
net = nengo.Network()
net.config[nengo.Ensemble].set_param("test", Parameter("test", None))
assert "test" not in net.config[nengo.Ensemble]
net.config[nengo.Ensemble].test = "testval"
assert "test" in net.config[nengo.Ensemble]
def test_external_class():
class A:
thing = Parameter("thing", default="hey")
inst = A()
config = nengo.Config(A)
config[A].set_param("amount", Parameter("amount", default=1))
# Extra param
assert config[inst].amount == 1
# Default still works like Nengo object
assert inst.thing == "hey"
with pytest.raises(ConfigError):
config[inst].thing
def test_external_class():
class A(object):
thing = Parameter(default='hey')
inst = A()
config = nengo.Config(A)
config[A].set_param('amount', Parameter(default=1))
# Extra param
assert config[inst].amount == 1
# Default still works like Nengo object
assert inst.thing == 'hey'
with pytest.raises(AttributeError):
config[inst].thing
def test_configstack():
"""Test that setting defaults with bare configs works."""
inhib = nengo.Config(nengo.Connection)
inhib[nengo.Connection].synapse = nengo.synapses.Lowpass(0.00848)
with nengo.Network() as net:
net.config[nengo.Connection].modulatory = True
e1 = nengo.Ensemble(5, dimensions=1)
e2 = nengo.Ensemble(6, dimensions=1)
excite = nengo.Connection(e1, e2)
with inhib:
inhibit = nengo.Connection(e1, e2)
assert excite.synapse == nengo.Connection.synapse.default
assert excite.modulatory
assert inhibit.synapse == inhib[nengo.Connection].synapse
assert inhibit.modulatory
def inh_ens_config(self):
"""(Config) Defaults for inhibitory input ensemble creation."""
cfg = nengo.Config(nengo.Ensemble, nengo.Connection)
cfg[nengo.Ensemble].update({
"neuron_type":
nengo.LIF(tau_ref=0.002),
"radius":
1,
"intercepts":
nengo.dists.Choice([0.1] * self.dimensions),
"max_rates":
nengo.dists.Choice([100])
})
cfg[nengo.Connection].synapse = None
return cfg
def motor_cortex(command_threshold,
n_neurons_per_command=30,
ens_config=None,
net=None):
if net is None:
net = nengo.Network()
if ens_config is None:
ens_config = nengo.Config(nengo.Ensemble)
ens_config[nengo.Ensemble].encoders = Choice([[1]])
ens_config[nengo.Ensemble].intercepts = Choice([command_threshold])
with net:
with ens_config:
net.press = nengo.Ensemble(n_neurons_per_command, dimensions=1)
net.release = nengo.Ensemble(n_neurons_per_command, dimensions=1)
return net
def controlled_integrator(n_neurons,
dimensions,
recurrent_config=None,
net=None):
if net is None:
net = nengo.Network()
if recurrent_config is None:
recurrent_config = nengo.Config(nengo.Connection)
recurrent_config[nengo.Connection].synapse = nengo.Lowpass(0.1)
with net:
net.ensemble = nengo.Ensemble(n_neurons, dimensions=dimensions + 1)
with recurrent_config:
nengo.Connection(net.ensemble,
net.ensemble[:dimensions],
function=lambda x: x[:-1] * (1.0 - x[-1]))
return net
