def test_rms():
t = np.linspace(0, 1, 1000)
for rms_desired in [0, 0.5, 1, 100]:
f = whitenoise(1, 100, rms=rms_desired)
rms = np.sqrt(np.mean([f(tt) ** 2 for tt in t]))
assert np.allclose(rms, rms_desired, atol=.1, rtol=.01)
def test_rms():
t = np.linspace(0, 1, 1000)
for rms_desired in [0, 0.5, 1, 100]:
f = whitenoise(1, 100, rms=rms_desired)
rms = np.sqrt(np.mean([f(tt)**2 for tt in t]))
assert np.allclose(rms, rms_desired, atol=.1, rtol=.01)
def test_array():
rms_desired = 0.5
f = whitenoise(1, 5, rms=rms_desired, dimensions=5)
t = np.linspace(0, 1, 1000)
data = np.array([f(tt) for tt in t])
rms = np.sqrt(np.mean(data**2, axis=0))
assert np.allclose(rms, rms_desired, atol=.1, rtol=.01)
def test_array():
rms_desired = 0.5
f = whitenoise(1, 5, rms=rms_desired, dimensions=5)
t = np.linspace(0, 1, 1000)
data = np.array([f(tt) for tt in t])
rms = np.sqrt(np.mean(data**2, axis=0))
assert np.allclose(rms, rms_desired, atol=.1, rtol=.01)
def _test_rates(Simulator, rates, name=None):
if name is None:
name = rates.__name__
n = 100
max_rates = 50 * np.ones(n)
# max_rates = 200 * np.ones(n)
intercepts = np.linspace(-0.99, 0.99, n)
encoders = np.ones((n, 1))
model = nengo.Network()
with model:
model.config[nengo.Ensemble].max_rates = max_rates
model.config[nengo.Ensemble].intercepts = intercepts
model.config[nengo.Ensemble].encoders = encoders
u = nengo.Node(output=whitenoise(1, 5, seed=8393))
a = nengo.Ensemble(n, 1, neuron_type=nengo.LIFRate())
b = nengo.Ensemble(n, 1, neuron_type=nengo.LIF())
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
up = nengo.Probe(u)
ap = nengo.Probe(a.neurons)
bp = nengo.Probe(b.neurons)
dt = 1e-3
sim = Simulator(model, dt=dt)
sim.run(2.)
t = sim.trange()
x = sim.data[up]
a_rates = sim.data[ap] / dt
spikes = sim.data[bp]
b_rates = rates(t, spikes)
with Plotter(Simulator) as plt:
ax = plt.subplot(411)
plt.plot(t, x)
ax = plt.subplot(412)
implot(plt, t, intercepts, a_rates.T, ax=ax)
ax.set_ylabel('intercept')
ax = plt.subplot(413)
implot(plt, t, intercepts, b_rates.T, ax=ax)
ax.set_ylabel('intercept')
ax = plt.subplot(414)
implot(plt, t, intercepts, (b_rates - a_rates).T, ax=ax)
ax.set_xlabel('time [s]')
ax.set_ylabel('intercept')
plt.savefig('utils.test_neurons.test_rates.%s.pdf' % name)
plt.close()
tmask = (t > 0.1) & (t < 1.9)
relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask])
return relative_rmse
def _test_rates(Simulator, rates, name=None):
if name is None:
name = rates.__name__
n = 100
max_rates = 50 * np.ones(n)
# max_rates = 200 * np.ones(n)
intercepts = np.linspace(-0.99, 0.99, n)
encoders = np.ones((n, 1))
nparams = dict(n_neurons=n)
eparams = dict(
max_rates=max_rates, intercepts=intercepts, encoders=encoders)
model = nengo.Network()
with model:
u = nengo.Node(output=whitenoise(1, 5, seed=8393))
a = nengo.Ensemble(nengo.LIFRate(**nparams), 1, **eparams)
b = nengo.Ensemble(nengo.LIF(**nparams), 1, **eparams)
nengo.Connection(u, a, synapse=0)
nengo.Connection(u, b, synapse=0)
up = nengo.Probe(u)
ap = nengo.Probe(a.neurons, "output", synapse=None)
bp = nengo.Probe(b.neurons, "output", synapse=None)
dt = 1e-3
sim = Simulator(model, dt=dt)
sim.run(2.)
t = sim.trange()
x = sim.data[up]
a_rates = sim.data[ap] / dt
spikes = sim.data[bp]
b_rates = rates(t, spikes)
with Plotter(Simulator) as plt:
ax = plt.subplot(411)
plt.plot(t, x)
ax = plt.subplot(412)
implot(plt, t, intercepts, a_rates.T, ax=ax)
ax.set_ylabel('intercept')
ax = plt.subplot(413)
implot(plt, t, intercepts, b_rates.T, ax=ax)
ax.set_ylabel('intercept')
ax = plt.subplot(414)
implot(plt, t, intercepts, (b_rates - a_rates).T, ax=ax)
ax.set_xlabel('time [s]')
ax.set_ylabel('intercept')
plt.savefig('utils.test_neurons.test_rates.%s.pdf' % name)
plt.close()
tmask = (t > 0.1) & (t < 1.9)
relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask])
return relative_rmse
def test_reset(Simulator, nl_nodirect):
"""Make sure resetting actually resets.
A learning network on weights is used as the example network as the
ultimate stress test; lots of weird stuff happens during learning, but
if we're able to reset back to initial connection weights and everything
then we're probably doing resetting right.
"""
noise = whitenoise(0.1, 5, dimensions=2, seed=328)
m = nengo.Network(seed=3902)
with m:
m.config[nengo.Ensemble].neuron_type = nl_nodirect()
u = nengo.Node(output=noise)
ens = nengo.Ensemble(200, dimensions=2)
error = nengo.Ensemble(200, dimensions=2)
square = nengo.Ensemble(200, dimensions=2)
nengo.Connection(u, ens)
nengo.Connection(u, error)
nengo.Connection(square, error, transform=-1)
err_conn = nengo.Connection(error, square, modulatory=True)
nengo.Connection(ens,
square,
learning_rule=[nengo.PES(err_conn),
nengo.BCM()],
solver=LstsqL2nz(weights=True))
square_p = nengo.Probe(square, synapse=0.1)
err_p = nengo.Probe(error, synapse=0.1)
sim = Simulator(m)
sim.run(0.2)
sim.run(0.6)
first_t = sim.trange()
first_square_p = np.array(sim.data[square_p], copy=True)
first_err_p = np.array(sim.data[err_p], copy=True)
sim.reset()
sim.run(0.8)
assert np.all(sim.trange() == first_t)
assert np.all(sim.data[square_p] == first_square_p)
assert np.all(sim.data[err_p] == first_err_p)
def run_synapse(Simulator, synapse, dt=1e-3, runtime=1., n_neurons=None):
model = nengo.Network(seed=2984)
with model:
u = nengo.Node(output=whitenoise(0.1, 5, seed=328))
if n_neurons is not None:
a = nengo.Ensemble(n_neurons, 1)
nengo.Connection(u, a, synapse=None)
target = a
else:
target = u
ref = nengo.Probe(target)
filtered = nengo.Probe(target, synapse=synapse)
sim = Simulator(model, dt=dt)
sim.run(runtime)
return sim.trange(), sim.data[ref], sim.data[filtered]
def run_synapse(Simulator, synapse, dt=1e-3, runtime=1., n_neurons=None):
model = nengo.Network(seed=2984)
with model:
u = nengo.Node(output=whitenoise(0.1, 5, seed=328))
if n_neurons is not None:
a = nengo.Ensemble(n_neurons, 1)
nengo.Connection(u, a, synapse=None)
target = a
else:
target = u
ref = nengo.Probe(target, synapse=None)
filtered = nengo.Probe(target, synapse=synapse)
sim = nengo.Simulator(model, dt=dt)
sim.run(runtime)
return sim.trange(), sim.data[ref], sim.data[filtered]
def test_reset(Simulator, nl_nodirect):
"""Make sure resetting actually resets.
A learning network on weights is used as the example network as the
ultimate stress test; lots of weird stuff happens during learning, but
if we're able to reset back to initial connection weights and everything
then we're probably doing resetting right.
"""
noise = whitenoise(0.1, 5, dimensions=2, seed=328)
m = nengo.Network(seed=3902)
with m:
m.config[nengo.Ensemble].neuron_type = nl_nodirect()
u = nengo.Node(output=noise)
ens = nengo.Ensemble(200, dimensions=2)
error = nengo.Ensemble(200, dimensions=2)
square = nengo.Ensemble(200, dimensions=2)
nengo.Connection(u, ens)
nengo.Connection(u, error)
nengo.Connection(square, error, transform=-1)
err_conn = nengo.Connection(error, square, modulatory=True)
nengo.Connection(ens, square,
learning_rule=[nengo.PES(err_conn), nengo.BCM()],
solver=LstsqL2nz(weights=True))
square_p = nengo.Probe(square, synapse=0.1)
err_p = nengo.Probe(error, synapse=0.1)
sim = Simulator(m)
sim.run(0.2)
sim.run(0.6)
first_t = sim.trange()
first_square_p = np.array(sim.data[square_p], copy=True)
first_err_p = np.array(sim.data[err_p], copy=True)
sim.reset()
sim.run(0.8)
assert np.all(sim.trange() == first_t)
assert np.all(sim.data[square_p] == first_square_p)
assert np.all(sim.data[err_p] == first_err_p)
def test_unsupervised(Simulator, nl_nodirect, learning_rule_type,
seed, rng, plt):
n = 200
m = nengo.Network(seed=seed)
with m:
m.config[nengo.Ensemble].neuron_type = nl_nodirect()
u = nengo.Node(whitenoise(0.1, 5, dimensions=2, seed=seed+1))
a = nengo.Ensemble(n, dimensions=2)
u_learned = nengo.Ensemble(n, dimensions=2)
initial_weights = rng.uniform(
high=1e-3,
size=(a.n_neurons, u_learned.n_neurons))
nengo.Connection(u, a)
conn = nengo.Connection(a.neurons, u_learned.neurons,
transform=initial_weights,
learning_rule_type=learning_rule_type)
inp_p = nengo.Probe(u)
trans_p = nengo.Probe(conn, 'transform')
ap = nengo.Probe(a, synapse=0.03)
up = nengo.Probe(u_learned, synapse=0.03)
sim = Simulator(m)
sim.run(0.5)
t = sim.trange()
name = learning_rule_type.__class__.__name__
plt.subplot(2, 1, 1)
plt.plot(t, sim.data[inp_p], label="Input")
plt.plot(t, sim.data[ap], label="Pre")
plt.plot(t, sim.data[up], label="Post")
plt.legend(loc="best", fontsize="x-small")
plt.subplot(2, 1, 2)
plt.plot(t, sim.data[trans_p][..., 4])
plt.xlabel("Time (s)")
plt.ylabel("Transform weight")
plt.saveas = 'test_learning_rules.test_unsupervised_%s.pdf' % name
assert not np.all(sim.data[trans_p][0] == sim.data[trans_p][-1])
import numpy as np
import nengo
import nengo_spinnaker
import matplotlib.pyplot as plt
from nengo.utils.functions import whitenoise
model = nengo.Network()
config = nengo_spinnaker.Config()
with model:
# -- input and pre popluation
inp = nengo.Node(whitenoise(0.1, 5, dimensions=2))
config[inp].f_of_t = True
pre = nengo.Ensemble(120, dimensions=2)
nengo.Connection(inp, pre)
# -- error population
prod_node = nengo.Node(lambda t, x: x[0] * x[1], size_in=2) # We'll give it the actual product
config[prod_node].f_of_t = True
nengo.Connection(inp, prod_node, synapse=None)
error = nengo.Ensemble(60, dimensions=1)
nengo.Connection(prod_node, error)
# -- inhibit error after 40 seconds
inhib = nengo.Node(lambda t: 2.0 if t > 40.0 else 0.0)
config[inhib].f_of_t = True
nengo.Connection(inhib, error.neurons, transform=[[-1]] * error.n_neurons)
import numpy as np
import nengo
from nengo.utils.functions import whitenoise
model = nengo.Model("Delayed connection")
input = nengo.Node(whitenoise(1, 5, seed=60))
A = nengo.Ensemble(nengo.LIF(40), dimensions=1)
nengo.Connection(input, A)
class Delay(object):
def __init__(self, dimensions, timesteps=50):
self.history = np.zeros((timesteps, dimensions))
def step(self, t, x):
self.history = np.roll(self.history, -1)
self.history[-1] = x
return self.history[0]
dt = 0.001
delay = Delay(1, timesteps=int(0.2 / 0.001))
delaynode = nengo.Node(delay.step, size_in=1)
nengo.Connection(A, delaynode)
B = nengo.Ensemble(nengo.LIF(40), dimensions=1)
nengo.Connection(delaynode, B)
import numpy as np
import nengo
import nengo_spinnaker
spinnaker = True
dimensions = 1
learning_rates = [1.0, 0.5, 0.25]
post_colours = ['r', 'g', 'y']
from nengo.utils.functions import whitenoise
model = nengo.Network()
with model:
config = nengo_spinnaker.Config()
inp = nengo.Node(whitenoise(0.1, 5, dimensions=dimensions), label = "inp")
config[inp].f_of_t = True
pre = nengo.Ensemble(60, dimensions=dimensions, label = "pre")
nengo.Connection(inp, pre)
posts = [nengo.Ensemble(60, dimensions=dimensions, label = "post%u" % i) for i, l in enumerate(learning_rates)]
conns = [nengo.Connection(pre, p, function=lambda x: np.random.random(dimensions)) for p in posts]
errors = [nengo.Ensemble(60, dimensions=dimensions, label = "error%u" % i) for i, l in enumerate(learning_rates)]
error_probes = [nengo.Probe(e, synapse=0.03) for e in errors]
for e, p, c, l in zip(errors, posts, conns, learning_rates):
# Error = pre - post
nengo.Connection(pre, e)
nengo.Connection(p, e, transform=-1)
