def test_noise_gen(Simulator, nl_nodirect, seed, plt): """Ensure that setting Ensemble.noise generates noise.""" with nengo.Network(seed=seed) as model: gain, bias = 1, 2 neg_noise, pos_noise = -4, 5 model.config[nengo.Ensemble].neuron_type = nl_nodirect() model.config[nengo.Ensemble].encoders = Choice([[1]]) model.config[nengo.Ensemble].gain = Choice([gain]) model.config[nengo.Ensemble].bias = Choice([bias]) pos = nengo.Ensemble(1, 1, noise=WhiteNoise(Gaussian(pos_noise, 0.01))) normal = nengo.Ensemble(1, 1) neg = nengo.Ensemble(1, 1, noise=WhiteNoise(Gaussian(neg_noise, 0.01))) pos_p = nengo.Probe(pos.neurons, synapse=0.1) normal_p = nengo.Probe(normal.neurons, synapse=0.1) neg_p = nengo.Probe(neg.neurons, synapse=0.1) with Simulator(model) as sim: sim.run(0.06) t = sim.trange() plt.title("bias=%d, gain=%d" % (bias, gain)) plt.plot(t, sim.data[pos_p], c='b', label="noise=%d" % pos_noise) plt.plot(t, sim.data[normal_p], c='k', label="no noise") plt.plot(t, sim.data[neg_p], c='r', label="noise=%d" % neg_noise) plt.legend(loc="best") assert np.all(sim.data[pos_p] >= sim.data[normal_p]) assert np.all(sim.data[normal_p] >= sim.data[neg_p]) assert not np.allclose(sim.data[normal_p], sim.data[pos_p]) assert not np.allclose(sim.data[normal_p], sim.data[neg_p])
def test_noise(Simulator, nl_nodirect, seed, plt): """Ensure that setting Ensemble.noise generates noise.""" with nengo.Network(seed=seed) as model: inp, gain, bias = 1, 5, 2 neg_noise, pos_noise = -4, 20 model.config[nengo.Ensemble].neuron_type = nl_nodirect() model.config[nengo.Ensemble].encoders = Choice([[1]]) model.config[nengo.Ensemble].gain = Choice([gain]) model.config[nengo.Ensemble].bias = Choice([bias]) const = nengo.Node(output=inp) pos = nengo.Ensemble( 1, 1, noise=StochasticProcess(Choice([pos_noise]))) normal = nengo.Ensemble(1, 1) neg = nengo.Ensemble( 1, 1, noise=StochasticProcess(Choice([neg_noise]))) nengo.Connection(const, pos) nengo.Connection(const, normal) nengo.Connection(const, neg) pos_p = nengo.Probe(pos.neurons, synapse=0.1) normal_p = nengo.Probe(normal.neurons, synapse=0.1) neg_p = nengo.Probe(neg.neurons, synapse=0.1) sim = Simulator(model) sim.run(0.06) t = sim.trange() plt.title("input=%d, bias=%d, gain=%d" % (inp, bias, gain)) plt.plot(t, sim.data[pos_p], c='b', label="noise=%d" % pos_noise) plt.plot(t, sim.data[normal_p], c='k', label="no noise") plt.plot(t, sim.data[neg_p], c='r', label="noise=%d" % neg_noise) plt.legend(loc="best") assert np.all(sim.data[pos_p] >= sim.data[normal_p]) assert np.all(sim.data[normal_p] >= sim.data[neg_p]) assert not np.all(sim.data[normal_p] == sim.data[pos_p]) assert not np.all(sim.data[normal_p] == sim.data[neg_p])
def test_noise_gen(Simulator, nl_nodirect, seed, plt, allclose): """Ensure that setting Ensemble.noise generates noise.""" with nengo.Network(seed=seed) as model: intercepts = -0.5 neg_noise, pos_noise = -5, 5 model.config[nengo.Ensemble].neuron_type = nl_nodirect() model.config[nengo.Ensemble].encoders = Choice([[1]]) model.config[nengo.Ensemble].intercepts = Choice([intercepts]) pos = nengo.Ensemble(1, 1, noise=WhiteNoise(Uniform(0, pos_noise))) normal = nengo.Ensemble(1, 1) neg = nengo.Ensemble(1, 1, noise=WhiteNoise(Uniform(neg_noise, 0))) pos_p = nengo.Probe(pos.neurons, synapse=0.1) normal_p = nengo.Probe(normal.neurons, synapse=0.1) neg_p = nengo.Probe(neg.neurons, synapse=0.1) with Simulator(model) as sim: sim.run(0.06) t = sim.trange() plt.title("intercepts=%d" % intercepts) plt.plot(t, sim.data[pos_p], c="b", label="noise=%d" % pos_noise) plt.plot(t, sim.data[normal_p], c="k", label="no noise") plt.plot(t, sim.data[neg_p], c="r", label="noise=%d" % neg_noise) plt.legend(loc="best") assert np.sum(sim.data[pos_p], axis=0) >= np.sum(sim.data[normal_p], axis=0) assert np.sum(sim.data[normal_p], axis=0) >= np.sum(sim.data[neg_p], axis=0) assert not allclose(sim.data[normal_p], sim.data[pos_p], record_rmse=False) assert not allclose(sim.data[normal_p], sim.data[neg_p], record_rmse=False)
def motor_cortex(command_threshold, n_neurons_per_command=30): with nengo.Network() as motor_cortex: ens_args = {'dimensions': 1, 'encoders': Choice([[1]]), 'intercepts': Choice([command_threshold])} motor_cortex.press = nengo.Ensemble(n_neurons_per_command, **ens_args) motor_cortex.release = nengo.Ensemble(n_neurons_per_command, **ens_args) return motor_cortex
def test_distributions(): check_init_args(PDF, ["x", "p"]) check_repr(PDF([1, 2, 3], [0.1, 0.8, 0.1])) assert (repr(PDF( [1, 2], [0.4, 0.6])) == "PDF(x=array([1., 2.]), p=array([0.4, 0.6]))") check_init_args(Uniform, ["low", "high", "integer"]) check_repr(Uniform(1, 3)) check_repr(Uniform(1, 4, integer=True)) assert repr(Uniform(0, 1)) == "Uniform(low=0, high=1)" assert repr(Uniform( 0, 5, integer=True)) == "Uniform(low=0, high=5, integer=True)" check_init_args(Gaussian, ["mean", "std"]) check_repr(Gaussian(0, 2)) assert repr(Gaussian(1, 0.1)) == "Gaussian(mean=1, std=0.1)" check_init_args(Exponential, ["scale", "shift", "high"]) check_repr(Exponential(2.0)) check_repr(Exponential(2.0, shift=0.1)) check_repr(Exponential(2.0, shift=0.1, high=10.0)) assert repr(Exponential(2.0)) == "Exponential(scale=2.0)" check_init_args(UniformHypersphere, ["surface", "min_magnitude"]) check_repr(UniformHypersphere()) check_repr(UniformHypersphere(surface=True)) check_repr(UniformHypersphere(min_magnitude=0.3)) assert repr(UniformHypersphere()) == "UniformHypersphere()" assert repr( UniformHypersphere(surface=True)) == "UniformHypersphere(surface=True)" check_init_args(Choice, ["options", "weights"]) check_repr(Choice([3, 2, 1])) check_repr(Choice([3, 2, 1], weights=[0.1, 0.2, 0.7])) assert repr(Choice([1, 2, 3])) == "Choice(options=array([1., 2., 3.]))" assert (repr( Choice([1, 2, 3], weights=[0.1, 0.5, 0.4]) ) == "Choice(options=array([1., 2., 3.]), weights=array([0.1, 0.5, 0.4]))") check_init_args(Samples, ["samples"]) check_repr(Samples([3, 2, 1])) assert repr(Samples([3, 2, 1])) == "Samples(samples=array([3., 2., 1.]))" check_init_args(SqrtBeta, ["n", "m"]) check_repr(SqrtBeta(3)) check_repr(SqrtBeta(3, m=2)) assert repr(SqrtBeta(3)) == "SqrtBeta(n=3)" assert repr(SqrtBeta(3, 2)) == "SqrtBeta(n=3, m=2)" check_init_args(SubvectorLength, ["dimensions", "subdimensions"]) check_repr(SubvectorLength(6)) check_repr(SubvectorLength(6, 2)) assert repr(SubvectorLength(3)) == "SubvectorLength(dimensions=3)" check_init_args(CosineSimilarity, ["dimensions"]) check_repr(CosineSimilarity(6)) assert repr(CosineSimilarity(6)) == "CosineSimilarity(dimensions=6)"
def __init__(self, theta=Uniform(-np.pi, np.pi), freq=Uniform(0.2, 2), phase=Uniform(-np.pi, np.pi), sigma_x=Choice([0.45]), sigma_y=Choice([0.45])): self.theta = theta self.freq = freq self.phase = phase self.sigma_x = sigma_x self.sigma_y = sigma_y
def test_choice_errors(): with pytest.raises(ValidationError, match="Number of weights.*must match.*options"): Choice([2], [1, 2, 3]) with pytest.raises(ValidationError, match="All weights must be non-negative"): Choice([2], [-1]) with pytest.raises(ValidationError, match="Sum of weights must be positive"): Choice([1, 2], [0, 0]) with pytest.raises(ValidationError, match="Options must be of dimensionality 1"): Choice([0]).sample(n=2, d=1)
def RhythmicDMP(n_per_d, freq, forcing_f, tau=0.025, net=None): if net is None: net = nengo.Network(label="Rhythmic DMP") out_dims = forcing_f(0.).size omega = freq * tau * 2 * np.pi with net: # --- Decode forcing_f from oscillator net.osc = nengo.Ensemble(n_per_d * 2, dimensions=2, intercepts=Exponential(0.15, 0.3, 0.6), label=forcing_f.__name__) nengo.Connection(net.osc, net.osc, synapse=tau, transform=[[1, -omega], [omega, 1]]) net.output = nengo.Node(size_in=out_dims) nengo.Connection(net.osc, net.output, function=radial_f(forcing_f), synapse=None) # --- Drive the oscillator to a starting position net.reset = nengo.Node(size_in=1) d_intercepts = Exponential(0.2, -0.5, 0.1) net.diff_inhib = nengo.Ensemble(20, dimensions=1, intercepts=d_intercepts, encoders=Choice([[1]])) net.diff = nengo.Ensemble(n_per_d, dimensions=2) nengo.Connection(net.reset, net.diff_inhib, transform=-1, synapse=None) nengo.Connection(net.diff_inhib.neurons, net.diff.neurons, transform=-np.ones((n_per_d, 20))) nengo.Connection(net.osc, net.diff) reset_goal = np.array([-1, omega * 0]) nengo.Connection(net.diff, net.osc, function=lambda x: reset_goal - x) # --- Inhibit the oscillator by default i_intercepts = Exponential(0.15, -0.5, 0.1) net.inhibit = nengo.Ensemble(20, dimensions=1, intercepts=i_intercepts, encoders=Choice([[1]])) nengo.Connection(net.inhibit.neurons, net.osc.neurons, transform=-np.ones((n_per_d * 2, 20))) # --- Disinhibit when appropriate net.disinhibit = nengo.Node(size_in=1) nengo.Connection(net.disinhibit, net.inhibit, transform=-1) return net
def _test_rates(Simulator, rates, plt, seed, name=None): if name is None: name = rates.__name__ n = 100 intercepts = np.linspace(-0.99, 0.99, n) model = nengo.Network(seed=seed) with model: model.config[nengo.Ensemble].max_rates = Choice([50]) model.config[nengo.Ensemble].encoders = Choice([[1]]) u = nengo.Node(output=WhiteNoise(2., 5).f( rng=np.random.RandomState(seed=seed))) a = nengo.Ensemble(n, 1, intercepts=intercepts, neuron_type=nengo.LIFRate()) b = nengo.Ensemble(n, 1, intercepts=intercepts, neuron_type=nengo.LIF()) nengo.Connection(u, a, synapse=0) nengo.Connection(u, b, synapse=0) up = nengo.Probe(u) ap = nengo.Probe(a.neurons) bp = nengo.Probe(b.neurons) sim = Simulator(model) sim.run(2.) t = sim.trange() x = sim.data[up] a_rates = sim.data[ap] spikes = sim.data[bp] b_rates = rates(t, spikes) ax = plt.subplot(411) plt.plot(t, x) ax = plt.subplot(412) implot(plt, t, intercepts, a_rates.T, ax=ax) ax.set_ylabel('intercept') ax = plt.subplot(413) implot(plt, t, intercepts, b_rates.T, ax=ax) ax.set_ylabel('intercept') ax = plt.subplot(414) implot(plt, t, intercepts, (b_rates - a_rates).T, ax=ax) ax.set_xlabel('time [s]') ax.set_ylabel('intercept') plt.saveas = 'utils.test_neurons.test_rates.%s.pdf' % name tmask = (t > 0.1) & (t < 1.9) relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask]) return relative_rmse
def _test_rates(Simulator, rates, plt, seed): n = 100 intercepts = np.linspace(-0.99, 0.99, n) model = nengo.Network(seed=seed) with model: model.config[nengo.Ensemble].max_rates = Choice([50]) model.config[nengo.Ensemble].encoders = Choice([[1]]) u = nengo.Node(output=WhiteSignal(2, high=5)) a = nengo.Ensemble(n, 1, intercepts=intercepts, neuron_type=nengo.LIFRate()) b = nengo.Ensemble(n, 1, intercepts=intercepts, neuron_type=nengo.LIF()) nengo.Connection(u, a, synapse=0) nengo.Connection(u, b, synapse=0) up = nengo.Probe(u) ap = nengo.Probe(a.neurons) bp = nengo.Probe(b.neurons) with Simulator(model, seed=seed + 1) as sim: sim.run(2.) t = sim.trange() x = sim.data[up] a_rates = sim.data[ap] spikes = sim.data[bp] b_rates = rates(t, spikes) if plt is not None: ax = plt.subplot(411) plt.plot(t, x) ax = plt.subplot(412) implot(plt, t, intercepts, a_rates.T, ax=ax) ax.set_ylabel('intercept') ax = plt.subplot(413) implot(plt, t, intercepts, b_rates.T, ax=ax) ax.set_ylabel('intercept') ax = plt.subplot(414) implot(plt, t, intercepts, (b_rates - a_rates).T, ax=ax) ax.set_xlabel('time [s]') ax.set_ylabel('intercept') tmask = (t > 0.1) & (t < 1.9) relative_rmse = rms(b_rates[tmask] - a_rates[tmask]) / rms(a_rates[tmask]) return relative_rmse
def motor_cortex(command_threshold, n_neurons_per_command=30, ens_config=None, net=None): if net is None: net = nengo.Network() if ens_config is None: ens_config = nengo.Config(nengo.Ensemble) ens_config[nengo.Ensemble].encoders = Choice([[1]]) ens_config[nengo.Ensemble].intercepts = Choice([command_threshold]) with net: with ens_config: net.press = nengo.Ensemble(n_neurons_per_command, dimensions=1) net.release = nengo.Ensemble(n_neurons_per_command, dimensions=1) return net
class LoihiSpikingRectifiedLinear(SpikingRectifiedLinear): """Simulate spiking rectified linear neurons as done by Loihi. On Loihi, the inter-spike interval has to be an integer. This causes aliasing in the firing rates such that a wide variety of inputs produce the same output firing rate. This class reproduces this effect. It can be used in e.g. ``nengo`` or ``nengo_dl`` to reproduce these unique Loihi effects. """ state = { "voltage": Choice([0]), } def __init__(self, amplitude=1, **kwargs): super().__init__(amplitude=amplitude, **kwargs) install_dl_builders() def rates(self, x, gain, bias, dt=0.001): return loihi_spikingrectifiedlinear_rates(self, x, gain, bias, dt) def step(self, dt, J, output, voltage): voltage += J * dt spikes_mask = voltage > 1 output[:] = spikes_mask * (self.amplitude / dt) voltage[voltage < 0] = 0 voltage[spikes_mask] = 0
def test_all_negative_activities(allclose, plt, seed, Simulator, Solver): class CheckActivitiesSolver(Solver): def __call__(self, A, Y, rng=np.random): assert np.all(A < 0) return super().__call__(A, Y, rng=rng) val = -0.5 with nengo.Network(seed=seed) as net: input = nengo.Node(output=val, label="input") ens = nengo.Ensemble( 30, 1, neuron_type=nengo.Tanh(), encoders=Choice([[1]]), intercepts=Uniform(0, 0.95), eval_points=Uniform(-1, -0.1), ) nengo.Connection(input, ens) in_p = nengo.Probe(input, "output") ens_p = nengo.Probe( ens, "decoded_output", synapse=0.05, solver=CheckActivitiesSolver() ) with Simulator(net) as sim: sim.run(0.3) t = sim.trange() plt.plot(t, sim.data[in_p], label="Input") plt.plot(t, sim.data[ens_p], label="Neuron approximation, pstc=0.05") plt.xlim(right=t[-1]) plt.legend(loc=0) assert allclose(sim.data[in_p], val, atol=0.1, rtol=0.01) assert allclose(sim.data[ens_p][-10:], val, atol=0.1, rtol=0.01)
def Thalamus(dimensions, n_neurons_per_ensemble=50, mutual_inhib=1, threshold=0, net=None): """Inhibits non-selected actions. Converts basal ganglia output into a signal with (approximately) 1 for the selected action and 0 elsewhere. """ if net is None: net = nengo.Network("Thalamus") with net: net.actions = EnsembleArray(n_neurons_per_ensemble, dimensions, intercepts=Uniform(threshold, 1), encoders=Choice([[1.0]]), label="actions") nengo.Connection(net.actions.output, net.actions.input, transform=(np.eye(dimensions) - 1) * mutual_inhib) net.bias = nengo.Node([1], label="thalamus bias") nengo.Connection(net.bias, net.actions.input, transform=np.ones((dimensions, 1))) net.input = net.actions.input net.output = net.actions.output return net
def __init__(self, n_neurons, dimensions, radius=1.0, encoders=nengo.Default, **ens_kwargs): super(Product, self).__init__(self) with self: self.config[nengo.Ensemble].update(ens_kwargs) self.A = nengo.Node(size_in=dimensions, label="A") self.B = nengo.Node(size_in=dimensions, label="B") self.dimensions = dimensions if encoders is nengo.Default: encoders = Choice([[1, 1], [1, -1], [-1, 1], [-1, -1]]) optimizer = SubvectorRadiusOptimizer(n_neurons, 2, ens_kwargs=ens_kwargs) scaled_r = radius * optimizer.find_optimal_radius(dimensions, 1) self.product = EnsembleArray(n_neurons, n_ensembles=dimensions, ens_dimensions=2, radius=scaled_r, encoders=encoders, **ens_kwargs) nengo.Connection(self.A, self.product.input[::2], synapse=None) nengo.Connection(self.B, self.product.input[1::2], synapse=None) self.output = self.product.add_output('product', lambda x: x[0] * x[1])
def make_mem_network(net, n_neurons, dimensions, make_mem_func, make_mem_args, make_diff_func, make_diff_args, mem_synapse=0.1, fdbk_transform=1.0, input_transform=1.0, difference_gain=1.0, gate_gain=3): with net: net.input = nengo.Node(size_in=dimensions) # integrator to store value if np.isscalar(fdbk_transform): fdbk_matrix = np.eye(dimensions) * fdbk_transform else: fdbk_matrix = np.matrix(fdbk_transform) net.mem = make_mem_func(n_neurons=n_neurons, dimensions=dimensions, label="mem", **make_mem_args) if isinstance(net.mem, nengo.Network): mem_output = net.mem.output mem_input = net.mem.input else: mem_output = mem_input = net.mem nengo.Connection(mem_output, mem_input, synapse=mem_synapse, transform=fdbk_matrix) # calculate difference between stored value and input net.diff = make_diff_func(n_neurons=n_neurons, dimensions=dimensions, label="Diff", **make_diff_args) if isinstance(net.diff, nengo.Network): net.diff_input = net.diff.input diff_output = net.diff.output else: net.diff_input = diff_output = net.diff nengo.Connection(net.input, net.diff_input, synapse=None, transform=net.input_transform) nengo.Connection(mem_output, net.diff_input, transform=-1) # feed difference into integrator nengo.Connection(diff_output, mem_input, transform=difference_gain, synapse=mem_synapse) # gate difference (if gate==0, update stored value, # otherwise retain stored value) # Note: A node is used for the input to make reset circuit more # straightforward net.gate = nengo.Ensemble(n_neurons, 1, encoders=Choice([[1]]), intercepts=Exponential(0.15, 0.5, 1), label='Gate') if isinstance(net.diff, nengo.Network): for e in net.diff.ensembles: nengo.Connection(net.gate, e.neurons, transform=[[-gate_gain]] * e.n_neurons) else: nengo.Connection(net.gate, net.diff.neurons, transform=[[-gate_gain]] * e.n_neurons) # Make output net.output = net.mem.output
def AuditoryPeriphery(freqs, sound_process, auditory_filter, neurons_per_freq=12, fs=50000., adaptive_neurons=False, net=None): if net is None: net = nengo.Network(label="Auditory Periphery") net.freqs = freqs net.sound_process = sound_process net.auditory_filter = auditory_filter net.fs = fs with net: # Inner hair cell activity net.fb = AuditoryFilterBank(freqs, sound_process, filterbank=auditory_filter, samplerate=fs) net.ihc = nengo.Node(output=net.fb, size_out=freqs.size) # Cochlear neurons projecting down auditory nerve neuron_type = nengo.AdaptiveLIF() if adaptive_neurons else nengo.LIF() net.an = nengo.networks.EnsembleArray(neurons_per_freq, freqs.size, intercepts=Uniform(-0.1, 0.5), encoders=Choice([[1]]), neuron_type=neuron_type) nengo.Connection(net.ihc, net.an.input) return net
def Product(neuron_per_dimension, input_magnitude): model = nengo.Network(label="Product") with model: model.A = nengo.Node(output=None, size_in=1) model.B = nengo.Node(output=None, size_in=1) model.combined = nengo.Ensemble(neuron_per_dimension * 2, dimensions=2, radius=np.sqrt(input_magnitude**2 + input_magnitude**2), encoders=Choice([[1, 1], [-1, 1], [1, -1], [-1, -1]])) model.prod = nengo.Ensemble(neuron_per_dimension, dimensions=1, radius=input_magnitude * 2) nengo.Connection(model.A, model.combined[0], synapse=None) nengo.Connection(model.B, model.combined[1], synapse=None) def product(x): return x[0] * x[1] nengo.Connection(model.combined, model.prod, function=product) return model
class SpikingRectifiedLinear(RectifiedLinear): """A rectified integrate and fire neuron model. Each neuron is modeled as a rectified line. That is, the neuron's activity scales linearly with current, unless the current is less than zero, at which point the neural activity will stay at zero. This is a spiking version of the RectifiedLinear neuron model. Parameters ---------- amplitude : float Scaling factor on the neuron output. Corresponds to the relative amplitude of the output spikes of the neuron. initial_state : {str: Distribution or array_like} Mapping from state variables names to their desired initial value. These values will override the defaults set in the class's state attribute. """ state = {"spikes": Choice([0]), "voltage": Uniform(low=0, high=1)} def rates(self, x, gain, bias): """Use RectifiedLinear to determine rates.""" J = self.current(x, gain, bias) out = np.zeros_like(J) RectifiedLinear.step(self, dt=1.0, J=J, rates=out) return out def step(self, dt, J, spikes, voltage): """Implement the integrate and fire nonlinearity.""" voltage += np.maximum(J, 0) * dt n_spikes = np.floor(voltage) spikes[:] = (self.amplitude / dt) * n_spikes voltage -= n_spikes
def sample(self, num, d=1, rng=np.random): """Samples ``n`` points in ``d`` dimensions.""" y = self._sample(d, rng) r = 1./np.max(np.abs(y), axis=0) assert r.shape == (d,) rI = r*np.eye(d) return Choice(np.vstack([rI, -rI])).sample(num, d=d, rng=rng)
def __init__(self, dimensions, n_neurons_per_ensemble=50, mutual_inhib=1.0, threshold=0.0, **kwargs): if "net" in kwargs: raise ObsoleteError("The 'net' argument is no longer supported.") kwargs.setdefault("label", "Thalamus") super().__init__(**kwargs) with self: self.actions = EnsembleArray( n_neurons_per_ensemble, dimensions, intercepts=Uniform(threshold, 1), encoders=Choice([[1.0]]), label="actions", ) nengo.Connection( self.actions.output, self.actions.input, transform=(np.eye(dimensions) - 1) * mutual_inhib, ) self.bias = nengo.Node([1], label="thalamus bias") nengo.Connection(self.bias, self.actions.input, transform=np.ones((dimensions, 1))) self.input = self.actions.input self.output = self.actions.output
def make_thresh_ens_net(self, threshold=0.5, thresh_func=lambda x: 1, exp_scale=None, num_ens=1, net=None, **args): if net is None: label_str = args.get('label', 'Threshold_Ens_Net') net = nengo.Network(label=label_str) if exp_scale is None: exp_scale = (1 - threshold) / 10.0 with net: ens_args = dict(args) ens_args['n_neurons'] = args.get('n_neurons', self.n_neurons_ens) ens_args['dimensions'] = args.get('dimensions', 1) ens_args['intercepts'] = \ Exponential(scale=exp_scale, shift=threshold, high=1) ens_args['encoders'] = Choice([[1]]) ens_args['eval_points'] = Uniform(min(threshold + 0.1, 1.0), 1.1) ens_args['n_eval_points'] = 5000 net.input = nengo.Node(size_in=num_ens) net.output = nengo.Node(size_in=num_ens) for i in range(num_ens): thresh_ens = nengo.Ensemble(**ens_args) nengo.Connection(net.input[i], thresh_ens, synapse=None) nengo.Connection(thresh_ens, net.output[i], function=thresh_func, synapse=None) return net
def Product_2D_ens(n_neurons, dimensions, input_magnitude=1, config=None, net=None): """Computes the element-wise product of two equally sized vectors.""" if net is None: net = nengo.Network(label="Product") if config is None: config = nengo.Config(nengo.Ensemble) config[nengo.Ensemble].encoders = Choice([[1, 1], [1, -1], [-1, 1], [-1, -1]]) with net, config: net.A = nengo.Node(size_in=dimensions, label="A") net.B = nengo.Node(size_in=dimensions, label="B") net.output = nengo.Node(size_in=dimensions, label="output") net.product = EnsembleArray(n_neurons, n_ensembles=dimensions, ens_dimensions=2, radius=input_magnitude * np.sqrt(2)) nengo.Connection(net.A, net.product.input[::2], synapse=None) nengo.Connection(net.B, net.product.input[1::2], synapse=None) net.output = net.product.add_output('product', lambda x: x[0] * x[1]) return net
def Product(neuron_per_dimension, input_magnitude): # Create the model object model = nengo.Network(label='Product') with model: # Create passthrough nodes to redirect both inputs model.A = nengo.Node(output=None, size_in=1) model.B = nengo.Node(output=None, size_in=1) model.combined = nengo.Ensemble(neuron_per_dimension * 2, dimensions=2, radius=np.sqrt(input_magnitude**2 + input_magnitude**2), encoders=Choice([[1, 1], [-1, 1], [1, -1], [-1, -1]])) model.prod = nengo.Ensemble(neuron_per_dimension, dimensions=1, radius=input_magnitude * 2) # Connect everything up nengo.Connection(model.A, model.combined[0], synapse=None) nengo.Connection(model.B, model.combined[1], synapse=None) def product(x): return x[0] * x[1] nengo.Connection(model.combined, model.prod, function=product) return model
def test_noise_copies_ok(Simulator, NonDirectNeuronType, seed, plt, allclose): """Make sure the same noise process works in multiple ensembles. We test this both with the default system and without. """ process = FilteredNoise(synapse=nengo.Alpha(1.0), dist=Choice([[0.5]])) with nengo.Network(seed=seed) as model: if ( NonDirectNeuronType.spiking or RegularSpiking in NonDirectNeuronType.__bases__ ): neuron_type = NonDirectNeuronType(initial_state={"voltage": Choice([0])}) else: neuron_type = NonDirectNeuronType() model.config[nengo.Ensemble].neuron_type = neuron_type model.config[nengo.Ensemble].encoders = Choice([[1]]) model.config[nengo.Ensemble].gain = Choice([5]) model.config[nengo.Ensemble].bias = Choice([2]) model.config[nengo.Ensemble].noise = process const = nengo.Node(output=1) a = nengo.Ensemble(1, 1, noise=process) b = nengo.Ensemble(1, 1, noise=process) c = nengo.Ensemble(1, 1) # defaults to noise=process nengo.Connection(const, a) nengo.Connection(const, b) nengo.Connection(const, c) ap = nengo.Probe(a.neurons, synapse=0.01) bp = nengo.Probe(b.neurons, synapse=0.01) cp = nengo.Probe(c.neurons, synapse=0.01) with Simulator(model) as sim: sim.run(0.06) t = sim.trange() plt.subplot(2, 1, 1) plt.plot(t, sim.data[ap], lw=3) plt.plot(t, sim.data[bp], lw=2) plt.plot(t, sim.data[cp]) plt.subplot(2, 1, 2) plt.plot(*nengo.utils.ensemble.tuning_curves(a, sim), lw=3) plt.plot(*nengo.utils.ensemble.tuning_curves(b, sim), lw=2) plt.plot(*nengo.utils.ensemble.tuning_curves(c, sim)) assert allclose(sim.data[ap], sim.data[bp]) assert allclose(sim.data[bp], sim.data[cp])
def __init__(self, base_type, amplitude=1.0, initial_state=None): if "voltage" in base_type.state: raise ValidationError( "Cannot already have a 'voltage' state variable", attr="base_type", obj=self, ) self.state = {"spikes": Choice([0]), "voltage": Uniform(low=0, high=1)} super().__init__(base_type, amplitude=amplitude, initial_state=initial_state)
def test_argreprs(): def check_init_args(cls, args): assert getfullargspec(cls.__init__).args[1:] == args def check_repr(obj): assert eval(repr(obj)) == obj check_init_args(PDF, ["x", "p"]) check_repr(PDF([1, 2, 3], [0.1, 0.8, 0.1])) check_init_args(Uniform, ["low", "high", "integer"]) check_repr(Uniform(1, 3)) check_repr(Uniform(1, 4, integer=True)) check_init_args(Gaussian, ["mean", "std"]) check_repr(Gaussian(0, 2)) check_init_args(Exponential, ["scale", "shift", "high"]) check_repr(Exponential(2.0)) check_repr(Exponential(2.0, shift=0.1)) check_repr(Exponential(2.0, shift=0.1, high=10.0)) check_init_args(UniformHypersphere, ["surface", "min_magnitude"]) check_repr(UniformHypersphere()) check_repr(UniformHypersphere(surface=True)) check_repr(UniformHypersphere(min_magnitude=0.3)) check_init_args(Choice, ["options", "weights"]) check_repr(Choice([3, 2, 1])) check_repr(Choice([3, 2, 1], weights=[0.1, 0.2, 0.7])) check_init_args(Samples, ["samples"]) check_repr(Samples([3, 2, 1])) check_init_args(SqrtBeta, ["n", "m"]) check_repr(SqrtBeta(3)) check_repr(SqrtBeta(3, m=2)) check_init_args(SubvectorLength, ["dimensions", "subdimensions"]) check_repr(SubvectorLength(6)) check_repr(SubvectorLength(6, 2)) check_init_args(CosineSimilarity, ["dimensions"]) check_repr(CosineSimilarity(6))
def test_argreprs(): def check_init_args(cls, args): assert getfullargspec(cls.__init__).args[1:] == args def check_repr(obj): assert eval(repr(obj)) == obj check_init_args(PDF, ['x', 'p']) check_repr(PDF([1, 2, 3], [0.1, 0.8, 0.1])) check_init_args(Uniform, ['low', 'high', 'integer']) check_repr(Uniform(1, 3)) check_repr(Uniform(1, 4, integer=True)) check_init_args(Gaussian, ['mean', 'std']) check_repr(Gaussian(0, 2)) check_init_args(Exponential, ['scale', 'shift', 'high']) check_repr(Exponential(2.)) check_repr(Exponential(2., shift=0.1)) check_repr(Exponential(2., shift=0.1, high=10.)) check_init_args(UniformHypersphere, ['surface', 'min_magnitude']) check_repr(UniformHypersphere()) check_repr(UniformHypersphere(surface=True)) check_repr(UniformHypersphere(min_magnitude=0.3)) check_init_args(Choice, ['options', 'weights']) check_repr(Choice([3, 2, 1])) check_repr(Choice([3, 2, 1], weights=[0.1, 0.2, 0.7])) check_init_args(Samples, ['samples']) check_repr(Samples([3, 2, 1])) check_init_args(SqrtBeta, ['n', 'm']) check_repr(SqrtBeta(3)) check_repr(SqrtBeta(3, m=2)) check_init_args(SubvectorLength, ['dimensions', 'subdimensions']) check_repr(SubvectorLength(6)) check_repr(SubvectorLength(6, 2)) check_init_args(CosineSimilarity, ['dimensions']) check_repr(CosineSimilarity(6))
def test_choice(weights, rng): n = 1000 choices = [[1, 1], [1, -1], [-1, 1], [-1, -1]] N = len(choices) dist = Choice(choices, weights=weights) # If d is passed, it has to match with pytest.raises(ValueError): dist.sample(n, d=4, rng=rng) sample = dist.sample(n, rng=rng) tsample, tchoices = list(map(tuple, sample)), list(map(tuple, choices)) # check that frequency of choices matches weights inds = [tchoices.index(s) for s in tsample] hist, bins = np.histogram(inds, bins=np.linspace(-0.5, N - 0.5, N + 1)) p_empirical = hist / float(hist.sum()) p = np.ones(N) / N if dist.p is None else dist.p sterr = 1. / np.sqrt(n) # expected maximum standard error assert np.allclose(p, p_empirical, atol=2 * sterr)
def thresh_ens_config(self): cfg = nengo.Config(nengo.Ensemble) cfg[nengo.Ensemble].update({ 'radius': 1, 'intercepts': Uniform(0.5, 1.0), 'encoders': Choice([[1]]), 'eval_points': Uniform(0.75, 1.1), 'n_eval_points': self.n_eval_points, }) return cfg