def test_alif(Simulator, plt):
"""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=AdaptiveLIFRate(**nparams),
dimensions=1,
**eparams)
b = nengo.Ensemble(neuron_type=AdaptiveLIF(**nparams),
dimensions=1,
**eparams)
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
ap = nengo.Probe(a.neurons)
bp = nengo.Probe(b.neurons)
dt = 1e-3
with Simulator(model, dt=dt) as sim:
sim.run(2.)
t = sim.trange()
a_rates = sim.data[ap]
spikes = sim.data[bp]
b_rates = nengo.Lowpass(0.04).filtfilt(spikes)
tmask = (t > 0.1) & (t < 1.7)
rel_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask])
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')
assert rel_rmse < 0.07
def test_probeable():
def check_neuron_type(neuron_type, expected):
assert neuron_type.probeable == expected
ens = nengo.Ensemble(10, 1, neuron_type=neuron_type)
assert ens.neurons.probeable == expected + ("input", )
with nengo.Network():
check_neuron_type(Direct(), ("output", ))
check_neuron_type(RectifiedLinear(), ("output", ))
check_neuron_type(SpikingRectifiedLinear(), ("output", "voltage"))
check_neuron_type(Sigmoid(), ("output", ))
check_neuron_type(Tanh(), ("output", ))
check_neuron_type(LIFRate(), ("output", ))
check_neuron_type(LIF(), ("output", "voltage", "refractory_time"))
check_neuron_type(AdaptiveLIFRate(), ("output", "adaptation"))
check_neuron_type(
AdaptiveLIF(),
("output", "voltage", "refractory_time", "adaptation"))
check_neuron_type(Izhikevich(), ("output", "voltage", "recovery"))
check_neuron_type(RegularSpiking(LIFRate()),
("output", "rate_out", "voltage"))
check_neuron_type(StochasticSpiking(AdaptiveLIFRate()),
("output", "rate_out", "adaptation"))
check_neuron_type(PoissonSpiking(LIFRate()), ("output", "rate_out"))
def test_alif_rate(Simulator, plt, allclose):
n = 100
max_rates = 50 * 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=AdaptiveLIFRate(),
)
nengo.Connection(u, a, synapse=None)
ap = nengo.Probe(a.neurons)
with Simulator(model) as sim:
sim.run(2.0)
t = sim.trange()
rates = sim.data[ap]
_, ref = tuning_curves(a, sim, inputs=0.5)
ax = plt.subplot(211)
implot(plt, t, intercepts[::-1], rates.T, 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)
ax.set_xlabel("input")
ax.set_xlabel("rate")
# check that initial tuning curve is the same as LIF rates
assert allclose(rates[1], 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)
def test_argreprs():
"""Test repr() for each neuron type."""
def check_init_args(cls, args):
assert getfullargspec(cls.__init__).args[1:] == args
def check_repr(obj):
assert eval(repr(obj)) == obj
check_init_args(Direct, [])
check_repr(Direct())
check_init_args(RectifiedLinear, ["amplitude"])
check_repr(RectifiedLinear())
check_repr(RectifiedLinear(amplitude=2))
check_init_args(SpikingRectifiedLinear, ["amplitude"])
check_repr(SpikingRectifiedLinear())
check_repr(SpikingRectifiedLinear(amplitude=2))
check_init_args(Sigmoid, ["tau_ref"])
check_repr(Sigmoid())
check_repr(Sigmoid(tau_ref=0.1))
check_init_args(LIFRate, ["tau_rc", "tau_ref", "amplitude"])
check_repr(LIFRate())
check_repr(LIFRate(tau_rc=0.1))
check_repr(LIFRate(tau_ref=0.1))
check_repr(LIFRate(amplitude=2))
check_repr(LIFRate(tau_rc=0.05, tau_ref=0.02))
check_repr(LIFRate(tau_rc=0.05, amplitude=2))
check_repr(LIFRate(tau_ref=0.02, amplitude=2))
check_repr(LIFRate(tau_rc=0.05, tau_ref=0.02, amplitude=2))
check_init_args(LIF, ["tau_rc", "tau_ref", "min_voltage", "amplitude"])
check_repr(LIF())
check_repr(LIF(tau_rc=0.1))
check_repr(LIF(tau_ref=0.1))
check_repr(LIF(amplitude=2))
check_repr(LIF(min_voltage=-0.5))
check_repr(LIF(tau_rc=0.05, tau_ref=0.02))
check_repr(LIF(tau_rc=0.05, amplitude=2))
check_repr(LIF(tau_ref=0.02, amplitude=2))
check_repr(LIF(tau_rc=0.05, tau_ref=0.02, amplitude=2))
check_repr(LIF(tau_rc=0.05, tau_ref=0.02, min_voltage=-0.5, amplitude=2))
check_init_args(AdaptiveLIFRate,
["tau_n", "inc_n", "tau_rc", "tau_ref", "amplitude"])
check_repr(AdaptiveLIFRate())
check_repr(AdaptiveLIFRate(tau_n=0.1))
check_repr(AdaptiveLIFRate(inc_n=0.5))
check_repr(AdaptiveLIFRate(tau_rc=0.1))
check_repr(AdaptiveLIFRate(tau_ref=0.1))
check_repr(AdaptiveLIFRate(amplitude=2))
check_repr(
AdaptiveLIFRate(tau_n=0.1,
inc_n=0.5,
tau_rc=0.05,
tau_ref=0.02,
amplitude=2))
check_init_args(
AdaptiveLIF,
["tau_n", "inc_n", "tau_rc", "tau_ref", "min_voltage", "amplitude"])
check_repr(AdaptiveLIF())
check_repr(AdaptiveLIF(tau_n=0.1))
check_repr(AdaptiveLIF(inc_n=0.5))
check_repr(AdaptiveLIF(tau_rc=0.1))
check_repr(AdaptiveLIF(tau_ref=0.1))
check_repr(AdaptiveLIF(min_voltage=-0.5))
check_repr(
AdaptiveLIF(
tau_n=0.1,
inc_n=0.5,
tau_rc=0.05,
tau_ref=0.02,
min_voltage=-0.5,
amplitude=2,
))
check_init_args(
Izhikevich,
["tau_recovery", "coupling", "reset_voltage", "reset_recovery"])
check_repr(Izhikevich())
check_repr(Izhikevich(tau_recovery=0.1))
check_repr(Izhikevich(coupling=0.3))
check_repr(Izhikevich(reset_voltage=-1))
check_repr(Izhikevich(reset_recovery=5))
check_repr(
Izhikevich(tau_recovery=0.1,
coupling=0.3,
reset_voltage=-1,
reset_recovery=5))