def test_vector(self):
"""A network that represents sin(t), cos(t), arctan(t)."""
N = 40
m = nengo.Model('test_vector', seed=123)
m.make_node('in', output=lambda t: [np.sin(t), np.cos(t), np.arctan(t)])
m.make_ensemble('A', nengo.LIF(N * 3), 3, radius=2)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.02)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(5)
with Plotter(self.Simulator) as plt:
t = sim.data(m.t)
plt.plot(t, sim.data('in'), label='Input')
plt.plot(t, sim.data('A'), label='Neuron approximation, pstc=0.02')
plt.legend(loc='best', prop={'size': 10})
plt.savefig('test_ensemble.test_vector.pdf')
plt.close()
target = np.vstack((np.sin(np.arange(5000) / 1000.),
np.cos(np.arange(5000) / 1000.),
np.arctan(np.arange(5000) / 1000.))).T
logger.debug("In RMSE: %f", rmse(target, sim.data('in')))
self.assertTrue(rmse(target, sim.data('in') < 0.001))
self.assertTrue(rmse(target, sim.data('A')) < 0.1)
def test_scalar(Simulator, nl):
"""A network that represents sin(t)."""
N = 30
m = nengo.Model('test_scalar', seed=123)
input = nengo.Node(output=np.sin, label='input')
A = nengo.Ensemble(nl(N), 1, label='A')
nengo.Connection(input, A)
in_p = nengo.Probe(input, 'output')
A_p = nengo.Probe(A, 'decoded_output', filter=0.02)
sim = Simulator(m)
sim.run(5.0)
with Plotter(Simulator, nl) as plt:
t = sim.trange()
plt.plot(t, sim.data(in_p), label='Input')
plt.plot(t, sim.data(A_p), label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar.pdf')
plt.close()
target = np.sin(np.arange(5000) / 1000.)
target.shape = (-1, 1)
logger.debug("[New API] input RMSE: %f", rmse(target, sim.data(in_p)))
logger.debug("[New API] A RMSE: %f", rmse(target, sim.data(A_p)))
assert rmse(target, sim.data(in_p)) < 0.001
assert rmse(target, sim.data(A_p)) < 0.1
def test_vector(Simulator, nl):
"""A network that represents sin(t), cos(t), arctan(t)."""
N = 40
m = nengo.Model('test_vector', seed=123)
input = nengo.Node(output=lambda t: [np.sin(t), np.cos(t), np.arctan(t)])
A = nengo.Ensemble(nl(N * 3), 3, radius=2)
nengo.Connection(input, A)
in_p = nengo.Probe(input, 'output')
A_p = nengo.Probe(A, 'decoded_output', filter=0.02)
sim = Simulator(m)
sim.run(5)
with Plotter(Simulator, nl) as plt:
t = sim.trange()
plt.plot(t, sim.data(in_p), label='Input')
plt.plot(t, sim.data(A_p), label='Neuron approximation, pstc=0.02')
plt.legend(loc='best', prop={'size': 10})
plt.savefig('test_ensemble.test_vector.pdf')
plt.close()
target = np.vstack((np.sin(np.arange(5000) / 1000.),
np.cos(np.arange(5000) / 1000.),
np.arctan(np.arange(5000) / 1000.))).T
logger.debug("In RMSE: %f", rmse(target, sim.data(in_p)))
assert rmse(target, sim.data(in_p)) < 0.01
assert rmse(target, sim.data(A_p)) < 0.1
def test_scalar(self):
"""A network that represents sin(t)."""
simulator = self.Simulator
params = dict(simulator=simulator, seed=123, dt=0.001)
N = 30
target = np.sin(np.arange(4999) / 1000.)
target.shape = (4999, 1)
# Old API
net = nef.Network('test_scalar', **params)
net.make_input('in', value=np.sin)
net.make('A', N, 1)
net.connect('in', 'A')
in_p = net.make_probe('in', dt_sample=0.001, pstc=0.0)
a_p = net.make_probe('A', dt_sample=0.001, pstc=0.02)
net.run(5)
in_data = in_p.get_data()
a_data = a_p.get_data()
with Plotter(simulator) as plt:
t = net.model.data[net.model.simtime]
plt.plot(t, in_data, label='Input')
plt.plot(t, a_data, label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar-old.pdf')
plt.close()
logger.debug("[Old API] input RMSE: %f", rmse(target, in_data))
logger.debug("[Old API] A RMSE: %f", rmse(target, a_data))
self.assertTrue(rmse(target, in_data) < 0.001)
self.assertTrue(rmse(target, a_data) < 0.1)
# New API
m = nengo.Model('test_scalar', **params)
m.make_node('in', output=np.sin)
m.make_ensemble('A', nengo.LIF(N), 1)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.02)
m.run(5)
with Plotter(simulator) as plt:
t = m.data[m.simtime]
plt.plot(t, m.data['in'], label='Input')
plt.plot(t, m.data['A'], label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar-new.pdf')
plt.close()
logger.debug("[New API] input RMSE: %f", rmse(target, m.data['in']))
logger.debug("[New API] A RMSE: %f", rmse(target, m.data['A']))
self.assertTrue(rmse(target, m.data['in']) < 0.001)
self.assertTrue(rmse(target, m.data['A']) < 0.1)
# Check old/new API similarity
logger.debug("Old/New API RMSE: %f", rmse(a_data, m.data['A']))
self.assertTrue(rmse(a_data, m.data['A']) < 0.1)
def test_scalar(self):
"""A network that represents sin(t)."""
simulator = self.Simulator
params = dict(simulator=simulator, seed=123, dt=0.001)
N = 30
target = np.sin(np.arange(4999) / 1000.)
target.shape = (4999, 1)
# Old API
net = nef.Network('test_scalar', **params)
net.make_input('in', value=np.sin)
net.make('A', N, 1)
net.connect('in', 'A')
in_p = net.make_probe('in', dt_sample=0.001, pstc=0.0)
a_p = net.make_probe('A', dt_sample=0.001, pstc=0.02)
net.run(5)
in_data = in_p.get_data()
a_data = a_p.get_data()
with Plotter(simulator) as plt:
t = net.model.data[net.model.simtime]
plt.plot(t, in_data, label='Input')
plt.plot(t, a_data, label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar-old.pdf')
plt.close()
logger.debug("[Old API] input RMSE: %f", rmse(target, in_data))
logger.debug("[Old API] A RMSE: %f", rmse(target, a_data))
self.assertTrue(rmse(target, in_data) < 0.001)
self.assertTrue(rmse(target, a_data) < 0.1)
# New API
m = nengo.Model('test_scalar', **params)
m.make_node('in', output=np.sin)
m.make_ensemble('A', nengo.LIF(N), 1)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.02)
m.run(5)
with Plotter(simulator) as plt:
t = m.data[m.simtime]
plt.plot(t, m.data['in'], label='Input')
plt.plot(t, m.data['A'], label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar-new.pdf')
plt.close()
logger.debug("[New API] input RMSE: %f", rmse(target, m.data['in']))
logger.debug("[New API] A RMSE: %f", rmse(target, m.data['A']))
self.assertTrue(rmse(target, m.data['in']) < 0.001)
self.assertTrue(rmse(target, m.data['A']) < 0.1)
# Check old/new API similarity
logger.debug("Old/New API RMSE: %f", rmse(a_data, m.data['A']))
self.assertTrue(rmse(a_data, m.data['A']) < 0.1)
def test_scalar(self):
"""A network that represents sin(t)."""
N = 30
m = nengo.Model('test_scalar', seed=123)
m.make_node('in', output=np.sin)
m.make_ensemble('A', nengo.LIF(N), 1)
m.connect('in', 'A')
m.probe('in')
m.probe('A', filter=0.02)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(5.0)
with Plotter(self.Simulator) as plt:
t = sim.data(m.t)
plt.plot(t, sim.data('in'), label='Input')
plt.plot(t, sim.data('A'), label='Neuron approximation, pstc=0.02')
plt.legend(loc=0)
plt.savefig('test_ensemble.test_scalar.pdf')
plt.close()
target = np.sin(np.arange(5000) / 1000.)
target.shape = (-1, 1)
logger.debug("[New API] input RMSE: %f", rmse(target, sim.data('in')))
logger.debug("[New API] A RMSE: %f", rmse(target, sim.data('A')))
self.assertTrue(rmse(target, sim.data('in')) < 0.001)
self.assertTrue(rmse(target, sim.data('A')) < 0.1)
def test_integrator(self):
model = nengo.Model('Integrator')
with model:
inputs = {0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}
input = nengo.Node(nengo.helpers.piecewise(inputs))
tau = 0.1
T = nengo.networks.Integrator(
tau, neurons=nengo.LIF(100), dimensions=1)
nengo.Connection(input, T.input, filter=tau)
A = nengo.Ensemble(nengo.LIF(100), dimensions=1)
nengo.Connection(A, A, transform=[[1]], filter=tau)
nengo.Connection(input, A, transform=[[tau]], filter=tau)
input_p = nengo.Probe(input, 'output')
A_p = nengo.Probe(A, 'decoded_output', filter=0.01)
T_p = nengo.Probe(T.ensemble, 'decoded_output', filter=0.01)
sim = self.Simulator(model, dt=0.001)
sim.run(6.0)
with Plotter(self.Simulator) as plt:
t = sim.trange()
plt.plot(t, sim.data(A_p), label='Manual')
plt.plot(t, sim.data(T_p), label='Template')
plt.plot(t, sim.data(input_p), 'k', label='Input')
plt.legend(loc=0)
plt.savefig('test_integrator.test_integrator.pdf')
plt.close()
self.assertTrue(rmse(sim.data(A_p), sim.data(T_p)) < 0.2)
def test_oscillator(self):
model = nengo.Model('Oscillator')
inputs = {0: [1, 0], 0.5: [0, 0]}
model.make_node('Input', nengo.helpers.piecewise(inputs))
tau = 0.1
freq = 5
model.add(Oscillator('T', tau, freq, neurons=nengo.LIF(100)))
model.connect('Input', 'T.In')
model.make_ensemble('A', nengo.LIF(100), dimensions=2)
model.connect('A',
'A',
filter=tau,
transform=[[1, -freq * tau], [freq * tau, 1]])
model.connect('Input', 'A')
model.probe('Input')
model.probe('A', filter=0.01)
model.probe('T.Oscillator', filter=0.01)
sim = model.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(3.0)
with Plotter(self.Simulator) as plt:
t = sim.data(model.t)
plt.plot(t, sim.data('A'), label='Manual')
plt.plot(t, sim.data('T.Oscillator'), label='Template')
plt.plot(t, sim.data('Input'), 'k', label='Input')
plt.legend(loc=0)
plt.savefig('test_oscillator.test_oscillator.pdf')
plt.close()
self.assertTrue(rmse(sim.data('A'), sim.data('T.Oscillator')) < 0.3)
def test_oscillator(Simulator, nl):
model = nengo.Model('Oscillator')
inputs = {0: [1, 0], 0.5: [0, 0]}
input = nengo.Node(nengo.helpers.piecewise(inputs), label='Input')
tau = 0.1
freq = 5
T = nengo.networks.Oscillator(
tau, freq, label="Oscillator", neurons=nl(100))
nengo.Connection(input, T.input)
A = nengo.Ensemble(nl(100), label='A', dimensions=2)
nengo.Connection(A, A, filter=tau,
transform=[[1, -freq*tau], [freq*tau, 1]])
nengo.Connection(input, A)
in_probe = nengo.Probe(input, "output")
A_probe = nengo.Probe(A, "decoded_output", filter=0.01)
T_probe = nengo.Probe(T.ensemble, "decoded_output", filter=0.01)
sim = Simulator(model)
sim.run(3.0)
with Plotter(Simulator, nl) as plt:
t = sim.trange()
plt.plot(t, sim.data(A_probe), label='Manual')
plt.plot(t, sim.data(T_probe), label='Template')
plt.plot(t, sim.data(in_probe), 'k', label='Input')
plt.legend(loc=0)
plt.savefig('test_oscillator.test_oscillator.pdf')
plt.close()
assert rmse(sim.data(A_probe), sim.data(T_probe)) < 0.3
def test_oscillator(self):
model = nengo.Model('Oscillator')
inputs = {0:[1,0],0.5:[0,0]}
model.make_node('Input', nengo.helpers.piecewise(inputs))
tau = 0.1
freq = 5
model.add(Oscillator('T', tau, freq, neurons=nengo.LIF(100)))
model.connect('Input', 'T.In')
model.make_ensemble('A', nengo.LIF(100), dimensions=2)
model.connect('A', 'A', filter=tau,
transform=[[1, -freq*tau], [freq*tau, 1]])
model.connect('Input', 'A')
model.probe('Input')
model.probe('A', filter=0.01)
model.probe('T.Oscillator', filter=0.01)
sim = model.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(3.0)
with Plotter(self.Simulator) as plt:
t = sim.data(model.t)
plt.plot(t, sim.data('A'), label='Manual')
plt.plot(t, sim.data('T.Oscillator'), label='Template')
plt.plot(t, sim.data('Input'), 'k', label='Input')
plt.legend(loc=0)
plt.savefig('test_oscillator.test_oscillator.pdf')
plt.close()
self.assertTrue(rmse(sim.data('A'), sim.data('T.Oscillator')) < 0.3)
def test_integrator(self):
model = nengo.Model('Integrator')
inputs = {0:0, 0.2:1, 1:0, 2:-2, 3:0, 4:1, 5:0}
model.make_node('Input', nengo.helpers.piecewise(inputs))
tau = 0.1
model.add(Integrator('T', tau, neurons=nengo.LIF(100), dimensions=1))
model.connect('Input', 'T.In', filter=tau)
model.make_ensemble('A', nengo.LIF(100), dimensions=1)
model.connect('A', 'A', transform=[[1]], filter=tau)
model.connect('Input', 'A', transform=[[tau]], filter=tau)
model.probe('Input')
model.probe('A', filter=0.01)
model.probe('T.Integrator', filter=0.01)
sim = model.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(6.0)
with Plotter(self.Simulator) as plt:
t = sim.data(model.t)
plt.plot(t, sim.data('A'), label='Manual')
plt.plot(t, sim.data('T.Integrator'), label='Template')
plt.plot(t, sim.data('Input'), 'k', label='Input')
plt.legend(loc=0)
plt.savefig('test_integrator.test_integrator.pdf')
plt.close()
self.assertTrue(rmse(sim.data('A'), sim.data('T.Integrator')) < 0.2)
def test_product(Simulator, nl):
N = 80
m = nengo.Model('test_product', seed=124)
sin = nengo.Node(output=np.sin)
cons = nengo.Node(output=-.5)
factors = nengo.Ensemble(nl(2 * N), dimensions=2, radius=1.5)
if nl != nengo.Direct:
factors.encoders = np.tile(
[[1, 1], [-1, 1], [1, -1], [-1, -1]],
(factors.n_neurons // 4, 1))
product = nengo.Ensemble(nl(N), dimensions=1)
nengo.Connection(sin, factors, transform=[[1], [0]])
nengo.Connection(cons, factors, transform=[[0], [1]])
nengo.Connection(
factors, product, function=lambda x: x[0] * x[1], filter=0.01)
sin_p = nengo.Probe(sin, 'output', sample_every=.01)
# TODO
# m.probe(conn, sample_every=.01)
factors_p = nengo.Probe(
factors, 'decoded_output', sample_every=.01, filter=.01)
product_p = nengo.Probe(
product, 'decoded_output', sample_every=.01, filter=.01)
sim = Simulator(m)
sim.run(6)
with Plotter(Simulator, nl) as plt:
t = sim.trange(dt=.01)
plt.subplot(211)
plt.plot(t, sim.data(factors_p))
plt.plot(t, np.sin(np.arange(0, 6, .01)))
plt.plot(t, sim.data(sin_p))
plt.subplot(212)
plt.plot(t, sim.data(product_p))
# TODO
# plt.plot(sim.data(conn))
plt.plot(t, -.5 * np.sin(np.arange(0, 6, .01)))
plt.savefig('test_ensemble.test_prod.pdf')
plt.close()
sin = np.sin(np.arange(0, 6, .01))
assert rmse(sim.data(factors_p)[:, 0], sin) < 0.1
assert rmse(sim.data(factors_p)[20:, 1], -0.5) < 0.1
assert rmse(sim.data(product_p)[:, 0], -0.5 * sin) < 0.1
def test_product(self):
def product(x):
return x[0] * x[1]
m = nengo.Model('test_product', seed=124)
N = 80
m.make_node('sin', output=np.sin)
m.make_node('-0.5', output=-.5)
factors = m.make_ensemble(
'factors', nengo.LIF(2 * N), dimensions=2, radius=1.5)
factors.encoders = np.tile([[1, 1],[-1, 1],[1, -1],[-1, -1]],
(factors.n_neurons / 4, 1))
m.make_ensemble('product', nengo.LIF(N), dimensions=1)
m.connect('sin', 'factors', transform=[[1], [0]])
m.connect('-0.5', 'factors', transform=[[0], [1]])
conn = m.connect('factors', 'product', function=product, filter=0.01)
m.probe('sin', sample_every=.01)
# m.probe(conn, sample_every=.01) # FIXME
m.probe('factors', sample_every=.01, filter=.01)
m.probe('product', sample_every=.01, filter=.01)
sim = m.simulator(dt=0.001, sim_class=self.Simulator)
sim.run(6)
with Plotter(self.Simulator) as plt:
plt.subplot(211)
plt.plot(sim.data('factors'))
plt.plot(np.sin(np.arange(0, 6, .01)))
plt.plot(sim.data('sin'))
plt.subplot(212)
plt.plot(sim.data('product'))
#plt.plot(sim.data(conn))
plt.plot(-.5 * np.sin(np.arange(0, 6, .01)))
plt.savefig('test_ensemble.test_prod.pdf')
plt.close()
self.assertTrue(rmse(sim.data('factors')[:, 0],
np.sin(np.arange(0, 6, .01))) < 0.1)
self.assertTrue(rmse(sim.data('factors')[20:, 1], -0.5) < 0.1)
def match(a, b):
self.assertTrue(rmse(a, b) < 0.1)
match(sim.data('product')[:, 0], -0.5 * np.sin(np.arange(0, 6, .01)))
def test_vector(self):
"""A network that represents sin(t), cos(t), arctan(t)."""
simulator = self.Simulator
params = dict(simulator=simulator, seed=123, dt=0.001)
N = 40
target = np.vstack(
(np.sin(np.arange(4999) / 1000.), np.cos(np.arange(4999) / 1000.),
np.arctan(np.arange(4999) / 1000.))).T
# Old API
net = nef.Network('test_vector', **params)
net.make_input('sin', value=np.sin)
net.make_input('cos', value=np.cos)
net.make_input('arctan', value=np.arctan)
net.make('A', N * 3, 3, radius=2)
net.connect('sin', 'A', transform=[[1], [0], [0]])
net.connect('cos', 'A', transform=[[0], [1], [0]])
net.connect('arctan', 'A', transform=[[0], [0], [1]])
sin_p = net.make_probe('sin', dt_sample=0.001, pstc=0.0)
cos_p = net.make_probe('cos', dt_sample=0.001, pstc=0.0)
arctan_p = net.make_probe('arctan', dt_sample=0.001, pstc=0.0)
a_p = net.make_probe('A', dt_sample=0.001, pstc=0.02)
net.run(5)
sin_data = sin_p.get_data()
cos_data = cos_p.get_data()
arctan_data = arctan_p.get_data()
a_data = a_p.get_data()
with Plotter(simulator) as plt:
t = net.model.data[net.model.simtime]
plt.plot(t, sin_data, label='sin')
plt.plot(t, cos_data, label='cos')
plt.plot(t, arctan_data, label='arctan')
plt.plot(t, a_data, label='Neuron approximation, pstc=0.02')
plt.legend(loc=0, prop={'size': 10})
plt.savefig('test_ensemble.test_vector-old.pdf')
plt.close()
logger.debug("[Old API] sin RMSE: %f", rmse(target[:, 0], sin_data))
logger.debug("[Old API] cos RMSE: %f", rmse(target[:, 1], cos_data))
logger.debug("[Old API] atan RMSE: %f", rmse(target[:, 2],
arctan_data))
logger.debug("[Old API] A RMSE: %f", rmse(target, a_data))
self.assertTrue(rmse(target, a_data) < 0.1)
# New API
m = nengo.Model('test_vector', **params)
m.make_node('sin', output=np.sin)
m.make_node('cos', output=np.cos)
m.make_node('arctan', output=np.arctan)
m.make_ensemble('A', nengo.LIF(N * 3), 3, radius=2)
m.connect('sin', 'A', transform=[[1], [0], [0]])
m.connect('cos', 'A', transform=[[0], [1], [0]])
m.connect('arctan', 'A', transform=[[0], [0], [1]])
m.probe('sin')
m.probe('cos')
m.probe('arctan')
m.probe('A', filter=0.02)
m.run(5)
with Plotter(simulator) as plt:
t = m.data[m.simtime]
plt.plot(t, m.data['sin'], label='sin')
plt.plot(t, m.data['cos'], label='cos')
plt.plot(t, m.data['arctan'], label='arctan')
plt.plot(t, m.data['A'], label='Neuron approximation, pstc=0.02')
plt.legend(loc=0, prop={'size': 10})
plt.savefig('test_ensemble.test_vector-new.pdf')
plt.close()
# Not sure why, but this isn't working...
logger.debug("[New API] sin RMSE: %f", rmse(target[:, 0],
m.data['sin']))
logger.debug("[New API] cos RMSE: %f", rmse(target[:, 1],
m.data['cos']))
logger.debug("[New API] atan RMSE: %f",
rmse(target[:, 2], m.data['arctan']))
logger.debug("[New API] A RMSE: %f", rmse(target, m.data['A']))
self.assertTrue(rmse(target, m.data['A']) < 0.1)
# Check old/new API similarity
logger.debug("Old/New API RMSE: %f", rmse(a_data, m.data['A']))
self.assertTrue(rmse(a_data, m.data['A']) < 0.1)
def _test_circularconv(self, dims=5, neurons_per_product=128):
rng = np.random.RandomState(42342)
n_neurons = neurons_per_product * dims
n_neurons_d = 2 * neurons_per_product * (2 * dims -
(2 if dims % 2 == 0 else 1))
radius = 1
a = rng.normal(scale=np.sqrt(1. / dims), size=dims)
b = rng.normal(scale=np.sqrt(1. / dims), size=dims)
c = circconv(a, b)
self.assertTrue(np.abs(a).max() < radius)
self.assertTrue(np.abs(b).max() < radius)
self.assertTrue(np.abs(c).max() < radius)
### model
model = nengo.Model("circular convolution")
inputA = model.make_node("inputA", output=a)
inputB = model.make_node("inputB", output=b)
A = model.add(
EnsembleArray('A', nengo.LIF(n_neurons), dims, radius=radius))
B = model.add(
EnsembleArray('B', nengo.LIF(n_neurons), dims, radius=radius))
C = model.add(
EnsembleArray('C', nengo.LIF(n_neurons), dims, radius=radius))
D = model.add(
CircularConvolution('D',
neurons=nengo.LIF(n_neurons_d),
dimensions=A.dimensions,
radius=radius))
inputA.connect_to(A)
inputB.connect_to(B)
A.connect_to(D.A)
B.connect_to(D.B)
D.output.connect_to(C)
model.probe(A, filter=0.03)
model.probe(B, filter=0.03)
model.probe(C, filter=0.03)
model.probe(D.ensemble, filter=0.03)
# check FFT magnitude
d = np.dot(D.transformA, a) + np.dot(D.transformB, b)
self.assertTrue(np.abs(d).max() < radius)
### simulation
sim = model.simulator(sim_class=self.Simulator)
sim.run(1.0)
t = sim.data(model.t).flatten()
with Plotter(self.Simulator) as plt:
def plot(sim, a, A, title=""):
a_ref = np.tile(a, (len(t), 1))
a_sim = sim.data(A)
colors = ['b', 'g', 'r', 'c', 'm', 'y']
for i in xrange(min(dims, len(colors))):
plt.plot(t, a_ref[:, i], '--', color=colors[i])
plt.plot(t, a_sim[:, i], '-', color=colors[i])
plt.title(title)
plt.subplot(221)
plot(sim, a, A, title="A")
plt.subplot(222)
plot(sim, b, B, title="B")
plt.subplot(223)
plot(sim, c, C, title="C")
plt.subplot(224)
plot(sim, d, D.ensemble, title="D")
plt.savefig('test_circularconv.test_circularconv_%d.pdf' % dims)
plt.close()
### results
tmask = t > (0.5 + sim.model.dt / 2)
self.assertEqual(sim.data(A)[tmask].shape, (499, dims))
a_sim = sim.data(A)[tmask].mean(axis=0)
b_sim = sim.data(B)[tmask].mean(axis=0)
c_sim = sim.data(C)[tmask].mean(axis=0)
d_sim = sim.data(D.ensemble)[tmask].mean(axis=0)
rtol, atol = 0.1, 0.05
self.assertTrue(np.allclose(a, a_sim, rtol=rtol, atol=atol))
self.assertTrue(np.allclose(b, b_sim, rtol=rtol, atol=atol))
self.assertTrue(np.allclose(d, d_sim, rtol=rtol, atol=atol))
self.assertTrue(rmse(c, c_sim) < 0.075)
def test_vector(self):
"""A network that represents sin(t), cos(t), arctan(t)."""
simulator = self.Simulator
params = dict(simulator=simulator, seed=123, dt=0.001)
N = 40
target = np.vstack((np.sin(np.arange(4999) / 1000.),
np.cos(np.arange(4999) / 1000.),
np.arctan(np.arange(4999) / 1000.))).T
# Old API
net = nef.Network('test_vector', **params)
net.make_input('sin', value=np.sin)
net.make_input('cos', value=np.cos)
net.make_input('arctan', value=np.arctan)
net.make('A', N * 3, 3, radius=2)
net.connect('sin', 'A', transform=[[1], [0], [0]])
net.connect('cos', 'A', transform=[[0], [1], [0]])
net.connect('arctan', 'A', transform=[[0], [0], [1]])
sin_p = net.make_probe('sin', dt_sample=0.001, pstc=0.0)
cos_p = net.make_probe('cos', dt_sample=0.001, pstc=0.0)
arctan_p = net.make_probe('arctan', dt_sample=0.001, pstc=0.0)
a_p = net.make_probe('A', dt_sample=0.001, pstc=0.02)
net.run(5)
sin_data = sin_p.get_data()
cos_data = cos_p.get_data()
arctan_data = arctan_p.get_data()
a_data = a_p.get_data()
with Plotter(simulator) as plt:
t = net.model.data[net.model.simtime]
plt.plot(t, sin_data, label='sin')
plt.plot(t, cos_data, label='cos')
plt.plot(t, arctan_data, label='arctan')
plt.plot(t, a_data, label='Neuron approximation, pstc=0.02')
plt.legend(loc=0, prop={'size': 10})
plt.savefig('test_ensemble.test_vector-old.pdf')
plt.close()
logger.debug("[Old API] sin RMSE: %f", rmse(target[:,0], sin_data))
logger.debug("[Old API] cos RMSE: %f", rmse(target[:,1], cos_data))
logger.debug("[Old API] atan RMSE: %f", rmse(target[:,2], arctan_data))
logger.debug("[Old API] A RMSE: %f", rmse(target, a_data))
self.assertTrue(rmse(target, a_data) < 0.1)
# New API
m = nengo.Model('test_vector', **params)
m.make_node('sin', output=np.sin)
m.make_node('cos', output=np.cos)
m.make_node('arctan', output=np.arctan)
m.make_ensemble('A', nengo.LIF(N * 3), 3, radius=2)
m.connect('sin', 'A', transform=[[1], [0], [0]])
m.connect('cos', 'A', transform=[[0], [1], [0]])
m.connect('arctan', 'A', transform=[[0], [0], [1]])
m.probe('sin')
m.probe('cos')
m.probe('arctan')
m.probe('A', filter=0.02)
m.run(5)
with Plotter(simulator) as plt:
t = m.data[m.simtime]
plt.plot(t, m.data['sin'], label='sin')
plt.plot(t, m.data['cos'], label='cos')
plt.plot(t, m.data['arctan'], label='arctan')
plt.plot(t, m.data['A'], label='Neuron approximation, pstc=0.02')
plt.legend(loc=0, prop={'size': 10})
plt.savefig('test_ensemble.test_vector-new.pdf')
plt.close()
# Not sure why, but this isn't working...
logger.debug("[New API] sin RMSE: %f", rmse(target[:,0], m.data['sin']))
logger.debug("[New API] cos RMSE: %f", rmse(target[:,1], m.data['cos']))
logger.debug("[New API] atan RMSE: %f",
rmse(target[:,2], m.data['arctan']))
logger.debug("[New API] A RMSE: %f", rmse(target, m.data['A']))
self.assertTrue(rmse(target, m.data['A']) < 0.1)
# Check old/new API similarity
logger.debug("Old/New API RMSE: %f", rmse(a_data, m.data['A']))
self.assertTrue(rmse(a_data, m.data['A']) < 0.1)
def match(a, b):
self.assertTrue(rmse(a, b) < 0.1)
def _test_circularconv(self, dims=5, neurons_per_product=128):
rng = np.random.RandomState(42342)
n_neurons = neurons_per_product * dims
n_neurons_d = 2 * neurons_per_product * (
2*dims - (2 if dims % 2 == 0 else 1))
radius = 1
a = rng.normal(scale=np.sqrt(1./dims), size=dims)
b = rng.normal(scale=np.sqrt(1./dims), size=dims)
c = circconv(a, b)
self.assertTrue(np.abs(a).max() < radius)
self.assertTrue(np.abs(b).max() < radius)
self.assertTrue(np.abs(c).max() < radius)
### model
model = nengo.Model("circular convolution")
inputA = model.make_node("inputA", output=a)
inputB = model.make_node("inputB", output=b)
A = model.add(EnsembleArray(
'A', nengo.LIF(n_neurons), dims, radius=radius))
B = model.add(EnsembleArray(
'B', nengo.LIF(n_neurons), dims, radius=radius))
C = model.add(EnsembleArray(
'C', nengo.LIF(n_neurons), dims, radius=radius))
D = model.add(CircularConvolution(
'D', neurons=nengo.LIF(n_neurons_d),
dimensions=A.dimensions, radius=radius))
inputA.connect_to(A)
inputB.connect_to(B)
A.connect_to(D.A)
B.connect_to(D.B)
D.output.connect_to(C)
model.probe(A, filter=0.03)
model.probe(B, filter=0.03)
model.probe(C, filter=0.03)
model.probe(D.ensemble, filter=0.03)
# check FFT magnitude
d = np.dot(D.transformA, a) + np.dot(D.transformB, b)
self.assertTrue(np.abs(d).max() < radius)
### simulation
sim = model.simulator(sim_class=self.Simulator)
sim.run(1.0)
t = sim.data(model.t).flatten()
with Plotter(self.Simulator) as plt:
def plot(sim, a, A, title=""):
a_ref = np.tile(a, (len(t), 1))
a_sim = sim.data(A)
colors = ['b', 'g', 'r', 'c', 'm', 'y']
for i in xrange(min(dims, len(colors))):
plt.plot(t, a_ref[:,i], '--', color=colors[i])
plt.plot(t, a_sim[:,i], '-', color=colors[i])
plt.title(title)
plt.subplot(221)
plot(sim, a, A, title="A")
plt.subplot(222)
plot(sim, b, B, title="B")
plt.subplot(223)
plot(sim, c, C, title="C")
plt.subplot(224)
plot(sim, d, D.ensemble, title="D")
plt.savefig('test_circularconv.test_circularconv_%d.pdf' % dims)
plt.close()
### results
tmask = t > (0.5 + sim.model.dt/2)
self.assertEqual(sim.data(A)[tmask].shape, (499, dims))
a_sim = sim.data(A)[tmask].mean(axis=0)
b_sim = sim.data(B)[tmask].mean(axis=0)
c_sim = sim.data(C)[tmask].mean(axis=0)
d_sim = sim.data(D.ensemble)[tmask].mean(axis=0)
rtol, atol = 0.1, 0.05
self.assertTrue(np.allclose(a, a_sim, rtol=rtol, atol=atol))
self.assertTrue(np.allclose(b, b_sim, rtol=rtol, atol=atol))
self.assertTrue(np.allclose(d, d_sim, rtol=rtol, atol=atol))
self.assertTrue(rmse(c, c_sim) < 0.075)
def test_circularconv(Simulator, nl, dims=4, neurons_per_product=128):
rng = np.random.RandomState(42342)
n_neurons = neurons_per_product
n_neurons_d = 2 * neurons_per_product
radius = 1
a = rng.normal(scale=np.sqrt(1./dims), size=dims)
b = rng.normal(scale=np.sqrt(1./dims), size=dims)
c = circconv(a, b)
assert np.abs(a).max() < radius
assert np.abs(b).max() < radius
assert np.abs(c).max() < radius
### model
model = nengo.Model("circular convolution")
inputA = nengo.Node(output=a)
inputB = nengo.Node(output=b)
A = EnsembleArray(nl(n_neurons), dims, radius=radius)
B = EnsembleArray(nl(n_neurons), dims, radius=radius)
C = EnsembleArray(nl(n_neurons), dims, radius=radius)
D = nengo.networks.CircularConvolution(
neurons=nl(n_neurons_d),
dimensions=A.dimensions, radius=radius)
nengo.Connection(inputA, A.input)
nengo.Connection(inputB, B.input)
nengo.Connection(A.output, D.A)
nengo.Connection(B.output, D.B)
nengo.Connection(D.output, C.input)
A_p = nengo.Probe(A.output, 'output', filter=0.03)
B_p = nengo.Probe(B.output, 'output', filter=0.03)
C_p = nengo.Probe(C.output, 'output', filter=0.03)
D_p = nengo.Probe(D.ensemble.output, 'output', filter=0.03)
# check FFT magnitude
d = np.dot(D.transformA, a) + np.dot(D.transformB, b)
assert np.abs(d).max() < radius
### simulation
sim = Simulator(model)
sim.run(1.0)
t = sim.trange()
with Plotter(Simulator, nl) as plt:
def plot(sim, a, A, title=""):
a_ref = np.tile(a, (len(t), 1))
a_sim = sim.data(A_p)
colors = ['b', 'g', 'r', 'c', 'm', 'y']
for i in range(min(dims, len(colors))):
plt.plot(t, a_ref[:, i], '--', color=colors[i])
plt.plot(t, a_sim[:, i], '-', color=colors[i])
plt.title(title)
plt.subplot(221)
plot(sim, a, A, title="A")
plt.subplot(222)
plot(sim, b, B, title="B")
plt.subplot(223)
plot(sim, c, C, title="C")
plt.subplot(224)
plot(sim, d, D.ensemble, title="D")
plt.savefig('test_circularconv.test_circularconv_%d.pdf' % dims)
plt.close()
### results
tmask = t > (0.5 + sim.model.dt/2)
assert sim.data(A_p)[tmask].shape == (499, dims)
a_sim = sim.data(A_p)[tmask].mean(axis=0)
b_sim = sim.data(B_p)[tmask].mean(axis=0)
c_sim = sim.data(C_p)[tmask].mean(axis=0)
d_sim = sim.data(D_p)[tmask].mean(axis=0)
rtol, atol = 0.1, 0.05
assert np.allclose(a, a_sim, rtol=rtol, atol=atol)
assert np.allclose(b, b_sim, rtol=rtol, atol=atol)
assert np.allclose(d, d_sim, rtol=rtol, atol=atol)
assert rmse(c, c_sim) < 0.075
