def test_signal_indexing_1(self):
m = nengo.Model("test_signal_indexing_1")
one = Signal(n=1, name='a')
two = Signal(n=2, name='b')
three = Signal(n=3, name='c')
tmp = Signal(n=3, name='tmp')
m.signals = [one, two, three, tmp]
m.operators = [
ProdUpdate(Constant(1), three[:1], Constant(0), one),
ProdUpdate(Constant(2.0), three[1:], Constant(0), two),
Reset(tmp),
DotInc(Constant([[0, 0, 1], [0, 1, 0], [1, 0, 0]]), three, tmp),
Copy(src=tmp, dst=three, as_update=True),
]
sim = m.simulator(sim_class=self.Simulator, builder=testbuilder)
sim.signals[three] = np.asarray([1, 2, 3])
sim.step()
self.assertTrue(np.all(sim.signals[one] == 1))
self.assertTrue(np.all(sim.signals[two] == [4, 6]))
self.assertTrue(np.all(sim.signals[three] == [3, 2, 1]))
sim.step()
self.assertTrue(np.all(sim.signals[one] == 3))
self.assertTrue(np.all(sim.signals[two] == [4, 2]))
self.assertTrue(np.all(sim.signals[three] == [1, 2, 3]))
def test_scalar(self):
"""A network that represents sin(t)."""
N = 30
m = nengo.Model('test_scalar', seed=123)
m.make_node('in', output=np.sin)
m.make_ensemble('A', nengo.LIF(N), 1)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.02)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(5.0)
with Plotter(self.Simulator) as plt:
t = sim.data(m.t)
plt.plot(t, sim.data('in'), label='Input')
plt.plot(t, sim.data('A'), label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar.pdf')
plt.close()
target = np.sin(np.arange(5000) / 1000.)
target.shape = (-1, 1)
logger.debug("[New API] input RMSE: %f", rmse(target, sim.data('in')))
logger.debug("[New API] A RMSE: %f", rmse(target, sim.data('A')))
self.assertTrue(rmse(target, sim.data('in')) < 0.001)
self.assertTrue(rmse(target, sim.data('A')) < 0.1)
def test_constant_vector(self):
"""A network that represents a constant 3D vector."""
N = 30
vals = [0.6, 0.1, -0.5]
m = nengo.Model('test_constant_vector', seed=123)
m.make_node('in', output=vals)
m.make_ensemble('A', nengo.LIF(N * len(vals)), len(vals))
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.1)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(1.0)
with Plotter(self.Simulator) as plt:
t = sim.data(m.t)
plt.plot(t, sim.data('in'), label='Input')
plt.plot(t, sim.data('A'), label='Neuron approximation, pstc=0.1')
plt.legend(loc=0, prop={'size': 10})
plt.savefig('test_ensemble.test_constant_vector.pdf')
plt.close()
self.assertTrue(np.allclose(sim.data('in')[-10:], vals,
atol=.1, rtol=.01))
self.assertTrue(np.allclose(sim.data('A')[-10:], vals,
atol=.1, rtol=.01))
def test_constant_scalar(self):
"""A Network that represents a constant value."""
N = 30
val = 0.5
m = nengo.Model('test_constant_scalar', seed=123)
m.make_node('in', output=val)
m.make_ensemble('A', nengo.LIF(N), 1)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.1)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(1.0)
with Plotter(self.Simulator) as plt:
t = sim.data(m.t)
plt.plot(t, sim.data('in'), label='Input')
plt.plot(t, sim.data('A'), label='Neuron approximation, pstc=0.1')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_constant_scalar.pdf')
plt.close()
self.assertTrue(np.allclose(sim.data('in').ravel(), val,
atol=.1, rtol=.01))
self.assertTrue(np.allclose(sim.data('A')[-10:], val,
atol=.1, rtol=.01))
def test_integrator(self):
model = nengo.Model('Integrator')
inputs = {0:0, 0.2:1, 1:0, 2:-2, 3:0, 4:1, 5:0}
model.make_node('Input', nengo.helpers.piecewise(inputs))
tau = 0.1
model.add(Integrator('T', tau, neurons=nengo.LIF(100), dimensions=1))
model.connect('Input', 'T.In', filter=tau)
model.make_ensemble('A', nengo.LIF(100), dimensions=1)
model.connect('A', 'A', transform=[[1]], filter=tau)
model.connect('Input', 'A', transform=[[tau]], filter=tau)
model.probe('Input')
model.probe('A', filter=0.01)
model.probe('T.Integrator', filter=0.01)
sim = model.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(6.0)
with Plotter(self.Simulator) as plt:
t = sim.data(model.t)
plt.plot(t, sim.data('A'), label='Manual')
plt.plot(t, sim.data('T.Integrator'), label='Template')
plt.plot(t, sim.data('Input'), 'k', label='Input')
plt.legend(loc=0)
plt.savefig('test_integrator.test_integrator.pdf')
plt.close()
self.assertTrue(rmse(sim.data('A'), sim.data('T.Integrator')) < 0.2)
def test_simple_direct_mode(self):
dt = 0.001
m = nengo.Model("test_simple_direct_mode")
time = Signal(n=1, name='time')
sig = Signal(n=1, name='sig')
pop = Direct(n_in=1, n_out=1, fn=np.sin)
m.signals = [sig, time]
m.operators = []
Builder().build_direct(pop, m, dt)
m.operators += [
ProdUpdate(Constant(dt), Constant(1), Constant(1), time),
DotInc(Constant([[1.0]]), time, pop.input_signal),
ProdUpdate(Constant([[1.0]]), pop.output_signal, Constant(0), sig)
]
sim = m.simulator(sim_class=self.Simulator, dt=dt, builder=testbuilder)
sim.step()
for i in range(5):
sim.step()
t = (i + 2) * dt
self.assertTrue(np.allclose(sim.signals[time], t),
msg='%s != %s' % (sim.signals[time], t))
self.assertTrue(np.allclose(sim.signals[sig], np.sin(t - dt * 2)),
msg='%s != %s' %
(sim.signals[sig], np.sin(t - dt * 2)))
def test_vector(self):
"""A network that represents sin(t), cos(t), arctan(t)."""
N = 40
m = nengo.Model('test_vector', seed=123)
m.make_node('in', output=lambda t: [np.sin(t), np.cos(t), np.arctan(t)])
m.make_ensemble('A', nengo.LIF(N * 3), 3, radius=2)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.02)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(5)
with Plotter(self.Simulator) as plt:
t = sim.data(m.t)
plt.plot(t, sim.data('in'), label='Input')
plt.plot(t, sim.data('A'), label='Neuron approximation, pstc=0.02')
plt.legend(loc='best', prop={'size': 10})
plt.savefig('test_ensemble.test_vector.pdf')
plt.close()
target = np.vstack((np.sin(np.arange(5000) / 1000.),
np.cos(np.arange(5000) / 1000.),
np.arctan(np.arange(5000) / 1000.))).T
logger.debug("In RMSE: %f", rmse(target, sim.data('in')))
self.assertTrue(rmse(target, sim.data('in') < 0.001))
self.assertTrue(rmse(target, sim.data('A')) < 0.1)
def test_simple(self):
params = dict(simulator=self.Simulator, seed=123, dt=0.001)
# Old API
net = nef.Network('test_simple', **params)
net.make_input('in', value=np.sin)
p = net.make_probe('in', dt_sample=0.001, pstc=0.0)
rawp = net._raw_probe(net.inputs['in'], dt_sample=.001)
st_probe = net._raw_probe(net.model.simtime, dt_sample=.001)
net.run(0.01)
data = p.get_data()
raw_data = rawp.get_data()
st_data = st_probe.get_data()
self.assertTrue(
np.allclose(st_data.ravel(), np.arange(0.001, 0.0105, .001)))
self.assertTrue(
np.allclose(raw_data.ravel(), np.sin(np.arange(0, 0.0095, .001))))
# -- the make_probe call induces a one-step delay
# on readout even when the pstc is really small.
self.assertTrue(
np.allclose(data.ravel()[1:], np.sin(np.arange(0, 0.0085, .001))))
# New API
m = nengo.Model('test_simple', **params)
node = m.make_node('in', output=np.sin)
m.probe('in')
m.run(0.01)
self.assertTrue(
np.allclose(m.data[m.simtime].ravel(),
np.arange(0.001, 0.0105, .001)))
self.assertTrue(
np.allclose(m.data['in'].ravel(),
np.sin(np.arange(0, 0.0095, .001))))
def test_scalar(self):
"""A network that represents sin(t)."""
simulator = self.Simulator
params = dict(simulator=simulator, seed=123, dt=0.001)
N = 30
target = np.sin(np.arange(4999) / 1000.)
target.shape = (4999, 1)
# Old API
net = nef.Network('test_scalar', **params)
net.make_input('in', value=np.sin)
net.make('A', N, 1)
net.connect('in', 'A')
in_p = net.make_probe('in', dt_sample=0.001, pstc=0.0)
a_p = net.make_probe('A', dt_sample=0.001, pstc=0.02)
net.run(5)
in_data = in_p.get_data()
a_data = a_p.get_data()
with Plotter(simulator) as plt:
t = net.model.data[net.model.simtime]
plt.plot(t, in_data, label='Input')
plt.plot(t, a_data, label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar-old.pdf')
plt.close()
logger.debug("[Old API] input RMSE: %f", rmse(target, in_data))
logger.debug("[Old API] A RMSE: %f", rmse(target, a_data))
self.assertTrue(rmse(target, in_data) < 0.001)
self.assertTrue(rmse(target, a_data) < 0.1)
# New API
m = nengo.Model('test_scalar', **params)
m.make_node('in', output=np.sin)
m.make_ensemble('A', nengo.LIF(N), 1)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.02)
m.run(5)
with Plotter(simulator) as plt:
t = m.data[m.simtime]
plt.plot(t, m.data['in'], label='Input')
plt.plot(t, m.data['A'], label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar-new.pdf')
plt.close()
logger.debug("[New API] input RMSE: %f", rmse(target, m.data['in']))
logger.debug("[New API] A RMSE: %f", rmse(target, m.data['A']))
self.assertTrue(rmse(target, m.data['in']) < 0.001)
self.assertTrue(rmse(target, m.data['A']) < 0.1)
# Check old/new API similarity
logger.debug("Old/New API RMSE: %f", rmse(a_data, m.data['A']))
self.assertTrue(rmse(a_data, m.data['A']) < 0.1)
def test_oscillator(self):
model = nengo.Model('Oscillator')
inputs = {0: [1, 0], 0.5: [0, 0]}
model.make_node('Input', nengo.helpers.piecewise(inputs))
tau = 0.1
freq = 5
model.add(Oscillator('T', tau, freq, neurons=nengo.LIF(100)))
model.connect('Input', 'T.In')
model.make_ensemble('A', nengo.LIF(100), dimensions=2)
model.connect('A',
'A',
filter=tau,
transform=[[1, -freq * tau], [freq * tau, 1]])
model.connect('Input', 'A')
model.probe('Input')
model.probe('A', filter=0.01)
model.probe('T.Oscillator', filter=0.01)
sim = model.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(3.0)
with Plotter(self.Simulator) as plt:
t = sim.data(model.t)
plt.plot(t, sim.data('A'), label='Manual')
plt.plot(t, sim.data('T.Oscillator'), label='Template')
plt.plot(t, sim.data('Input'), 'k', label='Input')
plt.legend(loc=0)
plt.savefig('test_oscillator.test_oscillator.pdf')
plt.close()
self.assertTrue(rmse(sim.data('A'), sim.data('T.Oscillator')) < 0.3)
def test_passthrough(self):
dt = 0.001
m = nengo.Model("test_passthrough", seed=0)
m.make_node("in", output=np.sin)
m.make_node("in2", output=lambda t: t)
m.add(PassthroughNode("pass"))
m.add(Node("out", output=lambda x: x))
m.connect("in", "pass", filter=None)
m.connect("in2", "pass", filter=None)
m.connect("pass", "out", filter=None)
m.probe("in")
m.probe("in2")
m.probe("out")
sim = m.simulator(dt=dt, sim_class=self.Simulator)
runtime = 0.5
sim.run(runtime)
with Plotter(self.Simulator) as plt:
plt.plot(sim.data(m.t),
sim.data('in') + sim.data('in2'),
label='in+in2')
plt.plot(sim.data(m.t)[:-2], sim.data('out')[2:], label='out')
plt.legend(loc='best')
plt.savefig('test_node.test_passthrough.pdf')
plt.close()
# One-step delay between first and second nonlinearity
sim_in = sim.data('in')[:-1] + sim.data('in2')[:-1]
sim_out = sim.data('out')[1:]
self.assertTrue(np.allclose(sim_in, sim_out))
def test_connected(self):
dt = 0.001
m = nengo.Model('test_connected', seed=123)
m.make_node('in', output=np.sin)
# Not using make_node, as make_node connects time to node
m.add(Node('out', output=np.square))
m.connect('in', 'out', filter=None) # Direct connection
m.probe('in')
m.probe('out')
sim = m.simulator(dt=dt, sim_class=self.Simulator)
runtime = 0.5
sim.run(runtime)
with Plotter(self.Simulator) as plt:
plt.plot(sim.data(m.t), sim.data('in'), label='sin')
plt.plot(sim.data(m.t), sim.data('out'), label='sin squared')
plt.legend(loc='best')
plt.savefig('test_node.test_connected.pdf')
plt.close()
sim_t = sim.data(m.t).ravel()
sim_sin = sim.data('in').ravel()
sim_sq = sim.data('out').ravel()
t = dt * np.arange(len(sim_t))
self.assertTrue(np.allclose(sim_t, t))
self.assertTrue(np.allclose(sim_sin[1:],
np.sin(t[:-1]))) # 1-step delay
self.assertTrue(np.allclose(sim_sq[1:],
sim_sin[:-1]**2)) # 1-step delay
def run(sim_type, dim, DperE, cleanup_n):
sim_class = {0: nengo.Simulator, 1: SimOCL}[sim_type]
input_vector = hrr.HRR(dim).v
cleanup_encoders = np.array([input_vector] * cleanup_n)
num_ensembles = int(dim / DperE)
dim = num_ensembles * DperE
NperE = NperD * DperE
print "Building..."
start = time.time()
model = nengo.Model("PES timing", seed=seed)
def input_func(x):
return input_vector
inn = nengo.Node(output=input_func)
# Build ensembles
cleanup = nengo.Ensemble(label='cleanup',
neurons=nengo.LIF(cleanup_n),
dimensions=dim,
encoders=cleanup_encoders)
nengo.Connection(inn, cleanup)
ensembles = \
build.build_cleanup_pes(cleanup, inn, DperE, NperD, num_ensembles, learning_rate)
output_ensembles = ensembles[0]
error_ensembles = ensembles[1]
# Build probes
output_probes = [
nengo.Probe(o, 'decoded_output', filter=0.1) for o in output_ensembles
]
error_probes = [
nengo.Probe(e, 'decoded_output', filter=0.1) for e in error_ensembles
]
input_probe = nengo.Probe(inn, 'output')
end = time.time()
print "Build Time: ", end - start
# Run model
print "Simulating..."
start = time.time()
sim = sim_class(model, dt=0.001)
sim.run(sim_length)
end = time.time()
print "Sim Time: ", end - start
end = time.time()
print "Plot Time: ", end - start
overall_end = time.time()
print "Total time: ", overall_end - overall_start
plt.show()
def test_time(self):
m = nengo.Model("test_signal_indexing_1")
sim = m.simulator(sim_class=self.Simulator)
self.assertEqual(0.00, sim.signals[sim.model.t.signal])
sim.step()
self.assertEqual(0.001, sim.signals[sim.model.t.signal])
sim.step()
self.assertEqual(0.002, sim.signals[sim.model.t.signal])
def test_steps(self):
m = nengo.Model("test_signal_indexing_1")
sim = m.simulator(sim_class=self.Simulator)
self.assertEqual(0, sim.signals[sim.model.steps.signal])
sim.step()
self.assertEqual(1, sim.signals[sim.model.steps.signal])
sim.step()
self.assertEqual(2, sim.signals[sim.model.steps.signal])
def test_counters(self):
m = nengo.Model('test_counters', seed=123)
m.probe(m.steps)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(0.003)
self.assertTrue(
np.allclose(sim.data(m.t).flatten(), [0.00, .001, .002]))
self.assertTrue(np.allclose(sim.data(m.steps).flatten(), [0, 1, 2]))
def test_nested_network(self):
# --smoke test that it runs
base = nengo.Model('base')
with declarative_syntax(base):
demo_bg.BG('BG1')
demo_bg.BG('BG2')
# -- this doesn't work yet, but I think it should
conn.connect('BG1.output', 'BG1.input')
def subnetwork(name):
# -- XXX: figure out when add_to_model should be called
# so that this actually works.
#return nengo.networks.Network(name)
# -- XXX: abuse Model to be a sub-model as well (should be Network?)
rval = nengo.Model(name)
# -- XXX should immediately add to active model so that name lookup by
# parent works right away?
return rval
def test_multiplication(self):
model = nengo.Model('multiplication')
with declarative_syntax(model):
ens.ensemble('A', nengo.LIF(100), dimensions=1, radius=10)
ens.ensemble('B', nengo.LIF(100), dimensions=1, radius=10)
ens.ensemble('Combined', nengo.LIF(100), dimensions=2, radius=15)
ens.ensemble('D', nengo.LIF(100), dimensions=1, radius=20)
ens.encoders(
'Combined',
np.tile([[1, 1], [-1, 1], [1, -1], [-1, -1]],
(ens.n_neurons('Combined') / 4, 1)))
ens.node('Input A', piecewise({0: 0, 2.5: 10, 4: -10}))
ens.node('Input B', piecewise({0: 10, 1.5: 2, 3: 0, 4.5: 2}))
conn.connect('Input A', 'A')
conn.connect('Input B', 'B')
conn.connect('A', 'Combined', transform=[[1], [0]])
conn.connect('B', 'Combined', transform=[[0], [1]])
conn.connect('Combined', 'D', function=lambda x: x[0] * x[1])
for name in 'Input A', 'Input B':
probe(name)
for name in 'A', 'B', 'Combined', 'D':
probe(name, filter=0.01)
sim = model.simulator()
sim.run(5)
import matplotlib.pyplot as plt
# Plot the input signals and decoded ensemble values
correct_ans = nengo.helpers.piecewise({
0: 0,
1.5: 0,
2.5: 20,
3: 0,
4: 0,
4.5: -20
})
t = sim.data(model.t)
plt.plot(t, sim.data('A'), label="Decoded A")
plt.plot(t, sim.data('B'), label="Decoded B")
plt.plot(t, sim.data('D'), label="Decoded D")
out = [0] * t.shape[0]
for i in np.arange(t.shape[0]):
out[i] = correct_ans(t[i])
plt.plot(t, out)
plt.legend()
plt.ylim(-25, 25)
def test_constant_vector(self):
"""A network that represents a constant 3D vector."""
simulator = self.Simulator
params = dict(simulator=simulator, seed=123, dt=0.001)
N = 30
vals = [0.6, 0.1, -0.5]
# Old API
net = nef.Network('test_constant_vector', **params)
net.make_input('in', value=vals)
net.make('A', N * len(vals), len(vals))
net.connect('in', 'A', transform=np.eye(len(vals)))
in_p = net.make_probe('in', dt_sample=0.001, pstc=0.0)
a_p = net.make_probe('A', dt_sample=0.001, pstc=0.1)
net.run(1)
in_data = in_p.get_data()
a_data = a_p.get_data()
with Plotter(simulator) as plt:
t = net.model.data[net.model.simtime]
plt.plot(t, in_data, label='Input')
plt.plot(t, a_data, label='Neuron approximation, pstc=0.1')
plt.legend(loc=0, prop={'size': 10})
plt.savefig('test_ensemble.test_constant_vector-old.pdf')
plt.close()
self.assertTrue(np.allclose(in_data[-10:], vals, atol=.05, rtol=.05))
self.assertTrue(np.allclose(a_data[-10:], vals, atol=.05, rtol=.05))
# New API
m = nengo.Model('test_constant_vector', **params)
m.make_node('in', output=vals)
m.make_ensemble('A', nengo.LIF(N * len(vals)), len(vals))
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.1)
m.run(1)
with Plotter(simulator) as plt:
t = m.data[m.simtime]
plt.plot(t, m.data['in'], label='Input')
plt.plot(t, m.data['A'], label='Neuron approximation, pstc=0.1')
plt.legend(loc=0, prop={'size': 10})
plt.savefig('test_ensemble.test_constant_vector-new.pdf')
plt.close()
self.assertTrue(
np.allclose(m.data['in'][-10:], vals, atol=.05, rtol=.05))
self.assertTrue(
np.allclose(m.data['A'][-10:], vals, atol=.05, rtol=.05))
def test_constant_scalar(self):
"""A Network that represents a constant value."""
simulator = self.Simulator
params = dict(simulator=simulator, seed=123, dt=0.001)
N = 30
val = 0.5
# old api
net = nef.Network('test_constant_scalar', **params)
net.make_input('in', value=[val])
net.make('A', N, 1)
net.connect('in', 'A')
in_p = net.make_probe('in', dt_sample=0.001, pstc=0.0)
a_p = net.make_probe('A', dt_sample=0.001, pstc=0.1)
net.run(1)
in_data = in_p.get_data()
a_data = a_p.get_data()
with Plotter(simulator) as plt:
t = net.model.data[net.model.simtime]
plt.plot(t, in_data, label='Input')
plt.plot(t, a_data, label='Neuron approximation, pstc=0.1')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_constant_scalar-old.pdf')
plt.close()
self.assertTrue(np.allclose(in_data.ravel(), val, atol=.05, rtol=.05))
self.assertTrue(np.allclose(a_data[-10:], val, atol=.05, rtol=.05))
# New API
m = nengo.Model('test_constant_scalar', **params)
m.make_node('in', output=val)
m.make_ensemble('A', nengo.LIF(N), 1)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.1)
m.run(1)
with Plotter(simulator) as plt:
t = m.data[m.simtime]
plt.plot(t, m.data['in'], label='Input')
plt.plot(t, m.data['A'], label='Neuron approximation, pstc=0.1')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_constant_scalar-new.pdf')
plt.close()
self.assertTrue(
np.allclose(m.data['in'].ravel(), val, atol=.05, rtol=.05))
self.assertTrue(np.allclose(m.data['A'][-10:], val, atol=.05,
rtol=.05))
def _test_cconv(self, D, neurons_per_product):
# D is dimensionality of semantic pointers
m = nengo.Model(.001)
rng = np.random.RandomState(1234)
A = m.add(Constant(D, value=rng.randn(D)))
B = m.add(Constant(D, value=rng.randn(D)))
CircularConvolution(m, A, B, neurons_per_product=neurons_per_product)
sim = self.Simulator(m)
sim.run_steps(10)
def _test_encoders(self, n_neurons=10, n_dimensions=3, encoders=None):
if encoders is None:
encoders = np.random.randn(n_neurons, n_dimensions)
orig_encoders = encoders.copy()
args = {'name': 'A',
'neurons': nengo.LIF(n_neurons),
'dimensions': n_dimensions}
model = nengo.Model('_test_encoders')
ens = model.add(Ensemble(encoders=encoders, **args))
sim = model.simulator(dt=0.001)
self.assertTrue(np.allclose(orig_encoders, sim.model.get(ens).encoders))
def test_long_name(self):
m = nengo.Model('test_long_name', seed=123)
m.make_ensemble(("This is an extremely long name that will test "
"if we can access sim data with long names"),
nengo.LIF(10), 1)
m.probe("This is an extremely long name that will test "
"if we can access sim data with long names")
sim = m.simulator(sim_class=self.Simulator)
sim.run(0.01)
self.assertIsNotNone(
sim.data("This is an extremely long name that will test "
"if we can access sim data with long names"))
def testEnsemble(self):
# Create a simple model containing a single projection
model = nengo.Model("Test Model")
# Add an ensemble to the model
a = model.make_ensemble("A", nengo.LIF(100), 1)
b = model.make_ensemble("B", nengo.LIF(200), 1)
# Add some connections
model.connect('A', 'B')
# Now try to build the model
sim = model.simulator(sim_class=spinnaker.Simulator,
hostname="spinn-7")
def test_decoder_to_nonlinearity(self):
N = 30
m = nengo.Model('test_decoder_to_nonlinearity', seed=123)
a = m.make_ensemble('A', nengo.LIF(N), dimensions=1)
b = m.make_ensemble('B', nengo.LIF(N), dimensions=1)
m.make_node('in', output=np.sin)
m.make_node('inh', piecewise({0: 0, 2.5: 1}))
m.make_node('ideal', piecewise({0: np.sin, 2.5: 0}))
m.connect('in', 'A')
m.connect('inh', 'B')
con = m.connect('B', a.neurons, transform=[[-2.5]] * N)
m.probe('in')
m.probe('A', filter=0.1)
m.probe('B', filter=0.1)
m.probe('inh')
m.probe('ideal')
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(5.0)
with Plotter(self.Simulator) as plt:
t = sim.data(m.t)
plt.plot(t, sim.data('in'), label='Input')
plt.plot(t, sim.data('A'), label='Neuron approx, pstc=0.1')
plt.plot(t,
sim.data('B'),
label='Neuron approx of inhib sig, pstc=0.1')
plt.plot(t, sim.data('inh'), label='Inhib signal')
plt.plot(t, sim.data('ideal'), label='Ideal output')
plt.legend(loc=0, prop={'size': 10})
plt.savefig(
'test_tononlinearity_connection.test_decoder_to_nonlinearity.pdf'
)
plt.close()
self.assertTrue(
np.allclose(sim.data('A')[-10:],
sim.data('ideal')[-10:],
atol=.1,
rtol=.01))
self.assertTrue(
np.allclose(sim.data('B')[-10:],
sim.data('inh')[-10:],
atol=.1,
rtol=.01))
def test_simple_direct_mode(self):
m = nengo.Model("test_simple_direct_mode")
sig = m.add(Signal())
pop = m.add(Direct(n_in=1, n_out=1, fn=np.sin))
m.add(Encoder(m.simtime, pop, weights=[[1.0]]))
m.add(Decoder(pop, sig, weights=[[1.0]]))
m.add(Transform(1.0, sig, sig))
sim = self.Simulator(m)
for i in range(5):
sim.step()
if i > 0:
self.assertEqual(sim.signals[sig],
np.sin(sim.signals[m.simtime] - .001))
def test_encoder_decoder_with_views(self):
m = nengo.Model("")
dt = 0.001
foo = Signal(n=1, name='foo')
pop = Direct(n_in=2, n_out=2, fn=lambda x: x + 1, name='pop')
decoders = np.asarray([.2, .1])
m.signals = [foo]
m.operators = []
Builder().build_direct(pop, m, dt)
m.operators += [
DotInc(Constant([[1.0], [2.0]]), foo[:], pop.input_signal),
ProdUpdate(Constant(decoders * 0.5), pop.output_signal,
Constant(0.2), foo[:])
]
def check(sig, target):
self.assertTrue(
np.allclose(sim.signals[sig],
target), "%s: value %s is not close to target %s" %
(sig, sim.signals[sig], target))
sim = m.simulator(sim_class=self.Simulator, dt=dt, builder=testbuilder)
#set initial value of foo (foo=1.0)
sim.signals[foo] = np.asarray([1.0])
#pop.input_signal = [0,0]
#pop.output_signal = [0,0]
sim.step()
#DotInc to pop.input_signal (input=[1.0,2.0])
#produpdate updates foo (foo=[0.2])
#pop updates pop.output_signal (output=[2,3])
check(foo, .2)
check(pop.input_signal, [1, 2])
check(pop.output_signal, [2, 3])
sim.step()
#DotInc to pop.input_signal (input=[0.2,0.4])
# (note that pop resets its own input signal each timestep)
#produpdate updates foo (foo=[0.39]) 0.2*0.5*2+0.1*0.5*3 + 0.2*0.2
#pop updates pop.output_signal (output=[1.2,1.4])
check(foo, .39)
check(pop.input_signal, [0.2, 0.4])
check(pop.output_signal, [1.2, 1.4])
def test_seeding(self):
"""Test that setting the model seed fixes everything"""
### TODO: this really just checks random parameters in ensembles.
### Are there other objects with random parameters that should be
### tested? (Perhaps initial weights of learned connections)
m = nengo.Model('test_seeding')
m.make_node('in', output=1)
m.make_ensemble('A', nengo.LIF(40), 1)
m.make_ensemble('B', nengo.LIF(20), 1)
m.connect('in', 'A')
m.connect('A', 'B', function=lambda x: x**2)
m.probe('in')
m.probe('A', filter=0.01)
m.probe('B', filter=0.01)
m.seed = 872
m1 = m.simulator(dt=0.001).model
m2 = m.simulator(dt=0.001).model
m.seed = 873
m3 = m.simulator(dt=0.001).model
def compare_objs(obj1, obj2, attrs, equal=True):
for attr in attrs:
check = (np.all(getattr(obj1, attr) == getattr(obj2, attr))
if equal else np.any(
getattr(obj1, attr) != getattr(obj2, attr)))
if not check:
print getattr(obj1, attr)
print getattr(obj2, attr)
self.assertTrue(check)
ens_attrs = ('encoders', 'max_rates', 'intercepts')
A = [mi.get('A') for mi in [m1, m2, m3]]
B = [mi.get('B') for mi in [m1, m2, m3]]
compare_objs(A[0], A[1], ens_attrs)
compare_objs(B[0], B[1], ens_attrs)
compare_objs(A[0], A[2], ens_attrs, equal=False)
compare_objs(B[0], B[2], ens_attrs, equal=False)
neur_attrs = ('gain', 'bias')
compare_objs(A[0].neurons, A[1].neurons, neur_attrs)
compare_objs(B[0].neurons, B[1].neurons, neur_attrs)
compare_objs(A[0].neurons, A[2].neurons, neur_attrs, equal=False)
compare_objs(B[0].neurons, B[2].neurons, neur_attrs, equal=False)
def test_product(self):
def product(x):
return x[0] * x[1]
m = nengo.Model('test_product', seed=124)
N = 80
m.make_node('sin', output=np.sin)
m.make_node('-0.5', output=-.5)
factors = m.make_ensemble(
'factors', nengo.LIF(2 * N), dimensions=2, radius=1.5)
factors.encoders = np.tile([[1, 1],[-1, 1],[1, -1],[-1, -1]],
(factors.n_neurons / 4, 1))
m.make_ensemble('product', nengo.LIF(N), dimensions=1)
m.connect('sin', 'factors', transform=[[1], [0]])
m.connect('-0.5', 'factors', transform=[[0], [1]])
conn = m.connect('factors', 'product', function=product, filter=0.01)
m.probe('sin', sample_every=.01)
# m.probe(conn, sample_every=.01) # FIXME
m.probe('factors', sample_every=.01, filter=.01)
m.probe('product', sample_every=.01, filter=.01)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(6)
with Plotter(self.Simulator) as plt:
plt.subplot(211)
plt.plot(sim.data('factors'))
plt.plot(np.sin(np.arange(0, 6, .01)))
plt.plot(sim.data('sin'))
plt.subplot(212)
plt.plot(sim.data('product'))
#plt.plot(sim.data(conn))
plt.plot(-.5 * np.sin(np.arange(0, 6, .01)))
plt.savefig('test_ensemble.test_prod.pdf')
plt.close()
self.assertTrue(rmse(sim.data('factors')[:, 0],
np.sin(np.arange(0, 6, .01))) < 0.1)
self.assertTrue(rmse(sim.data('factors')[20:, 1], -0.5) < 0.1)
def match(a, b):
self.assertTrue(rmse(a, b) < 0.1)
match(sim.data('product')[:, 0], -0.5 * np.sin(np.arange(0, 6, .01)))
