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)
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)
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_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_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))
model = nengo.Network()
with model:
model.config[nengo.Ensemble].max_rates = max_rates
model.config[nengo.Ensemble].intercepts = intercepts
model.config[nengo.Ensemble].encoders = encoders
u = nengo.Node(output=whitenoise(1, 5, seed=8393))
a = nengo.Ensemble(n, 1, neuron_type=nengo.LIFRate())
b = nengo.Ensemble(n, 1, neuron_type=nengo.LIF())
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
up = nengo.Probe(u)
ap = nengo.Probe(a.neurons)
bp = nengo.Probe(b.neurons)
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 _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 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_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)
with Simulator(model) as sim:
sim.run(2.0)
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_rates(Simulator, rates, plt, seed):
n = 100
intercepts = np.linspace(-0.99, 0.99, n)
model = nengo.Network(seed=seed)
with model:
model.config[nengo.Ensemble].max_rates = nengo.dists.Choice([50])
model.config[nengo.Ensemble].encoders = nengo.dists.Choice([[1]])
u = nengo.Node(output=nengo.processes.WhiteSignal(2, high=5))
a = nengo.Ensemble(n,
1,
intercepts=intercepts,
neuron_type=nengo.LIFRate())
b = nengo.Ensemble(n,
1,
intercepts=intercepts,
neuron_type=nengo.LIF())
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
up = nengo.Probe(u)
ap = nengo.Probe(a.neurons)
bp = nengo.Probe(b.neurons)
with Simulator(model, seed=seed + 1) as sim:
sim.run(2.)
t = sim.trange()
x = sim.data[up]
a_rates = sim.data[ap]
spikes = sim.data[bp]
b_rates = rates(t, spikes)
if plt is not None:
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')
tmask = (t > 0.1) & (t < 1.9)
relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask])
return relative_rmse
def _test_rates(Simulator, rates, plt, seed, name=None):
if name is None:
name = rates.__name__
n = 100
intercepts = np.linspace(-0.99, 0.99, n)
model = nengo.Network(seed=seed)
with model:
model.config[nengo.Ensemble].max_rates = Choice([50])
model.config[nengo.Ensemble].encoders = Choice([[1]])
u = nengo.Node(output=WhiteNoise(2., 5).f(
rng=np.random.RandomState(seed=seed)))
a = nengo.Ensemble(n, 1,
intercepts=intercepts, neuron_type=nengo.LIFRate())
b = nengo.Ensemble(n, 1,
intercepts=intercepts, neuron_type=nengo.LIF())
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
up = nengo.Probe(u)
ap = nengo.Probe(a.neurons)
bp = nengo.Probe(b.neurons)
sim = Simulator(model)
sim.run(2.)
t = sim.trange()
x = sim.data[up]
a_rates = sim.data[ap]
spikes = sim.data[bp]
b_rates = rates(t, spikes)
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.saveas = 'utils.test_neurons.test_rates.%s.pdf' % name
tmask = (t > 0.1) & (t < 1.9)
relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask])
return relative_rmse
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)
with Simulator(model) 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_rates(Simulator, rates, plt, seed):
n = 100
intercepts = np.linspace(-0.99, 0.99, n)
model = nengo.Network(seed=seed)
with model:
model.config[nengo.Ensemble].max_rates = Choice([50])
model.config[nengo.Ensemble].encoders = Choice([[1]])
u = nengo.Node(output=WhiteSignal(2, high=5))
a = nengo.Ensemble(n, 1,
intercepts=intercepts, neuron_type=nengo.LIFRate())
b = nengo.Ensemble(n, 1,
intercepts=intercepts, neuron_type=nengo.LIF())
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
up = nengo.Probe(u)
ap = nengo.Probe(a.neurons)
bp = nengo.Probe(b.neurons)
with Simulator(model, seed=seed+1) as sim:
sim.run(2.)
t = sim.trange()
x = sim.data[up]
a_rates = sim.data[ap]
spikes = sim.data[bp]
b_rates = rates(t, spikes)
if plt is not None:
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')
tmask = (t > 0.1) & (t < 1.9)
relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask])
return relative_rmse
