def test_relu_response_curves(Simulator, plt, allclose):
n = 256
encoders = np.ones((n, 1))
gain = np.zeros(n)
bias = np.linspace(0, 50, n)
with nengo.Network() as model:
a = nengo.Ensemble(n,
1,
neuron_type=nengo.SpikingRectifiedLinear(),
encoders=encoders,
gain=gain,
bias=bias)
ap = nengo.Probe(a.neurons)
dt = 0.001
t_final = 1.0
with Simulator(model, dt=dt) as sim:
sim.run(t_final)
scount = np.sum(sim.data[ap] > 0, axis=0)
actual = nengo.SpikingRectifiedLinear().rates(0., gain, bias)
plt.plot(bias, actual, "b", label="Ideal")
plt.plot(bias, scount, "g", label="Loihi")
plt.xlabel("Bias current")
plt.ylabel("Firing rate (Hz)")
plt.legend(loc="best")
assert allclose(actual, scount, atol=5)
def test_regular_spiking(Simulator, inference_only, seed):
with nengo.Network() as net:
config.configure_settings(inference_only=inference_only)
inp = nengo.Node([1])
ens0 = nengo.Ensemble(
100,
1,
neuron_type=nengo.SpikingRectifiedLinear(amplitude=2),
seed=seed)
ens1 = nengo.Ensemble(
100,
1,
neuron_type=nengo.RegularSpiking(nengo.RectifiedLinear(),
amplitude=2),
seed=seed,
)
nengo.Connection(inp, ens0)
nengo.Connection(inp, ens1)
p0 = nengo.Probe(ens0.neurons)
p1 = nengo.Probe(ens1.neurons)
with pytest.warns(None) as recwarns:
with Simulator(net) as sim:
sim.run_steps(50)
assert np.allclose(sim.data[p0], sim.data[p1])
# check that it is actually using the tensorflow implementation
assert not any("native TensorFlow implementation" in str(w.message)
for w in recwarns)
def test_neuron_to_neuron(Simulator, factor, seed, allclose, plt):
# note: we use these weird factor values so that voltages don't line up
# exactly with the firing threshold. since loihi neurons fire when
# voltage > threshold (rather than >=), if the voltages line up
# exactly then we need an extra spike each time to push `b` over threshold
dt = 5e-4
with nengo.Network(seed=seed) as net:
n = 10
stim = nengo.Node(lambda t: [np.sin(t * 2 * np.pi)])
a = nengo.Ensemble(n, 1)
nengo.Connection(stim, a)
b = nengo.Ensemble(n, 1, neuron_type=nengo.SpikingRectifiedLinear(),
gain=np.ones(n), bias=np.zeros(n))
nengo.Connection(a.neurons, b.neurons, synapse=None,
transform=np.eye(n) * factor)
p_a = nengo.Probe(a.neurons)
p_b = nengo.Probe(b.neurons)
with Simulator(net, dt=dt) as sim:
sim.run(1.0)
y_ref = np.floor(np.sum(sim.data[p_a] > 0, axis=0) * factor)
y_sim = np.sum(sim.data[p_b] > 0, axis=0)
plt.plot(y_ref, c='k')
plt.plot(y_sim)
assert allclose(y_sim, y_ref, atol=1)
def test_conv_onchip(Simulator, plt):
"""Tests a fully on-chip conv connection. """
from nengo._vendor.npconv2d.conv2d import conv2d
kernel = np.array([[-1, 2, -1], [-1, 2, -1], [-1, 2, -1]], dtype=float)
kernel /= kernel.max()
image = np.array([[1, 2, 1, 2, 0], [2, 3, 2, 1, 1], [1, 2, 1, 2, 3],
[2, 3, 2, 1, 1], [1, 2, 1, 2, 0]],
dtype=float)
image /= image.max()
input_scale = 119.
bias = input_scale * image.ravel()
neuron_type = nengo.SpikingRectifiedLinear()
y_ref = LoihiSpikingRectifiedLinear().rates(image.ravel(), input_scale, 0)
y_ref = conv2d(y_ref.reshape(1, 5, 5, 1),
kernel.reshape(3, 3, 1, 1),
pad='VALID')
y_ref = LoihiSpikingRectifiedLinear().rates(y_ref.ravel(), 1.,
0.).reshape(3, 3)
with nengo.Network() as net:
a = nengo.Ensemble(bias.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([0]),
bias=bias)
transform = nengo_transforms.Convolution(n_filters=1,
input_shape=(5, 5, 1),
init=kernel.reshape(
3, 3, 1, 1))
b = nengo.Ensemble(transform.output_shape.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([1]),
bias=nengo.dists.Choice([0]))
nengo.Connection(a.neurons, b.neurons, transform=transform)
bp = nengo.Probe(b.neurons, synapse=nengo.Alpha(0.02))
with Simulator(net) as sim:
sim.run(0.3)
y_ref = y_ref / input_scale
y = sim.data[bp][-1].reshape(3, -1) / input_scale
plt.subplot(121)
plt.imshow(y_ref)
plt.colorbar()
plt.subplot(122)
plt.imshow(y)
plt.colorbar()
assert np.allclose(y, y_ref, atol=0.02, rtol=0.1)
def test_amplitude(Simulator, amplitude, neuron_type, seed, plt, allclose):
with nengo.Network(seed=seed) as net:
a = nengo.Node([0.5])
n = 100
ens = nengo.Ensemble(n,
1,
neuron_type=neuron_type(amplitude=amplitude))
ens2 = nengo.Ensemble(
n,
1,
gain=np.ones(n),
bias=np.zeros(n),
neuron_type=nengo.SpikingRectifiedLinear(),
)
nengo.Connection(a, ens)
# note: slight boost on transform so that the post neurons are pushed
# over threshold, rather than ==threshold
nengo.Connection(ens.neurons,
ens2.neurons,
synapse=None,
transform=np.eye(n) * 1.02)
node = nengo.Node(size_in=n)
nengo.Connection(ens.neurons, node, synapse=None)
ens_p = nengo.Probe(ens, synapse=0.1)
neuron_p = nengo.Probe(ens.neurons)
indirect_p = nengo.Probe(node)
neuron2_p = nengo.Probe(ens2.neurons)
with Simulator(net, precompute=True) as sim:
sim.run(1)
spikemean1 = np.mean(sim.data[neuron_p], axis=0)
spikemean2 = np.mean(sim.data[neuron2_p], axis=0)
plt.subplot(211)
plt.plot(sim.trange(), sim.data[ens_p])
plt.subplot(212)
i = np.argsort(spikemean1)
plt.plot(spikemean1[i])
plt.plot(spikemean2[i], linestyle="--")
assert allclose(sim.data[ens_p][sim.trange() > 0.9], 0.5, atol=0.05)
assert np.max(sim.data[neuron_p]) == amplitude / sim.dt
# the identity neuron-to-neuron connection causes `ens2` to fire at
# `amplitude` * the firing rate of `ens` (i.e., the same overall firing
# rate as `ens`)
assert allclose(spikemean1, spikemean2, atol=1)
# note: one-timestep delay, despite synapse=None
assert allclose(sim.data[neuron_p][:-1], sim.data[indirect_p][1:])
def test_loihi_rates(dt, neuron_type, Simulator, plt, allclose):
n = 256
x = np.linspace(-0.1, 1, n)
encoders = np.ones((n, 1))
max_rates = 400 * np.ones(n)
intercepts = 0 * np.ones(n)
gain, bias = neuron_type.gain_bias(max_rates, intercepts)
j = x * gain + bias
with nengo.Network() as model:
a = nengo.Ensemble(n,
1,
neuron_type=neuron_type,
encoders=encoders,
gain=gain,
bias=j)
ap = nengo.Probe(a.neurons)
with Simulator(model, dt=dt) as sim:
sim.run(1.0)
est_rates = sim.data[ap].mean(axis=0)
ref_rates = loihi_rates(neuron_type, x[np.newaxis, :], gain, bias,
dt=dt).squeeze(axis=0)
ref_rates2 = None
if isinstance(neuron_type, nengo.RegularSpiking):
if isinstance(neuron_type.base_type, nengo.LIFRate):
neuron_type2 = nengo.LIF(
tau_rc=neuron_type.base_type.tau_rc,
tau_ref=neuron_type.base_type.tau_ref,
amplitude=neuron_type.amplitude,
)
elif isinstance(neuron_type.base_type, nengo.RectifiedLinear):
neuron_type2 = nengo.SpikingRectifiedLinear(
amplitude=neuron_type.amplitude, )
ref_rates2 = loihi_rates(neuron_type2,
x[np.newaxis, :],
gain,
bias,
dt=dt).squeeze(axis=0)
plt.plot(x, ref_rates, "k", label="predicted")
if ref_rates2 is not None:
plt.plot(x, ref_rates2, "b", label="predicted-base")
plt.plot(x, est_rates, "g", label="measured")
plt.legend(loc="best")
assert ref_rates.shape == est_rates.shape
assert allclose(est_rates, ref_rates, atol=1, rtol=0, xtol=1)
if ref_rates2 is not None:
assert allclose(ref_rates2, ref_rates)
def test_conv_input(channels_last, Simulator, plt, allclose):
input_shape = ImageShape(4, 4, 1, channels_last=channels_last)
seed = 3 # fix seed to do the same computation for both channel positions
rng = np.random.RandomState(seed + 1)
with nengo.Network(seed=seed) as net:
nengo_loihi.add_params(net)
a = nengo.Node(rng.uniform(0, 1, size=input_shape.size))
nc = 2
kernel = np.array([1., -1.]).reshape((1, 1, 1, nc))
transform = nengo_loihi.Conv2D.from_kernel(kernel, input_shape)
b = nengo.Ensemble(transform.output_shape.size,
1,
neuron_type=nengo.SpikingRectifiedLinear(),
max_rates=nengo.dists.Choice([50]),
intercepts=nengo.dists.Choice([0]))
net.config[b].on_chip = False
nengo.Connection(a, b.neurons, transform=transform)
output_shape = transform.output_shape
nf = 4
kernel = rng.uniform(-0.005, 0.005, size=(nc, 3, 3, nf))
transform = nengo_loihi.Conv2D.from_kernel(kernel, output_shape)
c = nengo.Ensemble(transform.output_shape.size,
1,
neuron_type=nengo.LIF(),
max_rates=nengo.dists.Choice([100]),
intercepts=nengo.dists.Choice([0]))
nengo.Connection(b.neurons, c.neurons, transform=transform)
output_shape = transform.output_shape
p = nengo.Probe(c.neurons)
with nengo.Simulator(net, optimize=False) as sim:
sim.run(1.0)
with Simulator(net, seed=seed) as sim_loihi:
sim_loihi.run(1.0)
p0 = np.sum(sim.data[p] > 0, axis=0).reshape(output_shape.shape())
p1 = np.sum(sim_loihi.data[p] > 0, axis=0).reshape(output_shape.shape())
if not output_shape.channels_last:
p0 = np.transpose(p0, (1, 2, 0))
p1 = np.transpose(p1, (1, 2, 0))
plt.plot(p0.ravel(), 'k')
plt.plot(p1.ravel(), 'b--')
# loihi spikes are not exactly the same, but should be close-ish
assert allclose(p0, p1, rtol=0.15, atol=1)
def run_snn(model,
x_test,
y_test,
params_load_path,
iteration,
timesteps=50,
scale_firing_rates=1000,
synapse=0.01,
batch_size=16):
"""
Run model in spiking setting
:param batch_size: batch size
:param model: model reference
:param x_test: testing features
:param y_test: testing labels
:param params_load_path: path to load parameters
:param iteration: number of current iteration
:param timesteps: number of timesteps
:param scale_firing_rates: firing rate scaling
:param synapse: synaptic smoothing
:return: accuracy, precision, recall, f1 and confusion matrix from the testing data
"""
converter = nengo_dl.Converter(
model,
swap_activations={tf.nn.relu: nengo.SpikingRectifiedLinear()},
scale_firing_rates=scale_firing_rates,
synapse=synapse
) # create a Nengo converter object and swap all relu activations with spiking relu
with converter.net:
nengo_dl.configure_settings(stateful=False)
output_layer = converter.outputs[model.get_layer(
'output_layer')] # output layer for simulator
x_test_tiled = np.tile(x_test,
(1, timesteps, 1)) # tile test data to timesteps
with nengo_dl.Simulator(converter.net) as simulator:
simulator.load_params(params_load_path)
# Get the statistics
accuracy, precision, recall, f1, confusion_matrix = get_metrics(
simulator, output_layer, x_test_tiled, y_test, batch_size,
f'{iteration}. CNN (SNN conversion)')
return {
'accuracy': accuracy,
'precision': precision,
'recall': recall,
'f1': f1,
'confusion_matrix': confusion_matrix
}
def test_drop_trace_spikes(Simulator, seed):
with nengo.Network(seed=seed) as net:
a = nengo.Ensemble(10, 1, gain=nengo.dists.Choice([1]),
bias=nengo.dists.Choice([2000]),
neuron_type=nengo.SpikingRectifiedLinear())
b = nengo.Node(size_in=1)
conn = nengo.Connection(a, b, learning_rule_type=nengo.PES(1))
nengo.Connection(b, conn.learning_rule)
with Simulator(net, target="sim") as sim:
with pytest.raises(SimulationError):
sim.run(1.0)
def test_swap_activations_key_never_used():
"""
Ensure warnings are thrown properly when there is an unused swap activations key.
"""
def relu(x):
return tf.maximum(x, 0)
def relu2(x):
return tf.maximum(x, 0)
inp = tf.keras.Input((1,))
out = tf.keras.layers.Dense(units=10, activation=relu)(inp)
# Test that swap_activations are throwing warnings when not used
with pytest.warns(UserWarning, match="no layers in the model with that activation"):
conv = converter.Converter(
tf.keras.Model(inp, out),
allow_fallback=False,
swap_activations={
relu: nengo.RectifiedLinear(),
relu2: nengo.RectifiedLinear(),
},
)
assert conv.swap_activations.unused_keys() == {relu2}
# Test that there is no warning if all keys are used
inp = tf.keras.Input((1,))
out = tf.keras.layers.Dense(units=10, activation=relu)(inp)
out = tf.keras.layers.Dense(units=10, activation=relu2)(out)
with pytest.warns(None) as recwarns:
conv = converter.Converter(
tf.keras.Model(inp, out),
allow_fallback=False,
swap_activations={
relu: nengo.RectifiedLinear(),
relu2: nengo.RectifiedLinear(),
nengo.RectifiedLinear(): nengo.SpikingRectifiedLinear(),
},
)
assert not any(
"no layers in the model with that activation" in w.message for w in recwarns
)
assert len(conv.swap_activations.unused_keys()) == 0
# check swap_activations dict functions
assert len(conv.swap_activations) == 3
assert set(conv.swap_activations.keys()) == {relu, relu2, nengo.RectifiedLinear()}
def test_scale_firing_rates_cases(Simulator, scale_firing_rates, expected_rates):
input_val = 100
bias_val = 50
n_steps = 100
inp = tf.keras.Input(shape=(1,))
x0 = tf.keras.layers.ReLU()(inp)
x1 = tf.keras.layers.Dense(
units=1,
activation=tf.nn.relu,
kernel_initializer=tf.initializers.constant([[1]]),
bias_initializer=tf.initializers.constant([[bias_val]]),
)(inp)
model = tf.keras.Model(inp, [x0, x1])
# convert indices to layers
scale_firing_rates = (
{model.layers[k]: v for k, v in scale_firing_rates.items()}
if isinstance(scale_firing_rates, dict)
else scale_firing_rates
)
conv = converter.Converter(
model,
swap_activations={tf.nn.relu: nengo.SpikingRectifiedLinear()},
scale_firing_rates=scale_firing_rates,
)
with Simulator(conv.net) as sim:
sim.run_steps(
n_steps, data={conv.inputs[inp]: np.ones((1, n_steps, 1)) * input_val}
)
for i, p in enumerate(conv.net.probes):
# spike heights are scaled down
assert np.allclose(np.max(sim.data[p]), 1 / sim.dt / expected_rates[i])
# number of spikes is scaled up
assert np.allclose(
np.count_nonzero(sim.data[p]),
(input_val if i == 0 else input_val + bias_val)
* expected_rates[i]
* n_steps
* sim.dt,
atol=1,
)
def test_learning_phase(Simulator):
with nengo.Network() as net:
inp = nengo.Node([0])
ens = nengo.Ensemble(1,
1,
gain=[0],
bias=[1],
neuron_type=nengo.SpikingRectifiedLinear())
nengo.Connection(inp, ens, synapse=None)
p = nengo.Probe(ens.neurons)
with tf.keras.backend.learning_phase_scope(1):
with Simulator(net) as sim:
sim.run_steps(10)
assert np.allclose(sim.data[p], 1)
with Simulator(net) as sim:
sim.run_steps(10)
assert np.allclose(sim.data[p], 0)
def get_ensemble(self, dim):
if self.pairs_per_dim != 1:
# To support this, we need to figure out how to deal with the
# `post_inds` that map neurons to axons. Either we can do this
# on the host, in which case we'd have inputs going to the chip
# where we can have multiple spikes per axon per timestep, or we
# need to do it on the chip with one input axon per neuron.
raise NotImplementedError(
"Input neurons with more than one neuron per dimension")
n_neurons = 2 * dim * self.pairs_per_dim
encoders = np.vstack([np.eye(dim), -np.eye(dim)] * self.pairs_per_dim)
ens = nengo.Ensemble(n_neurons,
dim,
neuron_type=nengo.SpikingRectifiedLinear(),
encoders=encoders,
gain=self.gain.repeat(dim),
bias=self.bias.repeat(dim),
add_to_container=False)
return ens
def test_neuron_to_neuron(Simulator, factor, do_pre_slice,
seed, allclose, plt):
# note: we use these weird factor values so that voltages don't line up
# exactly with the firing threshold. since loihi neurons fire when
# voltage > threshold (rather than >=), if the voltages line up
# exactly then we need an extra spike each time to push `b` over threshold
dt = 5e-4
simtime = 0.2
na = 500 # test big to ensure full weight matrices are not being used
if do_pre_slice:
nb = int(np.ceil(na / 2.))
pre_slice = slice(None, None, 2)
else:
nb = na
pre_slice = slice(None)
with nengo.Network(seed=seed) as net:
stim = nengo.Node(lambda t: [np.sin(t * 2 * np.pi / simtime)])
a = nengo.Ensemble(na, 1)
nengo.Connection(stim, a)
b = nengo.Ensemble(nb, 1, neuron_type=nengo.SpikingRectifiedLinear(),
gain=np.ones(nb), bias=np.zeros(nb))
nengo.Connection(a.neurons[pre_slice], b.neurons, synapse=None,
transform=factor)
p_a = nengo.Probe(a.neurons)
p_b = nengo.Probe(b.neurons)
with Simulator(net, dt=dt) as sim:
sim.run(simtime)
y_ref = np.floor(np.sum(sim.data[p_a][:, pre_slice] > 0, axis=0) * factor)
y_sim = np.sum(sim.data[p_b] > 0, axis=0)
plt.plot(y_ref, c='k')
plt.plot(y_sim)
assert allclose(y_sim, y_ref, atol=1)
def build_SNN_simple(image_size, config):
with nengo.Network(seed=config["seed"]) as net:
# remove some unnecessary features to speed up the training
nengo_dl.configure_settings(stateful=False)
n_ensembles = 10000
# input node
inp = nengo.Node(np.zeros(image_size[-1])) #
u = nengo.networks.EnsembleArray(
n_neurons=50,
n_ensembles=n_ensembles,
neuron_type=nengo.SpikingRectifiedLinear(),
)
nengo.Connection(inp, u.input, transform=np.zeros((n_ensembles, 512)))
out = nengo.Node(size_in=101)
nengo.Connection(u.output,
out,
transform=nengo_dl.dists.Glorot(),
synapse=None)
p = nengo.Probe(out)
return net
def test_run_profile(network, train, pytestconfig, monkeypatch, tmpdir):
monkeypatch.chdir(tmpdir)
if network == "integrator":
net = benchmarks.integrator(3, 2, nengo.SpikingRectifiedLinear())
elif network == "cconv":
net = benchmarks.cconv(3, 10, nengo.LIF())
elif network == "test":
with nengo.Network() as net:
ens = nengo.Ensemble(10, 1)
net.p = nengo.Probe(ens)
benchmarks.run_profile(
net,
train=train,
n_steps=10,
do_profile=True,
device=pytestconfig.getoption("--device"),
unroll_simulation=pytestconfig.getoption("--unroll-simulation"),
dtype=pytestconfig.getoption("dtype"),
)
assert net.config[net].inference_only == (not train)
def test_neuron_to_neuron(Simulator, factor, do_pre_slice, sparse, seed,
allclose, plt):
# note: we use these weird factor values so that voltages don't line up
# exactly with the firing threshold. since loihi neurons fire when
# voltage > threshold (rather than >=), if the voltages line up
# exactly then we need an extra spike each time to push `b` over threshold
dt = 5e-4
simtime = 0.2
na = 500 # test big to ensure full weight matrices are not being used
if do_pre_slice:
nb = int(np.ceil(na / 2.0))
pre_slice = slice(None, None, 2)
else:
nb = na
pre_slice = slice(None)
if sparse != "dense":
if nengo_transforms is None:
pytest.skip("Sparse matrices require nengo transforms")
shape = (nb, nb)
data = factor * np.ones(nb)
rowi = coli = np.arange(nb)
if sparse == "nengo":
transform = nengo_transforms.Sparse(shape,
indices=np.array(
(rowi, coli)).T,
init=data)
elif sparse == "scipy":
transform = nengo_transforms.Sparse(shape,
init=scipy.sparse.coo_matrix(
(data, (rowi, coli)),
shape=shape))
else:
transform = factor
with nengo.Network(seed=seed) as net:
stim = nengo.Node(lambda t: [np.sin(t * 2 * np.pi / simtime)])
a = nengo.Ensemble(na, 1)
nengo.Connection(stim, a)
b = nengo.Ensemble(
nb,
1,
neuron_type=nengo.SpikingRectifiedLinear(),
gain=np.ones(nb),
bias=np.zeros(nb),
)
nengo.Connection(a.neurons[pre_slice],
b.neurons,
synapse=None,
transform=transform)
p_a = nengo.Probe(a.neurons)
p_b = nengo.Probe(b.neurons)
with Simulator(net, dt=dt) as sim:
sim.run(simtime)
y_ref = np.floor(np.sum(sim.data[p_a][:, pre_slice] > 0, axis=0) * factor)
y_sim = np.sum(sim.data[p_b] > 0, axis=0)
plt.plot(y_ref, c="k")
plt.plot(y_sim)
assert allclose(y_sim, y_ref, atol=1)
LoihiSpikingRectifiedLinear,
install_dl_builders,
loihi_rates,
nengo_rates,
)
v0_arg = dict(initial_state={"voltage": nengo.dists.Choice([0])})
@pytest.mark.parametrize("dt", [3e-4, 1e-3])
@pytest.mark.parametrize(
"neuron_type",
[
nengo.LIF(**v0_arg),
nengo.LIF(tau_ref=0.001, tau_rc=0.07, amplitude=0.34, **v0_arg),
nengo.SpikingRectifiedLinear(**v0_arg),
nengo.SpikingRectifiedLinear(amplitude=0.23, **v0_arg),
nengo.RegularSpiking(nengo.LIFRate(), **v0_arg),
nengo.RegularSpiking(nengo.LIFRate(tau_ref=0.001, tau_rc=0.03),
amplitude=0.31,
**v0_arg),
nengo.RegularSpiking(nengo.RectifiedLinear(), **v0_arg),
nengo.RegularSpiking(nengo.RectifiedLinear(), amplitude=0.46, **
v0_arg),
],
)
def test_loihi_rates(dt, neuron_type, Simulator, plt, allclose):
n = 256
x = np.linspace(-0.1, 1, n)
encoders = np.ones((n, 1))
model.add(tf.keras.layers.Dense(32))
conv = converter.Converter(model, allow_fallback=False)
assert conv.verify(training=False)
assert conv.verify(training=True)
@pytest.mark.parametrize(
"keras_activation, nengo_activation, swap",
[
(tf.nn.sigmoid, nengo.RectifiedLinear(), {
tf.nn.sigmoid: tf.nn.relu
}),
(
tf.nn.relu,
nengo.SpikingRectifiedLinear(),
{
tf.nn.relu: nengo.SpikingRectifiedLinear()
},
),
(tf.nn.relu, nengo.LIF(), {
nengo.RectifiedLinear(): nengo.LIF()
}),
],
)
def test_activation_swap(Simulator, keras_activation, nengo_activation, swap,
rng):
inp = x = tf.keras.Input(shape=(100, ))
x = tf.keras.layers.Activation(activation=keras_activation)(x)
x = tf.keras.layers.Dense(
units=100,
def test_conv_preslice(Simulator, plt):
from nengo._vendor.npconv2d.conv2d import conv2d
kernel = np.array([[-1, 2, -1], [-1, 2, -1], [-1, 2, -1]], dtype=float)
kernel /= kernel.max()
image = np.array([[1, 2, 1, 2, 0], [2, 3, 2, 1, 1], [1, 2, 1, 2, 3],
[2, 3, 2, 1, 1], [1, 2, 1, 2, 0]],
dtype=float)
image /= image.max()
image2 = np.column_stack([c * x for c in image.T for x in (1, -1)])
input_gain = 149.
neuron_type = nengo.SpikingRectifiedLinear()
y_ref = LoihiSpikingRectifiedLinear().rates(image.ravel(), input_gain, 0)
y_ref = conv2d(y_ref.reshape(1, 5, 5, 1),
kernel.reshape(3, 3, 1, 1),
pad='VALID')
y_ref = LoihiSpikingRectifiedLinear().rates(y_ref.ravel(), 1.,
0.).reshape(3, 3)
with nengo.Network() as net:
u = nengo.Node(image2.ravel())
a = nengo.Ensemble(50,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([input_gain]),
bias=nengo.dists.Choice([0]))
transform = nengo_transforms.Convolution(n_filters=1,
input_shape=(5, 5, 1),
init=kernel.reshape(
3, 3, 1, 1))
b = nengo.Ensemble(transform.output_shape.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([1]),
bias=nengo.dists.Choice([0]))
nengo.Connection(u, a.neurons, synapse=None)
nengo.Connection(a.neurons[::2], b.neurons, transform=transform)
bp = nengo.Probe(b.neurons, synapse=nengo.Alpha(0.02))
hw_opts = dict(snip_max_spikes_per_step=100)
with Simulator(net, hardware_options=hw_opts) as sim:
sim.run(0.3)
y_ref = y_ref / input_gain
y = sim.data[bp][-1].reshape(3, -1) / input_gain
plt.subplot(121)
plt.imshow(y_ref)
plt.colorbar()
plt.subplot(122)
plt.imshow(y)
plt.colorbar()
assert np.allclose(y, y_ref, atol=0.02, rtol=0.1)
def test_conv_overlap_input(Simulator, plt):
"""Tests a fully on-chip conv connection. """
conv2d = pytest.importorskip("nengo._vendor.npconv2d.conv2d")
kernel = np.array([[-1, 2, -1], [-1, 2, -1], [-1, 2, -1]], dtype=float)
kernel /= kernel.max()
image = np.array(
[
[1, 2, 1, 2, 0],
[2, 3, 2, 1, 1],
[1, 2, 1, 2, 3],
[2, 3, 2, 1, 1],
[1, 2, 1, 2, 0],
],
dtype=float,
)
image /= image.max()
input_scale = 119.0
bias = input_scale * image.ravel()
neuron_type = nengo.SpikingRectifiedLinear()
y_ref = LoihiSpikingRectifiedLinear().rates(image.ravel(), input_scale, 0)
y_ref = conv2d.conv2d(y_ref.reshape((1, 5, 5, 1)),
kernel.reshape((3, 3, 1, 1)),
pad="VALID")
y_ref = LoihiSpikingRectifiedLinear().rates(y_ref.ravel(), 1.0,
0.0).reshape((3, 3))
with nengo.Network() as net:
a = nengo.Ensemble(
bias.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([0]),
bias=bias,
)
transform = nengo_transforms.Convolution(n_filters=1,
input_shape=(4, 5, 1),
init=kernel.reshape(
(3, 3, 1, 1)))
b0 = nengo.Ensemble(
transform.output_shape.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([1]),
bias=nengo.dists.Choice([0]),
)
b1 = nengo.Ensemble(
transform.output_shape.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([1]),
bias=nengo.dists.Choice([0]),
)
nengo.Connection(a.neurons[:20], b0.neurons, transform=transform)
nengo.Connection(a.neurons[5:], b1.neurons, transform=transform)
b0p = nengo.Probe(b0.neurons, synapse=nengo.Alpha(0.02))
b1p = nengo.Probe(b1.neurons, synapse=nengo.Alpha(0.02))
with Simulator(net) as sim:
sim.run(0.3)
y_ref = y_ref / input_scale
y0 = sim.data[b0p][-1].reshape((2, -1)) / input_scale
y1 = sim.data[b1p][-1].reshape((2, -1)) / input_scale
plt.subplot(131)
plt.imshow(y_ref)
plt.colorbar()
plt.subplot(132)
plt.imshow(b0)
plt.colorbar()
plt.subplot(133)
plt.imshow(b1)
plt.colorbar()
assert np.allclose(y0, y_ref[:2], atol=0.02, rtol=0.1)
assert np.allclose(y1, y_ref[1:], atol=0.02, rtol=0.1)
def test_conv2d_weights(channels_last, hw_opts, request, plt, seed, rng,
allclose):
def loihi_rates_n(neuron_type, x, gain, bias, dt):
"""Compute Loihi rates on higher dimensional inputs"""
y = x.reshape(-1, x.shape[-1])
gain = np.asarray(gain)
bias = np.asarray(bias)
if gain.ndim == 0:
gain = gain * np.ones(x.shape[-1])
if bias.ndim == 0:
bias = bias * np.ones(x.shape[-1])
rates = loihi_rates(neuron_type, y, gain, bias, dt)
return rates.reshape(*x.shape)
if channels_last:
plt.saveas = None
pytest.xfail("Blocked by CxBase cannot be > 256 bug")
target = request.config.getoption("--target")
if target != 'loihi' and len(hw_opts) > 0:
pytest.skip("Hardware options only available on hardware")
pop_type = 32
# load data
with open(os.path.join(test_dir, 'mnist10.pkl'), 'rb') as f:
test10 = pickle.load(f)
test_x = test10[0][0].reshape(28, 28)
test_x = test_x[3:24, 3:24]
test_x = 1.999 * test_x - 0.999
filters = Gabor(freq=Uniform(0.5, 1)).generate(8, (7, 7), rng=rng)
sti, stj = 2, 2
tau_rc = 0.02
tau_ref = 0.002
tau_s = 0.005
dt = 0.001
encode_type = nengo.SpikingRectifiedLinear()
encode_gain = 1. / dt
encode_bias = 0.
neuron_type = nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref)
neuron_gain = 1.
neuron_bias = 1.
pres_time = 0.2
# --- compute ideal outputs
def conv_pm(x, kernel):
y0 = scipy.signal.correlate2d(x[0], kernel, mode='valid')[::sti, ::stj]
y1 = scipy.signal.correlate2d(x[1], kernel, mode='valid')[::sti, ::stj]
return [y0, -y1]
ref_out = np.array([test_x, -test_x])
ref_out = loihi_rates_n(encode_type, ref_out, encode_gain, encode_bias, dt)
ref_out = ref_out / encode_gain
ref_out = np.array([conv_pm(ref_out, kernel) for kernel in filters])
ref_out = ref_out.sum(axis=1) # sum positive and negative parts
ref_out = loihi_rates_n(neuron_type, ref_out, neuron_gain, neuron_bias, dt)
# --- compute nengo_loihi outputs
inp_biases = np.stack([test_x, -test_x], axis=-1 if channels_last else 0)
inp_shape = nengo_transforms.ChannelShape(inp_biases.shape,
channels_last=channels_last)
kernel = np.array([filters, -filters]) # two channels, pos and neg
kernel = np.transpose(kernel, (2, 3, 0, 1))
conv2d_transform = nengo_transforms.Convolution(
8,
inp_shape,
strides=(sti, stj),
channels_last=channels_last,
kernel_size=(7, 7),
init=kernel)
out_size = ref_out.size
nf, nyi, nyj = ref_out.shape
assert out_size <= 1024
model = Model()
# input block
inp = LoihiBlock(inp_shape.size, label='inp')
assert inp.n_neurons <= 1024
inp.compartment.configure_relu()
inp.compartment.bias[:] = inp_biases.ravel()
inp_ax = Axon(np.prod(inp_shape.spatial_shape), label='inp_ax')
inp_ax.set_compartment_axon_map(target_axons=conv.pixel_idxs(inp_shape),
atoms=conv.channel_idxs(inp_shape))
inp.add_axon(inp_ax)
model.add_block(inp)
# conv block
neurons = LoihiBlock(out_size, label='neurons')
assert neurons.n_neurons <= 1024
neurons.compartment.configure_lif(tau_rc=tau_rc, tau_ref=tau_ref, dt=dt)
neurons.compartment.configure_filter(tau_s, dt=dt)
neurons.compartment.bias[:] = neuron_bias
synapse = Synapse(np.prod(inp_shape.spatial_shape), label='synapse')
weights, indices, axon_to_weight_map, bases = conv.conv2d_loihi_weights(
conv2d_transform)
synapse.set_population_weights(weights,
indices,
axon_to_weight_map,
bases,
pop_type=pop_type)
neurons.add_synapse(synapse)
out_probe = Probe(target=neurons, key='spiked')
neurons.add_probe(out_probe)
inp_ax.target = synapse
model.add_block(neurons)
# simulation
discretize_model(model)
n_steps = int(pres_time / dt)
if target == 'loihi':
with HardwareInterface(model, use_snips=False, seed=seed,
**hw_opts) as sim:
sim.run_steps(n_steps)
sim_out = sim.get_probe_output(out_probe)
else:
with EmulatorInterface(model, seed=seed) as sim:
sim.run_steps(n_steps)
sim_out = sim.get_probe_output(out_probe)
sim_out = np.sum(sim_out, axis=0) / pres_time
if channels_last:
sim_out.shape = (nyi, nyj, nf)
sim_out = np.transpose(sim_out, (2, 0, 1))
else:
sim_out.shape = (nf, nyi, nyj)
out_max = max(ref_out.max(), sim_out.max())
# --- plot results
rows = 2
cols = 2
ax = plt.subplot(rows, cols, 1)
tile(filters, cols=8, ax=ax)
ax = plt.subplot(rows, cols, 2)
tile(ref_out, vmin=0, vmax=out_max, cols=8, ax=ax)
ax = plt.subplot(rows, cols, 3)
plt.hist(ref_out.ravel(), bins=31)
plt.hist(sim_out.ravel(), bins=31)
ax = plt.subplot(rows, cols, 4)
# tile(sim_out, vmin=0, vmax=1, cols=8, ax=ax)
tile(sim_out, vmin=0, vmax=out_max, cols=8, ax=ax)
assert allclose(sim_out, ref_out, atol=10, rtol=1e-3)
def test_conv_split(Simulator, rng, plt, allclose):
channels_last = False
# load data
with open(os.path.join(test_dir, 'mnist10.pkl'), 'rb') as f:
test10 = pickle.load(f)
input_shape = nengo_transforms.ChannelShape((1, 28, 28),
channels_last=channels_last)
n_filters = 8
kernel_size = (7, 7)
kernel = Gabor(freq=Uniform(0.5, 1)).generate(n_filters,
kernel_size,
rng=rng)
kernel = kernel[None, :, :, :] # single channel
kernel = np.transpose(kernel, (2, 3, 0, 1))
strides = (2, 2)
seed = 3 # fix seed to do the same computation for both channel positions
with nengo.Network(seed=seed) as net:
nengo_loihi.add_params(net)
a = nengo.Node(test10[0][0].ravel())
# --- make population to turn image into spikes
nc = 1
in_kernel = np.array([1.]).reshape((1, 1, 1, nc))
transform = nengo_transforms.Convolution(1,
input_shape,
kernel_size=(1, 1),
init=in_kernel,
channels_last=channels_last)
b = nengo.Ensemble(transform.output_shape.size,
1,
neuron_type=nengo.SpikingRectifiedLinear(),
max_rates=nengo.dists.Choice([50]),
intercepts=nengo.dists.Choice([0]))
net.config[b].on_chip = False
nengo.Connection(a, b.neurons, transform=transform)
in_shape = transform.output_shape
transform = nengo_transforms.Convolution(n_filters,
in_shape,
kernel_size=kernel_size,
strides=strides,
init=kernel,
channels_last=channels_last)
out_shape = transform.output_shape
split_slices = conv.split_channels(out_shape,
max_size=1024,
max_channels=4)
# --- make convolution population, split across ensembles
cc = []
cp = []
out_shapes = []
xslice = conv.ImageSlice(in_shape)
for yslice in split_slices:
transform_xy = conv.split_transform(transform, xslice, yslice)
out_shapes.append(transform_xy.output_shape)
c = nengo.Ensemble(transform_xy.output_shape.size,
1,
neuron_type=nengo.LIF(),
max_rates=nengo.dists.Choice([15]),
intercepts=nengo.dists.Choice([0]))
nengo.Connection(b.neurons, c.neurons, transform=transform_xy)
cc.append(c)
cp.append(nengo.Probe(c.neurons))
simtime = 0.3
with nengo.Simulator(net, optimize=False) as sim_nengo:
sim_nengo.run(simtime)
hw_opts = dict(snip_max_spikes_per_step=100)
with Simulator(net, seed=seed, hardware_options=hw_opts) as sim_loihi:
sim_loihi.run(simtime)
nengo_out = []
loihi_out = []
for p, out_shape_i in zip(cp, out_shapes):
nengo_out.append(
(sim_nengo.data[p] > 0).sum(axis=0).reshape(out_shape_i.shape))
loihi_out.append(
(sim_loihi.data[p] > 0).sum(axis=0).reshape(out_shape_i.shape))
if channels_last:
nengo_out = np.concatenate(nengo_out, axis=2)
loihi_out = np.concatenate(loihi_out, axis=2)
# put channels first to display them separately
nengo_out = np.transpose(nengo_out, (2, 0, 1))
loihi_out = np.transpose(loihi_out, (2, 0, 1))
else:
nengo_out = np.concatenate(nengo_out, axis=0)
loihi_out = np.concatenate(loihi_out, axis=0)
out_max = np.maximum(nengo_out.max(), loihi_out.max())
# --- plot results
rows = 2
cols = 3
ax = plt.subplot(rows, cols, 1)
imshow(test10[0][0].reshape((28, 28)), vmin=0, vmax=1, ax=ax)
ax = plt.subplot(rows, cols, 2)
tile(np.transpose(kernel[0], (2, 0, 1)), cols=8, ax=ax)
ax = plt.subplot(rows, cols, 3)
plt.hist(nengo_out.ravel(), bins=31)
plt.hist(loihi_out.ravel(), bins=31)
ax = plt.subplot(rows, cols, 4)
tile(nengo_out, vmin=0, vmax=out_max, cols=8, ax=ax)
ax = plt.subplot(rows, cols, 6)
tile(loihi_out, vmin=0, vmax=out_max, cols=8, ax=ax)
assert allclose(loihi_out, nengo_out, atol=0.05 * out_max, rtol=0.15)
def test_chip_population_axons(on_chip, precompute, pop_type, channels_last,
Simulator, rng):
"""Check that all types of population axons work as inputs or between cores.
Also, on the chip, dummy axons were still having an effect. Check this is fixed.
"""
def conv_layer(input=None, label=None, **kwargs):
conv = nengo.Convolution(**kwargs)
layer = nengo.Ensemble(conv.output_shape.size, 1, label=label)
conn = (nengo.Connection(input, layer.neurons, transform=conv)
if input is not None else None)
return layer, conv, conn
if pop_type == 16 and not channels_last:
pytest.skip(
"pop16 axons not compatible with single-compartment shifts")
max_rate = 100
amp = 1 / max_rate
n_filters0 = 4
n_filters1 = 4
# 6 x 6 input will have one unused pixel at edge with 3 x 3 kernel and stride 2
input_shape = (6, 6, 1) if channels_last else (1, 6, 6)
input_shape = nengo_transforms.ChannelShape(input_shape,
channels_last=channels_last)
X = rng.uniform(0.2, 1, size=input_shape.shape)
kernel0 = rng.uniform(0.2, 1, size=(1, 1, 1, n_filters0))
kernel1 = rng.uniform(0.1, 0.5, size=(3, 3, n_filters0, n_filters1))
with nengo.Network(seed=0) as net:
nengo_loihi.add_params(net)
net.config[nengo.Ensemble].neuron_type = nengo.SpikingRectifiedLinear(
amplitude=amp)
net.config[nengo.Ensemble].max_rates = nengo.dists.Choice([max_rate])
net.config[nengo.Ensemble].intercepts = nengo.dists.Choice([0])
net.config[nengo.Connection].synapse = 0.005
inp = nengo.Node(X.ravel()) if not on_chip else None
# first layer is off-chip to translate the inputs into spikes
layer0, conv0, _ = conv_layer(
input=inp,
n_filters=n_filters0,
input_shape=input_shape,
channels_last=channels_last,
kernel_size=(1, 1),
init=kernel0,
label="layer0",
)
net.config[layer0].on_chip = on_chip
if on_chip:
assert kernel0.shape[:2] == (1, 1)
w = kernel0[0, 0]
Y = X.dot(w) if channels_last else np.tensordot(w.T, X, axes=1)
layer0.gain = nengo.dists.Choice([0.0])
layer0.bias = Y.ravel() * max_rate
layer1, conv1, conn1 = conv_layer(
input=layer0.neurons,
n_filters=n_filters1,
input_shape=conv0.output_shape,
channels_last=channels_last,
kernel_size=(3, 3),
strides=(2, 2),
init=kernel1,
label="layer1",
)
net.config[conn1].pop_type = pop_type
probe = nengo.Probe(layer1.neurons)
sim_time = 0.1
with Simulator(net, target="sim") as emulator:
emulator.run(sim_time)
with Simulator(net, target="loihi", precompute=precompute) as loihi:
loihi.run(sim_time)
assert np.all(emulator.data[probe].sum(axis=0) > 0)
assert np.array_equal(loihi.data[probe], emulator.data[probe])
return layer, conv
dt = 0.001 # simulation timestep
presentation_time = 0.1 # input presentation time
max_rate = 100 # neuron firing rates
# neuron spike amplitude (scaled so that the overall output is ~1)
amp = 1 / max_rate
# input image shape
input_shape = inp_shape
with nengo.Network(seed=0) as net:
# set up the default parameters for ensembles/connections
nengo_loihi.add_params(net)
net.config[nengo.Ensemble].neuron_type = (nengo.SpikingRectifiedLinear(
amplitude=amp))
net.config[nengo.Ensemble].max_rates = nengo.dists.Choice([max_rate])
net.config[nengo.Ensemble].intercepts = nengo.dists.Choice([0])
net.config[nengo.Connection].synapse = None
# the input node that will be used to feed in input images
inp = nengo.Node(nengo.processes.PresentInput(test_data[0],
presentation_time),
size_out=out_size)
# the output node provides the 10-dimensional classification
out = nengo.Node(size_in=10)
for _ in range(n_parallel):
# build parallel copies of the network
layer, conv = conv_layer(inp,
1,
def close(self):
"""Dummy close function"""
def accept(self):
"""Dummy accept function"""
def sendto(self, *args):
"""Dummy sendto function"""
def recv_into(self, *args):
"""Dummy recv_into function"""
return DummyCom
@pytest.fixture(params=[nengo.RectifiedLinear(), nengo.SpikingRectifiedLinear()])
def params(request): # pragma: no cover
"""Create a dummy network and extract params for fullstack tests
Fixture itself is parametrized for neuron type
"""
# Tell Nengo to use 32b, like the FPGA
nengo.rc.set("precision", "bits", "32")
# Arbitrary params (keep `my_func` in mind if changing dims)
neuron = request.param
n_neurons = 200
dims_out = 2
dims_in = 2 * dims_out
seed = 10
def test_conv_preslice(on_chip, Simulator, plt):
conv2d = pytest.importorskip("nengo._vendor.npconv2d.conv2d")
kernel = np.array([[-1, 2, -1], [-1, 2, -1], [-1, 2, -1]], dtype=float)
kernel /= kernel.max()
image = np.array(
[
[1, 2, 1, 2, 0],
[2, 3, 2, 1, 1],
[1, 2, 1, 2, 3],
[2, 3, 2, 1, 1],
[1, 2, 1, 2, 0],
],
dtype=float,
)
image /= image.max()
image2 = np.column_stack([c * x for c in image.T for x in (1, -1)])
input_gain = 149.0
neuron_type = nengo.SpikingRectifiedLinear()
loihi_neuron = LoihiSpikingRectifiedLinear()
layer0_neuron = loihi_neuron if on_chip else neuron_type
y_ref = layer0_neuron.rates(image.ravel(), input_gain, 0)
y_ref = conv2d.conv2d(y_ref.reshape((1, 5, 5, 1)),
kernel.reshape((3, 3, 1, 1)),
pad="VALID")
y_ref = loihi_neuron.rates(y_ref.ravel(), 1.0, 0.0).reshape((3, 3))
with nengo.Network() as net:
nengo_loihi.add_params(net)
u = nengo.Node(image2.ravel())
a = nengo.Ensemble(
50,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([input_gain]),
bias=nengo.dists.Choice([0]),
)
net.config[a].on_chip = on_chip
transform = nengo_transforms.Convolution(n_filters=1,
input_shape=(5, 5, 1),
init=kernel.reshape(
(3, 3, 1, 1)))
b = nengo.Ensemble(
transform.output_shape.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([1]),
bias=nengo.dists.Choice([0]),
)
nengo.Connection(u, a.neurons, synapse=None)
nengo.Connection(a.neurons[::2], b.neurons, transform=transform)
bp = nengo.Probe(b.neurons, synapse=nengo.Alpha(0.02))
with Simulator(net) as sim:
assert sim.precompute is True
sim.run(0.3)
y_ref = y_ref / input_gain
y = sim.data[bp][-1].reshape((3, -1)) / input_gain
plt.subplot(121)
plt.imshow(y_ref)
plt.colorbar()
plt.subplot(122)
plt.imshow(y)
plt.colorbar()
assert np.allclose(y, y_ref, atol=0.02, rtol=0.1)
def go(NPre=100, N=30, t=10, m=Uniform(30, 30), i=Uniform(-0.8, 0.8), seed=0, dt=0.001, f=DoubleExp(1e-3, 1e-1), fS=DoubleExp(1e-3, 1e-1), neuron_type=LIF(), d1=None, d2=None, f1=None, f2=None, e1=None, e2=None, l1=False, l2=False, test=False, freq=1, phase=0, tDrive=0.2):
A = [[1, 1e-1*2*np.pi*freq], [-1e-1*2*np.pi*freq, 1]] # tau*A + I
if isinstance(neuron_type, Bio) and not f1: f1=DoubleExp(1e-3, 1e-1)
if isinstance(neuron_type, Bio) and not f2: f2=DoubleExp(1e-3, 1e-1)
stim = lambda t: [np.sin(2*np.pi*freq*t+phase), np.cos(2*np.pi*freq*t+phase)]
with nengo.Network(seed=seed) as model:
inpt = nengo.Node(stim)
tar = nengo.Ensemble(1, 2, neuron_type=nengo.Direct())
pre = nengo.Ensemble(NPre, 2, max_rates=m, neuron_type=nengo.SpikingRectifiedLinear(), radius=2, seed=seed)
ens = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, radius=2, seed=seed)
nengo.Connection(inpt, tar, synapse=None, transform=A, seed=seed)
nengo.Connection(inpt, pre, synapse=None, seed=seed)
c1 = nengo.Connection(pre, ens, synapse=f1, seed=seed, solver=NoSolver(d1))
pInpt = nengo.Probe(inpt, synapse=None)
pTar = nengo.Probe(tar, synapse=None)
pPre = nengo.Probe(pre.neurons, synapse=None)
pEns = nengo.Probe(ens.neurons, synapse=None)
# Encoder Learning (Bio)
if l1:
tarEns = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed)
nengo.Connection(inpt, tarEns, synapse=None, seed=seed)
learnEncoders(c1, tarEns, fS)
pTarEns = nengo.Probe(tarEns.neurons, synapse=None)
if l2:
pre2 = nengo.Ensemble(NPre, 2, max_rates=m, neuron_type=nengo.LIF(), seed=seed, radius=2)
tarEns2 = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=nengo.LIF(), seed=seed)
ens2 = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=2)
# ens3 = nengo.Ensemble(N, 2, max_rates=m, intercepts=i, neuron_type=neuron_type, seed=seed, radius=2)
# nengo.Connection(tar, pre2, synapse=f)
# c3 = nengo.Connection(ens, ens2, synapse=f2, seed=seed)
# c4 = nengo.Connection(pre2, ens3, synapse=f1, seed=seed)
# learnEncoders(c3, ens3, fS)
# pTarEns2 = nengo.Probe(ens3.neurons, synapse=None)
# pEns2 = nengo.Probe(ens2.neurons, synapse=None)
nengo.Connection(inpt, pre2, synapse=f)
nengo.Connection(pre2, tarEns2, synapse=f, seed=seed)
c3 = nengo.Connection(ens, ens2, synapse=f2, seed=seed)
learnEncoders(c3, tarEns2, fS, alpha=3e-7)
pTarEns2 = nengo.Probe(tarEns2.neurons, synapse=None)
pEns2 = nengo.Probe(ens2.neurons, synapse=None)
if test:
c2 = nengo.Connection(ens, ens, synapse=f2, seed=seed, solver=NoSolver(d2))
off = nengo.Node(lambda t: 1 if t>tDrive else 0)
nengo.Connection(off, pre.neurons, synapse=None, transform=-1e4*np.ones((NPre, 1)))
with nengo.Simulator(model, seed=seed, dt=dt, progress_bar=False) as sim:
if isinstance(neuron_type, Bio):
setWeights(c1, d1, e1)
if l2: setWeights(c3, d2, e2)
# if l2: setWeights(c4, d1, e1)
if test: setWeights(c2, d2, e2)
neuron.h.init()
sim.run(t, progress_bar=True)
reset_neuron(sim, model)
else:
sim.run(t, progress_bar=True)
e1 = c1.e if l1 else e1
e2 = c3.e if l2 else e2
return dict(
times=sim.trange(),
inpt=sim.data[pInpt],
tar=sim.data[pTar],
pre=sim.data[pPre],
ens=sim.data[pEns],
tarEns=sim.data[pTarEns] if l1 else None,
tarEns2=sim.data[pTarEns2] if l2 else None,
ens2=sim.data[pEns2] if l2 else None,
e1=e1,
e2=e2,
)
from nengo_loihi.neurons import (
AlphaRCNoise,
discretize_tau_rc,
discretize_tau_ref,
loihi_rates,
LoihiLIF,
LoihiSpikingRectifiedLinear,
LowpassRCNoise,
)
@pytest.mark.parametrize('dt', [3e-4, 1e-3])
@pytest.mark.parametrize('neuron_type', [
nengo.LIF(),
nengo.LIF(tau_ref=0.001, tau_rc=0.07, amplitude=0.34),
nengo.SpikingRectifiedLinear(),
nengo.SpikingRectifiedLinear(amplitude=0.23),
])
def test_loihi_rates(dt, neuron_type, Simulator, plt, allclose):
n = 256
x = np.linspace(-0.1, 1, n)
encoders = np.ones((n, 1))
max_rates = 400 * np.ones(n)
intercepts = 0 * np.ones(n)
gain, bias = neuron_type.gain_bias(max_rates, intercepts)
j = x * gain + bias
with nengo.Network() as model:
a = nengo.Ensemble(n,
1,
return mean_rates
def is_spiking_type(neuron_type):
return isinstance(neuron_type, (nengo.LIF, nengo.SpikingRectifiedLinear))
# test the trained networks on test set
mean_rates = run_network(activation=nengo.RectifiedLinear(),
n_steps=10,
plot_idx=plot_no)
plt.savefig(outdir + f'/{plot_no}.jpg')
plot_no += 1
# test the trained networks using spiking neurons
run_network(activation=nengo.SpikingRectifiedLinear(),
scale_firing_rates=100,
synapse=0.005,
plot_idx=plot_no)
plt.savefig(outdir + f'/{plot_no}.jpg')
plot_no += 1
# test the trained networks using spiking neurons
run_network(activation=nengo_loihi.neurons.LoihiSpikingRectifiedLinear(),
scale_firing_rates=100,
synapse=0.005,
plot_idx=plot_no)
plt.savefig(outdir + f'/{plot_no}.jpg')
plot_no += 1
