def test_nengo_dl_neurons(neuron_type, inference_only, Simulator, plt,
allclose):
install_dl_builders()
dt = 0.0007
n = 256
encoders = np.ones((n, 1))
gain = np.zeros(n)
if isinstance(neuron_type, nengo.SpikingRectifiedLinear):
bias = np.linspace(0, 1001, n)
else:
bias = np.linspace(0, 30, n)
with nengo.Network() as model:
nengo_dl.configure_settings(inference_only=inference_only)
a = nengo.Ensemble(n,
1,
neuron_type=neuron_type,
encoders=encoders,
gain=gain,
bias=bias)
ap = nengo.Probe(a.neurons)
t_final = 1.0
with nengo_dl.Simulator(model, dt=dt) as dl_sim:
dl_sim.run(t_final)
with Simulator(model, dt=dt) as loihi_sim:
loihi_sim.run(t_final)
rates_dlsim = (dl_sim.data[ap] > 0).sum(axis=0) / t_final
rates_loihisim = (loihi_sim.data[ap] > 0).sum(axis=0) / t_final
zeros = np.zeros((1, gain.size))
rates_ref = neuron_type.rates(zeros, gain, bias, dt=dt).squeeze(axis=0)
plt.plot(bias, rates_loihisim, 'r', label='loihi sim')
plt.plot(bias, rates_dlsim, 'b-.', label='dl sim')
plt.plot(bias, rates_ref, 'k--', label='rates_ref')
plt.legend(loc='best')
atol = 1. / t_final # the fundamental unit for our rates
assert rates_ref.shape == rates_dlsim.shape == rates_loihisim.shape
assert allclose(rates_dlsim, rates_ref, atol=atol, rtol=0, xtol=1)
assert allclose(rates_loihisim, rates_ref, atol=atol, rtol=0, xtol=1)
def rate_nengo_dl_net(neuron_type,
discretize=True,
dt=0.001,
nx=256,
gain=1.,
bias=0.):
"""Create a network for determining rate curves with Nengo DL.
Arguments
---------
neuron_type : NeuronType
The neuron type used in the network's ensemble.
discretize : bool, optional (Default: True)
Whether the tau_ref and tau_rc values should be discretized
before generating rate curves.
dt : float, optional (Default: 0.001)
Simulator timestep.
nx : int, optional (Default: 256)
Number of x points in the rate curve.
gain : float, optional (Default: 1.)
Gain of all neurons.
bias : float, optional (Default: 0.)
Bias of all neurons.
"""
net = nengo.Network()
net.dt = dt
net.bias = bias
net.gain = gain
lif_kw = dict(amplitude=neuron_type.amplitude)
if isinstance(neuron_type, LoihiLIF):
net.x = np.linspace(-1, 30, nx)
net.sigma = 0.02
lif_kw['tau_rc'] = neuron_type.tau_rc
lif_kw['tau_ref'] = neuron_type.tau_ref
if discretize:
lif_kw['tau_ref'] = discretize_tau_ref(lif_kw['tau_ref'], dt)
lif_kw['tau_rc'] = discretize_tau_rc(lif_kw['tau_rc'], dt)
lif_kw['tau_ref'] += 0.5 * dt
elif isinstance(neuron_type, LoihiSpikingRectifiedLinear):
net.x = np.linspace(-1, 999, nx)
net.tau_ref1 = 0.5 * dt
net.j = neuron_type.current(net.x, gain, bias) - 1
with net:
if isinstance(neuron_type, LoihiLIF) and discretize:
nengo_dl.configure_settings(lif_smoothing=net.sigma)
net.stim = nengo.Node(np.zeros(nx))
net.ens = nengo.Ensemble(nx,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([gain]),
bias=nengo.dists.Choice([bias]))
nengo.Connection(net.stim, net.ens.neurons, synapse=None)
net.probe = nengo.Probe(net.ens.neurons)
rates = dict(ref=loihi_rates(neuron_type, net.x, gain, bias, dt=dt))
# rates['med'] is an approximation of the smoothed Loihi tuning curve
if isinstance(neuron_type, LoihiLIF):
rates['med'] = nengo.LIF(**lif_kw).rates(net.x, gain, bias)
elif isinstance(neuron_type, LoihiSpikingRectifiedLinear):
rates['med'] = np.zeros_like(net.j)
rates['med'][net.j > 0] = (neuron_type.amplitude /
(net.tau_ref1 + 1. / net.j[net.j > 0]))
return net, rates, lif_kw