def test_function_output_size(Simulator, nl_nodirect): """Try a function that outputs both 0-d and 1-d arrays""" def bad_function(x): return x if x > 0 else 0 model = nengo.Network(seed=9) with model: model.config[nengo.Ensemble].neuron_type = nl_nodirect() u = nengo.Node(output=lambda t: t - 1) a = nengo.Ensemble(n_neurons=100, dimensions=1) b = nengo.Ensemble(n_neurons=100, dimensions=1) nengo.Connection(u, a) nengo.Connection(a, b, function=bad_function) up = nengo.Probe(u, synapse=None) bp = nengo.Probe(b, synapse=0.03) sim = Simulator(model) sim.run(2.) t = sim.trange() x = nengo.utils.numpy.filt(sim.data[up].clip(0, np.inf), 0.03 / sim.dt) y = sim.data[bp] with Plotter(Simulator, nl_nodirect) as plt: plt.plot(t, x, 'k') plt.plot(t, y) plt.savefig('test_connection.test_function_output_size.pdf') plt.close() assert np.allclose(x, y, atol=0.1)
def test_slicing_function(Simulator, nl): """Test using a pre-slice and a function""" N = 300 f_in = lambda t: [np.cos(3 * t), np.sin(3 * t)] f_x = lambda x: [x, -x**2] with nengo.Network(seed=99) as model: model.config[nengo.Ensemble].neuron_type = nl() u = nengo.Node(output=f_in) a = nengo.Ensemble(N, 2, radius=1.5) b = nengo.Ensemble(N, 2, radius=1.5) nengo.Connection(u, a) nengo.Connection(a[1], b, function=f_x) up = nengo.Probe(u, synapse=0.03) bp = nengo.Probe(b, synapse=0.03) sim = Simulator(model) sim.run(1.) t = sim.trange() v = sim.data[up] w = np.column_stack(f_x(v[:, 1])) y = sim.data[bp] with Plotter(Simulator, nl) as plt: plt.plot(t, y) plt.plot(t, w, ':') plt.savefig('test_connection.test_slicing_function.pdf') plt.close() assert np.allclose(w, y, atol=0.1, rtol=0.0)
def test_node_to_neurons(Simulator, nl_nodirect): name = 'node_to_neurons' N = 30 m = nengo.Network(label=name, seed=123) with m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() a = nengo.Ensemble(N, dimensions=1) inn = nengo.Node(output=np.sin) inh = nengo.Node(piecewise({0: 0, 2.5: 1})) nengo.Connection(inn, a) nengo.Connection(inh, a.neurons, transform=[[-2.5]] * N) inn_p = nengo.Probe(inn, 'output') a_p = nengo.Probe(a, 'decoded_output', synapse=0.1) inh_p = nengo.Probe(inh, 'output') sim = Simulator(m) sim.run(5.0) t = sim.trange() ideal = np.sin(t) ideal[t >= 2.5] = 0 with Plotter(Simulator, nl_nodirect) as plt: plt.plot(t, sim.data[inn_p], label='Input') plt.plot(t, sim.data[a_p], label='Neuron approx, synapse=0.1') plt.plot(t, sim.data[inh_p], label='Inhib signal') plt.plot(t, ideal, label='Ideal output') plt.legend(loc=0, prop={'size': 10}) plt.savefig('test_connection.test_' + name + '.pdf') plt.close() assert np.allclose(sim.data[a_p][-10:], 0, atol=.1, rtol=.01)
def test_vector(Simulator, nl): name = 'vector' N1, N2 = 50, 50 transform = [-1, 0.5] m = nengo.Network(label=name, seed=123) with m: m.config[nengo.Ensemble].neuron_type = nl() u = nengo.Node(output=[0.5, 0.5]) a = nengo.Ensemble(N1, dimensions=2) b = nengo.Ensemble(N2, dimensions=2) nengo.Connection(u, a) nengo.Connection(a, b, transform=transform) up = nengo.Probe(u, 'output') bp = nengo.Probe(b, synapse=0.03) sim = Simulator(m) sim.run(1.0) t = sim.trange() x = sim.data[up] y = x * transform yhat = sim.data[bp] with Plotter(Simulator, nl) as plt: plt.plot(t, y, '--') plt.plot(t, yhat) plt.savefig('test_connection.test_' + name + '.pdf') plt.close() assert np.allclose(y[-10:], yhat[-10:], atol=.1, rtol=.01)
def test_neurons_to_neurons(Simulator, nl_nodirect): name = 'neurons_to_neurons' N1, N2 = 30, 50 m = nengo.Network(label=name, seed=123) with m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() a = nengo.Ensemble(N1, dimensions=1) b = nengo.Ensemble(N2, dimensions=1) inp = nengo.Node(output=1) nengo.Connection(inp, a) nengo.Connection(a.neurons, b.neurons, transform=-1 * np.ones((N2, N1))) inp_p = nengo.Probe(inp, 'output') a_p = nengo.Probe(a, 'decoded_output', synapse=0.1) b_p = nengo.Probe(b, 'decoded_output', synapse=0.1) sim = Simulator(m) sim.run(5.0) t = sim.trange() with Plotter(Simulator, nl_nodirect) as plt: plt.plot(t, sim.data[inp_p], label='Input') plt.plot(t, sim.data[a_p], label='A, represents input') plt.plot(t, sim.data[b_p], label='B, should be 0') plt.legend(loc=0, prop={'size': 10}) plt.savefig('test_connection.test_' + name + '.pdf') plt.close() assert np.allclose(sim.data[a_p][-10:], 1, atol=.1, rtol=.01) assert np.allclose(sim.data[b_p][-10:], 0, atol=.1, rtol=.01)
def plt(request): """a pyplot-compatible plotting interface. Please use this if your test creates plots. This will keep saved plots organized in a simulator-specific folder, with an automatically generated name. savefig() and close() will automatically be called when the test function completes. If you need to override the default filename, set `plt.saveas` to the desired filename. """ dirname = recorder_dirname(request, "plots") plotter = Plotter(dirname, request.module.__name__, parametrize_function_name(request, request.function.__name__)) request.addfinalizer(lambda: plotter.__exit__(None, None, None)) return plotter.__enter__()
def test_decoder_solver(solver): rng = np.random.RandomState(39408) dims = 1 n_neurons = 100 n_points = 500 rates = get_rate_function(n_neurons, dims, rng=rng) E = get_encoders(n_neurons, dims, rng=rng) train = get_eval_points(n_points, dims, rng=rng) Atrain = rates(np.dot(train, E)) D, _ = solver(Atrain, train, rng=rng) test = get_eval_points(n_points, dims, rng=rng, sort=True) Atest = rates(np.dot(test, E)) est = np.dot(Atest, D) rel_rmse = rms(est - test) / rms(test) with Plotter(nengo.Simulator) as plt: plt.plot(test, np.zeros_like(test), 'k--') plt.plot(test, test - est) plt.title("relative RMSE: %0.2e" % rel_rmse) plt.savefig('test_decoders.test_decoder_solver.%s.pdf' % solver.__name__) plt.close() assert np.allclose(test, est, atol=3e-2, rtol=1e-3) assert rel_rmse < 0.02
def test_sine_waves(Simulator, nl): radius = 2 dim = 5 product = nengo.networks.Product(nl(200), dim, radius) func_A = lambda t: radius*np.sin(np.arange(1, dim+1)*2*np.pi*t) func_B = lambda t: radius*np.sin(np.arange(dim, 0, -1)*2*np.pi*t) pstc = 0.003 with product: input_A = nengo.Node(output=func_A) input_B = nengo.Node(output=func_B) nengo.Connection(input_A, product.A) nengo.Connection(input_B, product.B) p = nengo.Probe(product.output, synapse=pstc) sim = Simulator(product, seed=123) sim.run(1.0) t = sim.trange() AB = np.asarray(list(map(func_A, t))) * np.asarray(list(map(func_B, t))) delay = 0.011 offset = np.where(t > delay)[0] with Plotter(Simulator) as plt: for i in range(dim): plt.subplot(dim+1, 1, i+1) plt.plot(t + delay, AB[:, i], label="$A \cdot B$") plt.plot(t, sim.data[p][:, i], label="Output") plt.legend() plt.savefig('test_product.test_sine_waves.pdf') plt.close() assert rmse(AB[:len(offset), :], sim.data[p][offset, :]) < 0.3
def test_scalar(Simulator, nl): """A network that represents sin(t).""" N = 30 m = nengo.Network(label='test_scalar', seed=123) with m: input = nengo.Node(output=np.sin, label='input') A = nengo.Ensemble(nl(N), 1, label='A') nengo.Connection(input, A) in_p = nengo.Probe(input, 'output') A_p = nengo.Probe(A, 'decoded_output', synapse=0.02) sim = Simulator(m) sim.run(5.0) with Plotter(Simulator, nl) as plt: t = sim.trange() plt.plot(t, sim.data[in_p], label='Input') plt.plot(t, sim.data[A_p], 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_p])) logger.debug("[New API] A RMSE: %f", rmse(target, sim.data[A_p])) assert rmse(target, sim.data[in_p]) < 0.001 assert rmse(target, sim.data[A_p]) < 0.1
def test_neurons_to_ensemble(Simulator, nl_nodirect): name = 'neurons_to_ensemble' N = 20 m = nengo.Network(label=name, seed=123) with m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() a = nengo.Ensemble(N * 2, dimensions=2) b = nengo.Ensemble(N * 3, dimensions=3) c = nengo.Ensemble(N, dimensions=N * 2) nengo.Connection(a.neurons, b, transform=-10 * np.ones((3, N * 2))) nengo.Connection(a.neurons, c) a_p = nengo.Probe(a, 'decoded_output', synapse=0.01) b_p = nengo.Probe(b, 'decoded_output', synapse=0.01) c_p = nengo.Probe(c, 'decoded_output', synapse=0.01) sim = Simulator(m) sim.run(5.0) t = sim.trange() with Plotter(Simulator, nl_nodirect) as plt: plt.plot(t, sim.data[a_p], label='A') plt.plot(t, sim.data[b_p], label='B') plt.plot(t, sim.data[c_p], label='C') plt.savefig('test_connection.test_' + name + '.pdf') plt.close() assert np.all(sim.data[b_p][-10:] < 0)
def test_target_function(Simulator, nl_nodirect, dimension): model = nengo.Network("Connection Helper", seed=12) eval_points = UniformHypersphere().sample(1000, dimension, np.random.RandomState(seed=12)) targets = eval_points**2 with model: model.config[nengo.Ensemble].neuron_type = nl_nodirect() inp = nengo.Node(np.sin) ens1 = nengo.Ensemble(100, dimension) ens2 = nengo.Ensemble(100, dimension) ens3 = nengo.Ensemble(100, dimension) transform = [[1] if i % 2 == 0 else [-1] for i in range(dimension)] nengo.Connection(inp, ens1, transform=transform) nengo.Connection(ens1, ens2, **target_function(eval_points, targets)) nengo.Connection(ens1, ens3, function=lambda x: x**2) probe1 = nengo.Probe(ens2, synapse=0.03) probe2 = nengo.Probe(ens3, synapse=0.03) sim = nengo.Simulator(model) sim.run(1) with Plotter(Simulator, nl_nodirect) as plt: plt.plot(sim.trange(), sim.data[probe1]) plt.plot(sim.trange(), sim.data[probe2], '--') plt.savefig('utils.test_connection.test_target_function' '_2D.pdf') plt.close() assert np.allclose(sim.data[probe1], sim.data[probe2], atol=0.2)
def test_connected(Simulator): m = nengo.Network(label='test_connected', seed=123) with m: input = nengo.Node(output=lambda t: np.sin(t), label='input') output = nengo.Node(output=lambda t, x: np.square(x), size_in=1, label='output') nengo.Connection(input, output, synapse=None) # Direct connection p_in = nengo.Probe(input, 'output') p_out = nengo.Probe(output, 'output') sim = Simulator(m) runtime = 0.5 sim.run(runtime) with Plotter(Simulator) as plt: t = sim.trange() plt.plot(t, sim.data[p_in], label='sin') plt.plot(t, sim.data[p_out], label='sin squared') plt.plot(t, np.sin(t), label='ideal sin') plt.plot(t, np.sin(t)**2, label='ideal squared') plt.legend(loc='best') plt.savefig('test_node.test_connected.pdf') plt.close() sim_t = sim.trange() sim_sin = sim.data[p_in].ravel() sim_sq = sim.data[p_out].ravel() t = 0.001 * np.arange(len(sim_t)) assert np.allclose(sim_t, t) # 1-step delay assert np.allclose(sim_sin[1:], np.sin(t[:-1])) assert np.allclose(sim_sq[1:], sim_sin[:-1]**2)
def test_vector(Simulator, nl): """A network that represents sin(t), cos(t), arctan(t).""" N = 40 m = nengo.Network(label='test_vector', seed=123) with m: input = nengo.Node( output=lambda t: [np.sin(t), np.cos(t), np.arctan(t)]) A = nengo.Ensemble(nl(N * 3), 3, radius=2) nengo.Connection(input, A) in_p = nengo.Probe(input, 'output') A_p = nengo.Probe(A, 'decoded_output', synapse=0.02) sim = Simulator(m) sim.run(5) with Plotter(Simulator, nl) as plt: t = sim.trange() plt.plot(t, sim.data[in_p], label='Input') plt.plot(t, sim.data[A_p], 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_p])) assert rmse(target, sim.data[in_p]) < 0.01 assert rmse(target, sim.data[A_p]) < 0.1
def test_constant_vector(Simulator, nl): """A network that represents a constant 3D vector.""" N = 30 vals = [0.6, 0.1, -0.5] m = nengo.Network(label='test_constant_vector', seed=123) with m: input = nengo.Node(output=vals) A = nengo.Ensemble(nl(N * len(vals)), len(vals)) nengo.Connection(input, A) in_p = nengo.Probe(input, 'output') A_p = nengo.Probe(A, 'decoded_output', synapse=0.1) sim = Simulator(m) sim.run(1.0) with Plotter(Simulator, nl) as plt: t = sim.trange() plt.plot(t, sim.data[in_p], label='Input') plt.plot(t, sim.data[A_p], label='Neuron approximation, pstc=0.1') plt.legend(loc=0, prop={'size': 10}) plt.savefig('test_ensemble.test_constant_vector.pdf') plt.close() assert np.allclose(sim.data[in_p][-10:], vals, atol=.1, rtol=.01) assert np.allclose(sim.data[A_p][-10:], vals, atol=.1, rtol=.01)
def test_thalamus(Simulator): with nengo.Network(seed=123) as net: bg = nengo.networks.BasalGanglia(dimensions=5, label="BG") input = nengo.Node([0.8, 0.4, 0.4, 0.4, 0.4], label="input") nengo.Connection(input, bg.input, synapse=None) thal = nengo.networks.Thalamus(dimensions=5) nengo.Connection(bg.output, thal.input) p = nengo.Probe(thal.output, synapse=0.01) sim = Simulator(net) sim.run(0.2) t = sim.trange() output = np.mean(sim.data[p][t > 0.1], axis=0) with Plotter(Simulator) as plt: plt.plot(t, sim.data[p]) plt.ylabel("Output") plt.savefig('test_basalganglia.test_thalamus.pdf') plt.close() assert output[0] > 0.8 assert np.all(output[1:] < 0.01)
def test_inputgatedmemory(Simulator): with nengo.Network(seed=123) as net: test_input = nengo.Node(piecewise({0.0: 0, 0.3: 0.5, 1.0: 0})) gate_input = nengo.Node(piecewise({0.0: 0, 0.8: 1})) reset_input = nengo.Node(0) mem = nengo.networks.InputGatedMemory(100, 1, difference_gain=5.0) nengo.Connection(test_input, mem.input) nengo.Connection(gate_input, mem.gate) nengo.Connection(reset_input, mem.reset_node) mem_p = nengo.Probe(mem.output, synapse=0.01) sim = Simulator(net) sim.run(1.2) data = sim.data[mem_p] trange = sim.trange() with Plotter(Simulator) as plt: plt.plot(trange, data) plt.savefig('test_workingmemory.test_inputgatedmemory.pdf') plt.close() assert abs(np.mean(data[trange < 0.3])) < 0.01 assert abs(np.mean(data[(trange > 0.8) & (trange < 1.0)]) - 0.5) < 0.02 assert abs(np.mean(data[trange > 1.0]) - 0.5) < 0.02
def test_constant_scalar(Simulator, nl): """A Network that represents a constant value.""" N = 30 val = 0.5 m = nengo.Network(label='test_constant_scalar', seed=123) with m: input = nengo.Node(output=val, label='input') A = nengo.Ensemble(nl(N), 1) nengo.Connection(input, A) in_p = nengo.Probe(input, 'output') A_p = nengo.Probe(A, 'decoded_output', synapse=0.1) sim = Simulator(m, dt=0.001) sim.run(1.0) with Plotter(Simulator, nl) as plt: t = sim.trange() plt.plot(t, sim.data[in_p], label='Input') plt.plot(t, sim.data[A_p], label='Neuron approximation, pstc=0.1') plt.legend(loc=0) plt.savefig('test_ensemble.test_constant_scalar.pdf') plt.close() assert np.allclose(sim.data[in_p].ravel(), val, atol=.1, rtol=.01) assert np.allclose(sim.data[A_p][-10:], val, atol=.1, rtol=.01)
def test_integrator(Simulator, nl): model = nengo.Network(label='Integrator', seed=892) with model: model.config[nengo.Ensemble].neuron_type = nl() inputs = {0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0} input = nengo.Node(piecewise(inputs)) tau = 0.1 T = nengo.networks.Integrator(tau, n_neurons=100, dimensions=1) nengo.Connection(input, T.input, synapse=tau) A = nengo.Ensemble(100, dimensions=1) nengo.Connection(A, A, synapse=tau) nengo.Connection(input, A, transform=tau, synapse=tau) input_p = nengo.Probe(input) A_p = nengo.Probe(A, synapse=0.01) T_p = nengo.Probe(T.ensemble, synapse=0.01) sim = Simulator(model, dt=0.001) sim.run(6.0) with Plotter(Simulator, nl) as plt: t = sim.trange() plt.plot(t, sim.data[A_p], label='Manual') plt.plot(t, sim.data[T_p], label='Template') plt.plot(t, sim.data[input_p], 'k', label='Input') plt.legend(loc=0) plt.savefig('test_integrator.test_integrator.pdf') plt.close() assert rmse(sim.data[A_p], sim.data[T_p]) < 0.2
def test_passthrough_filter(Simulator): m = nengo.Network(label="test_passthrough", seed=0) with m: omega = 2 * np.pi * 5 u = nengo.Node(output=lambda t: np.sin(omega * t)) passthrough = nengo.Node(size_in=1) v = nengo.Node(output=lambda t, x: x, size_in=1) synapse = 0.3 nengo.Connection(u, passthrough, synapse=None) nengo.Connection(passthrough, v, synapse=synapse) up = nengo.Probe(u) vp = nengo.Probe(v) dt = 0.001 sim = Simulator(m, dt=dt) sim.run(1.0) t = sim.trange() x = sim.data[up] y = filt(x, synapse / dt) z = sim.data[vp] with Plotter(Simulator) as plt: plt.plot(t, x) plt.plot(t, y) plt.plot(t, z) plt.savefig("test_node.test_passthrough_filter.pdf") plt.close() # TODO: we have a two-step delay here since the passthrough node is not # actually optimized out. We should look into doing this. assert np.allclose(y[:-2], z[2:])
def test_passthrough(Simulator): m = nengo.Network(label="test_passthrough", seed=0) with m: in1 = nengo.Node(output=lambda t: np.sin(t)) in2 = nengo.Node(output=lambda t: t) passthrough = nengo.Node(size_in=1) out = nengo.Node(output=lambda t, x: x, size_in=1) nengo.Connection(in1, passthrough, synapse=None) nengo.Connection(in2, passthrough, synapse=None) nengo.Connection(passthrough, out, synapse=None) in1_p = nengo.Probe(in1, 'output') in2_p = nengo.Probe(in2, 'output') out_p = nengo.Probe(out, 'output') sim = Simulator(m) runtime = 0.5 sim.run(runtime) with Plotter(Simulator) as plt: plt.plot(sim.trange(), sim.data[in1_p] + sim.data[in2_p], label='in+in2') plt.plot(sim.trange()[:-2], sim.data[out_p][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[in1_p][:-1] + sim.data[in2_p][:-1] sim_out = sim.data[out_p][1:] assert np.allclose(sim_in, sim_out)
def test_neurons_to_node(Simulator, nl_nodirect): name = 'neurons_to_node' N = 30 m = nengo.Network(label=name, seed=123) with m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() a = nengo.Ensemble(N, dimensions=1) out = nengo.Node(lambda t, x: x, size_in=N) nengo.Connection(a.neurons, out, synapse=None) a_spikes = nengo.Probe(a, 'spikes') out_p = nengo.Probe(out, 'output') sim = Simulator(m) sim.run(0.6) t = sim.trange() with Plotter(Simulator, nl_nodirect) as plt: ax = plt.subplot(111) try: from nengo.matplotlib import rasterplot rasterplot(t, sim.data[a_spikes], ax=ax) rasterplot(t, sim.data[out_p], ax=ax) except ImportError: pass plt.savefig('test_connection.test_' + name + '.pdf') plt.close() assert np.allclose(sim.data[a_spikes][:-1], sim.data[out_p][1:])
def plt(request): """A pyplot-compatible plotting interface. Please use this if your test creates plots. This will keep saved plots organized in a simulator-specific folder, with an automatically generated name. savefig() and close() will automatically be called when the test function completes. If you need to override the default filename, set `plt.saveas` to the desired filename. """ dirname = recorder_dirname(request, 'plots') plotter = Plotter( dirname, request.module.__name__, parametrize_function_name(request, request.function.__name__)) request.addfinalizer(lambda: plotter.__exit__(None, None, None)) return plotter.__enter__()
def test_alif(Simulator): """Test ALIF and ALIFRate by comparing them to each other""" n = 100 max_rates = 50 * np.ones(n) intercepts = np.linspace(-0.99, 0.99, n) encoders = np.ones((n, 1)) nparams = dict(tau_n=1, inc_n=10e-3) eparams = dict(n_neurons=n, max_rates=max_rates, intercepts=intercepts, encoders=encoders) model = nengo.Network() with model: u = nengo.Node(output=0.5) a = nengo.Ensemble(neuron_type=nengo.AdaptiveLIFRate(**nparams), dimensions=1, **eparams) b = nengo.Ensemble(neuron_type=nengo.AdaptiveLIF(**nparams), dimensions=1, **eparams) nengo.Connection(u, a, synapse=0) nengo.Connection(u, b, synapse=0) ap = nengo.Probe(a, "spikes", synapse=0) bp = nengo.Probe(b, "spikes", synapse=0) dt = 1e-3 sim = Simulator(model, dt=dt) sim.run(2.) t = sim.trange() a_rates = sim.data[ap] / dt spikes = sim.data[bp] b_rates = rates_kernel(t, spikes) tmask = (t > 0.1) & (t < 1.7) rel_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask]) with Plotter(Simulator) as plt: ax = plt.subplot(311) implot(plt, t, intercepts[::-1], a_rates.T, ax=ax) ax.set_ylabel('input') ax = plt.subplot(312) implot(plt, t, intercepts[::-1], b_rates.T, ax=ax) ax.set_ylabel('input') ax = plt.subplot(313) implot(plt, t, intercepts[::-1], (b_rates - a_rates)[tmask].T, ax=ax) ax.set_xlabel('time [s]') ax.set_ylabel('input') plt.savefig('test_neurons.test_alif.pdf') plt.close() assert rel_rmse < 0.07
def test_solvers(Simulator, nl_nodirect): N = 100 decoder_solvers = [ Lstsq(), LstsqNoise(), LstsqL2(), LstsqL2nz(), LstsqL1() ] weight_solvers = [LstsqL1(weights=True), LstsqDrop(weights=True)] dt = 1e-3 tfinal = 4 def input_function(t): return np.interp(t, [1, 3], [-1, 1], left=-1, right=1) model = nengo.Network('test_solvers', seed=290) with model: u = nengo.Node(output=input_function) a = nengo.Ensemble(nl_nodirect(N), dimensions=1) nengo.Connection(u, a) ap = nengo.Probe(a) probes = [] names = [] for solver in decoder_solvers + weight_solvers: b = nengo.Ensemble(nl_nodirect(N), dimensions=1, seed=99) nengo.Connection(a, b, solver=solver) probes.append(nengo.Probe(b)) names.append( "%s(%s)" % (solver.__class__.__name__, 'w' if solver.weights else 'd')) sim = Simulator(model, dt=dt) sim.run(tfinal) t = sim.trange() # ref = sim.data[up] ref = filtfilt(sim.data[ap], 20) outputs = np.array([sim.data[probe] for probe in probes]) outputs_f = filtfilt(outputs, 20, axis=1) close = allclose(t, ref, outputs_f, plotter=Plotter(Simulator, nl_nodirect), filename='test_decoders.test_solvers.pdf', labels=names, atol=0.05, rtol=0, buf=100, delay=7) for name, c in zip(names, close): assert c, "Solver '%s' does not meet tolerances" % name
def test_product(Simulator, nl): N = 80 m = nengo.Network(label='test_product', seed=124) with m: sin = nengo.Node(output=np.sin) cons = nengo.Node(output=-.5) factors = nengo.Ensemble(nl(2 * N), dimensions=2, radius=1.5) if nl != nengo.Direct: factors.encoders = np.tile([[1, 1], [-1, 1], [1, -1], [-1, -1]], (factors.n_neurons // 4, 1)) product = nengo.Ensemble(nl(N), dimensions=1) nengo.Connection(sin, factors[0]) nengo.Connection(cons, factors[1]) nengo.Connection(factors, product, function=lambda x: x[0] * x[1], synapse=0.01) sin_p = nengo.Probe(sin, 'output', sample_every=.01) # TODO # m.probe(conn, sample_every=.01) factors_p = nengo.Probe(factors, 'decoded_output', sample_every=.01, synapse=.01) product_p = nengo.Probe(product, 'decoded_output', sample_every=.01, synapse=.01) sim = Simulator(m) sim.run(6) with Plotter(Simulator, nl) as plt: t = sim.trange(dt=.01) plt.subplot(211) plt.plot(t, sim.data[factors_p]) plt.plot(t, np.sin(np.arange(0, 6, .01))) plt.plot(t, sim.data[sin_p]) plt.subplot(212) plt.plot(t, sim.data[product_p]) # TODO # plt.plot(sim.data[conn]) plt.plot(t, -.5 * np.sin(np.arange(0, 6, .01))) plt.savefig('test_ensemble.test_prod.pdf') plt.close() sin = np.sin(np.arange(0, 6, .01)) assert rmse(sim.data[factors_p][:, 0], sin) < 0.1 assert rmse(sim.data[factors_p][20:, 1], -0.5) < 0.1 assert rmse(sim.data[product_p][:, 0], -0.5 * sin) < 0.1
def _test_rates(Simulator, rates, name=None): if name is None: name = rates.__name__ n = 100 max_rates = 50 * np.ones(n) # max_rates = 200 * np.ones(n) intercepts = np.linspace(-0.99, 0.99, n) encoders = np.ones((n, 1)) nparams = dict(n_neurons=n) eparams = dict( max_rates=max_rates, intercepts=intercepts, encoders=encoders) model = nengo.Network() with model: u = nengo.Node(output=whitenoise(1, 5, seed=8393)) a = nengo.Ensemble(nengo.LIFRate(**nparams), 1, **eparams) b = nengo.Ensemble(nengo.LIF(**nparams), 1, **eparams) nengo.Connection(u, a, synapse=0) nengo.Connection(u, b, synapse=0) up = nengo.Probe(u) ap = nengo.Probe(a.neurons, "output", synapse=None) bp = nengo.Probe(b.neurons, "output", synapse=None) dt = 1e-3 sim = Simulator(model, dt=dt) sim.run(2.) t = sim.trange() x = sim.data[up] a_rates = sim.data[ap] / dt spikes = sim.data[bp] b_rates = rates(t, spikes) with Plotter(Simulator) as plt: ax = plt.subplot(411) plt.plot(t, x) ax = plt.subplot(412) implot(plt, t, intercepts, a_rates.T, ax=ax) ax.set_ylabel('intercept') ax = plt.subplot(413) implot(plt, t, intercepts, b_rates.T, ax=ax) ax.set_ylabel('intercept') ax = plt.subplot(414) implot(plt, t, intercepts, (b_rates - a_rates).T, ax=ax) ax.set_xlabel('time [s]') ax.set_ylabel('intercept') plt.savefig('utils.test_neurons.test_rates.%s.pdf' % name) plt.close() tmask = (t > 0.1) & (t < 1.9) relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask]) return relative_rmse
def plt(request): """a pyplot-compatible plotting interface. Please use this if your test creates plots. This will keep saved plots organized in a simulator-specific folder, with an automatically generated name. savefig() and close() will automatically be called when the test function completes. If you need to override the default filename, set `plt.saveas` to the desired filename. """ simulator, nl = ReferenceSimulator, None if 'Simulator' in request.funcargnames: simulator = request.getfuncargvalue('Simulator') if 'nl' in request.funcargnames: nl = request.getfuncargvalue('nl') elif 'nl_nodirect' in request.funcargnames: nl = request.getfuncargvalue('nl_nodirect') plotter = Plotter(simulator, request.module, request.function, nl=nl) request.addfinalizer(lambda p=plotter: p.__exit__(None, None, None)) return plotter.__enter__()
def test_lowpass(Simulator): dt = 1e-3 tau = 0.03 t, x, yhat = run_synapse(Simulator, nengo.synapses.Lowpass(tau), dt=dt) y = filt(x, tau / dt) assert allclose(t, y.flatten(), yhat.flatten(), delay=1, plotter=Plotter(Simulator), filename='test_synapse.test_lowpass.pdf')
def test_decoders(Simulator, nl): dt = 1e-3 tau = 0.01 t, x, yhat = run_synapse(Simulator, nengo.synapses.Lowpass(tau), dt=dt, n_neurons=100) y = filt(x, tau / dt) assert allclose(t, y.flatten(), yhat.flatten(), delay=1, plotter=Plotter(Simulator, nl), filename='test_synapse.test_decoders.pdf')
def test_solvers(Simulator, nl_nodirect): N = 100 decoder_solvers = [lstsq, lstsq_noise, lstsq_L2, lstsq_L2nz, lstsq_L1] weight_solvers = [lstsq_L1, lstsq_drop] dt = 1e-3 tfinal = 4 def input_function(t): return np.interp(t, [1, 3], [-1, 1], left=-1, right=1) model = nengo.Network('test_solvers', seed=290) with model: u = nengo.Node(output=input_function) # up = nengo.Probe(u) a = nengo.Ensemble(nl_nodirect(N), dimensions=1) ap = nengo.Probe(a) nengo.Connection(u, a) probes = [] names = [] for solver, arg in ([(s, 'decoder_solver') for s in decoder_solvers] + [(s, 'weight_solver') for s in weight_solvers]): b = nengo.Ensemble(nl_nodirect(N), dimensions=1, seed=99) nengo.Connection(a, b, **{arg: solver}) probes.append(nengo.Probe(b)) names.append(solver.__name__ + (" (%s)" % arg[0])) sim = nengo.Simulator(model, dt=dt) sim.run(tfinal) t = sim.trange() # ref = sim.data[up] ref = filtfilt(sim.data[ap], 20) outputs = np.array([sim.data[probe] for probe in probes]) outputs_f = filtfilt(outputs, 20, axis=1) close = allclose(t, ref, outputs_f, plotter=Plotter(Simulator, nl_nodirect), filename='test_decoders.test_solvers.pdf', labels=names, atol=0.05, rtol=0, buf=100, delay=7) for name, c in zip(names, close): assert c, "Solver '%s' does not meet tolerances" % name
def test_alif_rate(Simulator): n = 100 max_rates = 50 * np.ones(n) # max_rates = 200 * np.ones(n) intercepts = np.linspace(-0.99, 0.99, n) encoders = np.ones((n, 1)) model = nengo.Network() with model: u = nengo.Node(output=0.5) a = nengo.Ensemble(n, 1, max_rates=max_rates, intercepts=intercepts, encoders=encoders, neuron_type=nengo.AdaptiveLIFRate()) nengo.Connection(u, a, synapse=None) ap = nengo.Probe(a, "spikes", synapse=None) dt = 1e-3 sim = Simulator(model, dt=dt) sim.run(2.) t = sim.trange() rates = sim.data[ap] _, ref = tuning_curves(a, sim, eval_points=0.5) with Plotter(Simulator) as plt: ax = plt.subplot(211) implot(plt, t, intercepts[::-1], rates.T / dt, ax=ax) ax.set_xlabel('time [s]') ax.set_ylabel('input') ax = plt.subplot(212) ax.plot(intercepts, ref[:, ::-1].T, 'k--') ax.plot(intercepts, rates[[1, 500, 1000, -1], ::-1].T / dt) ax.set_xlabel('input') ax.set_xlabel('rate') plt.savefig('test_neurons.test_alif_rate.pdf') plt.close() # check that initial tuning curve is the same as LIF rates assert np.allclose(rates[1] / dt, ref, atol=0.1, rtol=1e-3) # check that curves in firing region are monotonically decreasing assert np.all(np.diff(rates[1:, intercepts < 0.4], axis=0) < 0)