def test_mapping(Simulator, plt, seed):
sys = Alpha(0.1)
syn = Lowpass(0.01)
gsyn = 2 * syn # scaled lowpass
isyn = 2 / s # scaled integrator
dt = 0.001
ss = ss2sim(sys, syn) # normal lowpass, continuous
dss = ss2sim(sys, syn, dt) # normal lowpass, discrete
gss = ss2sim(sys, gsyn) # scaled lowpass, continuous
gdss = ss2sim(sys, gsyn, dt) # scaled lowpass, discrete
iss = ss2sim(sys, isyn) # scaled integrator, continuous
idss = ss2sim(sys, isyn, dt) # scaled integrator, discrete
assert ss.analog and gss.analog and iss.analog
assert not (dss.analog or gdss.analog or idss.analog)
with Network(seed=seed) as model:
stim = nengo.Node(output=lambda t: np.sin(20 * np.pi * t))
probes = []
for mapped, synapse in ((ss, syn), (dss, syn), (gss, gsyn), (gdss, gsyn), (iss, isyn), (idss, isyn)):
A, B, C, D = mapped.ss
x = nengo.Node(size_in=2)
y = nengo.Node(size_in=1)
nengo.Connection(stim, x, transform=B, synapse=synapse)
nengo.Connection(x, x, transform=A, synapse=synapse)
nengo.Connection(x, y, transform=C, synapse=None)
nengo.Connection(stim, y, transform=D, synapse=None)
probes.append(nengo.Probe(y))
p_stim = nengo.Probe(stim)
pss, pdss, pgss, pgdss, piss, pidss = probes
sim = Simulator(model, dt=dt)
sim.run(1.0)
expected = apply_filter(sys, dt, sim.data[p_stim], axis=0)
plt.plot(sim.trange(), sim.data[pss], label="Continuous", alpha=0.5)
plt.plot(sim.trange(), sim.data[pdss], label="Discrete", alpha=0.5)
plt.plot(sim.trange(), sim.data[pgss], label="Gain Cont.", alpha=0.5)
plt.plot(sim.trange(), sim.data[pgdss], label="Gain Disc.", alpha=0.5)
plt.plot(sim.trange(), sim.data[piss], label="Integ Cont.", alpha=0.5)
plt.plot(sim.trange(), sim.data[pidss], label="Integ Disc.", alpha=0.5)
plt.plot(sim.trange(), expected, label="Expected", linestyle="--")
plt.legend()
assert np.allclose(sim.data[pss], expected, atol=0.01)
assert np.allclose(sim.data[pdss], expected)
assert np.allclose(sim.data[pgss], expected, atol=0.01)
assert np.allclose(sim.data[pgdss], expected)
assert np.allclose(sim.data[piss], expected, atol=0.01)
assert np.allclose(sim.data[pidss], expected)
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 test_balred(rng):
dt = 0.001
sys = Alpha(0.01) + Lowpass(0.001)
u = rng.normal(size=2000)
expected = apply_filter(sys, dt, u)
def check(order, within, tol, method='del'):
redsys = balred(sys, order, method=method)
assert redsys.order_den <= order
actual = apply_filter(redsys, dt, u)
assert abs(rmse(expected, actual) - within) < tol
with warns(UserWarning):
check(4, 0, 1e-13)
with warns(UserWarning):
check(3, 0, 1e-13)
check(2, 0.03, 0.01)
check(1, 0.3, 0.1)
def test_linear_network(neuron_type, atol, Simulator, plt, seed, rng):
n_neurons = 500
dt = 0.001
T = 1.0
sys = nengo.Lowpass(0.1)
scale_input = 2.0
synapse = 0.02
tau_probe = 0.005
with Network(seed=seed) as model:
stim = nengo.Node(
output=nengo.processes.WhiteSignal(T, high=10, seed=seed))
subnet = LinearNetwork(
sys, n_neurons, synapse=synapse, input_synapse=synapse, dt=dt,
neuron_type=neuron_type)
nengo.Connection(
stim, subnet.input, synapse=None, transform=scale_input)
assert subnet.synapse == subnet.input_synapse
assert subnet.output_synapse is None
p_stim = nengo.Probe(subnet.input, synapse=tau_probe)
p_x = nengo.Probe(subnet.x.output, synapse=tau_probe)
p_output = nengo.Probe(subnet.output, synapse=tau_probe)
with Simulator(model, dt=dt) as sim:
sim.run(T)
expected = apply_filter(sys, dt, sim.data[p_stim], axis=0)
plt.plot(sim.trange(), sim.data[p_output], label="Actual", alpha=0.5)
plt.plot(sim.trange(), sim.data[p_x], label="x", alpha=0.5)
plt.plot(sim.trange(), expected, label="Expected", alpha=0.5)
plt.legend()
assert np.allclose(sim.data[p_output], expected, atol=atol)
def check(order, within, tol, method='del'):
redsys = balred(sys, order, method=method)
assert redsys.order_den <= order
actual = apply_filter(redsys, dt, u)
assert abs(rmse(expected, actual) - within) < tol
