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)))