def Model(X, numNeu, d, E, synap, T, isPlot):
lenX = len(X)
populationCurves = []
representations = []
sts = []
model = nengo.Network(seed=581)
with model:
ensA = nengo.Ensemble(n_neurons=numNeu,
dimensions=d,
encoders=E.T,
normalize_encoders=False)
for i in range(len(X)):
with model:
inp = nengo.Node(X[i])
il = nengo.Connection(inp, ensA.neurons)
inpProbe = nengo.Probe(inp)
spikes = nengo.Probe(ensA.neurons)
voltage = nengo.Probe(ensA.neurons, 'voltage')
filtered = nengo.Probe(ensA, synapse=synap)
with nengo.Simulator(model, progress_bar=False, optimize=True) as sim:
if i % 10 == 0: print("running simulation for step:", i)
sim.run(T)
# x_axis = 50 x vals
# y_axis = n_neurons * 50 y values
responseCurves = response_curves(ensA, sim)
populationCurves.append(responseCurves)
representations.append(responseCurves[1])
sts.append(sim.data[filtered].T)
if isPlot:
plt.subplot(12, 7, i + 1)
plt.plot(sim.trange(), sim.data[filtered])
plt.show()
return populationCurves, representations, sts
def test_response_curves(Simulator, NonDirectNeuronType, plt, seed):
max_rate = 400
model = nengo.Network(seed=seed)
with model:
ens = nengo.Ensemble(
10,
dimensions=10,
neuron_type=NonDirectNeuronType(),
radius=1.5,
max_rates=Uniform(200, max_rate),
)
with Simulator(model) as sim:
eval_points, activities = response_curves(ens, sim)
plot_tuning_curves(plt, eval_points, activities)
assert eval_points.ndim == 1 and eval_points.size > 0
assert np.all(eval_points >= -1.0) and np.all(eval_points <= 1.0)
if not NonDirectNeuronType.negative:
assert np.all(activities >= 0.0)
assert np.all(activities <= max_rate)
# Activities along preferred direction must increase monotonically.
assert np.all(np.diff(activities, axis=0) >= 0.0)
def response_curve_plot(ens, sim):
rc = PlotInfo("Response curves", plot="multiline")
rc.x, rc.y = response_curves(ens, sim)
rc.x_label = "Input current"
rc.y = rc.y.T
rc.y_label = "Firing rate (Hz)"
if len(rc.y.shape) == 1:
rc.y.shape = 1, rc.y.shape[0]
if ens.n_neurons > 200:
rc.warnings.append("Only showing the first 200 neurons.")
rc.y = rc.y[:200]
return rc.to_dict()
def response_curve_plot(ens, sim):
rc = PlotInfo("Response curves", plot="multiline")
rc.x, rc.y = response_curves(ens, sim)
rc.x_label = "Input current"
rc.y = rc.y.T
rc.y_label = "Firing rate (Hz)"
if len(rc.y.shape) == 1:
rc.y.shape = 1, rc.y.shape[0]
if ens.n_neurons > 200:
rc.warnings.append("Only showing the first 200 neurons.")
rc.y = rc.y[:200]
return rc.to_dict()
def test_response_curves_direct_mode(Simulator, plt, seed, dimensions):
model = nengo.Network(seed=seed)
with model:
ens = nengo.Ensemble(
10, dimensions=dimensions, neuron_type=nengo.Direct(), radius=1.5)
with Simulator(model) as sim:
eval_points, activities = response_curves(ens, sim)
plot_tuning_curves(plt, eval_points, activities)
assert eval_points.ndim == 1 and eval_points.size > 0
assert np.all(eval_points >= -1.0) and np.all(eval_points <= 1.0)
# eval_points is passed through in direct mode neurons
assert np.allclose(eval_points, activities)
def test_response_curves_direct_mode(Simulator, plt, seed, dimensions):
model = nengo.Network(seed=seed)
with model:
ens = nengo.Ensemble(
10, dimensions=dimensions, neuron_type=nengo.Direct(), radius=1.5)
with Simulator(model) as sim:
eval_points, activities = response_curves(ens, sim)
plot_tuning_curves(plt, eval_points, activities)
assert eval_points.ndim == 1 and eval_points.size > 0
assert np.all(-1.0 <= eval_points) and np.all(eval_points <= 1.0)
# eval_points is passed through in direct mode neurons
assert np.allclose(eval_points, activities)
def ensemble_infomodal(ng, uid, conn_in_uids, conn_out_uids):
ens = ng.uids[uid]
params = [(attr, str(getattr(ens, attr)))
for attr in ('n_neurons', 'dimensions', 'radius', 'encoders',
'intercepts', 'max_rates', 'eval_points',
'n_eval_points', 'neuron_type', 'noise', 'seed')
if getattr(ens, attr) is not None]
if ng.page.sim is None:
plots = ("Simulation not yet running. "
"Start a simulation to see plots.")
else:
plots = []
rc = PlotInfo("Response curves", plot="multiline")
rc.x, rc.y = response_curves(ens, ng.page.sim)
rc.y = rc.y.T
if len(rc.y.shape) == 1:
rc.y.shape = 1, rc.y.shape[0]
if ens.n_neurons > 200:
rc.warnings.append("Only showing the first 200 neurons.")
rc.y = rc.y[:200]
plots.append(rc.to_dict())
tc = PlotInfo("Tuning curves")
if ens.dimensions == 1:
tc.plot = "multiline"
tc.x, tc.y = tuning_curves(ens, ng.page.sim)
tc.y = tc.y.T
if ens.n_neurons > 200:
tc.warnings.append("Only showing the first 200 neurons.")
tc.y = tc.y[:200]
else:
tc.warnings.append("Tuning curves only shown for "
"one-dimensional ensembles.")
plots.append(tc.to_dict())
conninfo = conn_infomodal(ng, uid, conn_in_uids, conn_out_uids)
js = ['Nengo.modal.title("Details for \'%s\'");' % ng.page.get_label(ens)]
js.append('Nengo.modal.footer("close");')
js.append(
'Nengo.modal.ensemble_body("%s", %s, %s, %s);' %
(uid, json.dumps(params), json.dumps(plots), json.dumps(conninfo)))
js.append('Nengo.modal.show();')
return '\n'.join(js)
def ensemble_infomodal(ng, uid, conn_in_uids, conn_out_uids):
ens = ng.uids[uid]
params = [(attr, str(getattr(ens, attr))) for attr in (
'n_neurons', 'dimensions', 'radius', 'encoders', 'intercepts',
'max_rates', 'eval_points', 'n_eval_points', 'neuron_type',
'noise', 'seed') if getattr(ens, attr) is not None]
if ng.page.sim is None:
plots = ("Simulation not yet running. "
"Start a simulation to see plots.")
else:
plots = []
rc = PlotInfo("Response curves", plot="multiline")
rc.x, rc.y = response_curves(ens, ng.page.sim)
rc.y = rc.y.T
if len(rc.y.shape) == 1:
rc.y.shape = 1, rc.y.shape[0]
if ens.n_neurons > 200:
rc.warnings.append("Only showing the first 200 neurons.")
rc.y = rc.y[:200]
plots.append(rc.to_dict())
tc = PlotInfo("Tuning curves")
if ens.dimensions == 1:
tc.plot = "multiline"
tc.x, tc.y = tuning_curves(ens, ng.page.sim)
tc.y = tc.y.T
if ens.n_neurons > 200:
tc.warnings.append("Only showing the first 200 neurons.")
tc.y = tc.y[:200]
else:
tc.warnings.append("Tuning curves only shown for "
"one-dimensional ensembles.")
plots.append(tc.to_dict())
conninfo = conn_infomodal(ng, uid, conn_in_uids, conn_out_uids)
js = ['Nengo.modal.title("Details for \'%s\'");' % ng.page.get_label(ens)]
js.append('Nengo.modal.footer("close");')
js.append('Nengo.modal.ensemble_body("%s", %s, %s, %s);' % (
uid, json.dumps(params), json.dumps(plots), json.dumps(conninfo)))
js.append('Nengo.modal.show();')
return '\n'.join(js)
def test_response_curves(Simulator, nl_nodirect, plt, seed):
max_rate = 400
model = nengo.Network(seed=seed)
with model:
ens = nengo.Ensemble(
10, dimensions=10, neuron_type=nl_nodirect(), radius=1.5,
max_rates=Uniform(200, max_rate))
sim = Simulator(model)
eval_points, activities = response_curves(ens, sim)
plot_tuning_curves(plt, eval_points, activities)
assert eval_points.ndim == 1 and eval_points.size > 0
assert np.all(-1.0 <= eval_points) and np.all(eval_points <= 1.0)
assert np.all(activities >= 0.0)
assert np.all(activities <= max_rate)
# Activities along preferred direction must increase monotonically.
assert np.all(np.diff(activities, axis=0) >= 0.0)
def test_parabola_response_curve(seed):
lower, upper = 50, 100
with nengo.Network(seed=seed) as model:
x = nengo.Ensemble(
250,
1,
neuron_type=Parabola(),
max_rates=nengo.dists.Uniform(lower, upper),
)
with nengo.Simulator(model) as sim:
_, a = response_curves(x, sim)
max_rates = a.max(axis=0)
assert max_rates.shape == (x.n_neurons, )
assert np.all(max_rates >= lower)
assert np.all(max_rates <= upper)
min_rates = a.min(axis=0)
assert np.all(min_rates >= 0)
assert np.mean(min_rates) <= 1e-2
rasterplot(sim.trange(), sim.data[p_spikes], ax1)
ax1.set_yticks([])
ax1.set_title('Neuronal responses')
# Tuning curves
ax2 = fig.add_subplot(223)
for n, a in enumerate(['a', 'b', 'c', 'd']):
angles = np.linspace(0, 2*np.pi, 100)
vecs = np.vstack([np.sin(angles), np.cos(angles)]).T
encoded = []
for v in vecs[:]:
encoded.append(np.dot(ens.encoders[n], v))
ins, response = response_curves(ens, sim, np.array(encoded))
assert np.all(ins == encoded)
ax2.plot(angles, response.T[n])
ax2.set_xlim(0, 2*np.pi)
ax2.set_xlabel("Angle")
ax2.set_xticks(np.array([0, 0.5, 1.0, 1.5, 2.0]) * np.pi)
ax2.set_xticklabels(['$0$', '$0.5\pi$', '$\pi$', '$1.5\pi$', '$2\pi$'])
ax2.set_ylabel("Firing rate / Hz")
ax2.set_title('Tuning curves')
# Output and direction vectors
ax3 = fig.add_subplot(224)
xs, ys = sim.data[p_out].T
n_points = len(xs) - 1
# to be more tuned to this dimension.
# ### Response curves
#
# If all else fails,
# we can still get some information
# about the tuning properties
# of the neurons in the ensemble
# using the **response curve**.
# The response curve is similar to the tuning curve,
# but instead of looking at the neural response
# to a particular input stimulus,
# we are intead looking at its response
# to (relative) injected current.
# This is analogous to the tuning curves
# with the inputs aligned to the
# preferred directions of each neuron.
# In[ ]:
from nengo.utils.ensemble import response_curves
model = nengo.Network()
with model:
ens_5d = nengo.Ensemble(15, dimensions=5)
with nengo.Simulator(model) as sim:
plt.plot(*response_curves(ens_5d, sim))
plt.ylabel("Firing rate (Hz)")
plt.xlabel("x along preferred direction")
