def test_nested_network(self):
# --smoke test that it runs
base = nengo.Model('base')
with declarative_syntax(base):
demo_bg.BG('BG1')
demo_bg.BG('BG2')
# -- this doesn't work yet, but I think it should
conn.connect('BG1.output', 'BG1.input')
def test_multiplication(self):
model = nengo.Model('multiplication')
with declarative_syntax(model):
ens.ensemble('A', nengo.LIF(100), dimensions=1, radius=10)
ens.ensemble('B', nengo.LIF(100), dimensions=1, radius=10)
ens.ensemble('Combined', nengo.LIF(100), dimensions=2, radius=15)
ens.ensemble('D', nengo.LIF(100), dimensions=1, radius=20)
ens.encoders('Combined',
np.tile([[1,1],[-1,1],[1,-1],[-1,-1]],
(ens.n_neurons('Combined')/4, 1)))
ens.node('Input A', piecewise({0:0, 2.5:10, 4:-10}))
ens.node('Input B', piecewise({0:10, 1.5:2, 3:0, 4.5:2}))
conn.connect('Input A', 'A')
conn.connect('Input B', 'B')
conn.connect('A','Combined', transform=[[1], [0]])
conn.connect('B','Combined', transform=[[0], [1]])
conn.connect('Combined', 'D', function=lambda x: x[0] * x[1])
for name in 'Input A', 'Input B':
probe(name)
for name in 'A', 'B', 'Combined', 'D':
probe(name, filter=0.01)
sim = model.simulator()
sim.run(5)
import matplotlib.pyplot as plt
# Plot the input signals and decoded ensemble values
correct_ans = nengo.helpers.piecewise({0:0, 1.5:0, 2.5:20, 3:0, 4:0, 4.5:-20})
t = sim.data(model.t)
plt.plot(t, sim.data('A'), label="Decoded A")
plt.plot(t, sim.data('B'), label="Decoded B")
plt.plot(t, sim.data('D'), label="Decoded D")
out = [0] * t.shape[0]
for i in np.arange(t.shape[0]):
out[i] = correct_ans(t[i])
plt.plot(t, out)
plt.legend()
plt.ylim(-25,25);
def BG(name,
dimensions = 1,
n_neurons_per_ensemble = 100,
radius = 1.5,
model=None,
mm = 1,
mp = 1,
me = 1,
mg = 1,
ws = 1,
wt = 1,
wm = 1,
wg = 1,
wp = 0.9,
we = 0.3,
e = 0.2,
ep = -0.25,
ee = -0.2,
eg = -0.2,
le = 0.2,
lg = 0.2,
tau_ampa = 0.002,
tau_gaba = 0.008,
output_weight = -3,
):
# connection weights from (Gurney, Prescott, & Redgrave, 2001)
if model is None:
# -- create a subnetwork of the active model
# (see nengo_decl.context.active_model)
model = subnetwork(name)
with declarative_syntax(model):
encoders = np.ones((n_neurons_per_ensemble, 1))
for label, lbound in (
('StrD1', e),
('StrD2', e),
('STN', ep),
('GPi', eg),
('GPe', ee)):
ens.ensemble_array(label,
intercepts=Uniform(lbound, 1),
neurons= nengo.LIF(
n_neurons_per_ensemble * dimensions),
n_ensembles= dimensions,
radius= radius,
encoders= encoders,
)
ens.passthrough('input', dimensions=dimensions)
ens.passthrough('output', dimensions=dimensions)
# spread the input to StrD1, StrD2, and STN
conn.connect('input', 'StrD1',
filter=None,
transform=np.eye(dimensions) * ws * (1 + lg))
conn.connect('input', 'strD2',
filter=None,
transform=np.eye(dimensions) * ws * (1 - le))
conn.connect('input', 'STN',
filter=None,
transform=np.eye(dimensions) * wt)
# connect the striatum to the GPi and GPe (inhibitory)
def func_str(x):
return max(x[0] - e, 0) * mm
conn.connect('StrD1', 'GPi',
function=func_str,
filter=tau_gaba,
transform=-np.eye(dimensions) * wm)
conn.connect('StrD2', 'GPe',
function=func_str,
filter=tau_gaba,
transform=-np.eye(dimensions) * wm)
# connect the STN to GPi and GPe (broad and excitatory)
def func_stn(x):
return max(x[0] - ep) * mp
tr = np.ones((dimensions, dimensions)) * wp
conn.connect('STN', 'GPi',
function=func_stn,
transform=tr,
filter=tau_ampa)
conn.connect('STN', 'GPe',
function=func_stn,
transform=tr,
filter=tau_ampa)
# connect the GPe to GPi and STN (inhibitory)
def func_gpe(x):
return max(x[0] - ee) * me
conn.connect('GPe', 'GPi',
function=func_gpe,
filter=tau_gaba,
transform=-np.eye(dimensions) * we)
conn.connect('GPe', 'STN',
function=func_gpe,
filter=tau_gaba,
transform=-np.eye(dimensions) * wg)
#connect GPi to output (inhibitory)
conn.connect('GPi', 'output',
function=lambda x: max(x[0] - eg) * mg,
filter=None,
transform=np.eye(dimensions) * output_weight)
return model
