def test_seed(Simulator, seed):
with nengo.Network() as model:
a = nengo.Node(WhiteSignal(0.1, high=100, seed=seed))
b = nengo.Node(WhiteSignal(0.1, high=100, seed=seed + 1))
c = nengo.Node(WhiteSignal(0.1, high=100))
d = nengo.Node(WhiteNoise(seed=seed))
e = nengo.Node(WhiteNoise())
ap = nengo.Probe(a)
bp = nengo.Probe(b)
cp = nengo.Probe(c)
dp = nengo.Probe(d)
ep = nengo.Probe(e)
with Simulator(model) as sim1:
sim1.run(0.1)
with Simulator(model) as sim2:
sim2.run(0.1)
tols = dict(atol=1e-7, rtol=1e-4)
assert np.allclose(sim1.data[ap], sim2.data[ap], **tols)
assert np.allclose(sim1.data[bp], sim2.data[bp], **tols)
assert not np.allclose(sim1.data[cp], sim2.data[cp], **tols)
assert not np.allclose(sim1.data[ap], sim1.data[bp], **tols)
assert np.allclose(sim1.data[dp], sim2.data[dp], **tols)
assert not np.allclose(sim1.data[ep], sim2.data[ep], **tols)
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_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 test_whitenoise(rng):
dist = DistributionMock(42)
process = WhiteNoise(dist, scale=False)
samples = process.run_steps(5, d=2, rng=rng)
assert np.all(samples == 42 * np.ones((5, 2)))
assert process.run_steps(5, rng=rng).shape == (5, 1)
assert process.run_steps(1, d=1, rng=rng).shape == (1, 1)
assert process.run_steps(2, d=3, rng=rng).shape == (2, 3)
def test_whitenoise(rng):
dist = DistributionMock(42)
process = WhiteNoise(dist, scale=False)
samples = process.run_steps(5, d=2, rng=rng)
assert np.all(samples == 42 * np.ones((5, 2)))
assert process.run_steps(5, rng=rng).shape == (5, 1)
assert process.run_steps(1, d=1, rng=rng).shape == (1, 1)
assert process.run_steps(2, d=3, rng=rng).shape == (2, 3)
def test_operators():
sig = Signal(np.array([0.0]), name="sig")
assert fnmatch(repr(TimeUpdate(sig, sig)), "<TimeUpdate at 0x*>")
assert fnmatch(repr(TimeUpdate(sig, sig, tag="tag")),
"<TimeUpdate 'tag' at 0x*>")
assert fnmatch(repr(Reset(sig)), "<Reset at 0x*>")
assert fnmatch(repr(Reset(sig, tag="tag")), "<Reset 'tag' at 0x*>")
assert fnmatch(repr(Copy(sig, sig)), "<Copy at 0x*>")
assert fnmatch(repr(Copy(sig, sig, tag="tag")), "<Copy 'tag' at 0x*>")
assert fnmatch(repr(ElementwiseInc(sig, sig, sig)),
"<ElementwiseInc at 0x*>")
assert fnmatch(repr(ElementwiseInc(sig, sig, sig, tag="tag")),
"<ElementwiseInc 'tag' at 0x*>")
assert fnmatch(repr(DotInc(sig, sig, sig)), "<DotInc at 0x*>")
assert fnmatch(repr(DotInc(sig, sig, sig, tag="tag")),
"<DotInc 'tag' at 0x*>")
assert fnmatch(repr(SimPyFunc(sig, lambda x: 0.0, True, sig)),
"<SimPyFunc at 0x*>")
assert fnmatch(
repr(SimPyFunc(sig, lambda x: 0.0, True, sig, tag="tag")),
"<SimPyFunc 'tag' at 0x*>",
)
assert fnmatch(repr(SimPES(sig, sig, sig, 0.1)), "<SimPES at 0x*>")
assert fnmatch(repr(SimPES(sig, sig, sig, 0.1, tag="tag")),
"<SimPES 'tag' at 0x*>")
assert fnmatch(repr(SimBCM(sig, sig, sig, sig, 0.1)), "<SimBCM at 0x*>")
assert fnmatch(repr(SimBCM(sig, sig, sig, sig, 0.1, tag="tag")),
"<SimBCM 'tag' at 0x*>")
assert fnmatch(repr(SimOja(sig, sig, sig, sig, 0.1, 1.0)),
"<SimOja at 0x*>")
assert fnmatch(repr(SimOja(sig, sig, sig, sig, 0.1, 1.0, tag="tag")),
"<SimOja 'tag' at 0x*>")
assert fnmatch(repr(SimVoja(sig, sig, sig, sig, 1.0, sig, 1.0)),
"<SimVoja at 0x*>")
assert fnmatch(
repr(SimVoja(sig, sig, sig, sig, 0.1, sig, 1.0, tag="tag")),
"<SimVoja 'tag' at 0x*>",
)
assert fnmatch(repr(SimRLS(sig, sig, sig, sig)), "<SimRLS at 0x*>")
assert fnmatch(
repr(SimRLS(sig, sig, sig, sig, tag="tag")),
"<SimRLS 'tag' at 0x*>",
)
assert fnmatch(repr(SimNeurons(LIF(), sig, {"sig": sig})),
"<SimNeurons at 0x*>")
assert fnmatch(
repr(SimNeurons(LIF(), sig, {"sig": sig}, tag="tag")),
"<SimNeurons 'tag' at 0x*>",
)
assert fnmatch(repr(SimProcess(WhiteNoise(), sig, sig, sig)),
"<SimProcess at 0x*>")
assert fnmatch(
repr(SimProcess(WhiteNoise(), sig, sig, sig, tag="tag")),
"<SimProcess 'tag' at 0x*>",
)
def test_reset(Simulator, nl_nodirect, seed, rng):
"""Make sure resetting actually resets."""
m = nengo.Network(seed=seed)
with m:
m.config[nengo.Ensemble].neuron_type = nl_nodirect()
u = nengo.Node(output=WhiteNoise(0.15, 5).f(d=2, rng=rng))
ens = nengo.Ensemble(60, dimensions=2)
square = nengo.Ensemble(60, dimensions=2)
nengo.Connection(u, ens)
nengo.Connection(ens, square, function=lambda x: x ** 2,
solver=LstsqL2nz(weights=True))
square_p = nengo.Probe(square, synapse=0.1)
sim = Simulator(m)
sim.run(0.1)
sim.run(0.2)
first_t = sim.trange()
first_square_p = np.array(sim.data[square_p], copy=True)
sim.reset()
sim.run(0.3)
assert np.all(sim.trange() == first_t)
assert np.all(sim.data[square_p] == first_square_p)
def test_izhikevich(Simulator, plt, seed, rng):
"""Smoke test for using Izhikevich neurons.
Tests that the 6 parameter sets listed in the original paper can be
simulated in Nengo (but doesn't test any properties of them).
"""
with nengo.Network() as m:
u = nengo.Node(output=WhiteNoise(0.6, 8).f(d=1, rng=rng))
# Seed the ensembles (not network) so we get the same sort of neurons
ens_args = {'n_neurons': 4, 'dimensions': 1, 'seed': seed}
rs = nengo.Ensemble(neuron_type=nengo.Izhikevich(), **ens_args)
ib = nengo.Ensemble(neuron_type=nengo.Izhikevich(reset_voltage=-55,
reset_recovery=4),
**ens_args)
ch = nengo.Ensemble(neuron_type=nengo.Izhikevich(reset_voltage=-50,
reset_recovery=2),
**ens_args)
fs = nengo.Ensemble(neuron_type=nengo.Izhikevich(tau_recovery=0.1),
**ens_args)
lts = nengo.Ensemble(neuron_type=nengo.Izhikevich(coupling=0.25),
**ens_args)
rz = nengo.Ensemble(neuron_type=nengo.Izhikevich(tau_recovery=0.1,
coupling=0.26),
**ens_args)
ensembles = (rs, ib, ch, fs, lts, rz)
out = {}
spikes = {}
for ens in ensembles:
nengo.Connection(u, ens)
out[ens] = nengo.Probe(ens, synapse=0.05)
spikes[ens] = nengo.Probe(ens.neurons)
up = nengo.Probe(u)
sim = Simulator(m)
sim.run(0.6)
t = sim.trange()
def plot(ens, title, ix):
ax = plt.subplot(len(ensembles), 1, ix)
plt.title(title)
plt.plot(t, sim.data[out[ens]], c='k', lw=1.5)
plt.plot(t, sim.data[up], c='k', ls=':')
ax = ax.twinx()
ax.set_yticks(())
rasterplot(t, sim.data[spikes[ens]], ax=ax)
plt.figure(figsize=(10, 12))
plot(rs, "Regular spiking", 1)
plot(ib, "Intrinsically bursting", 2)
plot(ch, "Chattering", 3)
plot(fs, "Fast spiking", 4)
plot(lts, "Low-threshold spiking", 5)
plot(rz, "Resonator", 6)
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_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_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_gaussian_whitenoise(rms, rng, plt):
d = 500
t = 0.1
dt = 0.001
process = WhiteNoise(Gaussian(0., rms))
values = process.run(t, d=d, dt=dt, rng=rng)
freq, val_psd = psd(values)
trange = process.trange(t, dt=dt)
plt.subplot(2, 1, 1)
plt.title("First two dimensions of white noise process, rms=%.1f" % rms)
plt.plot(trange, values[:, :2])
plt.xlim(right=trange[-1])
plt.subplot(2, 1, 2)
plt.title("Power spectrum")
plt.plot(freq, val_psd, drawstyle='steps')
val_rms = npext.rms(values, axis=0) * np.sqrt(dt)
assert np.allclose(val_rms.mean(), rms, rtol=0.02)
assert np.allclose(val_psd[1:-1] * np.sqrt(dt), rms, rtol=0.2)
def test_gaussian_whitenoise(rms, rng, plt):
d = 500
t = 0.1
dt = 0.001
process = WhiteNoise(Gaussian(0., rms))
values = process.run(t, d=d, dt=dt, rng=rng)
freq, val_psd = psd(values)
trange = process.trange(t, dt=dt)
plt.subplot(2, 1, 1)
plt.title("First two dimensions of white noise process, rms=%.1f" % rms)
plt.plot(trange, values[:, :2])
plt.xlim(right=trange[-1])
plt.subplot(2, 1, 2)
plt.title("Power spectrum")
plt.plot(freq, val_psd, drawstyle='steps')
val_rms = npext.rms(values, axis=0) * np.sqrt(dt)
assert np.allclose(val_rms.mean(), rms, rtol=0.02)
assert np.allclose(val_psd[1:-1] * np.sqrt(dt), rms, rtol=0.2)
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_reset(Simulator, seed):
trun = 0.1
with nengo.Network() as model:
u = nengo.Node(WhiteNoise(Gaussian(0, 1), scale=False))
up = nengo.Probe(u)
with Simulator(model, seed=seed) as sim:
sim.run(trun)
x = np.array(sim.data[up])
sim.reset()
sim.run(trun)
y = np.array(sim.data[up])
assert x.shape == y.shape
assert np.allclose(x, y)
def test_reset(seed):
trun = 0.1
with nengo.Network() as model:
u = nengo.Node(WhiteNoise(Gaussian(0, 1), scale=False))
up = nengo.Probe(u)
sim = nengo.Simulator(model, seed=seed)
sim.run(trun)
x = np.array(sim.data[up])
sim.reset()
sim.run(trun)
y = np.array(sim.data[up])
assert (x == y).all()
def run_synapse(Simulator, seed, synapse, dt=1e-3, runtime=1., n_neurons=None):
model = nengo.Network(seed=seed)
with model:
u = nengo.Node(output=WhiteNoise(runtime, 5).f(
rng=np.random.RandomState(seed)))
if n_neurons is not None:
a = nengo.Ensemble(n_neurons, 1)
nengo.Connection(u, a, synapse=None)
target = a
else:
target = u
ref = nengo.Probe(target)
filtered = nengo.Probe(target, synapse=synapse)
sim = Simulator(model, dt=dt)
sim.run(runtime)
return sim.trange(), sim.data[ref], sim.data[filtered]
def test_whitenoise_rms(rms, rng, plt):
d = 500
t = 100
dt = 0.001
process = WhiteNoise(dt * t, rms=rms)
values = nengo.processes.sample(t, process, dt=dt, d=d, rng=rng)
freq, val_psd = psd(values)
trange = np.arange(1, t + 1) * dt
plt.subplot(2, 1, 1)
plt.title("First two D of white noise process, rms=%.1f" % rms)
plt.plot(trange, values[:, :2])
plt.xlim(right=trange[-1])
plt.subplot(2, 1, 2)
plt.title("Power spectrum")
plt.plot(freq, val_psd, drawstyle='steps')
assert np.allclose(np.std(values), rms, rtol=0.02)
assert np.allclose(val_psd[1:-1], rms, rtol=0.35)
def test_dt_dependence(Simulator, nl_nodirect, plt, seed, rng):
"""Neurons should not wildly change with different dt."""
with nengo.Network(seed=seed) as m:
m.config[nengo.Ensemble].neuron_type = nl_nodirect()
u = nengo.Node(output=WhiteNoise(0.1, 5).f(d=2, rng=rng))
pre = nengo.Ensemble(60, dimensions=2)
square = nengo.Ensemble(60, dimensions=2)
nengo.Connection(u, pre)
nengo.Connection(pre, square, function=lambda x: x**2)
activity_p = nengo.Probe(square.neurons,
synapse=.05,
sample_every=0.001)
out_p = nengo.Probe(square, synapse=.05, sample_every=0.001)
activity_data = []
out_data = []
dts = (0.0001, 0.001)
colors = ('b', 'g', 'r')
for c, dt in zip(colors, dts):
sim = Simulator(m, dt=dt)
sim.run(0.1)
t = sim.trange(dt=0.001)
activity_data.append(sim.data[activity_p])
out_data.append(sim.data[out_p])
plt.subplot(2, 1, 1)
plt.plot(t, sim.data[out_p], c=c)
plt.subplot(2, 1, 2)
# Just plot 5 neurons
plt.plot(t, sim.data[activity_p][..., :5], c=c)
plt.subplot(2, 1, 1)
plt.xlim(right=t[-1])
plt.ylabel("Decoded output")
plt.subplot(2, 1, 2)
plt.xlim(right=t[-1])
plt.ylabel("Neural activity")
assert rmse(activity_data[0], activity_data[1]) < ((1. / dt) * 0.01)
assert np.allclose(out_data[0], out_data[1], atol=0.05)
def test_unsupervised(Simulator, learning_rule_type, seed, rng, plt):
n = 200
m = nengo.Network(seed=seed)
with m:
u = nengo.Node(WhiteNoise(0.5, high=5).f(d=2, rng=rng))
a = nengo.Ensemble(n, dimensions=2)
u_learned = nengo.Ensemble(n, dimensions=2)
initial_weights = rng.uniform(high=1e-3,
size=(a.n_neurons, u_learned.n_neurons))
nengo.Connection(u, a)
conn = nengo.Connection(a.neurons,
u_learned.neurons,
transform=initial_weights,
learning_rule_type=learning_rule_type)
inp_p = nengo.Probe(u)
trans_p = nengo.Probe(conn, 'transform', sample_every=0.01)
ap = nengo.Probe(a, synapse=0.03)
up = nengo.Probe(u_learned, synapse=0.03)
sim = Simulator(m)
sim.run(0.5)
t = sim.trange()
name = learning_rule_type.__class__.__name__
plt.subplot(2, 1, 1)
plt.plot(t, sim.data[inp_p], label="Input")
plt.plot(t, sim.data[ap], label="Pre")
plt.plot(t, sim.data[up], label="Post")
plt.legend(loc="best", fontsize="x-small")
plt.subplot(2, 1, 2)
plt.plot(sim.trange(dt=0.01), sim.data[trans_p][..., 4])
plt.xlabel("Time (s)")
plt.ylabel("Transform weight")
plt.saveas = 'test_learning_rules.test_unsupervised_%s.pdf' % name
assert not np.all(sim.data[trans_p][0] == sim.data[trans_p][-1])
def test_whitenoise_high(high, rng, plt):
rms = 0.5
d = 500
t = 1000
dt = 0.001
process = WhiteNoise(dt * t, high, rms=rms)
values = nengo.processes.sample(t, process, dt=dt, d=d, rng=rng)
freq, val_psd = psd(values)
trange = np.arange(1, t + 1) * dt
plt.subplot(2, 1, 1)
plt.title("First two D of white noise process, high=%d Hz" % high)
plt.plot(trange, values[:, :2])
plt.xlim(right=trange[-1])
plt.subplot(2, 1, 2)
plt.title("Power spectrum")
plt.plot(freq, val_psd, drawstyle='steps')
plt.xlim(right=high * 2.0)
assert np.allclose(np.std(values, axis=1), rms, rtol=0.15)
assert np.all(val_psd[rfftfreq(t, dt) > high] < rms * 0.5)
def test_gaussian_whitenoise(Simulator, rms, seed, plt):
d = 500
process = WhiteNoise(Gaussian(0., rms), scale=False)
with nengo.Network() as model:
u = nengo.Node(process, size_out=d)
up = nengo.Probe(u)
with Simulator(model, seed=seed) as sim:
sim.run(0.3)
values = sim.data[up]
freq, val_psd = psd(values, dt=sim.dt)
trange = sim.trange()
plt.subplot(2, 1, 1)
plt.title("First two dimensions of white noise process, rms=%.1f" % rms)
plt.plot(trange, values[:, :2])
plt.xlim(right=trange[-1])
plt.subplot(2, 1, 2)
plt.title("Power spectrum")
plt.plot(freq, val_psd, drawstyle='steps')
val_rms = npext.rms(values, axis=0)
assert np.allclose(val_rms.mean(), rms, rtol=0.02)
assert np.allclose(val_psd[1:-1], rms, rtol=0.2)
import numpy as np
import nengo
import nengo_spinnaker
# Import classes
from nengo.processes import WhiteNoise
from nengo_spinnaker.utils import profiling
# Parameters to profile
dimensions = 1
ensemble_size = 200
model = nengo.Network()
with model:
# Create standard communication channel network with white noise input
inp = nengo.Node(WhiteNoise(), label="inp")
inp_p = nengo.Probe(inp)
pre = nengo.Ensemble(ensemble_size, dimensions=dimensions, label="pre")
pre_p = nengo.Probe(pre, synapse=0.01)
nengo.Connection(inp, pre)
post = nengo.Ensemble(ensemble_size, dimensions=dimensions, label="post")
posts_p = nengo.Probe(post, synapse=0.01)
nengo.Connection(pre,
post,
function=lambda x: np.random.random(dimensions))
# Setup SpiNNaker-specific options to supply white noise from on
# chip and profile the ensemble at the start of the channel
nengo_spinnaker.add_spinnaker_params(model.config)
from nengo.processes import WhiteNoise
from nengo.utils.functions import piecewise
from nengo.utils.matplotlib import rasterplot
from nengo.dists import Uniform
model = nengo.Network(label='2D Decision Integrator', seed=11)
with model:
#Input
input1 = nengo.Node(-0.5)
input2 = nengo.Node(0.5)
#Ensembles
input = nengo.Ensemble(100, dimensions=2)
MT = nengo.Ensemble(100,
dimensions=2,
noise=WhiteNoise(dist=Uniform(-0.3, 0.3)))
LIP = nengo.Ensemble(200,
dimensions=2,
noise=WhiteNoise(dist=Uniform(-0.3, 0.3)))
output = nengo.Ensemble(100,
dimensions=2,
noise=WhiteNoise(dist=Uniform(-0.3, 0.3)))
weight = 0.1
#Connecting the input signal to the input ensemble
nengo.Connection(input1, input[0], synapse=0.01)
nengo.Connection(input2, input[1], synapse=0.01)
#Providing input to MT ensemble
nengo.Connection(input, MT, synapse=0.01)
def test_sampling_shape():
process = WhiteNoise(0.1)
assert nengo.processes.sample(1, process).shape == (1, )
assert nengo.processes.sample(5, process, d=1).shape == (5, 1)
assert nengo.processes.sample(1, process, d=2).shape == (1, 2)