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 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")