def test_scale_firing_rates():
inp = tf.keras.Input(shape=(1, ))
x = tf.keras.layers.ReLU()(inp)
model = tf.keras.Model(inp, x)
# scaling doesn't affect output at all for non-spiking neurons
conv = converter.Converter(model, scale_firing_rates=5)
assert conv.verify()
# works with existing amplitude values
neuron_type = nengo.RectifiedLinear(amplitude=2)
conv = converter.Converter(
model,
scale_firing_rates=5,
swap_activations={nengo.RectifiedLinear(): neuron_type},
)
assert neuron_type.amplitude == 2
assert conv.net.ensembles[0].neuron_type.amplitude == 2 / 5
# warning when applying scaling to non-amplitude neuron type
inp = tf.keras.Input(shape=(1, ))
x = tf.keras.layers.Activation(tf.nn.sigmoid)(inp)
model = tf.keras.Model(inp, x)
with pytest.warns(UserWarning, match="does not support amplitude"):
conv = converter.Converter(model, scale_firing_rates=5)
with pytest.raises(ValueError, match="does not match output"):
conv.verify()
def test_train_objective(Simulator, unroll, seed):
minibatch_size = 1
n_hidden = 20
n_steps = 10
with nengo.Network(seed=seed) as net:
inp = nengo.Node([1])
ens = nengo.Ensemble(n_hidden, 1, neuron_type=nengo.RectifiedLinear())
nengo.Connection(inp, ens, synapse=0.01)
p = nengo.Probe(ens)
with Simulator(net,
minibatch_size=minibatch_size,
unroll_simulation=unroll,
seed=seed) as sim:
x = np.ones((minibatch_size, n_steps, 1))
y = np.zeros((minibatch_size, n_steps, 1))
def obj(output, target):
return tf.reduce_mean((output[:, -1] - 0.5 - target[:, -1])**2)
sim.train({inp: x}, {p: y},
tf.train.MomentumOptimizer(1e-2, 0.9),
n_epochs=100,
objective=obj)
sim.check_gradients([p])
sim.run_steps(n_steps, input_feeds={inp: x})
assert np.allclose(sim.data[p][:, -1], y[:, -1] + 0.5, atol=1e-3)
def test_train_sparse(Simulator, seed):
minibatch_size = 4
n_hidden = 20
with nengo.Network(seed=seed) as net:
net.config[nengo.Ensemble].gain = nengo.dists.Choice([1])
net.config[nengo.Ensemble].bias = nengo.dists.Choice([0])
net.config[nengo.Ensemble].neuron_type = nengo.RectifiedLinear()
net.config[nengo.Connection].synapse = None
inp = nengo.Node([0, 0, 0, 0, 0])
ens = nengo.Ensemble(n_hidden, 1)
out = nengo.Node(size_in=2)
nengo.Connection(inp[[0, 2, 3]], ens.neurons, transform=dists.Glorot())
nengo.Connection(ens.neurons, out, transform=dists.Glorot())
p = nengo.Probe(out)
with Simulator(net,
minibatch_size=minibatch_size,
unroll_simulation=1,
seed=seed) as sim:
x = np.asarray([[[0, 0, 0, 0, 0]], [[0, 0, 1, 0, 0]], [[1, 0, 0, 0,
0]],
[[1, 0, 1, 0, 0]]])
y = np.asarray([[[0, 1]], [[1, 0]], [[1, 0]], [[0, 1]]])
sim.train({inp: x}, {p: y},
tf.train.MomentumOptimizer(0.1, 0.9, use_nesterov=True),
n_epochs=500)
sim.step(input_feeds={inp: x})
assert np.allclose(sim.data[p], y, atol=1e-3)
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_config_basic():
config = dict(n_neurons=400, radius=3, normalize_encoders=False)
stim = stimuli(0).configure(**config)
extra = dict(radius=4, neuron_type=nengo.RectifiedLinear())
x = stim.decode(**extra)
assert x._impl_kwargs == {**config, **extra}
with nengo.Network() as model:
x.make()
ensembles = model.all_ensembles
assert len(ensembles) == 1
assert ensembles[0].n_neurons == 400
assert ensembles[0].radius == 4 # extra takes precedence
assert ensembles[0].normalize_encoders == False
assert ensembles[0].neuron_type == nengo.RectifiedLinear()
def performance_samples(device): # pragma: no cover
"""
Run a brief sample of the benchmarks to check overall performance.
This is mainly used to quickly check that there haven't been any unexpected
performance regressions.
"""
# TODO: automatically run some basic performance tests during CI
default_kwargs = {
"n_steps": 1000,
"device": device,
"unroll_simulation": 25,
"progress_bar": False,
"do_profile": False
}
print("cconv + relu")
net = cconv(128, 64, nengo.RectifiedLinear())
run_profile(net, minibatch_size=64, **default_kwargs)
print("cconv + lif")
net = cconv(128, 64, nengo.LIF())
run_profile(net, minibatch_size=64, **default_kwargs)
print("integrator training + relu")
net = integrator(128, 32, nengo.RectifiedLinear())
run_profile(net, minibatch_size=64, train=True, **default_kwargs)
print("integrator training + lif")
net = integrator(128, 32, nengo.LIF())
run_profile(net, minibatch_size=64, train=True, **default_kwargs)
print("random")
net = random_network(128,
64,
nengo.RectifiedLinear(),
n_ensembles=50,
connections_per_ensemble=5,
seed=0)
run_profile(net, **default_kwargs)
print("spaun")
net = spaun(1)
run_profile(net, **default_kwargs)
def __init__(self, net, max_rate=100):
amp = 1 / max_rate
net.config[nengo.Ensemble].neuron_type = nengo.RectifiedLinear(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
self.net = net
self.layers = []
self.output_shapes = []
def profiling():
"""Run profiler on one of the benchmarks."""
# note: in order for GPU profiling to work, you have to manually add
# ...\CUDA\v8.0\extras\CUPTI\libx64 to your path
net, p = pes(128, 32, nengo.RectifiedLinear())
with nengo_dl.Simulator(net,
tensorboard=False,
unroll_simulation=50,
device="/gpu:0") as sim:
sim.run_steps(150, profile=True)
def test_run_profile(train, pytestconfig):
net = benchmarks.integrator(3, 2, nengo.RectifiedLinear())
benchmarks.run_profile(
net,
train=train,
n_steps=10,
do_profile=False,
device=pytestconfig.getvalue("--device"),
unroll_simulation=pytest.config.getvalue("--unroll_simulation"),
dtype=(tf.float32 if pytest.config.getvalue("dtype") == "float32" else
tf.float64))
assert net.config[net].inference_only == (not train)
def test_tensor_layer(Simulator):
with nengo.Network() as net:
inp = nengo.Node(np.arange(12))
# check that connection arguments work
layer0 = tensor_layer(inp, tf.identity, transform=2)
assert isinstance(layer0, TensorNode)
p0 = nengo.Probe(layer0)
# check that arguments are passed to layer function
layer1 = tensor_layer(layer0,
lambda x, axis: tf.reduce_sum(x, axis=axis),
axis=1,
shape_in=(2, 6))
assert layer1.size_out == 6
p1 = nengo.Probe(layer1)
# check that ensemble layers work
layer2 = tensor_layer(layer1,
nengo.RectifiedLinear(),
gain=[1] * 6,
bias=[-20] * 6)
assert isinstance(layer2, nengo.ensemble.Neurons)
assert np.allclose(layer2.ensemble.gain, 1)
assert np.allclose(layer2.ensemble.bias, -20)
p2 = nengo.Probe(layer2)
# check that size_in can be inferred from transform
layer3 = tensor_layer(layer2, lambda x: x, transform=np.ones((1, 6)))
assert layer3.size_in == 1
# check that size_in can be inferred from shape_in
layer4 = tensor_layer(layer3,
lambda x: x,
transform=nengo.dists.Uniform(-1, 1),
shape_in=(2, ))
assert layer4.size_in == 2
with Simulator(net, minibatch_size=2) as sim:
sim.step()
x = np.arange(12) * 2
assert np.allclose(sim.data[p0], x)
x = np.sum(np.reshape(x, (2, 6)), axis=0)
assert np.allclose(sim.data[p1], x)
x = np.maximum(x - 20, 0)
assert np.allclose(sim.data[p2], x)
def inh_ens_config(self):
"""(Config) Defaults for inhibitory input ensemble creation."""
cfg = nengo.Config(nengo.Ensemble, nengo.Connection)
cfg[nengo.Ensemble].update({
"neuron_type":
nengo.RectifiedLinear(),
"radius":
1,
"intercepts":
nengo.dists.Choice([0.1] * self.dimensions),
"max_rates":
nengo.dists.Choice([40])
})
cfg[nengo.Connection].synapse = None
return cfg
def test_dense_fallback_bias():
def relu(x):
return tf.maximum(x, 0)
inp = tf.keras.Input((1, ))
out = tf.keras.layers.Dense(units=10, activation=relu)(inp)
_test_convert(inp, out, allow_fallback=True)
# double check that extra biases aren't added when we _are_ using an Ensemble
conv = converter.Converter(
tf.keras.Model(inp, out),
allow_fallback=False,
swap_activations={relu: nengo.RectifiedLinear()},
)
assert conv.verify(training=True)
def _add_neuron_layer(self, layer):
inputs = [self._get_input(layer)]
neuron = layer["neuron"]
ntype = neuron["type"]
n = layer["outputs"]
gain = 1.0
bias = 0.0
amplitude = 1.0
if ntype == "ident":
neuron_type = nengo.Direct()
elif ntype == "relu":
neuron_type = nengo.RectifiedLinear()
elif ntype == "logistic":
neuron_type = nengo.Sigmoid()
elif ntype == "softlif":
tau_ref, tau_rc, alpha, amp, sigma = [
neuron["params"][k] for k in ["t", "r", "a", "m", "g"]
]
lif_type = self.lif_type.lower()
if lif_type == "lif":
neuron_type = nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref)
elif lif_type == "lifrate":
neuron_type = nengo.LIFRate(tau_rc=tau_rc, tau_ref=tau_ref)
elif lif_type == "softlifrate":
neuron_type = SoftLIFRate(sigma=sigma,
tau_rc=tau_rc,
tau_ref=tau_ref)
else:
raise KeyError("Unrecognized LIF type %r" % self.lif_type)
gain = alpha
bias = 1.0
amplitude = amp
else:
raise NotImplementedError("Neuron type %r" % ntype)
return self.add_neuron_layer(
n,
inputs=inputs,
neuron_type=neuron_type,
synapse=self.synapse,
gain=gain,
bias=bias,
amplitude=amplitude,
name=layer["name"],
)
def test_neurons_equality():
with nengo.Network():
neuron_type = nengo.LIF()
ens0 = nengo.Ensemble(10, 1, neuron_type=neuron_type)
assert ens0.neurons == ens0.neurons
assert ens0.neurons != neuron_type
ens1 = nengo.Ensemble(10, 1, neuron_type=neuron_type)
assert ens0.neurons != ens1.neurons
assert ens0.neuron_type == ens1.neuron_type
# this is the only way you could ever have two neurons objects that are
# equal but have different type
old_neurons = ens1.neurons
old_neuron_type = ens1.neuron_type
ens1.neuron_type = nengo.RectifiedLinear()
assert ens1.neurons == old_neurons
assert ens1.neuron_type != old_neuron_type
def _add_neuron_layer(self, layer):
neuron = layer['neuron']
ntype = neuron['type']
n = layer['outputs']
e = nengo.Ensemble(n, 1, label='%s_neurons' % layer['name'])
e.gain = np.ones(n)
e.bias = np.zeros(n)
transform = 1.
if ntype == 'ident':
e.neuron_type = nengo.Direct()
elif ntype == 'relu':
e.neuron_type = nengo.RectifiedLinear()
elif ntype == 'logistic':
e.neuron_type = nengo.Sigmoid()
elif ntype == 'softlif':
from .neurons import SoftLIFRate
tau_ref, tau_rc, alpha, amp, sigma, noise = [
neuron['params'][k] for k in ['t', 'r', 'a', 'm', 'g', 'n']]
lif_type = self.lif_type.lower()
if lif_type == 'lif':
e.neuron_type = nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref)
elif lif_type == 'lifrate':
e.neuron_type = nengo.LIFRate(tau_rc=tau_rc, tau_ref=tau_ref)
elif lif_type == 'softlifrate':
e.neuron_type = SoftLIFRate(
sigma=sigma, tau_rc=tau_rc, tau_ref=tau_ref)
else:
raise KeyError("Unrecognized LIF type %r" % self.lif_type)
e.gain = alpha * np.ones(n)
e.bias = np.ones(n)
transform = amp
else:
raise NotImplementedError("Neuron type %r" % ntype)
node = nengo.Node(size_in=n, label=layer['name'])
nengo.Connection(self._get_input(layer), e.neurons, synapse=None)
nengo.Connection(
e.neurons, node, transform=transform, synapse=self.synapse)
return node
def test_gradients(Simulator, unroll, seed):
minibatch_size = 4
with nengo.Network(seed=seed) as net:
net.config[nengo.Ensemble].gain = nengo.dists.Choice([1])
net.config[nengo.Ensemble].bias = nengo.dists.Uniform(-1, 1)
inp = nengo.Node([0], label="inp")
# sigmoid neurons
ens = nengo.Ensemble(10, 1, neuron_type=nengo.Sigmoid())
# normal decoded connection
nengo.Connection(inp, ens)
# recurrent connection
nengo.Connection(ens, ens, transform=0.1)
# rectified neurons
ens2 = nengo.Ensemble(10, 2, neuron_type=nengo.RectifiedLinear())
# neuron--neuron connection
nengo.Connection(ens,
ens2,
transform=[[1], [1]],
solver=nengo.solvers.LstsqL2(weights=True))
# sliced output, no synapse
nengo.Connection(inp, ens2[0], synapse=None, transform=0.5)
# sliced input, sliced output
inp2 = nengo.Node([0, 0], label="inp2")
nengo.Connection(inp2[0], ens2[1])
nengo.Probe(ens)
nengo.Probe(ens2)
with Simulator(net,
unroll_simulation=unroll,
minibatch_size=minibatch_size) as sim:
sim.check_gradients(atol=1e-4)
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_multiple_objective(Simulator, seed):
with nengo.Network(seed=seed) as net:
net.config[nengo.Connection].synapse = None
a = nengo.Node([0])
# note: b is configured this way so that the output, and therefore
# loss, will be equal to the input, so we can control it easily
b = nengo.Ensemble(100,
1,
neuron_type=nengo.RectifiedLinear(),
gain=nengo.dists.Choice([1]),
bias=nengo.dists.Choice([0]),
encoders=nengo.dists.Choice([[1]]))
c = nengo.Ensemble(10, 1)
nengo.Connection(a, b)
nengo.Connection(a, c)
p_b = nengo.Probe(b)
p_c = nengo.Probe(c)
with Simulator(net, unroll_simulation=1) as sim:
inputs = {a: np.ones((10, 1, 1))}
targets = {p_b: np.zeros((10, 1, 1)), p_c: np.zeros((10, 1, 1))}
objective = {p_b: lambda x, y: x, p_c: lambda x, y: x * 0}
assert np.allclose(sim.loss(inputs, targets, objective), 1, atol=1e-3)
b_bias = np.copy(sim.data[b].bias)
c_bias = sim.data[c].bias
sim.train(inputs,
targets,
tf.train.GradientDescentOptimizer(1.0),
objective=objective,
n_epochs=10)
assert np.allclose(sim.data[c].bias, c_bias)
assert not np.allclose(sim.data[b].bias, b_bias)
def _add_neuron_layer(self, layer):
inputs = [self._get_input(layer)]
neuron = layer['neuron']
ntype = neuron['type']
n = layer['outputs']
gain = 1.
bias = 0.
amplitude = 1.
if ntype == 'ident':
neuron_type = nengo.Direct()
elif ntype == 'relu':
neuron_type = nengo.RectifiedLinear()
elif ntype == 'logistic':
neuron_type = nengo.Sigmoid()
elif ntype == 'softlif':
from .neurons import SoftLIFRate
tau_ref, tau_rc, alpha, amp, sigma, noise = [
neuron['params'][k] for k in ['t', 'r', 'a', 'm', 'g', 'n']]
lif_type = self.lif_type.lower()
if lif_type == 'lif':
neuron_type = nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref)
elif lif_type == 'lifrate':
neuron_type = nengo.LIFRate(tau_rc=tau_rc, tau_ref=tau_ref)
elif lif_type == 'softlifrate':
neuron_type = SoftLIFRate(
sigma=sigma, tau_rc=tau_rc, tau_ref=tau_ref)
else:
raise KeyError("Unrecognized LIF type %r" % self.lif_type)
gain = alpha
bias = 1.
amplitude = amp
else:
raise NotImplementedError("Neuron type %r" % ntype)
return self.add_neuron_layer(
n, inputs=inputs, neuron_type=neuron_type, synapse=self.synapse,
gain=gain, bias=bias, amplitude=amplitude, name=layer['name'])
def test_train_recurrent(Simulator, truncation, seed):
batch_size = 100
minibatch_size = 100
n_hidden = 30
n_steps = 10
with nengo.Network(seed=seed) as net:
inp = nengo.Node([0])
ens = nengo.Ensemble(n_hidden,
1,
neuron_type=nengo.RectifiedLinear(),
gain=np.ones(n_hidden),
bias=np.linspace(-1, 1, n_hidden))
out = nengo.Node(size_in=1)
nengo.Connection(inp, ens, synapse=None)
nengo.Connection(ens, ens, synapse=0)
nengo.Connection(ens, out, synapse=None)
p = nengo.Probe(out)
with Simulator(net, minibatch_size=minibatch_size, seed=seed) as sim:
x = np.outer(np.linspace(0, 1, batch_size), np.ones(n_steps))[:, :,
None]
y = np.outer(np.linspace(0, 1, batch_size),
np.linspace(0, 1, n_steps))[:, :, None]
sim.train({inp: x}, {p: y},
tf.train.RMSPropOptimizer(1e-3),
n_epochs=200,
truncation=truncation)
sim.check_gradients(sim.tensor_graph.build_loss({p: "mse"}))
sim.run_steps(n_steps, input_feeds={inp: x[:minibatch_size]})
assert np.sqrt(np.mean(
(sim.data[p] - y[:minibatch_size])**2)) < (0.1 if truncation else 0.05)
def linear_net():
"""
A simple network with an input, output, and no nonlinearity.
"""
with nengo.Network() as net:
a = nengo.Node([1])
# note: in theory this would be nengo.Node(size_in=1), but due to
# https://github.com/tensorflow/tensorflow/issues/23383
# TensorFlow will hang
b = nengo.Ensemble(1,
1,
neuron_type=nengo.RectifiedLinear(),
gain=np.ones(1),
bias=np.ones(1) * 1e-6)
configure_settings(trainable=None)
net.config[b.neurons].trainable = False
nengo.Connection(a, b.neurons, synapse=None)
p = nengo.Probe(b.neurons)
return net, a, p
def test_networks(benchmark):
dimensions = 16
neurons_per_d = 10
neuron_type = nengo.RectifiedLinear()
net = benchmark(dimensions, neurons_per_d, neuron_type)
try:
assert net.inp.size_out == dimensions
except AttributeError:
assert net.inp_a.size_out == dimensions
assert net.inp_b.size_out == dimensions
assert net.p.size_in == dimensions
for ens in net.all_ensembles:
assert ens.neuron_type == neuron_type
if benchmark == benchmarks.cconv:
# the cconv network divides the neurons between two ensemble
# arrays
assert ens.n_neurons == ens.dimensions * (neurons_per_d // 2)
else:
assert ens.n_neurons == ens.dimensions * neurons_per_d
def build_network(neurons_per_d, seed):
with nengo.Network(seed=seed) as net:
net.config[nengo.Ensemble].neuron_type = nengo.RectifiedLinear()
net.config[nengo.Ensemble].gain = nengo.dists.Uniform(0.5, 1)
net.config[nengo.Ensemble].bias = nengo.dists.Uniform(-0.1, 0.1)
net.config[nengo.Connection].synapse = None
net.role_inp = nengo.Node(np.zeros(dims))
net.fill_inp = nengo.Node(np.zeros(dims))
net.cue_inp = nengo.Node(np.zeros(dims))
# circular convolution network to combine roles/fillers
cconv = nengo.networks.CircularConvolution(neurons_per_d, dims)
nengo.Connection(net.role_inp, cconv.input_a)
nengo.Connection(net.fill_inp, cconv.input_b)
# memory network to store the role/filler pairs
memory = nengo.Ensemble(neurons_per_d * dims, dims)
tau = 0.01
nengo.Connection(cconv.output,
memory,
transform=tau / t_int,
synapse=tau)
nengo.Connection(memory, memory, transform=1, synapse=tau)
# another circular convolution network to extract the cued filler
ccorr = nengo.networks.CircularConvolution(neurons_per_d,
dims,
invert_b=True)
nengo.Connection(memory, ccorr.input_a)
nengo.Connection(net.cue_inp, ccorr.input_b)
net.conv_probe = nengo.Probe(cconv.output, label="conv_probe")
net.memory_probe = nengo.Probe(memory, label="memory_probe")
net.output_probe = nengo.Probe(ccorr.output, label="output_probe")
return net
def test_tensor_layer(Simulator):
with nengo.Network() as net:
inp = nengo.Node(np.arange(12))
layer0 = tensor_layer(inp, tf.identity, transform=2)
assert isinstance(layer0, TensorNode)
p0 = nengo.Probe(layer0)
layer1 = tensor_layer(layer0,
lambda x, axis: tf.reduce_sum(x, axis=axis),
axis=1,
shape_in=(2, 6))
assert layer1.size_out == 6
p1 = nengo.Probe(layer1)
layer2 = tensor_layer(layer1,
nengo.RectifiedLinear(),
gain=[1] * 6,
bias=[-20] * 6)
assert isinstance(layer2, nengo.ensemble.Neurons)
assert np.allclose(layer2.ensemble.gain, 1)
assert np.allclose(layer2.ensemble.bias, -20)
p2 = nengo.Probe(layer2)
with Simulator(net, minibatch_size=2) as sim:
sim.step()
x = np.arange(12) * 2
assert np.allclose(sim.data[p0], x)
x = np.sum(np.reshape(x, (2, 6)), axis=0)
assert np.allclose(sim.data[p1], x)
x = np.maximum(x - 20, 0)
assert np.allclose(sim.data[p2], x)
def evaluate(self, p, plt):
files = []
sets = []
for f in os.listdir(p.dataset_dir):
if f.endswith('events'):
files.append(os.path.join(p.dataset_dir, f))
if p.test_set == 'one':
test_file = random.sample(files, 1)[0]
files.remove(test_file)
if p.n_data != -1:
files = random.sample(files, p.n_data)
inputs = []
targets = []
for f in files:
print(f)
times, imgs, targs = davis_track.load_data(
f,
dt=p.dt,
decay_time=p.decay_time,
separate_channels=p.separate_channels,
saturation=p.saturation,
merge=p.merge)
inputs.append(imgs)
targets.append(targs[:, :2])
inputs_all = np.vstack(inputs)
targets_all = np.vstack(targets)
if p.test_set == 'odd':
inputs_train = inputs_all[::2]
inputs_test = inputs_all[1::2]
targets_train = targets_all[::2]
targets_test = targets_all[1::2]
elif p.test_set == 'one':
times, imgs, targs = davis_track.load_data(
test_file,
dt=p.dt_test,
decay_time=p.decay_time,
separate_channels=p.separate_channels,
saturation=p.saturation)
inputs_test = imgs
targets_test = targs[:, :2]
inputs_train = inputs_all
targets_train = targets_all
if p.augment:
inputs_train, targets_train = davis_track.augment(
inputs_train,
targets_train,
separate_channels=p.separate_channels)
if p.separate_channels:
shape = (360 // p.merge, 240 // p.merge)
else:
shape = (180 // p.merge, 240 // p.merge)
dimensions = shape[0] * shape[1]
eval_points_train = inputs_train.reshape(-1, dimensions)
eval_points_test = inputs_test.reshape(-1, dimensions)
model = nengo.Network()
with model:
from nengo_extras.vision import Gabor, Mask
encoders = Gabor().generate(p.n_neurons,
(p.gabor_size, p.gabor_size))
encoders = Mask(shape).populate(encoders, flatten=True)
ens = nengo.Ensemble(
n_neurons=p.n_neurons,
dimensions=dimensions,
encoders=encoders,
neuron_type=nengo.RectifiedLinear(),
intercepts=nengo.dists.CosineSimilarity(p.gabor_size**2 + 2))
result = nengo.Node(None, size_in=targets_all.shape[1])
c = nengo.Connection(
ens,
result,
eval_points=eval_points_train,
function=targets_train,
solver=nengo.solvers.LstsqL2(reg=p.reg),
)
sim = nengo.Simulator(model)
error_train = sim.data[c].solver_info['rmses']
_, a_train = nengo.utils.ensemble.tuning_curves(
ens, sim, inputs=eval_points_train)
outputs_train = np.dot(a_train, sim.data[c].weights.T)
rmse_train = np.sqrt(
np.mean((targets_train - outputs_train)**2, axis=0))
_, a_test = nengo.utils.ensemble.tuning_curves(ens,
sim,
inputs=eval_points_test)
outputs_test = np.dot(a_test, sim.data[c].weights.T)
filt = nengo.synapses.Lowpass(p.output_filter)
outputs_test = filt.filt(outputs_test, dt=p.dt_test)
targets_test = filt.filt(targets_test, dt=p.dt_test)
rmse_test = np.sqrt(np.mean(
(targets_test - outputs_test)**2, axis=0)) * p.merge
if plt:
plt.subplot(2, 1, 1)
plt.plot(targets_train, ls='--')
plt.plot(outputs_train)
plt.title('train\nrmse=%1.4f,%1.4f' % tuple(rmse_train))
plt.subplot(2, 1, 2)
plt.plot(targets_test, ls='--')
plt.plot(outputs_test)
plt.title('test\nrmse=%1.4f,%1.4f' % tuple(rmse_test))
return dict(
rmse_train=rmse_train,
rmse_test=rmse_test,
)
def __init__(self, kp=0, kd=0, neural=False, adapt = False, num_motors=4, neuron_model=False, pes_learning_rate=1e-4):
#TODO
self.kp = kp
self.kd = kd
self.prev_time = time.time()
self.output = np.zeros(num_motors)
self.adapt = adapt
self.pes_learning_rate = pes_learning_rate
self.neuron_model = neuron_model
if neural == True:
model = nengo.Network(label="Adaptive Controller")
tau_rc = 0.02 #TODO: Check if this is in ms or s.
tau_ref = 0.002
if self.neuron_model == "RELU":
cur_model = nengo.RectifiedLinear()
elif self.neuron_model == "LIF":
cur_model = nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref) #lif model object.
elif self.neuron_model == "LIFRate":
cur_model = nengo.LIFRate(tau_rc=tau_rc, tau_ref=tau_ref) #lif model object.
def output_func(t, x):
self.output = np.copy(x)
def input_func_q(t, x):
return self.q
def input_func_dq(t, x):
return self.dq
def input_func_target(t, x):
return self.target
def input_func_d_target(t, x):
return self.d_target
with model:
output = nengo.Node(output_func, size_in=num_motors, size_out=0)
input_q = nengo.Node(input_func_q, size_in=num_motors, size_out=num_motors)
input_dq = nengo.Node(input_func_dq, size_in=num_motors, size_out=num_motors)
input_target = nengo.Node(input_func_target, size_in=num_motors, size_out=num_motors)
input_d_target = nengo.Node(input_func_d_target, size_in=num_motors, size_out=num_motors)
pes_learning_rate = 1e-4
#Adaptive component
if self.adapt:
adapt_ens = nengo.Ensemble(
n_neurons=1000, dimensions=num_motors,
radius=1.5,
neuron_type=cur_model)
learn_conn = nengo.Connection(
adapt_ens,
output,
learning_rule_type=nengo.PES(pes_learning_rate))
for i in range(num_motors):
inverter = nengo.Ensemble(500, dimensions=2, radius=1.5, neuron_type = cur_model)
proportional = nengo.Ensemble(500, dimensions=1, radius=1.5, neuron_type = cur_model)
derivative = nengo.Ensemble(500, dimensions=1, radius=1.5, neuron_type = cur_model)
control_signal = nengo.Ensemble(500, dimensions=1, radius=1.5, neuron_type = cur_model)
# invert terms that will be subtracted.
nengo.Connection(input_q[i], inverter[0], synapse=None, function=lambda x: x*-1)
nengo.Connection(input_dq[i], inverter[1], synapse=None, function=lambda x: x*-1)
# calculate proportional part
nengo.Connection(inverter[0], proportional, synapse=None, function=lambda x:x*kp)
nengo.Connection(input_target[i], proportional, synapse=None, function=lambda x:x*kp)
# calculate derivative part
nengo.Connection(inverter[1], derivative, synapse=None, function=lambda x:(x*kd))
nengo.Connection(input_d_target[i], derivative, synapse=None, function=lambda x:(x*kd))
# output
nengo.Connection(proportional, control_signal)
nengo.Connection(derivative, control_signal)
nengo.Connection(control_signal, output[i])
if self.adapt:
# adapt connections
nengo.Connection(input_q[i], adapt_ens, function=lambda x: np.zeros(num_motors), synapse=None)
nengo.Connection(control_signal, learn_conn.learning_rule[i], transform=-1, synapse=None)
# Nodes to access PID components.
# PID_Ens.append({"inverter":inverter,
# "proportional":proportional,
# "derivative": derivative, #TODO: Remove all except control signal.
# "control_signal": control_signal})
# control_signal_p = nengo.Probe(PID_Ens[0]["control_signal"], synapse=.01)
self.sim = nengo.Simulator(model)
def mnist(use_tensor_layer=True):
"""
A network designed to stress-test tensor layers (based on mnist net).
Parameters
----------
use_tensor_layer : bool
If True, use individual tensor_layers to build the network, as opposed
to a single TensorNode containing all layers.
Returns
-------
net : `nengo.Network`
benchmark network
"""
with nengo.Network() as net:
# create node to feed in images
net.inp = nengo.Node(np.ones(28 * 28))
if use_tensor_layer:
nengo_nl = nengo.RectifiedLinear()
ensemble_params = dict(max_rates=nengo.dists.Choice([100]),
intercepts=nengo.dists.Choice([0]))
amplitude = 1
synapse = None
x = nengo_dl.tensor_layer(net.inp,
tf.layers.conv2d,
shape_in=(28, 28, 1),
filters=32,
kernel_size=3)
x = nengo_dl.tensor_layer(x, nengo_nl, **ensemble_params)
x = nengo_dl.tensor_layer(x,
tf.layers.conv2d,
shape_in=(26, 26, 32),
transform=amplitude,
filters=32,
kernel_size=3)
x = nengo_dl.tensor_layer(x, nengo_nl, **ensemble_params)
x = nengo_dl.tensor_layer(x,
tf.layers.average_pooling2d,
shape_in=(24, 24, 32),
synapse=synapse,
transform=amplitude,
pool_size=2,
strides=2)
x = nengo_dl.tensor_layer(x, tf.layers.dense, units=128)
x = nengo_dl.tensor_layer(x, nengo_nl, **ensemble_params)
x = nengo_dl.tensor_layer(x,
tf.layers.dropout,
rate=0.4,
transform=amplitude)
x = nengo_dl.tensor_layer(x, tf.layers.dense, units=10)
else:
nl = tf.nn.relu
# def softlif_layer(x, sigma=1, tau_ref=0.002, tau_rc=0.02,
# amplitude=1):
# # x -= 1
# z = tf.nn.softplus(x / sigma) * sigma
# z += 1e-10
# rates = amplitude / (tau_ref + tau_rc * tf.log1p(1 / z))
# return rates
@nengo_dl.reshaped((28, 28, 1))
def mnist_node(_, x): # pragma: no cover
x = tf.layers.conv2d(x,
filters=32,
kernel_size=3,
activation=nl)
x = tf.layers.conv2d(x,
filters=32,
kernel_size=3,
activation=nl)
x = tf.layers.average_pooling2d(x, pool_size=2, strides=2)
x = tf.contrib.layers.flatten(x)
x = tf.layers.dense(x, 128, activation=nl)
x = tf.layers.dropout(x, rate=0.4)
x = tf.layers.dense(x, 10)
return x
node = nengo_dl.TensorNode(mnist_node,
size_in=28 * 28,
size_out=10)
x = node
nengo.Connection(net.inp, node, synapse=None)
net.p = nengo.Probe(x)
return net
def evaluate(self, p, plt):
files = []
sets = []
for f in os.listdir(p.dataset_dir):
if f.endswith('events'):
files.append(os.path.join(p.dataset_dir, f))
if p.test_set == 'one':
test_file = random.sample(files, 1)[0]
files.remove(test_file)
if p.n_data != -1:
files = random.sample(files, p.n_data)
inputs = []
targets = []
for f in files:
times, imgs, targs = davis_tracking.load_data(f, dt=p.dt, decay_time=p.decay_time,
separate_channels=p.separate_channels,
saturation=p.saturation, merge=p.merge)
inputs.append(imgs)
targets.append(targs[:,:2])
inputs_all = np.vstack(inputs)
targets_all = np.vstack(targets)
if p.test_set == 'odd':
inputs_train = inputs_all[::2]
inputs_test = inputs_all[1::2]
targets_train = targets_all[::2]
targets_test = targets_all[1::2]
dt_test = p.dt*2
elif p.test_set == 'one':
times, imgs, targs = davis_tracking.load_data(test_file, dt=p.dt_test, decay_time=p.decay_time,
separate_channels=p.separate_channels,
saturation=p.saturation, merge=p.merge)
inputs_test = imgs
targets_test = targs[:, :2]
inputs_train = inputs_all
targets_train = targets_all
dt_test = p.dt_test
if p.augment:
inputs_train, targets_train = davis_tracking.augment(inputs_train, targets_train,
separate_channels=p.separate_channels)
if p.separate_channels:
shape = (2, 180//p.merge, 240//p.merge)
else:
shape = (1, 180//p.merge, 240//p.merge)
dimensions = shape[0]*shape[1]*shape[2]
if p.normalize:
magnitude = np.linalg.norm(inputs_train.reshape(-1, dimensions), axis=1)
inputs_train = inputs_train*(1.0/magnitude[:,None,None])
magnitude = np.linalg.norm(inputs_test.reshape(-1, dimensions), axis=1)
inputs_test = inputs_test*(1.0/magnitude[:,None,None])
max_rate = 100
amp = 1 / max_rate
model = nengo.Network()
with model:
model.config[nengo.Ensemble].neuron_type = nengo.RectifiedLinear(amplitude=amp)
model.config[nengo.Ensemble].max_rates = nengo.dists.Choice([max_rate])
model.config[nengo.Ensemble].intercepts = nengo.dists.Choice([0])
model.config[nengo.Connection].synapse = None
inp = nengo.Node(
nengo.processes.PresentInput(inputs_test.reshape(-1, dimensions), dt_test),
size_out=dimensions,
)
out = nengo.Node(None, size_in=2)
if not p.split_spatial:
# do a standard convnet
conv1 = nengo.Convolution(p.n_features_1, shape, channels_last=False, strides=(p.stride_1,p.stride_1),
kernel_size=(p.kernel_size_1, p.kernel_size_1))
layer1 = nengo.Ensemble(conv1.output_shape.size, dimensions=1)
nengo.Connection(inp, layer1.neurons, transform=conv1)
conv2 = nengo.Convolution(p.n_features_2, conv1.output_shape, channels_last=False, strides=(p.stride_2,p.stride_2),
kernel_size=(p.kernel_size_2, p.kernel_size_2))
layer2 = nengo.Ensemble(conv2.output_shape.size, dimensions=1)
nengo.Connection(layer1.neurons, layer2.neurons, transform=conv2)
nengo.Connection(layer2.neurons, out, transform=nengo_dl.dists.Glorot())
else:
# do the weird spatially split convnet
convnet = davis_tracking.ConvNet(nengo.Network())
convnet.make_input_layer(
shape,
spatial_stride=(p.spatial_stride, p.spatial_stride),
spatial_size=(p.spatial_size,p.spatial_size))
nengo.Connection(inp, convnet.input)
convnet.make_middle_layer(n_features=p.n_features_1, n_parallel=p.n_parallel, n_local=1,
kernel_stride=(p.stride_1,p.stride_1), kernel_size=(p.kernel_size_1,p.kernel_size_1))
convnet.make_middle_layer(n_features=p.n_features_2, n_parallel=p.n_parallel, n_local=1,
kernel_stride=(p.stride_2,p.stride_2), kernel_size=(p.kernel_size_2,p.kernel_size_2))
convnet.make_output_layer(2)
nengo.Connection(convnet.output, out)
p_out = nengo.Probe(out)
N = len(inputs_train)
n_steps = int(np.ceil(N/p.minibatch_size))
dl_train_data = {inp: np.resize(inputs_train, (p.minibatch_size, n_steps, dimensions)),
p_out: np.resize(targets_train, (p.minibatch_size, n_steps, 2))}
N = len(inputs_test)
n_steps = int(np.ceil(N/p.minibatch_size))
dl_test_data = {inp: np.resize(inputs_test, (p.minibatch_size, n_steps, dimensions)),
p_out: np.resize(targets_test, (p.minibatch_size, n_steps, 2))}
with nengo_dl.Simulator(model, minibatch_size=p.minibatch_size) as sim:
#loss_pre = sim.loss(dl_test_data)
if p.n_epochs > 0:
sim.train(dl_train_data, tf.train.RMSPropOptimizer(learning_rate=p.learning_rate),
n_epochs=p.n_epochs)
loss_post = sim.loss(dl_test_data)
sim.run_steps(n_steps, data=dl_test_data)
data = sim.data[p_out].reshape(-1,2)[:len(targets_test)]
rmse_test = np.sqrt(np.mean((targets_test-data)**2, axis=0))*p.merge
if plt:
plt.plot(data*p.merge)
plt.plot(targets_test*p.merge, ls='--')
return dict(
rmse_test = rmse_test,
max_n_neurons = max([ens.n_neurons for ens in model.all_ensembles]),
test_targets = targets_test,
test_output = data,
test_loss = loss_post
)
assert net.inp.size_out == 28 * 28
assert net.p.size_in == 10
def test_spaun():
pytest.importorskip("_spaun")
dimensions = 2
net = benchmarks.spaun(dimensions=dimensions)
assert net.mem.mb1_net.output.size_in == dimensions
@pytest.mark.parametrize(
"dimensions, neurons_per_d, neuron_type, n_ensembles, n_connections",
((1, 10, nengo.RectifiedLinear(), 5, 3), (2, 4, nengo.LIF(), 10, 2)),
)
def test_random_network(
dimensions, neurons_per_d, neuron_type, n_ensembles, n_connections
):
net = benchmarks.random_network(
dimensions, neurons_per_d, neuron_type, n_ensembles, n_connections
)
_test_random(
net, dimensions, neurons_per_d, neuron_type, n_ensembles, n_connections
)
def _test_random(
net, dimensions, neurons_per_d, neuron_type, n_ensembles, n_connections
):
def test_tensor_layer(Simulator):
with nengo.Network() as net:
inp = nengo.Node(np.arange(12))
# check that connection arguments work
layer0 = Layer(tf.identity)(inp, transform=2)
assert isinstance(layer0, TensorNode)
p0 = nengo.Probe(layer0)
# check that arguments can be passed to layer function
layer1 = Layer(
partial(lambda x, axis: tf.reduce_sum(x, axis=axis),
axis=1))(layer0, shape_in=(2, 6))
assert layer1.size_out == 6
p1 = nengo.Probe(layer1)
class TestFunc:
def __init__(self, axis):
self.axis = axis
def __call__(self, x):
return tf.reduce_sum(x, axis=self.axis)
layer1b = Layer(TestFunc(axis=1))(layer0, shape_in=(2, 6))
assert layer1b.size_out == 6
# check that ensemble layers work
layer2 = Layer(nengo.RectifiedLinear())(layer1,
gain=[1] * 6,
bias=[-20] * 6)
assert isinstance(layer2, nengo.ensemble.Neurons)
assert np.allclose(layer2.ensemble.gain, 1)
assert np.allclose(layer2.ensemble.bias, -20)
p2 = nengo.Probe(layer2)
# check that size_in can be inferred from transform
layer3 = Layer(lambda x: x)(layer2, transform=np.ones((1, 6)))
assert layer3.size_in == 1
# check that size_in can be inferred from shape_in
layer4 = Layer(lambda x: x)(layer3,
transform=nengo.dists.Uniform(-1, 1),
shape_in=(2, ))
assert layer4.size_in == 2
# check that conn is marked non-trainable
with nengo.Network():
_, conn = Layer(tf.identity)(inp, return_conn=True)
assert not net.config[conn].trainable
with Simulator(net, minibatch_size=2) as sim:
sim.step()
x = np.arange(12) * 2
assert np.allclose(sim.data[p0], x)
x = np.sum(np.reshape(x, (2, 6)), axis=0)
assert np.allclose(sim.data[p1], x)
x = np.maximum(x - 20, 0)
assert np.allclose(sim.data[p2], x)
