def test_tuning_curves_1d(Simulator, plt, seed): """For 1D ensembles, should be able to do plt.plot(*tuning_curves(...)).""" model = nengo.Network(seed=seed) with model: ens_1d = nengo.Ensemble(10, dimensions=1, neuron_type=nengo.LIF()) with Simulator(model) as sim: plt.plot(*tuning_curves(ens_1d, sim))
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_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_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 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 forward(x, weights, biases): lif = nengo.LIF() for w, b in zip(weights, biases): x = np.dot(x, w) x += b if w is not weights[-1]: x = lif.rates(x, 1, 1) / 63.04 return x
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 forward(x, weights, biases): lif = nengo.LIF() layers = [] for w, b in zip(weights, biases): x = np.dot(x, w) + b x = lif.rates(x, 1, 1) / 63.04 layers.append(x) return x, layers
def test_amplitude(Simulator, seed, rng, plt): amp = 0.1 neuron0 = nengo.LIF() neuron = nengo.LIF(amplitude=amp) # check static x = np.linspace(-5, 30) y = amp * neuron0.rates(x, 1., 0.) y2 = neuron.rates(x, 1., 0.) assert np.allclose(y, y2, atol=1e-5) # check dynamic n = 100 x = 1.0 encoders = np.ones((n, 1)) max_rates = rng.uniform(low=20, high=200, size=n) intercepts = rng.uniform(low=-1, high=0.8, size=n) with nengo.Network(seed=seed) as model: ins = nengo.Node(x) ens = nengo.Ensemble(n, dimensions=1, neuron_type=neuron, encoders=encoders, max_rates=max_rates, intercepts=intercepts) nengo.Connection(ins, ens, synapse=None) spike_probe = nengo.Probe(ens.neurons) dt = 0.001 t_final = 0.5 with Simulator(model, dt=dt) as sim: sim.run(t_final) spikes = sim.data[spike_probe] r = spikes.sum(axis=0) * (dt / t_final) gain, bias = neuron0.gain_bias(max_rates, intercepts) r0 = amp * neuron0.rates(x, gain, bias) i = np.argsort(r0) plt.plot(r0[i]) plt.plot(r[i]) error = rms(r - r0) / rms(r0) assert (error < 0.02).all()
def performance_samples(device): # pragma: no cover """ Run a brief sample of the benchmarks to check overall performance. This is mainly used to quickly check that there haven't been any unexpected performance regressions. """ # TODO: automatically run some basic performance tests during CI default_kwargs = { "n_steps": 1000, "device": device, "unroll_simulation": 25, "progress_bar": False, "do_profile": False } print("cconv + relu") net = cconv(128, 64, nengo.RectifiedLinear()) run_profile(net, minibatch_size=64, **default_kwargs) print("cconv + lif") net = cconv(128, 64, nengo.LIF()) run_profile(net, minibatch_size=64, **default_kwargs) print("integrator training + relu") net = integrator(128, 32, nengo.RectifiedLinear()) run_profile(net, minibatch_size=64, train=True, **default_kwargs) print("integrator training + lif") net = integrator(128, 32, nengo.LIF()) run_profile(net, minibatch_size=64, train=True, **default_kwargs) print("random") net = random_network(128, 64, nengo.RectifiedLinear(), n_ensembles=50, connections_per_ensemble=5, seed=0) run_profile(net, **default_kwargs) print("spaun") net = spaun(1) run_profile(net, **default_kwargs)
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)))
def test_lif(Simulator, plt, rng, logger, dt): """Test that the dynamic model approximately matches the rates.""" n = 5000 x = 0.5 encoders = np.ones((n, 1)) max_rates = rng.uniform(low=10, high=200, size=n) intercepts = rng.uniform(low=-1, high=1, size=n) m = nengo.Network() with m: ins = nengo.Node(x) ens = nengo.Ensemble(n, dimensions=1, neuron_type=nengo.LIF(), encoders=encoders, max_rates=max_rates, intercepts=intercepts) nengo.Connection(ins, ens.neurons, transform=np.ones((n, 1)), synapse=None) spike_probe = nengo.Probe(ens.neurons) voltage_probe = nengo.Probe(ens.neurons, 'voltage') ref_probe = nengo.Probe(ens.neurons, 'refractory_time') t_final = 1.0 with Simulator(m, dt=dt) as sim: sim.run(t_final) i = 3 plt.subplot(311) plt.plot(sim.trange(), sim.data[spike_probe][:, :i]) plt.subplot(312) plt.plot(sim.trange(), sim.data[voltage_probe][:, :i]) plt.subplot(313) plt.plot(sim.trange(), sim.data[ref_probe][:, :i]) plt.ylim([-dt, ens.neuron_type.tau_ref + dt]) # check rates against analytic rates math_rates = ens.neuron_type.rates( x, *ens.neuron_type.gain_bias(max_rates, intercepts)) spikes = sim.data[spike_probe] sim_rates = (spikes > 0).sum(0) / t_final logger.info("ME = %f", (sim_rates - math_rates).mean()) logger.info("RMSE = %f", rms(sim_rates - math_rates) / (rms(math_rates) + 1e-20)) assert np.sum(math_rates > 0) > 0.5 * n, ( "At least 50% of neurons must fire") assert np.allclose(sim_rates, math_rates, atol=1, rtol=0.02) # if voltage and ref time are non-constant, the probe is doing something assert np.abs(np.diff(sim.data[voltage_probe])).sum() > 1 assert np.abs(np.diff(sim.data[ref_probe])).sum() > 1 # compute spike counts after each timestep actual_counts = (spikes > 0).cumsum(axis=0) expected_counts = np.outer(sim.trange(), math_rates) assert (abs(actual_counts - expected_counts) < 1).all()
def test_lif_step(ctx, upsample): """Test the lif nonlinearity, comparing one step with the Numpy version.""" rng = np.random dt = 1e-3 n_neurons = [12345, 23456, 34567] J = RA([rng.normal(scale=1.2, size=n) for n in n_neurons]) V = RA([rng.uniform(low=0, high=1, size=n) for n in n_neurons]) W = RA([rng.uniform(low=-5 * dt, high=5 * dt, size=n) for n in n_neurons]) OS = RA([np.zeros(n) for n in n_neurons]) ref = 2e-3 taus = rng.uniform(low=15e-3, high=80e-3, size=len(n_neurons)) amp = 1. queue = cl.CommandQueue(ctx) clJ = CLRA(queue, J) clV = CLRA(queue, V) clW = CLRA(queue, W) clOS = CLRA(queue, OS) clTaus = CLRA(queue, RA([t * np.ones(n) for t, n in zip(taus, n_neurons)])) # simulate host nls = [nengo.LIF(tau_ref=ref, tau_rc=taus[i]) for i, n in enumerate(n_neurons)] for i, nl in enumerate(nls): if upsample <= 1: nl.step_math(dt, J[i], OS[i], V[i], W[i]) else: s = np.zeros_like(OS[i]) for j in range(upsample): nl.step_math(dt / upsample, J[i], s, V[i], W[i]) OS[i] = (1./dt) * ((OS[i] > 0) | (s > 0)) # simulate device plan = plan_lif( queue, dt, clJ, clV, clW, clOS, ref, clTaus, amp, upsample=upsample) plan() if 1: a, b = V, clV for i in range(len(a)): nc, _ = not_close(a[i], b[i]).nonzero() if len(nc) > 0: j = nc[0] print("i", i, "j", j) print("J", J[i][j], clJ[i][j]) print("V", V[i][j], clV[i][j]) print("W", W[i][j], clW[i][j]) print("...", len(nc) - 1, "more") n_spikes = np.sum([np.sum(os) for os in OS]) if n_spikes < 1.0: logger.warn("LIF spiking mechanism was not tested!") assert ra.allclose(J, clJ.to_host()) assert ra.allclose(V, clV.to_host()) assert ra.allclose(W, clW.to_host()) assert ra.allclose(OS, clOS.to_host())
def test_config(): @nengo.config.configures(nengo.Ensemble) class TestConfigEnsemble(nengo.config.ConfigItem): something = nengo.config.Parameter(None) other = nengo.config.Parameter(0) @nengo.config.configures(nengo.Connection) class TestConfigConnection(nengo.config.ConfigItem): something_else = nengo.config.Parameter(None) class TestConfig(nengo.config.Config): config_items = [TestConfigEnsemble, TestConfigConnection] model = nengo.Network() with model: a = nengo.Ensemble(nengo.LIF(50), 1) b = nengo.Ensemble(nengo.LIF(90), 1) a2b = nengo.Connection(a, b, synapse=0.01) config = TestConfig() assert config[a].something is None assert config[b].something is None assert config[a].other == 0 assert config[b].other == 0 assert config[a2b].something_else is None config[a].something = 'hello' assert config[a].something == 'hello' config[a].something = 'world' assert config[a].something == 'world' with pytest.raises(AttributeError): config[a].something_else config[a2b].something with pytest.raises(AttributeError): config[a].something_else = 1 config[a2b].something = 1 with pytest.raises(KeyError): config['a'].something with pytest.raises(KeyError): config[None].something with pytest.raises(KeyError): config[model].something
def test_invalid_rates(Simulator): with nengo.Network() as model: nengo.Ensemble(1, 1, max_rates=[200], neuron_type=nengo.LIF(tau_ref=0.01)) with pytest.raises(ValueError): Simulator(model)
def test_withself(): model = nengo.Network(label='test_withself') with model: n1 = nengo.Node(output=0.5) assert n1 in model.nodes e1 = nengo.Ensemble(nengo.LIF(10), 1) assert e1 in model.ensembles c1 = nengo.Connection(n1, e1) assert c1 in model.connections ea1 = nengo.networks.EnsembleArray(nengo.LIF(10), 2) assert ea1 in model.networks assert len(ea1.ensembles) == 2 n2 = ea1.add_output("out", None) assert n2 in ea1.nodes with ea1: e2 = nengo.Ensemble(nengo.LIF(10), 1) assert e2 in ea1.ensembles assert len(nengo.Network.context) == 0
def test_neuron_probes(precompute, probe_target, Simulator, seed, plt, allclose): simtime = 0.3 with nengo.Network(seed=seed) as model: stim = nengo.Node(lambda t: [np.sin(t * 2 * np.pi / simtime)]) a = nengo.Ensemble( 1, 1, neuron_type=nengo.LIF(min_voltage=-1), encoders=nengo.dists.Choice([[1]]), max_rates=nengo.dists.Choice([100]), intercepts=nengo.dists.Choice([0.0]), ) nengo.Connection(stim, a, synapse=None) p_stim = nengo.Probe(stim, synapse=0.005) p_neurons = nengo.Probe(a.neurons, probe_target) probe_synapse = nengo.Alpha(0.01) p_stim_f = nengo.Probe(stim, synapse=probe_synapse.combine( nengo.Lowpass(0.005))) p_neurons_f = nengo.Probe(a.neurons, probe_target, synapse=probe_synapse) with Simulator(model, precompute=precompute) as sim: sim.run(simtime) scale = float(sim.data[p_neurons].max()) t = sim.trange() x = sim.data[p_stim] xf = sim.data[p_stim_f] y = sim.data[p_neurons] / scale yf = sim.data[p_neurons_f] / scale plt.plot(t, x, label="stim") plt.plot(t, xf, label="stim filt") plt.plot(t, y, label="loihi") plt.plot(t, yf, label="loihi filt") plt.legend() if probe_target == "input": # shape of current input should roughly match stimulus assert allclose(y, x, atol=0.4, rtol=0) # noisy, so rough match assert allclose(yf, xf, atol=0.05, rtol=0) # tight match elif probe_target == "voltage": # check for voltage fluctuations (spiking) when stimulus is positive, # and negative voltage when stimulus is most negative spos = (t > 0.1 * simtime) & (t < 0.4 * simtime) assert allclose(yf[spos], 0.5, atol=0.1, rtol=0.1) assert y[spos].std() > 0.25 sneg = (t > 0.7 * simtime) & (t < 0.9 * simtime) assert np.all(y[sneg] < 0)
def test_scalar_spiking(Simulator, seed): _test_RLS_network(Simulator, seed, dims=1, lrate=1e-5, neuron_type=nengo.LIF(), tau=0.01, T_train=1, T_test=0.5, tols=[0.03, 0.04, 0.04, 0.3])
def test_perfect_lif_invariance(Simulator, seed): # as long as the simulation time is divisible by dt, the same number of # spikes should be observed t = 1.0 errors = [] for dt in (0.0001, 0.0005, 0.001, 0.002): assert np.allclose(int(t / dt), t / dt) error = _test_lif(Simulator, seed, nengo.LIF(), 0, dt, t=t) errors.append(error) assert np.allclose(errors, errors[0])
def test_rls_scalar_spiking(Simulator, seed, plt): _test_rls_network( Simulator, seed, plt, neuron_type=nengo.LIF(), lrate=0.05, tau=0.01, tols=[0.04, 0.05, 0.04, 0.3], )
def test_neurontypeparam_probeable(): """NeuronTypeParam can update a probeable list.""" class Test(object): ntp = EnsembleNeuronTypeParam(default=None, optional=True) probeable = ['output'] inst = Test() assert inst.probeable == ['output'] inst.ntp = nengo.LIF() assert Counter(inst.probeable) == Counter(inst.ntp.probeable + ['output']) # The first element is important, as it's the default assert inst.probeable[0] == 'output' # Setting it again should result in the same list inst.ntp = nengo.LIF() assert Counter(inst.probeable) == Counter(inst.ntp.probeable + ['output']) assert inst.probeable[0] == 'output' # Unsetting it should clear the list appropriately inst.ntp = None assert inst.probeable == ['output']
def test_neurontypeparam(): """NeuronTypeParam must be a neuron type.""" class Test(object): ntp = NeuronTypeParam('ntp', default=None) inst = Test() inst.ntp = nengo.LIF() assert isinstance(inst.ntp, nengo.LIF) with pytest.raises(ValueError): inst.ntp = 'a'
def test_loihi_rates(dt, neuron_type, Simulator, plt, allclose): n = 256 x = np.linspace(-0.1, 1, n) encoders = np.ones((n, 1)) max_rates = 400 * np.ones(n) intercepts = 0 * np.ones(n) gain, bias = neuron_type.gain_bias(max_rates, intercepts) j = x * gain + bias with nengo.Network() as model: a = nengo.Ensemble(n, 1, neuron_type=neuron_type, encoders=encoders, gain=gain, bias=j) ap = nengo.Probe(a.neurons) with Simulator(model, dt=dt) as sim: sim.run(1.0) est_rates = sim.data[ap].mean(axis=0) ref_rates = loihi_rates(neuron_type, x[np.newaxis, :], gain, bias, dt=dt).squeeze(axis=0) ref_rates2 = None if isinstance(neuron_type, nengo.RegularSpiking): if isinstance(neuron_type.base_type, nengo.LIFRate): neuron_type2 = nengo.LIF( tau_rc=neuron_type.base_type.tau_rc, tau_ref=neuron_type.base_type.tau_ref, amplitude=neuron_type.amplitude, ) elif isinstance(neuron_type.base_type, nengo.RectifiedLinear): neuron_type2 = nengo.SpikingRectifiedLinear( amplitude=neuron_type.amplitude, ) ref_rates2 = loihi_rates(neuron_type2, x[np.newaxis, :], gain, bias, dt=dt).squeeze(axis=0) plt.plot(x, ref_rates, "k", label="predicted") if ref_rates2 is not None: plt.plot(x, ref_rates2, "b", label="predicted-base") plt.plot(x, est_rates, "g", label="measured") plt.legend(loc="best") assert ref_rates.shape == est_rates.shape assert allclose(est_rates, ref_rates, atol=1, rtol=0, xtol=1) if ref_rates2 is not None: assert allclose(ref_rates2, ref_rates)
def test_bad_weight_exponent_error(Simulator): with nengo.Network() as net: a = nengo.Ensemble(5, 1) b = nengo.Ensemble(5, 1, neuron_type=nengo.LIF(tau_rc=5.)) nengo.Connection(a.neurons, b.neurons, transform=1e-8 * np.ones((5, 5)), synapse=5.) with pytest.raises(BuildError, match="[Cc]ould not find.*weight exp"): with Simulator(net): pass
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_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 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_nested_context(Simulator): model = nengo.Network() with model: con1 = nengo.Network() con2 = nengo.Network() con3 = nengo.Network() with con1: e1 = nengo.Ensemble(nengo.LIF(1), 1) assert e1 in con1.ensembles with con2: e2 = nengo.Ensemble(nengo.LIF(1), 1) assert e2 in con2.ensembles assert e2 not in con1.ensembles with con3: e3 = nengo.Ensemble(nengo.LIF(1), 1) assert e3 in con3.ensembles assert e3 not in con2.ensembles \ and e3 not in con1.ensembles e4 = nengo.Ensemble(nengo.LIF(1), 1) assert e4 in con2.ensembles assert e4 not in con3.ensembles e5 = nengo.Ensemble(nengo.LIF(1), 1) assert e5 in con1.ensembles e6 = nengo.Ensemble(nengo.LIF(1), 1) assert e6 not in con1.ensembles
def test_conv_input(channels_last, Simulator, plt, allclose): input_shape = ImageShape(4, 4, 1, channels_last=channels_last) seed = 3 # fix seed to do the same computation for both channel positions rng = np.random.RandomState(seed + 1) with nengo.Network(seed=seed) as net: nengo_loihi.add_params(net) a = nengo.Node(rng.uniform(0, 1, size=input_shape.size)) nc = 2 kernel = np.array([1., -1.]).reshape((1, 1, 1, nc)) transform = nengo_loihi.Conv2D.from_kernel(kernel, input_shape) b = nengo.Ensemble(transform.output_shape.size, 1, neuron_type=nengo.SpikingRectifiedLinear(), max_rates=nengo.dists.Choice([50]), intercepts=nengo.dists.Choice([0])) net.config[b].on_chip = False nengo.Connection(a, b.neurons, transform=transform) output_shape = transform.output_shape nf = 4 kernel = rng.uniform(-0.005, 0.005, size=(nc, 3, 3, nf)) transform = nengo_loihi.Conv2D.from_kernel(kernel, output_shape) c = nengo.Ensemble(transform.output_shape.size, 1, neuron_type=nengo.LIF(), max_rates=nengo.dists.Choice([100]), intercepts=nengo.dists.Choice([0])) nengo.Connection(b.neurons, c.neurons, transform=transform) output_shape = transform.output_shape p = nengo.Probe(c.neurons) with nengo.Simulator(net, optimize=False) as sim: sim.run(1.0) with Simulator(net, seed=seed) as sim_loihi: sim_loihi.run(1.0) p0 = np.sum(sim.data[p] > 0, axis=0).reshape(output_shape.shape()) p1 = np.sum(sim_loihi.data[p] > 0, axis=0).reshape(output_shape.shape()) if not output_shape.channels_last: p0 = np.transpose(p0, (1, 2, 0)) p1 = np.transpose(p1, (1, 2, 0)) plt.plot(p0.ravel(), 'k') plt.plot(p1.ravel(), 'b--') # loihi spikes are not exactly the same, but should be close-ish assert allclose(p0, p1, rtol=0.15, atol=1)