def test_split_transform(rng):
n = 8
shape0 = nengo_transforms.ChannelShape((1, 1, n))
slice0 = conv.ImageSlice(shape0, channel_slice=slice(1, None, 2))
shape1 = nengo_transforms.ChannelShape((1, 1, n))
slice1 = conv.ImageSlice(shape1, channel_slice=slice(0, None, 3))
shape8 = nengo_transforms.ChannelShape((4, 1, 2))
slice8 = conv.ImageSlice(shape8, row_slice=slice(1, 3))
assert np.prod(shape8.shape) == n
transform = rng.uniform(-1, 1, size=(n, n))
assert np.array_equal(conv.split_transform(transform), transform)
assert np.array_equal(conv.split_transform(transform, in_slice=slice0),
transform[:, slice0.channel_slice])
assert np.array_equal(conv.split_transform(transform, out_slice=slice1),
transform[slice1.channel_slice, :])
assert np.array_equal(
conv.split_transform(transform, in_slice=slice0, out_slice=slice1),
transform[slice1.channel_slice, slice0.channel_slice])
with pytest.raises(AssertionError):
conv.split_transform(transform, in_slice=slice8)
with pytest.raises(AssertionError):
conv.split_transform(transform, out_slice=slice8)
def test_imageslice_api():
imageshape = nengo_transforms.ChannelShape((5, 6, 8))
imageslice = conv.ImageSlice(imageshape,
row_slice=slice(None, None, 2),
col_slice=slice(1, 4),
channel_slice=slice(1, None, 2))
assert not imageslice.channel_slice_only()
assert imageslice.row_idxs() == [0, 2, 4]
assert imageslice.col_idxs() == [1, 2, 3]
assert imageslice.channel_idxs() == [1, 3, 5, 7]
imageslice = conv.ImageSlice(imageshape, channel_slice=slice(2, None, 2))
assert imageslice.channel_slice_only()
assert imageslice.row_idxs() == list(range(5))
assert imageslice.col_idxs() == list(range(6))
assert imageslice.channel_idxs() == [2, 4, 6]
with pytest.raises(ValidationError, match="must be 2-D ChannelShape"):
conv.ImageSlice(nengo_transforms.ChannelShape((5, 6, 7, 8)))
def split_transform(transform, in_slice=None, out_slice=None):
a_slice = slice(None)
b_slice = slice(None)
if isinstance(transform, nengo_transforms.Convolution):
if in_slice is not None:
assert in_slice.channel_slice_only()
a_slice = in_slice.channel_slice
if out_slice is not None:
assert out_slice.channel_slice_only()
b_slice = out_slice.channel_slice
assert isinstance(transform.init, np.ndarray), "doesn't work with distributions"
kernel = transform.init[:, :, a_slice, b_slice]
rows, cols = transform.input_shape.spatial_shape
nc = kernel.shape[2]
input_shape = nengo_transforms.ChannelShape(
(rows, cols, nc) if transform.channels_last else (nc, rows, cols),
channels_last=transform.channels_last,
)
return nengo_transforms.Convolution(
kernel.shape[3],
input_shape,
strides=transform.strides,
channels_last=transform.channels_last,
padding=transform.padding,
kernel_size=transform.kernel_size,
init=kernel,
)
else:
if in_slice is not None:
assert in_slice.channel_slice_only()
a_slice = in_slice.channel_slice
if out_slice is not None:
assert out_slice.channel_slice_only()
b_slice = out_slice.channel_slice
return transform[b_slice, a_slice]
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_conv_input(channels_last, Simulator, plt, allclose):
input_shape = nengo_transforms.ChannelShape((4, 4, 1) if channels_last else
(1, 4, 4),
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_transforms.Convolution(nc,
input_shape,
channels_last=channels_last,
init=kernel,
kernel_size=(1, 1))
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=(3, 3, nc, nf))
transform = nengo_transforms.Convolution(nf,
output_shape,
channels_last=channels_last,
init=-kernel,
kernel_size=(3, 3))
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 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 test_pop_tiny(pop_type, channels_last, nc, request, plt, seed, allclose):
tau_rc = 0.02
tau_ref = 0.001
tau_s = 0.0
dt = 0.001
neuron_bias = 1.
pres_time = 0.4
sti, stj = 1, 1
if nc == 1:
filters = np.array([[-0.5, 2., -0.25], [-0.75, 2., -1.0],
[-0.5, 3., -0.5], [-1.0, 6.,
-0.25]]).reshape(1, 4, 1, 3)
inp_biases = np.array([[1, 5, 1], [2, 1, 2]])
inp_biases = inp_biases[:, :, None]
elif nc == 2:
filters = np.array([[[-0.5, 2., -0.2], [-0.7, 2., -1.0],
[-0.5, 3., -0.5], [-1.0, 6., -0.2]],
[[-1.0, 2., -1.0], [-0.5, 2., -0.5],
[-0.8, 3., -0.2], [-1.0, 4.,
-0.2]]]).reshape(2, 4, 1, 3)
inp_biases = np.array([[[1, 5, 1], [2, 1, 2]], [[0, 3, 1], [4, 2, 1]]])
inp_biases = np.transpose(inp_biases, (1, 2, 0))
# rearrange to (kernel_rows, kernel_cols, in_channels, out_channels)
filters = np.transpose(filters, (2, 3, 0, 1))
inp_biases = inp_biases / (inp_biases.max() + 0.001)
# --- compute nengo_loihi outputs
ni, nj, nk = inp_biases.shape
si, sj, nc, nf = filters.shape
nij = ni * nj
nyi = 1 + (ni - si) // sti
nyj = 1 + (nj - sj) // stj
out_size = nyi * nyj * nf
assert out_size <= 1024
model = Model()
# input block
inp = LoihiBlock(ni * nj * nk, label='inp')
assert inp.n_neurons <= 1024
inp.compartment.configure_relu()
inp.compartment.bias[:] = inp_biases.ravel()
inp_ax = Axon(nij, label='inp_ax')
# we always compute the pixel/channel idxs with channels_last=True
# (not sure why?), and then set it to the correct value afterwards
inp_shape = nengo_transforms.ChannelShape((ni, nj, nk), channels_last=True)
inp_ax.set_compartment_axon_map(target_axons=conv.pixel_idxs(inp_shape),
atoms=conv.channel_idxs(inp_shape))
inp_shape.shape = (ni, nj, nk) if channels_last else (nk, ni, nj)
inp_shape.channels_last = channels_last
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')
conv2d_transform = nengo_transforms.Convolution(
nf,
inp_shape,
strides=(sti, stj),
channels_last=channels_last,
init=filters,
kernel_size=(1, 3))
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)
target = request.config.getoption("--target")
if target == 'loihi':
with HardwareInterface(model, use_snips=False, seed=seed) 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) * (dt / 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 = sim_out.max()
# --- plot results
rows = 1
cols = 2
ax = plt.subplot(rows, cols, 1)
plt.hist(sim_out.ravel(), bins=11)
ax = plt.subplot(rows, cols, 2)
tile(sim_out, vmin=0, vmax=out_max, grid=True, ax=ax)
# ref_out determined by emulator running code known to work
if nc == 1:
ref_out = np.array([[0.06, 0.02], [0.055, 0.], [0.0825, 0.0225],
[0.125, 0.04]])
elif nc == 2:
ref_out = np.array([[0.0975, 0.02], [0.0825, 0.02], [0.125, 0.055],
[0.2475, 0.0825]])
assert allclose(sim_out[:, :, 0], ref_out, rtol=0, atol=1e-7)
def test_conv_connection(channels, channels_last, Simulator, seed, rng, plt,
allclose):
if channels_last:
plt.saveas = None
pytest.xfail("Blocked by CxBase cannot be > 256 bug")
# 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 = 1.999 * test_x - 0.999 # range (-1, 1)
input_shape = nengo_transforms.ChannelShape(
(test_x.shape + (channels, )) if channels_last else
((channels, ) + test_x.shape),
channels_last=channels_last)
filters = Gabor(freq=Uniform(0.5, 1)).generate(8, (7, 7), rng=rng)
filters = filters[None, :, :, :] # single channel
filters = np.transpose(filters, (2, 3, 0, 1))
strides = (2, 2)
tau_rc = 0.02
tau_ref = 0.002
tau_s = 0.005
dt = 0.001
neuron_type = LoihiLIF(tau_rc=tau_rc, tau_ref=tau_ref)
pres_time = 0.1
with nengo.Network(seed=seed) as model:
nengo_loihi.add_params(model)
u = nengo.Node(test_x.ravel(), label="u")
a = nengo.Ensemble(input_shape.size,
1,
neuron_type=LoihiSpikingRectifiedLinear(),
max_rates=nengo.dists.Choice([40 / channels]),
intercepts=nengo.dists.Choice([0]),
label='a')
model.config[a].on_chip = False
if channels == 1:
nengo.Connection(u, a.neurons, transform=1, synapse=None)
elif channels == 2:
# encode image into spikes using two channels (on/off)
if input_shape.channels_last:
nengo.Connection(u, a.neurons[0::2], transform=1, synapse=None)
nengo.Connection(u,
a.neurons[1::2],
transform=-1,
synapse=None)
else:
k = input_shape.spatial_shape[0] * input_shape.spatial_shape[1]
nengo.Connection(u, a.neurons[:k], transform=1, synapse=None)
nengo.Connection(u, a.neurons[k:], transform=-1, synapse=None)
filters = np.concatenate([filters, -filters], axis=2)
else:
raise ValueError("Test not configured for more than two channels")
conv2d_transform = nengo_transforms.Convolution(
8,
input_shape,
strides=strides,
kernel_size=(7, 7),
channels_last=channels_last,
init=filters)
output_shape = conv2d_transform.output_shape
gain, bias = neuron_type.gain_bias(max_rates=100, intercepts=0)
gain = gain * 0.01 # account for `a` max_rates
b = nengo.Ensemble(output_shape.size,
1,
neuron_type=neuron_type,
gain=nengo.dists.Choice([gain[0]]),
bias=nengo.dists.Choice([bias[0]]),
label='b')
nengo.Connection(a.neurons,
b.neurons,
synapse=tau_s,
transform=conv2d_transform)
bp = nengo.Probe(b.neurons)
with nengo.Simulator(model, dt=dt, optimize=False) as sim:
sim.run(pres_time)
ref_out = sim.data[bp].mean(axis=0).reshape(output_shape.shape)
# Currently, non-gpu TensorFlow does not support channels first in conv
use_nengo_dl = HAS_DL and channels_last
ndl_out = np.zeros_like(ref_out)
if use_nengo_dl:
with nengo_dl.Simulator(model, dt=dt) as sim_dl:
sim_dl.run(pres_time)
ndl_out = sim_dl.data[bp].mean(axis=0).reshape(output_shape.shape)
with nengo_loihi.Simulator(model, dt=dt, target='simreal') as sim_real:
sim_real.run(pres_time)
real_out = sim_real.data[bp].mean(axis=0).reshape(output_shape.shape)
with Simulator(model, dt=dt) as sim_loihi:
if "loihi" in sim_loihi.sims:
sim_loihi.sims["loihi"].snip_max_spikes_per_step = 800
sim_loihi.run(pres_time)
sim_out = sim_loihi.data[bp].mean(axis=0).reshape(output_shape.shape)
if not output_shape.channels_last:
ref_out = np.transpose(ref_out, (1, 2, 0))
ndl_out = np.transpose(ndl_out, (1, 2, 0))
real_out = np.transpose(real_out, (1, 2, 0))
sim_out = np.transpose(sim_out, (1, 2, 0))
out_max = max(ref_out.max(), sim_out.max())
# --- plot results
rows = 2
cols = 3
ax = plt.subplot(rows, cols, 1)
imshow(test_x, vmin=0, vmax=1, ax=ax)
ax = plt.subplot(rows, cols, 2)
tile(np.transpose(filters[0], (2, 0, 1)), 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(np.transpose(ref_out, (2, 0, 1)), vmin=0, vmax=out_max, cols=8, ax=ax)
ax = plt.subplot(rows, cols, 5)
tile(np.transpose(ndl_out, (2, 0, 1)), vmin=0, vmax=out_max, cols=8, ax=ax)
ax = plt.subplot(rows, cols, 6)
tile(np.transpose(sim_out, (2, 0, 1)), vmin=0, vmax=out_max, cols=8, ax=ax)
if use_nengo_dl:
assert allclose(ndl_out, ref_out, atol=1e-5, rtol=1e-5)
assert allclose(real_out, ref_out, atol=1, rtol=1e-3)
assert allclose(sim_out, ref_out, atol=10, rtol=1e-3)
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 make_channel_shape(spatial_shape, n_channels, channels_last):
shape = make_shape(spatial_shape, n_channels, channels_last)
return nengo_transforms.ChannelShape(shape, channels_last=channels_last)
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])
