def test_multi():
p_inh = 0.2
sparsity = 0.5
model = nengo.Network(seed=0)
with model:
a = nengo.Ensemble(n_neurons=50, dimensions=3, seed=1)
b = nengo.Ensemble(n_neurons=5, dimensions=3, seed=2)
c1 = nengo.Connection(a,
b,
solver=nengo_solver_dales.DalesL2(
reg=0.1,
p_inh=p_inh,
sparsity=sparsity,
multiprocess=False),
seed=1)
c2 = nengo.Connection(a,
b,
solver=nengo_solver_dales.DalesL2(
reg=0.1,
p_inh=p_inh,
sparsity=sparsity,
multiprocess=True),
seed=1)
sim = nengo.Simulator(model)
w1 = sim.data[c1].weights
w2 = sim.data[c2].weights
assert np.allclose(w1, w2)
def test_accuracy():
p_inh = 0.2
model = nengo.Network(seed=0)
with model:
a = nengo.Ensemble(n_neurons=100, dimensions=3, seed=1)
b = nengo.Ensemble(n_neurons=100, dimensions=3, seed=2)
c1 = nengo.Connection(a, b, solver=nengo.solvers.LstsqL2(weights=True))
c2 = nengo.Connection(a,
b,
solver=nengo_solver_dales.DalesL2(reg=0.1,
p_inh=p_inh,
sparsity=0.0))
c3 = nengo.Connection(a,
b,
solver=nengo_solver_dales.DalesL2(reg=0.1,
p_inh=p_inh,
sparsity=0.2))
sim = nengo.Simulator(model)
import pylab
x, a = nengo.utils.ensemble.tuning_curves(a,
sim,
inputs=sim.data[a].eval_points)
enc = sim.data[b].scaled_encoders
target = np.dot(x, enc.T)
w1 = sim.data[c1].weights
w2 = sim.data[c2].weights
w3 = sim.data[c3].weights
actual1 = np.dot(a, w1.T)
actual2 = np.dot(a, w2.T)
actual3 = np.dot(a, w3.T)
rms1 = np.mean(rmses(a, w1.T, target))
rms2 = np.mean(rmses(a, w2.T, target))
rms3 = np.mean(rmses(a, w3.T, target))
print(np.mean(rms1), np.mean(rms2), np.mean(rms3))
assert rms1 < rms2 < rms3
assert rms3 < rms1 * 5
pylab.subplot(1, 3, 1)
pylab.scatter(target, actual1, s=1)
pylab.subplot(1, 3, 2)
pylab.scatter(target, actual2, s=1)
pylab.subplot(1, 3, 3)
pylab.scatter(target, actual3, s=1)
pylab.show()
def test_multi_speed():
p_inh = 0.2
sparsity = 0.5
Ns = [200, 300, 400, 500]
ts = {}
ts[True] = []
ts[False] = []
for N in Ns:
w = None
for multi in [True, False]:
model = nengo.Network(seed=0)
with model:
a = nengo.Ensemble(n_neurons=N, dimensions=3)
b = nengo.Ensemble(n_neurons=N, dimensions=3)
c = nengo.Connection(a, b, solver=nengo_solver_dales.DalesL2(reg=0.1, p_inh=p_inh,
sparsity=sparsity, multiprocess=multi))
t_start = timeit.default_timer()
sim = nengo.Simulator(model)
t = timeit.default_timer() - t_start
ts[multi].append(t)
if w is None:
w = sim.data[c].weights
else:
assert np.allclose(w, sim.data[c].weights)
import pylab
pylab.loglog(Ns, ts[False], label='serial')
pylab.loglog(Ns, ts[True], label='multi')
pylab.xlabel('n_neurons')
pylab.ylabel('time')
pylab.legend(loc='best')
pylab.show()
def test_convert():
model = nengo.Network()
with model:
stim = nengo.Node(lambda t: 0 if t < 0.5 else 1)
p_stim = nengo.Probe(stim)
a = nengo.Ensemble(n_neurons=100, dimensions=1)
nengo.Connection(stim, a, synapse=None)
bs = []
p_bs = []
conns = []
for i in range(4):
b = nengo.Ensemble(n_neurons=100, dimensions=1)
bs.append(b)
p_bs.append(nengo.Probe(b, synapse=0.02))
conns.append(
nengo.Connection(
a,
b,
solver=nengo_solver_dales.DalesL2(),
))
syn1 = 0.1
syn2 = 0.01
conns[0].synapse = syn1
conns[1].synapse = syn2
nengo_solver_dales.split_exc_inh(conns[2],
model,
exc_synapse=syn1,
inh_synapse=syn2)
nengo_solver_dales.split_exc_inh(conns[3],
model,
exc_synapse=syn2,
inh_synapse=syn1)
for conn in conns[2:]:
assert conn not in model.all_connections
sim = nengo.Simulator(model)
sim.run(1.0)
import pylab
pylab.plot(sim.trange(), sim.data[p_stim])
labels = [
'%g' % syn1,
'%g' % syn2,
'%g+ %g-' % (syn1, syn2),
'%g+ %g-' % (syn2, syn1)
]
for i, p_b in enumerate(p_bs):
pylab.plot(sim.trange(), sim.data[p_b], label=labels[i])
pylab.legend(loc='best')
pylab.show()
def test_accuracy():
N = 200
p_inh = 0.2
sparsity = 0.5
tols = [None, 1e-80, 1e-40, 1e-30, 1e-12, 1e-10, 1e-8, 1e-6, 1e-4, 1e-2]
model = nengo.Network(seed=0)
with model:
a = nengo.Ensemble(n_neurons=N, dimensions=3, seed=1)
b = nengo.Ensemble(n_neurons=N, dimensions=3, seed=2)
cs = [nengo.Connection(a, b, solver=nengo_solver_dales.DalesL2(reg=0.1, p_inh=p_inh, sparsity=sparsity, tol=tol)) for tol in tols]
sim = nengo.Simulator(model)
import pylab
x, a = nengo.utils.ensemble.tuning_curves(a, sim, inputs=sim.data[a].eval_points)
enc = sim.data[b].scaled_encoders
target = np.dot(x, enc.T)
ws = [sim.data[c].weights for c in cs]
ts = [sim.data[c].solver_info['time'] for c in cs]
actuals = [np.dot(a, w.T) for w in ws]
rms = [np.mean(rmses(a, w.T, target)) for w in ws]
print(rms)
print(ts)
for i in range(len(tols)):
pylab.subplot(1, len(tols), i+1)
pylab.scatter(target, actuals[i], s=1)
pylab.title(rms[i])
pylab.figure()
pylab.plot(rms)
pylab.twinx()
pylab.plot(ts)
pylab.xticks(range(len(tols)), tols)
pylab.show()