def test_processes():
assert (
repr(WhiteSignal(0.2, 10, rms=0.3))
== "WhiteSignal(period=0.2, high=10, rms=0.3)"
)
check_init_args(WhiteNoise, ["dist", "scale"])
check_repr(WhiteNoise(scale=False))
assert repr(WhiteNoise()) == "WhiteNoise()"
assert repr(WhiteNoise(scale=False)) == "WhiteNoise(scale=False)"
check_init_args(FilteredNoise, ["synapse", "dist", "scale"])
check_repr(FilteredNoise(scale=False))
assert repr(FilteredNoise()) == "FilteredNoise()"
assert repr(FilteredNoise(scale=False)) == "FilteredNoise(scale=False)"
check_init_args(BrownNoise, ["dist"])
check_repr(BrownNoise())
assert repr(BrownNoise()) == "BrownNoise()"
check_init_args(PresentInput, ["inputs", "presentation_time"])
check_repr(PresentInput(inputs=np.array([1.2, 3.4]), presentation_time=5))
assert (
repr(PresentInput((1.2, 3.4), 5))
== "PresentInput(inputs=array([1.2, 3.4]), presentation_time=5)"
)
check_init_args(WhiteSignal, ["period", "high", "rms", "y0"])
check_repr(WhiteSignal(period=1.2, high=3.4, rms=5.6, y0=7.8))
assert repr(WhiteSignal(1, 2)) == "WhiteSignal(period=1, high=2)"
assert (
repr(WhiteSignal(1.2, 3.4, 5.6, 7.8))
== "WhiteSignal(period=1.2, high=3.4, rms=5.6, y0=7.8)"
)
check_init_args(Piecewise, ["data", "interpolation"])
check_repr(Piecewise(data={1: 0.1, 2: 0.2, 3: 0.3}))
assert (
repr(Piecewise({1: 0.1, 2: 0.2, 3: 0.3}))
== "Piecewise(data={1: array([0.1]), 2: array([0.2]), 3: array([0.3])})"
)
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 test_frozen():
"""Test attributes inherited from FrozenObject"""
a = WhiteNoise(dist=Gaussian(0.3, 0.2))
b = WhiteNoise(dist=Gaussian(0.3, 0.2))
c = FilteredNoise(dist=Gaussian(0.3, 0.2), synapse=Lowpass(0.02))
assert hash(a) == hash(a)
assert hash(b) == hash(b)
assert hash(c) == hash(c)
assert a == b
assert hash(a) == hash(b)
assert a != c
assert hash(a) != hash(c) # not guaranteed, but highly likely
assert b != c
assert hash(b) != hash(c) # not guaranteed, but highly likely
with pytest.raises(ValueError):
a.dist = Gaussian(0.3, 0.5) # test that dist param is frozen
with pytest.raises(ValueError):
a.dist.std = 0.4 # test that dist object is frozen
def test_noise_copies_ok(Simulator, nl_nodirect, seed, plt):
"""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.), dist=Choice([0.5]))
with nengo.Network(seed=seed) as model:
inp, gain, bias = 1, 5, 2
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])
model.config[nengo.Ensemble].noise = process
const = nengo.Node(output=inp)
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 np.allclose(sim.data[ap], sim.data[bp])
assert np.allclose(sim.data[bp], sim.data[cp])
