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)
