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