def test_lif_rate(n_elements):
"""Test the `lif_rate` nonlinearity"""
rng = np.random
dt = 1e-3
n_neurons = [123459, 23456, 34567]
J = RA([rng.normal(loc=1, scale=10, size=n) for n in n_neurons])
R = RA([np.zeros(n) for n in n_neurons])
ref = 2e-3
taus = list(rng.uniform(low=15e-3, high=80e-3, size=len(n_neurons)))
queue = cl.CommandQueue(ctx)
clJ = CLRA(queue, J)
clR = CLRA(queue, R)
clTau = CLRA(queue, RA(taus))
# simulate host
nls = [LIFRate(tau_ref=ref, tau_rc=taus[i])
for i, n in enumerate(n_neurons)]
for i, nl in enumerate(nls):
nl.step_math(dt, J[i], R[i])
# simulate device
plan = plan_lif_rate(queue, clJ, clR, ref, clTau, dt=dt,
n_elements=n_elements)
plan()
rate_sum = np.sum([np.sum(r) for r in R])
if rate_sum < 1.0:
logger.warn("LIF rate was not tested above the firing threshold!")
assert ra.allclose(J, clJ.to_host())
assert ra.allclose(R, clR.to_host())
def _plan_AdaptiveLIFRate(self, ops):
dt = self.model.dt
J = self.all_data[[self.sidx[op.J] for op in ops]]
R = self.all_data[[self.sidx[op.output] for op in ops]]
N = self.all_data[[self.sidx[op.states[0]] for op in ops]]
ref = self.RaggedArray(
[op.neurons.tau_ref * np.ones(op.J.size) for op in ops],
dtype=J.dtype)
tau = self.RaggedArray(
[op.neurons.tau_rc * np.ones(op.J.size) for op in ops],
dtype=J.dtype)
amp = self.RaggedArray(
[op.neurons.amplitude * np.ones(op.J.size) for op in ops],
dtype=J.dtype)
tau_n = self.RaggedArray(
[op.neurons.tau_n * np.ones(op.J.size) for op in ops],
dtype=J.dtype)
inc_n = self.RaggedArray(
[op.neurons.inc_n * np.ones(op.J.size) for op in ops],
dtype=J.dtype)
return [
plan_lif_rate(self.queue,
dt,
J,
R,
ref,
tau,
amp,
N=N,
tau_n=tau_n,
inc_n=inc_n)
]
def test_lif_rate(ctx, blockify):
"""Test the `lif_rate` nonlinearity"""
rng = np.random
dt = 1e-3
n_neurons = [123459, 23456, 34567]
J = RA([rng.normal(loc=1, scale=10, size=n) for n in n_neurons])
R = RA([np.zeros(n) for n in n_neurons])
ref = 2e-3
taus = list(rng.uniform(low=15e-3, high=80e-3, size=len(n_neurons)))
queue = cl.CommandQueue(ctx)
clJ = CLRA(queue, J)
clR = CLRA(queue, R)
clTaus = CLRA(queue, RA([t * np.ones(n) for t, n in zip(taus, n_neurons)]))
# simulate host
nls = [nengo.LIFRate(tau_ref=ref, tau_rc=taus[i])
for i, n in enumerate(n_neurons)]
for i, nl in enumerate(nls):
nl.step_math(dt, J[i], R[i])
# simulate device
plan = plan_lif_rate(queue, dt, clJ, clR, ref, clTaus, blockify=blockify)
plan()
rate_sum = np.sum([np.sum(r) for r in R])
if rate_sum < 1.0:
logger.warn("LIF rate was not tested above the firing threshold!")
assert ra.allclose(J, clJ.to_host())
assert ra.allclose(R, clR.to_host())
def plan_SimLIFRate(self, ops):
J = self.all_data[[self.sidx[op.J] for op in ops]]
R = self.all_data[[self.sidx[op.output] for op in ops]]
ref = self.RaggedArray([op.nl.tau_ref for op in ops])
tau = self.RaggedArray([op.nl.tau_rc for op in ops])
dt = self.model.dt
return [plan_lif_rate(self.queue, J, R, ref, tau, dt,
tag="lif_rate", n_elements=10)]
def _plan_LIFRate(self, ops):
J = self.all_data[[self.sidx[op.J] for op in ops]]
R = self.all_data[[self.sidx[op.output] for op in ops]]
ref = self.RaggedArray([op.neurons.tau_ref * np.ones(op.J.size)
for op in ops], dtype=J.dtype)
tau = self.RaggedArray([op.neurons.tau_rc * np.ones(op.J.size)
for op in ops], dtype=J.dtype)
dt = self.model.dt
return [plan_lif_rate(self.queue, J, R, ref, tau, dt)]
def _plan_LIFRate(self, ops):
dt = self.model.dt
J = self.all_data[[self.sidx[op.J] for op in ops]]
R = self.all_data[[self.sidx[op.output] for op in ops]]
ref = self.RaggedArray(
[np.array(op.neurons.tau_ref, dtype=J.dtype) for op in ops])
tau = self.RaggedArray(
[np.array(op.neurons.tau_rc, dtype=J.dtype) for op in ops])
return [plan_lif_rate(self.queue, dt, J, R, ref, tau, n_elements=2)]
def _plan_LIFRate(self, ops):
J = self.all_data[[self.sidx[op.J] for op in ops]]
R = self.all_data[[self.sidx[op.output] for op in ops]]
ref = self.RaggedArray(
[op.neurons.tau_ref * np.ones(op.J.size) for op in ops],
dtype=J.dtype)
tau = self.RaggedArray(
[op.neurons.tau_rc * np.ones(op.J.size) for op in ops],
dtype=J.dtype)
dt = self.model.dt
return [plan_lif_rate(self.queue, J, R, ref, tau, dt)]
def _plan_AdaptiveLIFRate(self, ops):
dt = self.model.dt
J = self.all_data[[self.sidx[op.J] for op in ops]]
R = self.all_data[[self.sidx[op.output] for op in ops]]
N = self.all_data[[self.sidx[op.states[0]] for op in ops]]
ref = self.RaggedArray(
[np.array(op.neurons.tau_ref, dtype=J.dtype) for op in ops])
tau = self.RaggedArray(
[np.array(op.neurons.tau_rc, dtype=J.dtype) for op in ops])
tau_n = self.RaggedArray(
[np.array(op.neurons.tau_n, dtype=J.dtype) for op in ops])
inc_n = self.RaggedArray(
[np.array(op.neurons.inc_n, dtype=J.dtype) for op in ops])
return [plan_lif_rate(self.queue, dt, J, R, ref, tau,
N=N, tau_n=tau_n, inc_n=inc_n, n_elements=2)]
def _plan_AdaptiveLIFRate(self, ops):
dt = self.model.dt
J = self.all_data[[self.sidx[op.J] for op in ops]]
R = self.all_data[[self.sidx[op.output] for op in ops]]
N = self.all_data[[self.sidx[op.states[0]] for op in ops]]
ref = self.RaggedArray([op.neurons.tau_ref * np.ones(op.J.size)
for op in ops], dtype=J.dtype)
tau = self.RaggedArray([op.neurons.tau_rc * np.ones(op.J.size)
for op in ops], dtype=J.dtype)
tau_n = self.RaggedArray([op.neurons.tau_n * np.ones(op.J.size)
for op in ops], dtype=J.dtype)
inc_n = self.RaggedArray([op.neurons.inc_n * np.ones(op.J.size)
for op in ops], dtype=J.dtype)
return [plan_lif_rate(self.queue, dt, J, R, ref, tau,
N=N, tau_n=tau_n, inc_n=inc_n)]
