def test_vector(Simulator, nl, plt, seed, allclose):
"""A network that represents sin(t), cos(t), cos(t)**2."""
N = 100
f = lambda t: [np.sin(6.3 * t), np.cos(6.3 * t), np.cos(6.3 * t)**2]
m = nengo.Network(label="test_vector", seed=seed)
with m:
m.config[nengo.Ensemble].neuron_type = nl()
input = nengo.Node(output=f)
A = nengo.Ensemble(N * 3, 3, radius=1.5)
nengo.Connection(input, A)
in_p = nengo.Probe(input)
A_p = nengo.Probe(A, synapse=0.03)
with Simulator(m) as sim:
sim.run(1.0)
t = sim.trange()
target = np.vstack(f(t)).T
assert signals_allclose(t,
target,
sim.data[in_p],
rtol=1e-3,
atol=1e-5,
allclose=allclose)
assert signals_allclose(
t,
target,
sim.data[A_p],
plt=plt,
atol=0.1,
delay=0.03,
buf=0.1,
allclose=allclose,
)
def test_scalar(Simulator, nl, plt, seed, allclose):
"""A network that represents sin(t)."""
N = 50
f = lambda t: np.sin(2 * np.pi * t)
m = nengo.Network(label="test_scalar", seed=seed)
with m:
m.config[nengo.Ensemble].neuron_type = nl()
input = nengo.Node(output=f)
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)
with Simulator(m) as sim:
sim.run(1.0)
t = sim.trange()
target = f(t)
assert signals_allclose(t,
target,
sim.data[in_p],
rtol=1e-3,
atol=1e-5,
allclose=allclose)
assert signals_allclose(t,
target,
sim.data[A_p],
atol=0.1,
delay=0.02,
plt=plt,
allclose=allclose)
def test_direct(Simulator, plt, seed, allclose):
dt = 1e-3
a = 0.7
synapse = LinearFilter([a], [1], analog=False)
t, x, yhat = run_synapse(Simulator, seed, synapse, dt=dt)
y = synapse.filt(x, dt=dt, y0=0)
assert signals_allclose(t, y, yhat, delay=dt, allclose=allclose)
assert signals_allclose(t, a * x, y, plt=plt, allclose=allclose)
def test_function_points(Simulator, seed, rng, plt, allclose):
x = rng.uniform(-1, 1, size=(1000, 1))
y = -x
with nengo.Network(seed=seed) as model:
u = nengo.Node(nengo.processes.WhiteSignal(1.0, high=9, rms=0.3))
a = nengo.Ensemble(100, 1)
v = nengo.Node(size_in=1)
nengo.Connection(u, a, synapse=None)
nengo.Connection(a, v, eval_points=x, function=y)
up = nengo.Probe(u, synapse=nengo.Alpha(0.01))
vp = nengo.Probe(v, synapse=nengo.Alpha(0.01))
with Simulator(model, seed=seed) as sim:
sim.run(1.0)
assert signals_allclose(
sim.trange(),
-sim.data[up],
sim.data[vp],
buf=0.01,
delay=0.005,
atol=5e-2,
rtol=3e-2,
plt=plt,
allclose=allclose,
)
def test_signals_allclose_plot(ny, rng, plt):
if plt.__file__ == "/dev/null":
pytest.skip("Only runs when plotting is enabled")
nt = 100 # signal length
atol = 1e-5
rtol = 1e-3
t = 0.01 * np.arange(nt)
x = rng.uniform(-1, 1, size=(nt, ny))
y = add_close_noise(x, atol, rtol, rng)
labels = ["lab%d" % i for i in range(ny)]
if ny == 1:
x, y, labels = x[:, 0], y[:, 0], labels[0]
fig = plt.figure()
result = signals_allclose(t, x, y, atol=atol, rtol=rtol, plt=plt, labels=labels)
# check the legend
legend = fig.axes[0].get_legend()
for i in range(ny):
ref_text = labels if ny == 1 else labels[i]
assert legend.texts[i].get_text() == ref_text
assert result
def test_configure_weight_solver(Simulator, seed, plt, allclose):
"""Ensures that connections that don't use the weight solver ignore it"""
n1, n2 = 100, 101
function = lambda x: x ** 2
with nengo.Network(seed=seed) as net:
net.config[nengo.Connection].solver = nengo.solvers.LstsqL2(weights=True)
u = nengo.Node(lambda t: np.sin(8 * t))
a = nengo.Ensemble(n1, 1)
b = nengo.Ensemble(n2, 1)
v = nengo.Node(size_in=1)
up = nengo.Probe(u, synapse=nengo.Alpha(0.01))
vp = nengo.Probe(v, synapse=nengo.Alpha(0.01))
nengo.Connection(u, a)
ens_conn = nengo.Connection(a, b, function=function)
nengo.Connection(b, v)
with nengo.Simulator(net) as sim:
sim.run(1.0)
t = sim.trange()
x = sim.data[up]
y = function(x)
z = sim.data[vp]
assert sim.data[ens_conn].weights.shape == (n2, n1)
assert signals_allclose(
t, y, z, buf=0.01, delay=0.015, atol=0.05, rtol=0.05, plt=plt, allclose=allclose
)
def test_weights(Simulator, AnyNeuronType, plt, seed, allclose):
n1, n2 = 100, 50
def func(t):
return [np.sin(4 * t), np.cos(12 * t)]
transform = np.array([[0.6, -0.4]])
m = nengo.Network(label="test_weights", seed=seed)
with m:
m.config[nengo.Ensemble].neuron_type = AnyNeuronType()
u = nengo.Node(output=func)
a = nengo.Ensemble(n1, dimensions=2, radius=1.4)
b = nengo.Ensemble(n2, dimensions=1)
bp = nengo.Probe(b)
nengo.Connection(u, a)
nengo.Connection(
a, b, synapse=0.01, transform=transform, solver=LstsqL2(weights=True)
)
with Simulator(m) as sim:
sim.run(1.0)
t = sim.trange()
x = np.array(func(t)).T
y = np.dot(x, transform.T)
z = nengo.Lowpass(0.01).filt(sim.data[bp], dt=sim.dt)
assert signals_allclose(
t, y, z, atol=0.15, buf=0.1, delay=0.025, plt=plt, allclose=allclose
)
def test_compare_solvers(Simulator, plt, seed, allclose):
pytest.importorskip("sklearn")
N = 70
decoder_solvers = [
Lstsq(),
LstsqNoise(),
LstsqL2(),
LstsqL2nz(),
LstsqL1(max_iter=5000),
]
weight_solvers = [LstsqL1(weights=True, max_iter=5000), LstsqDrop(weights=True)]
tfinal = 4
def input_function(t):
return np.interp(t, [1, 3], [-1, 1], left=-1, right=1)
model = nengo.Network(seed=seed)
with model:
u = nengo.Node(output=input_function)
a = nengo.Ensemble(N, dimensions=1)
nengo.Connection(u, a)
ap = nengo.Probe(a)
probes = []
names = []
for solver in decoder_solvers + weight_solvers:
b = nengo.Ensemble(N, dimensions=1, seed=seed + 1)
nengo.Connection(a, b, solver=solver)
probes.append(nengo.Probe(b))
names.append(
"%s(%s)" % (type(solver).__name__, "w" if solver.weights else "d")
)
with Simulator(model) as sim:
sim.run(tfinal)
t = sim.trange()
# ref = sim.data[up]
ref = nengo.Lowpass(0.02).filtfilt(sim.data[ap], dt=sim.dt)
outputs = np.array([sim.data[probe][:, 0] for probe in probes]).T
outputs_f = nengo.Lowpass(0.02).filtfilt(outputs, dt=sim.dt)
close = signals_allclose(
t,
ref,
outputs_f,
atol=0.07,
rtol=0,
buf=0.1,
delay=0.007,
plt=plt,
labels=names,
individual_results=True,
allclose=allclose,
)
for name, c in zip(names, close):
assert c, "Solver '%s' does not meet tolerances" % name
def test_linearfilter(Simulator, plt, seed, allclose):
dt = 1e-3
synapse = LinearFilter(butter_num, butter_den, analog=False)
t, x, yhat = run_synapse(Simulator, seed, synapse, dt=dt)
y = synapse.filt(x, dt=dt, y0=0)
assert signals_allclose(t, y, yhat, delay=dt, plt=plt, allclose=allclose)
def test_triangle(Simulator, plt, seed, allclose):
dt = 1e-3
tau = 0.03
t, x, ysim = run_synapse(Simulator, seed, Triangle(tau), dt=dt)
yfilt = Triangle(tau).filt(x, dt=dt, y0=0)
# compare with convolved filter
n_taps = int(round(tau / dt)) + 1
num = np.arange(n_taps, 0, -1, dtype=nengo.rc.float_dtype)
num /= num.sum()
y = np.convolve(x.ravel(), num)[:len(t)]
y.shape = (-1, 1)
assert allclose(y, yfilt, rtol=0)
assert signals_allclose(t,
y,
ysim,
delay=dt,
rtol=0,
plt=plt,
allclose=allclose)
# test y0 != 0
assert allclose(Triangle(tau).filt(np.ones(100), dt=dt, y0=1), 1)
def test_decoders(Simulator, plt, seed, allclose):
dt = 1e-3
tau = 0.01
t, x, yhat = run_synapse(Simulator, seed, Lowpass(tau), dt=dt, n_neurons=100)
y = Lowpass(tau).filt(x, dt=dt, y0=0)
assert signals_allclose(t, y, yhat, delay=dt, plt=plt, allclose=allclose)
def test_lowpass(Simulator, plt, seed, allclose):
dt = 1e-3
tau = 0.03
t, x, yhat = run_synapse(Simulator, seed, Lowpass(tau), dt=dt)
y = Lowpass(tau).filt(x, dt=dt, y0=0)
assert signals_allclose(t, y, yhat, delay=dt, plt=plt, allclose=allclose)
def test_alpha(Simulator, plt, seed, allclose):
dt = 1e-3
tau = 0.03
num, den = [1], [tau ** 2, 2 * tau, 1]
t, x, yhat = run_synapse(Simulator, seed, Alpha(tau), dt=dt)
y = LinearFilter(num, den).filt(x, dt=dt, y0=0)
assert signals_allclose(t, y, yhat, delay=dt, atol=5e-6, plt=plt, allclose=allclose)
def test_signals_allclose(multiple_targets, rng):
nt = 100 # signal length
ny = 3 # number of comparison signals
atol = 1e-5
rtol = 1e-3
t = 0.01 * np.arange(nt)
x = rng.uniform(-1, 1, size=(nt, ny if multiple_targets else 1))
get_y = lambda close: add_close_noise(
x, (1 if close else 3) * atol, (1 if close else 3) * rtol, rng
)
y_close = (
get_y(True)
if multiple_targets
else np.column_stack([get_y(True) for _ in range(ny)])
)
y_far = (
get_y(False)
if multiple_targets
else np.column_stack([get_y(False) for _ in range(ny)])
)
result = signals_allclose(
t, x, y_close, atol=atol, rtol=rtol, individual_results=False
)
assert result is True
result = signals_allclose(
t, x, y_far, atol=atol, rtol=rtol, individual_results=False
)
assert result is False
result = signals_allclose(
t, x, y_close, atol=atol, rtol=rtol, individual_results=True
)
assert np.array_equal(result, np.ones(ny, dtype=bool))
result = signals_allclose(
t, x, y_far, atol=atol, rtol=rtol, individual_results=True
)
assert np.array_equal(result, np.zeros(ny, dtype=bool))
def test_linear_analog(Simulator, seed):
dt = 1e-3
# The following num, den are for a 4th order analog Butterworth filter,
# generated with `scipy.signal.butter(4, 200, analog=True)`
num = np.array([1.60000000e09])
den = np.array(
[1.00000000e00, 5.22625186e02, 1.36568542e05, 2.09050074e07, 1.60000000e09]
)
synapse = LinearFilter(num, den, analog=True)
t, x, yhat = run_synapse(Simulator, seed, synapse, dt=dt)
y = synapse.filt(x, dt=dt, y0=0)
assert signals_allclose(t, y, yhat, delay=dt, atol=5e-4)
def test_zero_matrices(Simulator, zero, seed):
dt = 1e-3
A = np.diag(np.ones(2) * dt)
B = np.zeros((2, 1))
B[0] = 1
C = np.ones((1, 2))
D = np.ones((1,))
if zero == "C":
C[...] = 0
elif zero == "D":
D[...] = 0
num, den = ss2tf(A, B, C, D)
num = num.flatten()
synapse = LinearFilter(num, den, analog=False)
t, x, yhat = run_synapse(Simulator, seed, synapse, dt=dt)
y = synapse.filt(x, dt=dt, y0=0)
assert signals_allclose(t, y, yhat, delay=dt, atol=5e-5)
