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_run(Simulator, algebra, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(32, pointer_gen=rng, algebra=algebra) vocab.populate('A; B') with spa.Network(seed=seed, vocabs=VocabularyMap([vocab])) as model: model.superpos = spa.Superposition(2, vocab=32) def inputA(t): if 0 <= t < 0.1: return 'A' else: return 'B' model.input = spa.Transcode(inputA, output_vocab=vocab) model.input >> model.superpos.inputs[0] spa.sym.A >> model.superpos.inputs[1] with model: p = nengo.Probe(model.superpos.output, synapse=0.03) with Simulator(model) as sim: sim.run(0.2) error = rmse(vocab.parse("(B+A).normalized()").v, sim.data[p][-1]) assert error < 0.1 error = rmse(vocab.parse("(A+A).normalized()").v, sim.data[p][100]) assert error < 0.2
def test_scalar(Simulator, nl): """A network that represents sin(t).""" N = 30 m = nengo.Network(label='test_scalar', seed=123) with m: m.config[nengo.Ensemble].neuron_type = nl() input = nengo.Node(output=np.sin, label='input') A = nengo.Ensemble(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("Input RMSE: %f", npext.rmse(target, sim.data[in_p])) logger.debug("A RMSE: %f", npext.rmse(target, sim.data[A_p])) assert npext.rmse(target, sim.data[in_p]) < 0.001 assert npext.rmse(target, sim.data[A_p]) < 0.1
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: m.config[nengo.Ensemble].neuron_type = nl() input = nengo.Node( output=lambda t: [np.sin(t), np.cos(t), np.arctan(t)]) A = nengo.Ensemble(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", npext.rmse(target, sim.data[in_p])) assert npext.rmse(target, sim.data[in_p]) < 0.01 assert npext.rmse(target, sim.data[A_p]) < 0.1
def test_modred(rng): dt = 0.001 isys = Lowpass(0.05) noise = 0.5 * Lowpass(0.01) + 0.5 * Alpha(0.005) p = 0.999 sys = p * isys + (1 - p) * noise T, Tinv, S = balanced_transformation(sys) balsys = sys.transform(T, Tinv) # Keeping just the best state should remove the 3 noise dimensions # Discarding the lowest state should do at least as well for keep_states in (S.argmax(), list(set(range(len(sys))) - set((S.argmin(), )))): delsys = modred(balsys, keep_states) assert delsys.order_den == np.asarray(keep_states).size u = rng.normal(size=2000) expected = sys.filt(u, dt) actual = delsys.filt(u, dt) assert rmse(expected, actual) < 1e-4 step = np.zeros(2000) step[50:] = 1.0 dcsys = modred(balsys, keep_states, method='dc') assert np.allclose(dcsys.dcgain, balsys.dcgain) # use of shift related to nengo issue #938 assert not sys.has_passthrough assert dcsys.has_passthrough expected = shift(sys.filt(step, dt)) actual = dcsys.filt(step, dt) assert rmse(expected, actual) < 1e-4
def test_run(Simulator, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(16, rng=rng) with spa.SPA(seed=seed, vocabs=[vocab]) as model: model.bind = spa.Bind(dimensions=16) def inputA(t): if 0 <= t < 0.1: return "A" else: return "B" model.input = spa.Input(bind_A=inputA, bind_B="A") bind, vocab = model.get_module_output("bind") with model: p = nengo.Probe(bind, "output", synapse=0.03) with Simulator(model) as sim: sim.run(0.2) error = rmse(vocab.parse("B*A").v, sim.data[p][-1]) assert error < 0.1 error = rmse(vocab.parse("A*A").v, sim.data[p][100]) assert error < 0.1
def test_run(Simulator, algebra, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(16, pointer_gen=rng, algebra=algebra) vocab.populate('A; B') with spa.Network(seed=seed) as model: model.bind = spa.Bind(vocab) def inputA(t): if 0 <= t < 0.1: return 'A' else: return 'B' model.input = spa.Transcode(inputA, output_vocab=vocab) model.input >> model.bind.input_left spa.sym.A >> model.bind.input_right with model: p = nengo.Probe(model.bind.output, synapse=0.03) with Simulator(model) as sim: sim.run(0.2) error = rmse(vocab.parse("(B*A).normalized()").v, sim.data[p][-1]) assert error < 0.15 error = rmse(vocab.parse("(A*A).normalized()").v, sim.data[p][100]) assert error < 0.15
def test_run(Simulator, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(16, rng=rng) with spa.SPA(seed=seed, vocabs=[vocab]) as model: model.bind = spa.Bind(dimensions=16) def inputA(t): if 0 <= t < 0.1: return 'A' else: return 'B' model.input = spa.Input(bind_A=inputA, bind_B='A') bind, vocab = model.get_module_output('bind') with model: p = nengo.Probe(bind, 'output', synapse=0.03) sim = Simulator(model) sim.run(0.2) error = rmse(vocab.parse("B*A").v, sim.data[p][-1]) assert error < 0.1 error = rmse(vocab.parse("A*A").v, sim.data[p][100]) assert error < 0.1
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 run_param_set(self, n_neurons, d, seed, trial): seed = int(seed) n_neurons = int(n_neurons) d = int(d) rng = np.random.RandomState(seed) ctx = nengo.spa.SemanticPointer(d, rng) ctx.make_unitary() model = nengo.Network(seed=get_seed(rng)) with model: in_a = nengo.Node(SignalGenerator(self.duration), size_out=d) in_b = nengo.Node(output=ctx.v) old_prod = nengo.networks.Product(n_neurons, d) old_result = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) nengo.Connection(in_a, old_prod.A) nengo.Connection(in_b, old_prod.B) nengo.Connection( old_prod.output, old_result, transform=nengo.networks.product.dot_product_transform(d)) prod = spaopt.Product(n_neurons, d) result = nengo.Ensemble(1, 1, neuron_type=nengo.Direct()) nengo.Connection(in_a, prod.A) nengo.Connection(in_b, prod.B) nengo.Connection( prod.output, result, transform=nengo.networks.product.dot_product_transform(d)) with nengo.Network() as net: net.config[nengo.Ensemble].neuron_type = nengo.Direct() d_prod = nengo.networks.EnsembleArray(2, d, 2) d_result = nengo.Ensemble(1, 1) nengo.Connection(in_a, d_prod.input[::2]) nengo.Connection(in_b, d_prod.input[1::2]) nengo.Connection( d_prod.add_output('dot', lambda x: x[0] * x[1]), d_result, transform=[d * [1.]]) old_probe = nengo.Probe(old_result, synapse=None) probe = nengo.Probe(result, synapse=None) d_probe = nengo.Probe(d_result, synapse=None) sim = nengo.Simulator(model) sim.run(self.duration, progress_bar=False) return { 't': sim.trange(), 'default': rmse(sim.data[old_probe], sim.data[d_probe], axis=1), 'optimized': rmse(sim.data[probe], sim.data[d_probe], axis=1) }
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_product(Simulator, nl): N = 80 m = nengo.Network(label='test_product', seed=124) with m: m.config[nengo.Ensemble].neuron_type = nl() sin = nengo.Node(output=np.sin) cons = nengo.Node(output=-.5) factors = nengo.Ensemble(2 * N, dimensions=2, radius=1.5) factors.encoders = np.tile( [[1, 1], [-1, 1], [1, -1], [-1, -1]], (factors.n_neurons // 4, 1)) product = nengo.Ensemble(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 npext.rmse(sim.data[factors_p][:, 0], sin) < 0.1 assert npext.rmse(sim.data[factors_p][20:, 1], -0.5) < 0.1 assert npext.rmse(sim.data[product_p][:, 0], -0.5 * sin) < 0.1
def test_multiple_builds(Simulator, seed): # this is not a separate test because of nengo issue #1011 solver = BiasedSolver() A, Y = np.ones((1, 1)), np.ones((1, 1)) assert solver.bias is None solver(A, Y) assert solver.bias is not None with warns(UserWarning): solver(A, Y) # issue: #99 with Network(seed=seed) as model: stim = nengo.Node(output=0) x = nengo.Ensemble(100, 1) out = nengo.Node(size_in=1) nengo.Connection(stim, x, synapse=None) conn = Connection(x, out, synapse=None) p = nengo.Probe(out, synapse=0.1) assert isinstance(conn.solver, BiasedSolver) with Simulator(model): pass with Simulator(model) as sim: sim.run(0.1) assert rmse(sim.data[p], 0) < 0.01
def test_integrator(Simulator, nl): model = nengo.Network(label='Integrator') with model: 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, neurons=nl(100), dimensions=1) nengo.Connection(input, T.input, filter=tau) A = nengo.Ensemble(nl(100), dimensions=1) nengo.Connection(A, A, filter=tau) nengo.Connection(input, A, transform=tau, filter=tau) input_p = nengo.Probe(input, 'output') A_p = nengo.Probe(A, 'decoded_output', filter=0.01) T_p = nengo.Probe(T.ensemble, 'decoded_output', filter=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_integrator(Simulator, nl, plt): 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) 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) assert rmse(sim.data[A_p], sim.data[T_p]) < 0.2
def decode(spikes, targets, nTrain, dt=0.001, dtSample=0.001, reg=1e-3, penalty=0, evals=100, name="default", tauRiseMax=3e-2, tauFallMax=3e-1): d, tauRise, tauFall = dfOpt(spikes, targets, nTrain, name=name, evals=evals, reg=reg, penalty=penalty, dt=dt, dtSample=dtSample, tauRiseMax=tauRiseMax, tauFallMax=tauFallMax) print("tauRise: %.3f, tauFall: %.3f" % (tauRise, tauFall)) f = DoubleExp(tauRise, tauFall) A = np.zeros((0, spikes.shape[2])) Y = np.zeros((0, targets.shape[2])) for n in range(nTrain): A = np.append(A, f.filt(spikes[n], dt=dt), axis=0) Y = np.append(Y, targets[n], axis=0) X = np.dot(A, d) error = rmse(X, Y) d = d.reshape((-1, targets.shape[2])) return d, f, tauRise, tauFall, X, Y, error
def objective(hyperparams): tauRise = hyperparams['tauRise'] tauFall = hyperparams['tauFall'] dt = hyperparams['dt'] dtSample = hyperparams['dtSample'] f = DoubleExp(tauRise, tauFall) spikes = np.load('data/%s_spikes.npz' % hyperparams['name'])['spikes'] targets = np.load('data/%s_target.npz' % hyperparams['name'])['target'] A = np.zeros((0, spikes.shape[2])) Y = np.zeros((0, targets.shape[2])) for n in range(hyperparams['nTrain']): A = np.append(A, f.filt(spikes[n], dt=dt), axis=0) Y = np.append(Y, targets[n], axis=0) if dt != dtSample: A = A[::int(dtSample / dt)] Y = Y[::int(dtSample / dt)] d, _ = LstsqL2(reg=hyperparams['reg'])(A, Y) X = np.dot(A, d) loss = rmse(X, Y) loss += penalty * (10 * tauRise + tauFall) return { 'loss': loss, 'd': d, 'tauRise': tauRise, 'tauFall': tauFall, 'status': STATUS_OK }
def test_oscillator(Simulator, nl, plt): model = nengo.Network(label='Oscillator', seed=789) with model: model.config[nengo.Ensemble].neuron_type = nl() inputs = {0: [1, 0], 0.5: [0, 0]} input = nengo.Node(piecewise(inputs), label='Input') tau = 0.1 freq = 5 T = nengo.networks.Oscillator(tau, freq, n_neurons=100) nengo.Connection(input, T.input) A = nengo.Ensemble(100, dimensions=2) nengo.Connection(A, A, synapse=tau, transform=[[1, -freq*tau], [freq*tau, 1]]) nengo.Connection(input, A) in_probe = nengo.Probe(input) A_probe = nengo.Probe(A, synapse=0.01) T_probe = nengo.Probe(T.ensemble, synapse=0.01) sim = Simulator(model) sim.run(3.0) t = sim.trange() plt.plot(t, sim.data[A_probe], label='Manual') plt.plot(t, sim.data[T_probe], label='Template') plt.plot(t, sim.data[in_probe], 'k', label='Input') plt.legend(loc=0) assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.3
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_sine_waves(Simulator, plt, seed): radius = 2 dim = 5 product = nengo.networks.Product( 200, dim, radius, net=nengo.Network(seed=seed)) func_A = lambda t: np.sqrt(radius)*np.sin(np.arange(1, dim+1)*2*np.pi*t) func_B = lambda t: np.sqrt(radius)*np.sin(np.arange(dim, 0, -1)*2*np.pi*t) with product: input_A = nengo.Node(func_A) input_B = nengo.Node(func_B) nengo.Connection(input_A, product.A) nengo.Connection(input_B, product.B) p = nengo.Probe(product.output, synapse=0.005) with Simulator(product) as sim: sim.run(1.0) t = sim.trange() AB = np.asarray(list(map(func_A, t))) * np.asarray(list(map(func_B, t))) delay = 0.013 offset = np.where(t >= delay)[0] for i in range(dim): plt.subplot(dim+1, 1, i+1) plt.plot(t + delay, AB[:, i]) plt.plot(t, sim.data[p][:, i]) plt.xlim(right=t[-1]) plt.yticks((-2, 0, 2)) assert rmse(AB[:len(offset), :], sim.data[p][offset, :]) < 0.2
def test_sine_waves(Simulator, plt, seed): radius = 2 dim = 5 product = nengo.networks.Product(200, dim, radius, seed=seed) func_a = lambda t: np.sqrt(radius) * np.sin( np.arange(1, dim + 1) * 2 * np.pi * t) func_b = lambda t: np.sqrt(radius) * np.sin( np.arange(dim, 0, -1) * 2 * np.pi * t) with product: input_a = nengo.Node(func_a) input_b = nengo.Node(func_b) nengo.Connection(input_a, product.input_a) nengo.Connection(input_b, product.input_b) p = nengo.Probe(product.output, synapse=0.005) with Simulator(product) as sim: sim.run(1.0) t = sim.trange() ideal = (np.asarray([func_a(tt) for tt in t]) * np.asarray([func_b(tt) for tt in t])) delay = 0.013 offset = np.where(t >= delay)[0] for i in range(dim): plt.subplot(dim + 1, 1, i + 1) plt.plot(t + delay, ideal[:, i]) plt.plot(t, sim.data[p][:, i]) plt.xlim(right=t[-1]) plt.yticks((-2, 0, 2)) assert rmse(ideal[:len(offset), :], sim.data[p][offset, :]) < 0.2
def test_direct_mode_with_single_neuron(Simulator, plt, seed): radius = 2 dim = 5 config = nengo.Config(nengo.Ensemble) config[nengo.Ensemble].neuron_type = nengo.Direct() product = nengo.networks.Product( 1, dim, radius, net=nengo.Network(seed=seed), config=config) func_A = lambda t: np.sqrt(radius)*np.sin(np.arange(1, dim+1)*2*np.pi*t) func_B = lambda t: np.sqrt(radius)*np.sin(np.arange(dim, 0, -1)*2*np.pi*t) with product: input_A = nengo.Node(func_A) input_B = nengo.Node(func_B) nengo.Connection(input_A, product.A) nengo.Connection(input_B, product.B) p = nengo.Probe(product.output, synapse=0.005) sim = Simulator(product) sim.run(1.0) t = sim.trange() AB = np.asarray(list(map(func_A, t))) * np.asarray(list(map(func_B, t))) delay = 0.013 offset = np.where(t >= delay)[0] for i in range(dim): plt.subplot(dim+1, 1, i+1) plt.plot(t + delay, AB[:, i]) plt.plot(t, sim.data[p][:, i]) plt.xlim(right=t[-1]) assert rmse(AB[:len(offset), :], sim.data[p][offset, :]) < 0.2
def test_sine_waves(Simulator, plt, seed): radius = 2 dim = 5 product = nengo.networks.Product(200, dim, radius, seed=seed) func_a = lambda t: np.sqrt(radius)*np.sin(np.arange(1, dim+1)*2*np.pi*t) func_b = lambda t: np.sqrt(radius)*np.sin(np.arange(dim, 0, -1)*2*np.pi*t) with product: input_a = nengo.Node(func_a) input_b = nengo.Node(func_b) nengo.Connection(input_a, product.input_a) nengo.Connection(input_b, product.input_b) p = nengo.Probe(product.output, synapse=0.005) with Simulator(product) as sim: sim.run(1.0) t = sim.trange() ideal = (np.asarray([func_a(tt) for tt in t]) * np.asarray([func_b(tt) for tt in t])) delay = 0.013 offset = np.where(t >= delay)[0] for i in range(dim): plt.subplot(dim+1, 1, i+1) plt.plot(t + delay, ideal[:, i]) plt.plot(t, sim.data[p][:, i]) plt.xlim(right=t[-1]) plt.yticks((-2, 0, 2)) assert rmse(ideal[:len(offset), :], sim.data[p][offset, :]) < 0.2
def test_oscillator(Simulator, plt, seed): model = nengo.Network(seed=seed) with model: inputs = {0: [1, 0], 0.5: [0, 0]} input = nengo.Node(Piecewise(inputs), label="Input") tau = 0.1 freq = 5 T = nengo.networks.Oscillator(tau, freq, n_neurons=100) nengo.Connection(input, T.input) A = nengo.Ensemble(100, dimensions=2) nengo.Connection(A, A, synapse=tau, transform=[[1, -freq * tau], [freq * tau, 1]]) nengo.Connection(input, A) in_probe = nengo.Probe(input, sample_every=0.01) A_probe = nengo.Probe(A, synapse=0.01, sample_every=0.01) T_probe = nengo.Probe(T.ensemble, synapse=0.01, sample_every=0.01) with Simulator(model) as sim: sim.run(3.0) t = sim.trange(sample_every=0.01) plt.plot(t, sim.data[A_probe], label="Manual") plt.plot(t, sim.data[T_probe], label="Template") plt.plot(t, sim.data[in_probe], "k", label="Input") plt.legend(loc="best") assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.2
def test_integrator(Simulator, plt, seed): model = nengo.Network(seed=seed) with model: 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, sample_every=0.01) A_p = nengo.Probe(A, synapse=0.01, sample_every=0.01) T_p = nengo.Probe(T.ensemble, synapse=0.01, sample_every=0.01) with Simulator(model) as sim: sim.run(6.0) t = sim.trange(sample_every=0.01) 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='best') assert rmse(sim.data[A_p], sim.data[T_p]) < 0.1
def test_sine_waves(Simulator, nl): radius = 2 dim = 5 product = nengo.networks.Product( 200, dim, radius, neuron_type=nl(), seed=63) func_A = lambda t: np.sqrt(radius)*np.sin(np.arange(1, dim+1)*2*np.pi*t) func_B = lambda t: np.sqrt(radius)*np.sin(np.arange(dim, 0, -1)*2*np.pi*t) with product: input_A = nengo.Node(func_A) input_B = nengo.Node(func_B) nengo.Connection(input_A, product.A) nengo.Connection(input_B, product.B) p = nengo.Probe(product.output, synapse=0.005) sim = Simulator(product) sim.run(1.0) t = sim.trange() AB = np.asarray(list(map(func_A, t))) * np.asarray(list(map(func_B, t))) delay = 0.013 offset = np.where(t >= delay)[0] with Plotter(Simulator, nl) as plt: for i in range(dim): plt.subplot(dim+1, 1, i+1) plt.plot(t + delay, AB[:, i]) plt.plot(t, sim.data[p][:, i]) plt.savefig('test_product.test_sine_waves.pdf') plt.close() assert rmse(AB[:len(offset), :], sim.data[p][offset, :]) < 0.2
def test_oscillator(Simulator, nl): model = nengo.Network(label='Oscillator', seed=789) with model: inputs = {0: [1, 0], 0.5: [0, 0]} input = nengo.Node(piecewise(inputs), label='Input') tau = 0.1 freq = 5 T = nengo.networks.Oscillator( tau, freq, label="Oscillator", neurons=nl(100)) nengo.Connection(input, T.input) A = nengo.Ensemble(nl(100), label='A', dimensions=2) nengo.Connection(A, A, synapse=tau, transform=[[1, -freq*tau], [freq*tau, 1]]) nengo.Connection(input, A) in_probe = nengo.Probe(input, "output") A_probe = nengo.Probe(A, "decoded_output", synapse=0.01) T_probe = nengo.Probe(T.ensemble, "decoded_output", synapse=0.01) sim = Simulator(model) sim.run(3.0) with Plotter(Simulator, nl) as plt: t = sim.trange() plt.plot(t, sim.data[A_probe], label='Manual') plt.plot(t, sim.data[T_probe], label='Template') plt.plot(t, sim.data[in_probe], 'k', label='Input') plt.legend(loc=0) plt.savefig('test_oscillator.test_oscillator.pdf') plt.close() assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.3
def run_trial(): model = nengo.Network(seed=rng.randint(maxint)) with model: model.config[nengo.Ensemble].n_eval_points = n_eval_points stimulus = nengo.Node( output=lambda t: stimulus_fn(max(0., t - wait_duration)), size_out=2) product_net = nengo.networks.Product(n_neurons, 1) nengo.Connection(stimulus[0], product_net.input_a) nengo.Connection(stimulus[1], product_net.input_b) probe_test = nengo.Probe(product_net.output) ens_direct = nengo.Ensemble(1, dimensions=2, neuron_type=nengo.Direct()) result_direct = nengo.Node(size_in=1) nengo.Connection(stimulus, ens_direct) nengo.Connection(ens_direct, result_direct, function=lambda x: x[0] * x[1], synapse=None) probe_direct = nengo.Probe(result_direct) with Simulator(model) as sim: sim.run(duration + wait_duration, progress_bar=False) selection = sim.trange() > wait_duration test = sim.data[probe_test][selection] direct = sim.data[probe_direct][selection] return rmse(test, direct)
def test_direct_mode_with_single_neuron(Simulator, plt, seed): radius = 2 dim = 5 config = nengo.Config(nengo.Ensemble) config[nengo.Ensemble].neuron_type = nengo.Direct() with config: product = nengo.networks.Product( 1, dim, radius, net=nengo.Network(seed=seed)) func_A = lambda t: np.sqrt(radius)*np.sin(np.arange(1, dim+1)*2*np.pi*t) func_B = lambda t: np.sqrt(radius)*np.sin(np.arange(dim, 0, -1)*2*np.pi*t) with product: input_A = nengo.Node(func_A) input_B = nengo.Node(func_B) nengo.Connection(input_A, product.A) nengo.Connection(input_B, product.B) p = nengo.Probe(product.output, synapse=0.005) sim = Simulator(product) sim.run(1.0) t = sim.trange() AB = np.asarray(list(map(func_A, t))) * np.asarray(list(map(func_B, t))) delay = 0.013 offset = np.where(t >= delay)[0] for i in range(dim): plt.subplot(dim+1, 1, i+1) plt.plot(t + delay, AB[:, i]) plt.plot(t, sim.data[p][:, i]) plt.xlim(right=t[-1]) assert rmse(AB[:len(offset), :], sim.data[p][offset, :]) < 0.2
def run_trial(): model = nengo.Network(seed=rng.randint(maxint)) with model: model.config[nengo.Ensemble].n_eval_points = n_eval_points stimulus = nengo.Node( output=lambda t: stimulus_fn(max(0., t - wait_duration)), size_out=2) product_net = nengo.networks.Product(n_neurons, 1) nengo.Connection(stimulus[0], product_net.A) nengo.Connection(stimulus[1], product_net.B) probe_test = nengo.Probe(product_net.output) ens_direct = nengo.Ensemble( 1, dimensions=2, neuron_type=nengo.Direct()) result_direct = nengo.Node(size_in=1) nengo.Connection(stimulus, ens_direct) nengo.Connection( ens_direct, result_direct, function=lambda x: x[0] * x[1], synapse=None) probe_direct = nengo.Probe(result_direct) sim = nengo.Simulator(model) sim.run(duration + wait_duration, progress_bar=False) selection = sim.trange() > wait_duration test = sim.data[probe_test][selection] direct = sim.data[probe_direct][selection] return rmse(test, direct)
def test_sine_waves(Simulator, plt, seed): radius = 2 dim = 5 product = nengo_extras.networks.Product( 200, dim, radius, net=nengo.Network(seed=seed)) func_A = lambda t: np.sqrt(radius)*np.sin(np.arange(1, dim+1)*2*np.pi*t) func_B = lambda t: np.sqrt(radius)*np.sin(np.arange(dim, 0, -1)*2*np.pi*t) with product: input_A = nengo.Node(func_A) input_B = nengo.Node(func_B) nengo.Connection(input_A, product.A) nengo.Connection(input_B, product.B) p = nengo.Probe(product.output, synapse=0.005) with Simulator(product) as sim: sim.run(1.0) t = sim.trange() AB = np.asarray(list(map(func_A, t))) * np.asarray(list(map(func_B, t))) delay = 0.013 offset = np.where(t >= delay)[0] for i in range(dim): plt.subplot(dim+1, 1, i+1) plt.plot(t + delay, AB[:, i]) plt.plot(t, sim.data[p][:, i]) plt.xlim(right=t[-1]) plt.yticks((-2, 0, 2)) assert rmse(AB[:len(offset), :], sim.data[p][offset, :]) < 0.2
def test_oscillator(Simulator, plt, seed): model = nengo.Network(seed=seed) with model: inputs = {0: [1, 0], 0.5: [0, 0]} input = nengo.Node(Piecewise(inputs), label='Input') tau = 0.1 freq = 5 T = nengo.networks.Oscillator(tau, freq, n_neurons=100) nengo.Connection(input, T.input) A = nengo.Ensemble(100, dimensions=2) nengo.Connection(A, A, synapse=tau, transform=[[1, -freq*tau], [freq*tau, 1]]) nengo.Connection(input, A) in_probe = nengo.Probe(input, sample_every=0.01) A_probe = nengo.Probe(A, synapse=0.01, sample_every=0.01) T_probe = nengo.Probe(T.ensemble, synapse=0.01, sample_every=0.01) with Simulator(model) as sim: sim.run(3.0) t = sim.trange(sample_every=0.01) plt.plot(t, sim.data[A_probe], label='Manual') plt.plot(t, sim.data[T_probe], label='Template') plt.plot(t, sim.data[in_probe], 'k', label='Input') plt.legend(loc='best') assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.2
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 run_param_set(self, n_neurons, d, seed, trial): seed = int(seed) n_neurons = int(n_neurons) d = int(d) rng = np.random.RandomState(seed) ctx = nengo.spa.SemanticPointer(d, rng) ctx.make_unitary() model = nengo.Network(seed=get_seed(rng)) with model: in_a = nengo.Node(SignalGenerator(self.duration), size_out=d) in_b = nengo.Node(output=ctx.v) old_cconv = nengo.networks.CircularConvolution(n_neurons, d) old_result = nengo.Ensemble(1, d, neuron_type=nengo.Direct()) nengo.Connection(in_a, old_cconv.A) nengo.Connection(in_b, old_cconv.B) nengo.Connection(old_cconv.output, old_result) cconv = spaopt.CircularConvolution(n_neurons, d) result = nengo.Ensemble(1, d, neuron_type=nengo.Direct()) nengo.Connection(in_a, cconv.A) nengo.Connection(in_b, cconv.B) nengo.Connection(cconv.output, result) with nengo.Network() as net: net.config[nengo.Ensemble].neuron_type = nengo.Direct() d_cconv = nengo.networks.CircularConvolution(1, d) d_result = nengo.Ensemble(1, d) nengo.Connection(in_a, d_cconv.A) nengo.Connection(in_b, d_cconv.B) nengo.Connection(d_cconv.output, d_result) old_probe = nengo.Probe(old_result, synapse=None) probe = nengo.Probe(result, synapse=None) d_probe = nengo.Probe(d_result, synapse=None) sim = nengo.Simulator(model) sim.run(self.duration, progress_bar=False) return { 't': sim.trange(), 'default': rmse(sim.data[old_probe], sim.data[d_probe], axis=1), 'optimized': rmse(sim.data[probe], sim.data[d_probe], axis=1) }
def run_param_set(self, n_neurons, d, seed, trial): spaopt.optimization.SubvectorRadiusOptimizer.Simulator = \ nengo_spinnaker.Simulator rng = np.random.RandomState(seed) ctx = nengo.spa.SemanticPointer(d, rng) ctx.make_unitary() model = nengo.Network(seed=get_seed(rng)) with model: step = SignalGenerator(self.duration).make_step(0, d, .001, rng) in_a = nengo.Node(step, size_out=d) a = nengo.Node(size_in=d) b = nengo.Node(size_in=d) c = nengo.Node(size_in=d) nengo.Connection(in_a, a) nengo.Connection(a, b, synapse=None) nengo.Connection(b, c, synapse=None) old_repr = nengo.networks.EnsembleArray(n_neurons, d) nengo.Connection(in_a, old_repr.input) repr_ = spaopt.UnitEA(n_neurons, d, d) nengo.Connection(in_a, repr_.input) in_probe = nengo.Probe(c, synapse=0.005) old_probe = nengo.Probe(old_repr.output, synapse=0.005) probe = nengo.Probe(repr_.output, synapse=0.005) nengo_spinnaker.add_spinnaker_params(model.config) model.config[in_a].function_of_time = True sim = nengo_spinnaker.Simulator(model) sim.run(self.duration) sim.close() return { 't': sim.trange(), 'default': rmse(sim.data[old_probe], sim.data[in_probe], axis=1), 'optimized': rmse(sim.data[probe], sim.data[in_probe], axis=1) }
def test_product(Simulator, nl, plt, seed): N = 80 dt2 = 0.002 f = lambda t: np.sin(2 * np.pi * t) m = nengo.Network(seed=seed) with m: m.config[nengo.Ensemble].neuron_type = nl() sin = nengo.Node(output=f) cons = nengo.Node(output=-0.5) factors = nengo.Ensemble( 2 * N, dimensions=2, radius=1.5, encoders=Choice([[1, 1], [-1, 1], [1, -1], [-1, -1]]), ) product = nengo.Ensemble(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) factors_p = nengo.Probe(factors, sample_every=dt2, synapse=0.01) product_p = nengo.Probe(product, sample_every=dt2, synapse=0.01) with Simulator(m) as sim: sim.run(1) t = sim.trange(sample_every=dt2) plt.subplot(211) plt.plot(t, sim.data[factors_p]) plt.legend(["factor 1", "factor 2"], loc="best") plt.subplot(212) plt.plot(t, -0.5 * f(t), "k--") plt.plot(t, sim.data[product_p]) plt.legend(["exact product", "neural product"], loc="best") assert npext.rmse(sim.data[factors_p][:, 0], f(t)) < 0.1 assert npext.rmse(sim.data[factors_p][20:, 1], -0.5) < 0.1 assert npext.rmse(sim.data[product_p][:, 0], -0.5 * f(t)) < 0.1
def test_cchannelchain(Simulator, plt, rng, seed, outfile): dims = 2 layers = 5 n_neurons = 100 synapse = nengo.Lowpass(0.01) with nengo.Network(seed=seed) as model: value = nengo.dists.UniformHypersphere().sample(dims, 1, rng=rng)[:, 0] stim = nengo.Node(value) ens = [ nengo.Ensemble(n_neurons, dimensions=dims) for _ in range(layers) ] nengo.Connection(stim, ens[0]) for i in range(layers - 1): nengo.Connection(ens[i], ens[i + 1], synapse=synapse) p_input = nengo.Probe(stim) p_outputs = [ nengo.Probe(ens[i], synapse=synapse) for i in range(layers) ] sim = Simulator(model) sim.run(0.5) if type(plt).__name__ != 'Mock': figsize = (onecolumn, 4.0) if horizontal else (onecolumn * 2, 4.0) setup(figsize=figsize) colors = sns.cubehelix_palette(5) lines = [] for i, p_output in enumerate(p_outputs): l = plt.plot(sim.trange(), sim.data[p_output], c=colors[i % len(colors)]) lines.append(l[0]) plt.legend(lines, ["Ensemble %d" % i for i in range(1, 6)], loc='best') plt.plot(sim.trange(), sim.data[p_input], c='k', lw=1) plt.xlim(right=0.12) plt.yticks((-0.5, 0, 0.5)) plt.xticks((0, 0.05, 0.1)) plt.ylabel('Decoded output') plt.xlabel('Time (s)') sns.despine() plt.saveas = 'results-1.svg' outfile.write('"n_neurons": %d,\n' % sum(e.n_neurons for e in model.all_ensembles)) outfile.write('"simtime": 0.5,\n') outfile.write('"rmse": %f,\n' % (rmse(sim.data[p_outputs[-1]][sim.trange() > 0.4], value))) if hasattr(sim, 'close'): sim.close()
def test_echo_state(Simulator, plt, seed, rng, include_bias): test_t = 1.0 train_t = 5.0 dt = 0.001 n_neurons = 1000 dimensions = 2 process = WhiteSignal(train_t, high=10) with Network(seed=seed) as model: stim = nengo.Node(output=process, size_out=dimensions) esn = EchoState(n_neurons, dimensions, include_bias=include_bias, rng=rng) nengo.Connection(stim, esn.input, synapse=None) p = nengo.Probe(esn.output, synapse=None) p_stim = nengo.Probe(stim, synapse=None) # train the reservoir to compute a highpass filter def function(x): return Highpass(0.01).filt(x, dt=dt) esn.train(function, test_t, dt, process, seed=seed) with Simulator(model, dt=dt, seed=seed + 1) as sim: sim.run(test_t) ideal = function(sim.data[p_stim]) plt.figure() plt.plot(sim.trange(), sim.data[p_stim], label="Input") plt.plot(sim.trange(), sim.data[p], label="Output") plt.plot(sim.trange(), ideal, label="Ideal") plt.legend() if include_bias: assert rmse(sim.data[p], ideal) <= 0.5 * rms(ideal) else: assert rmse(sim.data[p], ideal) <= 0.7 * rms(ideal)
def test_cchannelchain(Simulator, plt, rng, seed, outfile): dims = 2 layers = 5 n_neurons = 100 synapse = nengo.Lowpass(0.01) with nengo.Network(seed=seed) as model: value = nengo.dists.UniformHypersphere().sample( dims, 1, rng=rng)[:, 0] stim = nengo.Node(value) ens = [nengo.Ensemble(n_neurons, dimensions=dims) for _ in range(layers)] nengo.Connection(stim, ens[0]) for i in range(layers - 1): nengo.Connection(ens[i], ens[i+1], synapse=synapse) p_input = nengo.Probe(stim) p_outputs = [nengo.Probe(ens[i], synapse=synapse) for i in range(layers)] sim = Simulator(model) sim.run(0.5) if type(plt).__name__ != 'Mock': figsize = (onecolumn, 4.0) if horizontal else (onecolumn * 2, 4.0) setup(figsize=figsize) colors = sns.cubehelix_palette(5) lines = [] for i, p_output in enumerate(p_outputs): l = plt.plot(sim.trange(), sim.data[p_output], c=colors[i % len(colors)]) lines.append(l[0]) plt.legend(lines, ["Ensemble %d" % i for i in range(1, 6)], loc='best') plt.plot(sim.trange(), sim.data[p_input], c='k', lw=1) plt.xlim(right=0.12) plt.yticks((-0.5, 0, 0.5)) plt.xticks((0, 0.05, 0.1)) plt.ylabel('Decoded output') plt.xlabel('Time (s)') sns.despine() plt.saveas = 'results-1.svg' outfile.write('"n_neurons": %d,\n' % sum( e.n_neurons for e in model.all_ensembles)) outfile.write('"simtime": 0.5,\n') outfile.write('"rmse": %f,\n' % ( rmse(sim.data[p_outputs[-1]][sim.trange() > 0.4], value))) if hasattr(sim, 'close'): sim.close()
def test_product(Simulator, nl): N = 80 dt2 = 0.002 f = lambda t: np.sin(6*t) m = nengo.Network(label='test_product', seed=124) with m: m.config[nengo.Ensemble].neuron_type = nl() sin = nengo.Node(output=f) cons = nengo.Node(output=-.5) factors = nengo.Ensemble( 2 * N, 2, radius=1.5, encoders=Choice([[1, 1], [-1, 1], [1, -1], [-1, -1]])) product = nengo.Ensemble(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) factors_p = nengo.Probe(factors, sample_every=dt2, synapse=0.01) product_p = nengo.Probe(product, sample_every=dt2, synapse=0.01) sim = Simulator(m) sim.run(1) t = sim.trange(dt=dt2) with Plotter(Simulator, nl) as plt: plt.subplot(211) plt.plot(t, sim.data[factors_p]) plt.legend(['factor 1', 'factor 2']) plt.subplot(212) plt.plot(t, -.5 * f(t), 'k--') plt.plot(t, sim.data[product_p]) plt.legend(['exact product', 'neural product'], loc=4) plt.savefig('test_ensemble.test_product.pdf') plt.close() assert npext.rmse(sim.data[factors_p][:, 0], f(t)) < 0.1 assert npext.rmse(sim.data[factors_p][20:, 1], -0.5) < 0.1 assert npext.rmse(sim.data[product_p][:, 0], -0.5 * f(t)) < 0.1
def run_param_set(self, n_neurons, d, seed, trial): seed = int(seed) n_neurons = int(n_neurons) d = int(d) rng = np.random.RandomState(seed) model = nengo.Network(seed=get_seed(rng)) with model: in_a = nengo.Node(SignalGenerator(self.duration), size_out=d) old_repr = nengo.networks.EnsembleArray(n_neurons, d) old_result = nengo.Ensemble(1, d, neuron_type=nengo.Direct()) nengo.Connection(in_a, old_repr.input) nengo.Connection(old_repr.output, old_result) repr_ = spaopt.UnitEA(n_neurons, d, d) result = nengo.Ensemble(1, d, neuron_type=nengo.Direct()) nengo.Connection(in_a, repr_.input) nengo.Connection(repr_.output, result) with nengo.Network() as net: net.config[nengo.Ensemble].neuron_type = nengo.Direct() d_repr = nengo.networks.EnsembleArray(1, d) d_result = nengo.Ensemble(1, d) nengo.Connection(in_a, d_repr.input) nengo.Connection(d_repr.output, d_result) old_probe = nengo.Probe(old_result, synapse=None) probe = nengo.Probe(result, synapse=None) d_probe = nengo.Probe(d_result, synapse=None) sim = nengo.Simulator(model) sim.run(self.duration, progress_bar=False) return { 't': sim.trange(), 'default': rmse(sim.data[old_probe], sim.data[d_probe], axis=1), 'optimized': rmse(sim.data[probe], sim.data[d_probe], axis=1) }
def test_echo_state(Simulator, plt, seed, rng, include_bias): test_t = 1.0 train_t = 5.0 dt = 0.001 n_neurons = 1000 dimensions = 2 process = WhiteSignal(train_t, high=10) with Network(seed=seed) as model: stim = nengo.Node(output=process, size_out=dimensions) esn = EchoState( n_neurons, dimensions, include_bias=include_bias, rng=rng) nengo.Connection(stim, esn.input, synapse=None) p = nengo.Probe(esn.output, synapse=None) p_stim = nengo.Probe(stim, synapse=None) # train the reservoir to compute a highpass filter def function(x): return Highpass(0.01).filt(x, dt=dt) esn.train(function, test_t, dt, process, seed=seed) with Simulator(model, dt=dt, seed=seed+1) as sim: sim.run(test_t) ideal = function(sim.data[p_stim]) plt.figure() plt.plot(sim.trange(), sim.data[p_stim], label="Input") plt.plot(sim.trange(), sim.data[p], label="Output") plt.plot(sim.trange(), ideal, label="Ideal") plt.legend() if include_bias: assert rmse(sim.data[p], ideal) <= 0.5 * rms(ideal) else: assert rmse(sim.data[p], ideal) <= 0.7 * rms(ideal)
def test_input_magnitude(Simulator, dims=16, magnitude=10): """Test to make sure the magnitude scaling works. Builds two different CircularConvolution networks, one with the correct magnitude and one with 1.0 as the input_magnitude. """ rng = np.random.RandomState(4238) neurons_per_product = 128 a = rng.normal(scale=np.sqrt(1./dims), size=dims) * magnitude b = rng.normal(scale=np.sqrt(1./dims), size=dims) * magnitude result = circconv(a, b) model = nengo.Network(label="circular conv", seed=1) model.config[nengo.Ensemble].neuron_type = nengo.LIFRate() with model: inputA = nengo.Node(a) inputB = nengo.Node(b) cconv = nengo.networks.CircularConvolution( neurons_per_product, dimensions=dims, input_magnitude=magnitude) nengo.Connection(inputA, cconv.A, synapse=None) nengo.Connection(inputB, cconv.B, synapse=None) res_p = nengo.Probe(cconv.output) cconv_bad = nengo.networks.CircularConvolution( neurons_per_product, dimensions=dims, input_magnitude=1) # incorrect magnitude nengo.Connection(inputA, cconv_bad.A, synapse=None) nengo.Connection(inputB, cconv_bad.B, synapse=None) res_p_bad = nengo.Probe(cconv_bad.output) sim = Simulator(model) sim.run(0.01) error = rmse(result, sim.data[res_p][-1]) / (magnitude ** 2) error_bad = rmse(result, sim.data[res_p_bad][-1]) / (magnitude ** 2) assert error < 0.1 assert error_bad > 0.1
def _test_lif(Simulator, seed, neuron_type, u, dt, n=500, t=2.0): with Network(seed=seed) as model: stim = nengo.Node(u) x = nengo.Ensemble(n, 1, neuron_type=neuron_type) nengo.Connection(stim, x, synapse=None) p = nengo.Probe(x.neurons) sim = Simulator(model, dt=dt) sim.run(t) expected = nengo.builder.ensemble.get_activities(sim.model, x, [u]) * t actual = (sim.data[p] > 0).sum(axis=0) return rmse(actual, expected, axis=0)
def _test_lif(Simulator, seed, neuron_type, u, dt, n=500, t=2.0): with Network(seed=seed) as model: stim = nengo.Node(u) x = nengo.Ensemble(n, 1, neuron_type=neuron_type) nengo.Connection(stim, x, synapse=None) p = nengo.Probe(x.neurons) with Simulator(model, dt=dt) as sim: sim.run(t) expected = get_activities(sim.model, x, [u]) * t actual = (sim.data[p] > 0).sum(axis=0) return rmse(actual, expected, axis=0)
def test_input_magnitude(Simulator, seed, rng, dims=16, magnitude=10): """Test to make sure the magnitude scaling works. Builds two different CircularConvolution networks, one with the correct magnitude and one with 1.0 as the input_magnitude. """ neurons_per_product = 128 a = rng.normal(scale=np.sqrt(1. / dims), size=dims) * magnitude b = rng.normal(scale=np.sqrt(1. / dims), size=dims) * magnitude result = circconv(a, b) model = nengo.Network(label="circular conv", seed=seed) model.config[nengo.Ensemble].neuron_type = nengo.LIFRate() with model: inputA = nengo.Node(a) inputB = nengo.Node(b) cconv = nengo.networks.CircularConvolution(neurons_per_product, dimensions=dims, input_magnitude=magnitude) nengo.Connection(inputA, cconv.A, synapse=None) nengo.Connection(inputB, cconv.B, synapse=None) res_p = nengo.Probe(cconv.output) cconv_bad = nengo.networks.CircularConvolution( neurons_per_product, dimensions=dims, input_magnitude=1) # incorrect magnitude nengo.Connection(inputA, cconv_bad.A, synapse=None) nengo.Connection(inputB, cconv_bad.B, synapse=None) res_p_bad = nengo.Probe(cconv_bad.output) sim = Simulator(model) sim.run(0.01) error = rmse(result, sim.data[res_p][-1]) / (magnitude**2) error_bad = rmse(result, sim.data[res_p_bad][-1]) / (magnitude**2) assert error < 0.1 assert error_bad > 0.1
def test_modred(rng): dt = 0.001 isys = Lowpass(0.05) noise = 0.5*Lowpass(0.01) + 0.5*Alpha(0.005) p = 0.999 sys = p*isys + (1-p)*noise balsys, S = balreal(sys) delsys = modred(balsys, S.argmax()) assert delsys.order_den == 1 u = rng.normal(size=2000) expected = apply_filter(sys, dt, u) actual = apply_filter(delsys, dt, u) assert rmse(expected, actual) < 1e-4 step = np.zeros(2000) step[50:] = 1.0 dcsys = modred(balsys, S.argmax(), method='dc') expected = apply_filter(sys, dt, step) actual = apply_filter(dcsys, dt, step) assert rmse(expected, actual) < 1e-4
def objective(hyperparams): taus_ens = [hyperparams['tau_rise'], hyperparams['ens']] taus_x = [hyperparams['tau_rise'], hyperparams['x']] h_ens = DoubleExp(taus_ens[0], taus_ens[1]) h_x = DoubleExp(taus_x[0], taus_x[1]) A = h_ens.filt(np.load('data/%s_ens.npz'%hyperparams['name'])['ens'], dt=hyperparams['dt_sample']) x = h_x.filt(np.load('data/%s_x.npz'%hyperparams['name'])['x'], dt=hyperparams['dt_sample']) if dt != dt_sample: A = A[::int(dt_sample/dt)] x = x[::int(dt_sample/dt)] d_ens = Lstsq()(A, x)[0] xhat = np.dot(A, d_ens) loss = rmse(xhat, x) loss += penalty * taus_ens[1] return {'loss': loss, 'taus_ens': taus_ens, 'taus_x': taus_x, 'd_ens': d_ens, 'status': STATUS_OK}
def test_connection(Simulator, seed, d): with Network(seed=seed) as model: stim = nengo.Node(output=lambda t: np.sin(t*2*np.pi), size_out=d) x = nengo.Ensemble(1, d, intercepts=[-1], neuron_type=nengo.LIFRate()) default = nengo.Node(size_in=d) improved = nengo.Node(size_in=d) stim_conn = Connection(stim, x, synapse=None) default_conn = nengo.Connection(x, default) improved_conn = Connection(x, improved) p_default = nengo.Probe(default) p_improved = nengo.Probe(improved) p_stim = nengo.Probe(stim, synapse=0.005) assert not isinstance(stim_conn.solver, BiasedSolver) assert not isinstance(default_conn.solver, BiasedSolver) assert isinstance(improved_conn.solver, BiasedSolver) with Simulator(model) as sim: sim.run(1.0) assert (rmse(sim.data[p_default], sim.data[p_stim]) > rmse(sim.data[p_improved], sim.data[p_stim]))
def test_connection(Simulator, seed, d): with Network(seed=seed) as model: stim = nengo.Node(output=lambda t: np.sin(t*2*np.pi), size_out=d) x = nengo.Ensemble(5, d, neuron_type=nengo.LIFRate()) default = nengo.Node(size_in=d) improved = nengo.Node(size_in=d) stim_conn = Connection(stim, x, synapse=None) default_conn = nengo.Connection(x, default) improved_conn = Connection(x, improved) p_default = nengo.Probe(default) p_improved = nengo.Probe(improved) p_stim = nengo.Probe(stim, synapse=0.005) assert not isinstance(stim_conn.solver, BiasedSolver) assert not isinstance(default_conn.solver, BiasedSolver) assert isinstance(improved_conn.solver, BiasedSolver) with Simulator(model) as sim: sim.run(1.0) assert (rmse(sim.data[p_default], sim.data[p_stim]) > rmse(sim.data[p_improved], sim.data[p_stim]))
def objective(hyperparams): taus_ens = [hyperparams['tau_rise'], hyperparams['tau_fall']] h_ens = DoubleExp(taus_ens[0], taus_ens[1]) A = h_ens.filt(np.load('data/%s_ens.npz'%hyperparams['name'])['ens'], dt=hyperparams['dt']) x = np.load('data/%s_x.npz'%hyperparams['name'])['x'] if dt != dt_sample: A = A[::int(dt_sample/dt)] x = x[::int(dt_sample/dt)] if hyperparams['reg']: d_ens = LstsqL2(reg=hyperparams['reg'])(A, x)[0] else: d_ens = Lstsq()(A, x)[0] xhat = np.dot(A, d_ens) loss = rmse(xhat, x) loss += penalty * (10*taus_ens[0] + taus_ens[1]) return {'loss': loss, 'taus_ens': taus_ens, 'd_ens': d_ens, 'status': STATUS_OK}
def objective(hyperparams): freq = hyperparams['freq'] tTrans = hyperparams['tTrans'] phase = hyperparams['phase'] mag = hyperparams['mag'] base = hyperparams['base'] times = np.load('data/%s_times.npz' % hyperparams['name'])['times'] sin = base + mag * np.sin(times * 2 * np.pi * freq + phase) vals = np.load('data/%s_vals.npz' % hyperparams['name'])['vals'] loss = rmse(sin[tTrans:], vals[tTrans:]) return { 'loss': loss, 'freq': freq, 'phase': phase, 'mag': mag, 'base': base, 'status': STATUS_OK }
def test_dt_dependence(Simulator, nl_nodirect, plt, seed, rng): """Neurons should not wildly change with different dt.""" freq = 10 * (2 * np.pi) input_signal = lambda t: [np.sin(freq * t), np.cos(freq * t)] with nengo.Network(seed=seed) as m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() u = nengo.Node(input_signal, size_out=2) pre = nengo.Ensemble(60, dimensions=2) square = nengo.Ensemble(60, dimensions=2) nengo.Connection(u, pre) nengo.Connection(pre, square, function=lambda x: x**2) activity_p = nengo.Probe(square.neurons, synapse=.05, sample_every=0.001) out_p = nengo.Probe(square, synapse=.05, sample_every=0.001) activity_data = [] out_data = [] dts = (0.0001, 0.001) colors = ('b', 'g', 'r') for c, dt in zip(colors, dts): with Simulator(m, dt=dt, seed=seed + 1) as sim: sim.run(0.1) t = sim.trange(dt=0.001) activity_data.append(sim.data[activity_p]) out_data.append(sim.data[out_p]) plt.subplot(2, 1, 1) plt.plot(t, sim.data[out_p], c=c) plt.subplot(2, 1, 2) # Just plot 5 neurons plt.plot(t, sim.data[activity_p][..., :5], c=c) plt.subplot(2, 1, 1) plt.xlim(right=t[-1]) plt.ylabel("Decoded output") plt.subplot(2, 1, 2) plt.xlim(right=t[-1]) plt.ylabel("Neural activity") assert rmse(activity_data[0], activity_data[1]) < ((1. / dt) * 0.01) assert np.allclose(out_data[0], out_data[1], atol=0.05)
def test_dt_dependence(Simulator, nl_nodirect, plt, seed, rng): """Neurons should not wildly change with different dt.""" freq = 10 * (2 * np.pi) input_signal = lambda t: [np.sin(freq*t), np.cos(freq*t)] with nengo.Network(seed=seed) as m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() u = nengo.Node(input_signal, size_out=2) pre = nengo.Ensemble(60, dimensions=2) square = nengo.Ensemble(60, dimensions=2) nengo.Connection(u, pre) nengo.Connection(pre, square, function=lambda x: x ** 2) activity_p = nengo.Probe(square.neurons, synapse=.05, sample_every=0.001) out_p = nengo.Probe(square, synapse=.05, sample_every=0.001) activity_data = [] out_data = [] dts = (0.0001, 0.001) colors = ('b', 'g', 'r') for c, dt in zip(colors, dts): with Simulator(m, dt=dt, seed=seed+1) as sim: sim.run(0.1) t = sim.trange(dt=0.001) activity_data.append(sim.data[activity_p]) out_data.append(sim.data[out_p]) plt.subplot(2, 1, 1) plt.plot(t, sim.data[out_p], c=c) plt.subplot(2, 1, 2) # Just plot 5 neurons plt.plot(t, sim.data[activity_p][..., :5], c=c) plt.subplot(2, 1, 1) plt.xlim(right=t[-1]) plt.ylabel("Decoded output") plt.subplot(2, 1, 2) plt.xlim(right=t[-1]) plt.ylabel("Neural activity") assert rmse(activity_data[0], activity_data[1]) < ((1. / dt) * 0.01) assert np.allclose(out_data[0], out_data[1], atol=0.05)
def test_neural_accuracy(Simulator, seed, rng, dims, neurons_per_product=128): a = rng.normal(scale=np.sqrt(1./dims), size=dims) b = rng.normal(scale=np.sqrt(1./dims), size=dims) result = circconv(a, b) model = nengo.Network(label="circular conv", seed=seed) model.config[nengo.Ensemble].neuron_type = nengo.LIFRate() with model: inputA = nengo.Node(a) inputB = nengo.Node(b) cconv = nengo.networks.CircularConvolution( neurons_per_product, dimensions=dims) nengo.Connection(inputA, cconv.A, synapse=None) nengo.Connection(inputB, cconv.B, synapse=None) res_p = nengo.Probe(cconv.output) sim = Simulator(model) sim.run(0.01) error = rmse(result, sim.data[res_p][-1]) assert error < 0.1
def test_neural_accuracy(Simulator, seed, rng, dims, neurons_per_product=128): a = rng.normal(scale=np.sqrt(1. / dims), size=dims) b = rng.normal(scale=np.sqrt(1. / dims), size=dims) result = circconv(a, b) model = nengo.Network(label="circular conv", seed=seed) model.config[nengo.Ensemble].neuron_type = nengo.LIFRate() with model: inputA = nengo.Node(a) inputB = nengo.Node(b) cconv = nengo.networks.CircularConvolution(neurons_per_product, dimensions=dims) nengo.Connection(inputA, cconv.A, synapse=None) nengo.Connection(inputB, cconv.B, synapse=None) res_p = nengo.Probe(cconv.output) sim = Simulator(model) sim.run(0.01) error = rmse(result, sim.data[res_p][-1]) assert error < 0.1
def test_direct_mode_with_single_neuron(Simulator, plt, seed): radius = 2 dim = 5 config = nengo.Config(nengo.Ensemble) config[nengo.Ensemble].neuron_type = nengo.Direct() with config: product = nengo.networks.Product(1, dim, radius, net=nengo.Network(seed=seed)) func_a = lambda t: np.sqrt(radius) * np.sin( np.arange(1, dim + 1) * 2 * np.pi * t) func_b = lambda t: np.sqrt(radius) * np.sin( np.arange(dim, 0, -1) * 2 * np.pi * t) with product: input_a = nengo.Node(func_a) input_b = nengo.Node(func_b) nengo.Connection(input_a, product.input_a) nengo.Connection(input_b, product.input_b) p = nengo.Probe(product.output, synapse=0.005) with Simulator(product) as sim: sim.run(1.0) t = sim.trange() ideal = np.asarray(list(map(func_a, t))) * np.asarray(list(map(func_b, t))) delay = 0.013 offset = np.where(t >= delay)[0] for i in range(dim): plt.subplot(dim + 1, 1, i + 1) plt.plot(t + delay, ideal[:, i]) plt.plot(t, sim.data[p][:, i]) plt.xlim(right=t[-1]) plt.yticks((-2, 0, 2)) assert rmse(ideal[:len(offset), :], sim.data[p][offset, :]) < 0.2
def test_basic(Simulator, seed, plt): # solve for a standard nengo connection using a feed-forward reservoir train_t = 5.0 test_t = 0.5 dt = 0.001 n_neurons = 100 synapse = 0.01 process = WhiteSignal(max(train_t, test_t), high=10, rms=0.3) def function(x): return x**2 with Network() as model: ens = nengo.Ensemble(n_neurons, 1, seed=seed) # <- must have seed! res = Reservoir(ens, ens.neurons, synapse) # Solve for the readout that approximates a function of the *filtered* # stimulus. We include a lowpass here because the final RMSE will be # with respect to the lowpass stimulus, which is also consistent # with what the NEF is doing. But in a general recurrent reservoir # this filter could hypothetically be anything. res.train( lambda x: function(Lowpass(synapse).filt(x, dt=dt)), train_t, dt, process, seed=seed+1) assert res.size_in == 1 assert res.size_mid == n_neurons assert res.size_out == 1 # Validation _, (_, _, check_output) = res.run( test_t, dt, process, seed=seed+2) stim = nengo.Node(output=process) output = nengo.Node(size_in=1) nengo.Connection(stim, ens, synapse=None) nengo.Connection(ens, output, function=function, synapse=None) # note the reservoir output already includes a synapse p_res = nengo.Probe(res.output, synapse=None) p_normal = nengo.Probe(output, synapse=synapse) p_stim = nengo.Probe(stim, synapse=synapse) with Simulator(model, dt=dt, seed=seed+2) as sim: sim.run(test_t) # Since the seed for the two test processes were the same, the validation # run should produce the same output as the test simulation. assert np.allclose(check_output, sim.data[p_res]) ideal = function(sim.data[p_stim]) plt.figure() plt.plot(sim.trange(), sim.data[p_res], label="Reservoir") plt.plot(sim.trange(), sim.data[p_normal], label="Standard") plt.plot(sim.trange(), ideal, label="Ideal") plt.legend() assert np.allclose(rmse(sim.data[p_res], ideal), rmse(sim.data[p_normal], ideal), atol=1e-2)