Пример #1
0
def test_inputgatedmemory(Simulator, plt, seed):
    to_memorize = 0.5
    start_memorizing = 0.4
    with nengo.Network(seed=seed) as net:
        test_input = nengo.Node(piecewise(
            {0.0: 0, 0.1: to_memorize, start_memorizing + 0.1: 0}))
        gate_input = nengo.Node(piecewise({0.0: 0, start_memorizing: 1}))
        reset_input = nengo.Node(0)

        mem = nengo.networks.InputGatedMemory(100, 1, difference_gain=5.0)
        nengo.Connection(test_input, mem.input)
        nengo.Connection(gate_input, mem.gate)
        nengo.Connection(reset_input, mem.reset)

        mem_p = nengo.Probe(mem.output, synapse=0.01)

    sim = Simulator(net)
    sim.run(0.5)

    data = sim.data[mem_p]
    t = sim.trange()

    plt.title("gating at %.1f s" % start_memorizing)
    plt.plot(t, data, label="value in memory")
    plt.axhline(to_memorize, c='k', lw=2, label="value to remember")
    plt.axvline(start_memorizing, c='k', ls=':', label="start gating")
    plt.legend(loc='best')

    assert abs(np.mean(data[t < 0.1])) < 0.01
    assert abs(np.mean(data[(t > 0.2) & (t <= 0.4)]) - 0.5) < 0.02
    assert abs(np.mean(data[t > 0.4]) - 0.5) < 0.02
Пример #2
0
def test_inputgatedmemory(Simulator):
    with nengo.Network(seed=123) as net:
        test_input = nengo.Node(piecewise({0.0: 0, 0.3: 0.5, 1.0: 0}))

        gate_input = nengo.Node(piecewise({0.0: 0, 0.8: 1}))

        reset_input = nengo.Node(0)

        mem = nengo.networks.InputGatedMemory(100, 1, difference_gain=5.0)
        nengo.Connection(test_input, mem.input)

        nengo.Connection(gate_input, mem.gate)

        nengo.Connection(reset_input, mem.reset_node)

        mem_p = nengo.Probe(mem.output, synapse=0.01)

    sim = Simulator(net)
    sim.run(1.2)

    data = sim.data[mem_p]
    trange = sim.trange()

    with Plotter(Simulator) as plt:
        plt.plot(trange, data)

        plt.savefig('test_workingmemory.test_inputgatedmemory.pdf')
        plt.close()

    assert abs(np.mean(data[trange < 0.3])) < 0.01
    assert abs(np.mean(data[(trange > 0.8) & (trange < 1.0)]) - 0.5) < 0.02
    assert abs(np.mean(data[trange > 1.0]) - 0.5) < 0.02
Пример #3
0
def test_inputgatedmemory(Simulator, plt, seed):
    to_memorize = 0.5
    start_memorizing = 0.4
    with nengo.Network(seed=seed) as net:
        test_input = nengo.Node(
            piecewise({
                0.0: 0,
                0.1: to_memorize,
                start_memorizing + 0.1: 0
            }))
        gate_input = nengo.Node(piecewise({0.0: 0, start_memorizing: 1}))
        reset_input = nengo.Node(0)

        mem = nengo.networks.InputGatedMemory(100, 1, difference_gain=5.0)
        nengo.Connection(test_input, mem.input)
        nengo.Connection(gate_input, mem.gate)
        nengo.Connection(reset_input, mem.reset)

        mem_p = nengo.Probe(mem.output, synapse=0.01)

    sim = Simulator(net)
    sim.run(0.5)

    data = sim.data[mem_p]
    t = sim.trange()

    plt.title("gating at %.1f s" % start_memorizing)
    plt.plot(t, data, label="value in memory")
    plt.axhline(to_memorize, c='k', lw=2, label="value to remember")
    plt.axvline(start_memorizing, c='k', ls=':', label="start gating")
    plt.legend(loc='best')

    assert abs(np.mean(data[t < 0.1])) < 0.01
    assert abs(np.mean(data[(t > 0.2) & (t <= 0.4)]) - 0.5) < 0.02
    assert abs(np.mean(data[t > 0.4]) - 0.5) < 0.02
Пример #4
0
def test_integrator(Simulator, nl, plt):
    model = nengo.Network(label='Integrator', seed=892)
    with model:
        model.config[nengo.Ensemble].neuron_type = nl()
        inputs = {0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}
        input = nengo.Node(piecewise(inputs))

        tau = 0.1
        T = nengo.networks.Integrator(tau, n_neurons=100, dimensions=1)
        nengo.Connection(input, T.input, synapse=tau)

        A = nengo.Ensemble(100, dimensions=1)
        nengo.Connection(A, A, synapse=tau)
        nengo.Connection(input, A, transform=tau, synapse=tau)

        input_p = nengo.Probe(input)
        A_p = nengo.Probe(A, synapse=0.01)
        T_p = nengo.Probe(T.ensemble, synapse=0.01)

    sim = Simulator(model, dt=0.001)
    sim.run(6.0)

    t = sim.trange()
    plt.plot(t, sim.data[A_p], label='Manual')
    plt.plot(t, sim.data[T_p], label='Template')
    plt.plot(t, sim.data[input_p], 'k', label='Input')
    plt.legend(loc=0)

    assert rmse(sim.data[A_p], sim.data[T_p]) < 0.2
Пример #5
0
def test_integrator(Simulator, nl):
    model = nengo.Network(label='Integrator', seed=892)
    with model:
        model.config[nengo.Ensemble].neuron_type = nl()
        inputs = {0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}
        input = nengo.Node(piecewise(inputs))

        tau = 0.1
        T = nengo.networks.Integrator(tau, n_neurons=100, dimensions=1)
        nengo.Connection(input, T.input, synapse=tau)

        A = nengo.Ensemble(100, dimensions=1)
        nengo.Connection(A, A, synapse=tau)
        nengo.Connection(input, A, transform=tau, synapse=tau)

        input_p = nengo.Probe(input)
        A_p = nengo.Probe(A, synapse=0.01)
        T_p = nengo.Probe(T.ensemble, synapse=0.01)

    sim = Simulator(model, dt=0.001)
    sim.run(6.0)

    with Plotter(Simulator, nl) as plt:
        t = sim.trange()
        plt.plot(t, sim.data[A_p], label='Manual')
        plt.plot(t, sim.data[T_p], label='Template')
        plt.plot(t, sim.data[input_p], 'k', label='Input')
        plt.legend(loc=0)
        plt.savefig('test_integrator.test_integrator.pdf')
        plt.close()

    assert rmse(sim.data[A_p], sim.data[T_p]) < 0.2
Пример #6
0
def test_node_to_neurons(Simulator, nl_nodirect):
    name = "node_to_neurons"
    N = 30

    m = nengo.Network(label=name, seed=123)
    with m:
        m.config[nengo.Ensemble].neuron_type = nl_nodirect()
        a = nengo.Ensemble(N, dimensions=1)
        inn = nengo.Node(output=np.sin)
        inh = nengo.Node(piecewise({0: 0, 2.5: 1}))
        nengo.Connection(inn, a)
        nengo.Connection(inh, a.neurons, transform=[[-2.5]] * N)

        inn_p = nengo.Probe(inn, "output")
        a_p = nengo.Probe(a, "decoded_output", synapse=0.1)
        inh_p = nengo.Probe(inh, "output")

    sim = Simulator(m)
    sim.run(5.0)
    t = sim.trange()
    ideal = np.sin(t)
    ideal[t >= 2.5] = 0

    with Plotter(Simulator, nl_nodirect) as plt:
        plt.plot(t, sim.data[inn_p], label="Input")
        plt.plot(t, sim.data[a_p], label="Neuron approx, synapse=0.1")
        plt.plot(t, sim.data[inh_p], label="Inhib signal")
        plt.plot(t, ideal, label="Ideal output")
        plt.legend(loc=0, prop={"size": 10})
        plt.savefig("test_connection.test_" + name + ".pdf")
        plt.close()

    assert np.allclose(sim.data[a_p][-10:], 0, atol=0.1, rtol=0.01)
Пример #7
0
def test_node_to_neurons(Simulator, nl_nodirect):
    name = 'node_to_neurons'
    N = 30

    m = nengo.Network(label=name, seed=123)
    with m:
        m.config[nengo.Ensemble].neuron_type = nl_nodirect()
        a = nengo.Ensemble(N, dimensions=1)
        inn = nengo.Node(output=np.sin)
        inh = nengo.Node(piecewise({0: 0, 2.5: 1}))
        nengo.Connection(inn, a)
        nengo.Connection(inh, a.neurons, transform=[[-2.5]] * N)

        inn_p = nengo.Probe(inn, 'output')
        a_p = nengo.Probe(a, 'decoded_output', synapse=0.1)
        inh_p = nengo.Probe(inh, 'output')

    sim = Simulator(m)
    sim.run(5.0)
    t = sim.trange()
    ideal = np.sin(t)
    ideal[t >= 2.5] = 0

    with Plotter(Simulator, nl_nodirect) as plt:
        plt.plot(t, sim.data[inn_p], label='Input')
        plt.plot(t, sim.data[a_p], label='Neuron approx, synapse=0.1')
        plt.plot(t, sim.data[inh_p], label='Inhib signal')
        plt.plot(t, ideal, label='Ideal output')
        plt.legend(loc=0, prop={'size': 10})
        plt.savefig('test_connection.test_' + name + '.pdf')
        plt.close()

    assert np.allclose(sim.data[a_p][-10:], 0, atol=.1, rtol=.01)
Пример #8
0
def test_ensemble_to_neurons(Simulator, nl_nodirect, plt, seed):
    N = 30

    m = nengo.Network(seed=seed)
    with m:
        m.config[nengo.Ensemble].neuron_type = nl_nodirect()
        a = nengo.Ensemble(N, dimensions=1)
        b = nengo.Ensemble(N, dimensions=1)
        inn = nengo.Node(output=np.sin)
        inh = nengo.Node(piecewise({0: 0, 0.5: 1}))
        nengo.Connection(inn, a)
        nengo.Connection(inh, b)
        nengo.Connection(b, a.neurons, transform=[[-2.5]] * N)

        inn_p = nengo.Probe(inn, 'output')
        a_p = nengo.Probe(a, 'decoded_output', synapse=0.1)
        b_p = nengo.Probe(b, 'decoded_output', synapse=0.1)
        inh_p = nengo.Probe(inh, 'output')

    with Simulator(m) as sim:
        sim.run(1.0)
    t = sim.trange()
    ideal = np.sin(t)
    ideal[t >= 0.5] = 0

    plt.plot(t, sim.data[inn_p], label='Input')
    plt.plot(t, sim.data[a_p], label='Neuron approx, pstc=0.1')
    plt.plot(t, sim.data[b_p], label='Neuron approx of inhib sig, pstc=0.1')
    plt.plot(t, sim.data[inh_p], label='Inhib signal')
    plt.plot(t, ideal, label='Ideal output')
    plt.legend(loc=0, prop={'size': 10})

    assert np.allclose(sim.data[a_p][-10:], 0, atol=.1, rtol=.01)
    assert np.allclose(sim.data[b_p][-10:], 1, atol=.1, rtol=.01)
Пример #9
0
def test_ensemble_to_neurons(Simulator, nl_nodirect, plt, seed):
    N = 30

    m = nengo.Network(seed=seed)
    with m:
        m.config[nengo.Ensemble].neuron_type = nl_nodirect()
        a = nengo.Ensemble(N, dimensions=1)
        b = nengo.Ensemble(N, dimensions=1)
        inn = nengo.Node(output=np.sin)
        inh = nengo.Node(piecewise({0: 0, 0.5: 1}))
        nengo.Connection(inn, a)
        nengo.Connection(inh, b)
        nengo.Connection(b, a.neurons, transform=[[-2.5]] * N)

        inn_p = nengo.Probe(inn, 'output')
        a_p = nengo.Probe(a, 'decoded_output', synapse=0.1)
        b_p = nengo.Probe(b, 'decoded_output', synapse=0.1)
        inh_p = nengo.Probe(inh, 'output')

    sim = Simulator(m)
    sim.run(1.0)
    t = sim.trange()
    ideal = np.sin(t)
    ideal[t >= 0.5] = 0

    plt.plot(t, sim.data[inn_p], label='Input')
    plt.plot(t, sim.data[a_p], label='Neuron approx, pstc=0.1')
    plt.plot(t, sim.data[b_p], label='Neuron approx of inhib sig, pstc=0.1')
    plt.plot(t, sim.data[inh_p], label='Inhib signal')
    plt.plot(t, ideal, label='Ideal output')
    plt.legend(loc=0, prop={'size': 10})

    assert np.allclose(sim.data[a_p][-10:], 0, atol=.1, rtol=.01)
    assert np.allclose(sim.data[b_p][-10:], 1, atol=.1, rtol=.01)
Пример #10
0
def test_node_to_neurons(Simulator, nl_nodirect):
    name = 'node_to_neurons'
    N = 30

    m = nengo.Model(name, seed=123)
    a = nengo.Ensemble(nl_nodirect(N), dimensions=1)
    inn = nengo.Node(output=np.sin)
    inh = nengo.Node(piecewise({0: 0, 2.5: 1}))
    nengo.Connection(inn, a)
    nengo.Connection(inh, a.neurons, transform=[[-2.5]]*N)

    inn_p = nengo.Probe(inn, 'output')
    a_p = nengo.Probe(a, 'decoded_output', filter=0.1)
    inh_p = nengo.Probe(inh, 'output')

    sim = Simulator(m)
    sim.run(5.0)
    t = sim.trange()
    ideal = np.sin(t)
    ideal[t >= 2.5] = 0

    with Plotter(Simulator, nl_nodirect) as plt:
        plt.plot(t, sim.data(inn_p), label='Input')
        plt.plot(t, sim.data(a_p), label='Neuron approx, filter=0.1')
        plt.plot(t, sim.data(inh_p), label='Inhib signal')
        plt.plot(t, ideal, label='Ideal output')
        plt.legend(loc=0, prop={'size': 10})
        plt.savefig('test_connection.test_' + name + '.pdf')
        plt.close()

    assert np.allclose(sim.data(a_p)[-10:], 0, atol=.1, rtol=.01)
Пример #11
0
def test_integrator(Simulator, plt, seed):
    model = nengo.Network(seed=seed)
    with model:
        inputs = {0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}
        input = nengo.Node(piecewise(inputs))

        tau = 0.1
        T = nengo.networks.Integrator(tau, n_neurons=100, dimensions=1)
        nengo.Connection(input, T.input, synapse=tau)

        A = nengo.Ensemble(100, dimensions=1)
        nengo.Connection(A, A, synapse=tau)
        nengo.Connection(input, A, transform=tau, synapse=tau)

        input_p = nengo.Probe(input, sample_every=0.01)
        A_p = nengo.Probe(A, synapse=0.01, sample_every=0.01)
        T_p = nengo.Probe(T.ensemble, synapse=0.01, sample_every=0.01)

    sim = Simulator(model)
    sim.run(6.0)

    t = sim.trange(dt=0.01)
    plt.plot(t, sim.data[A_p], label='Manual')
    plt.plot(t, sim.data[T_p], label='Template')
    plt.plot(t, sim.data[input_p], 'k', label='Input')
    plt.legend(loc='best')

    assert rmse(sim.data[A_p], sim.data[T_p]) < 0.1
Пример #12
0
def test_integrator(Simulator, nl):
    model = nengo.Model('Integrator')
    inputs = {0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}
    input = nengo.Node(piecewise(inputs))

    tau = 0.1
    T = nengo.networks.Integrator(tau, neurons=nl(100), dimensions=1)
    nengo.Connection(input, T.input, filter=tau)

    A = nengo.Ensemble(nl(100), dimensions=1)
    nengo.Connection(A, A, filter=tau)
    nengo.Connection(input, A, transform=tau, filter=tau)

    input_p = nengo.Probe(input, 'output')
    A_p = nengo.Probe(A, 'decoded_output', filter=0.01)
    T_p = nengo.Probe(T.ensemble, 'decoded_output', filter=0.01)

    sim = Simulator(model, dt=0.001)
    sim.run(6.0)

    with Plotter(Simulator, nl) as plt:
        t = sim.trange()
        plt.plot(t, sim.data(A_p), label='Manual')
        plt.plot(t, sim.data(T_p), label='Template')
        plt.plot(t, sim.data(input_p), 'k', label='Input')
        plt.legend(loc=0)
        plt.savefig('test_integrator.test_integrator.pdf')
        plt.close()

    assert rmse(sim.data(A_p), sim.data(T_p)) < 0.2
Пример #13
0
def test_oscillator(Simulator, plt, seed):
    model = nengo.Network(seed=seed)
    with model:
        inputs = {0: [1, 0], 0.5: [0, 0]}
        input = nengo.Node(piecewise(inputs), label='Input')

        tau = 0.1
        freq = 5
        T = nengo.networks.Oscillator(tau, freq, n_neurons=100)
        nengo.Connection(input, T.input)

        A = nengo.Ensemble(100, dimensions=2)
        nengo.Connection(A,
                         A,
                         synapse=tau,
                         transform=[[1, -freq * tau], [freq * tau, 1]])
        nengo.Connection(input, A)

        in_probe = nengo.Probe(input, sample_every=0.01)
        A_probe = nengo.Probe(A, synapse=0.01, sample_every=0.01)
        T_probe = nengo.Probe(T.ensemble, synapse=0.01, sample_every=0.01)

    with Simulator(model) as sim:
        sim.run(3.0)

    t = sim.trange(dt=0.01)
    plt.plot(t, sim.data[A_probe], label='Manual')
    plt.plot(t, sim.data[T_probe], label='Template')
    plt.plot(t, sim.data[in_probe], 'k', label='Input')
    plt.legend(loc='best')

    assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.2
Пример #14
0
def test_integrator(Simulator, plt, seed):
    model = nengo.Network(seed=seed)
    with model:
        inputs = {0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}
        input = nengo.Node(piecewise(inputs))

        tau = 0.1
        T = nengo.networks.Integrator(tau, n_neurons=100, dimensions=1)
        nengo.Connection(input, T.input, synapse=tau)

        A = nengo.Ensemble(100, dimensions=1)
        nengo.Connection(A, A, synapse=tau)
        nengo.Connection(input, A, transform=tau, synapse=tau)

        input_p = nengo.Probe(input, sample_every=0.01)
        A_p = nengo.Probe(A, synapse=0.01, sample_every=0.01)
        T_p = nengo.Probe(T.ensemble, synapse=0.01, sample_every=0.01)

    sim = Simulator(model)
    sim.run(6.0)

    t = sim.trange(dt=0.01)
    plt.plot(t, sim.data[A_p], label='Manual')
    plt.plot(t, sim.data[T_p], label='Template')
    plt.plot(t, sim.data[input_p], 'k', label='Input')
    plt.legend(loc='best')

    assert rmse(sim.data[A_p], sim.data[T_p]) < 0.1
Пример #15
0
def test_oscillator(Simulator, plt, seed):
    model = nengo.Network(seed=seed)
    with model:
        inputs = {0: [1, 0], 0.5: [0, 0]}
        input = nengo.Node(piecewise(inputs), label='Input')

        tau = 0.1
        freq = 5
        T = nengo.networks.Oscillator(tau, freq,  n_neurons=100)
        nengo.Connection(input, T.input)

        A = nengo.Ensemble(100, dimensions=2)
        nengo.Connection(A, A, synapse=tau,
                         transform=[[1, -freq*tau], [freq*tau, 1]])
        nengo.Connection(input, A)

        in_probe = nengo.Probe(input, sample_every=0.01)
        A_probe = nengo.Probe(A, synapse=0.01, sample_every=0.01)
        T_probe = nengo.Probe(T.ensemble, synapse=0.01, sample_every=0.01)

    sim = Simulator(model)
    sim.run(3.0)

    t = sim.trange(dt=0.01)
    plt.plot(t, sim.data[A_probe], label='Manual')
    plt.plot(t, sim.data[T_probe], label='Template')
    plt.plot(t, sim.data[in_probe], 'k', label='Input')
    plt.legend(loc='best')

    assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.2
Пример #16
0
def test_oscillator(Simulator, nl):
    model = nengo.Network(label='Oscillator', seed=789)
    with model:
        inputs = {0: [1, 0], 0.5: [0, 0]}
        input = nengo.Node(piecewise(inputs), label='Input')

        tau = 0.1
        freq = 5
        T = nengo.networks.Oscillator(
            tau, freq, label="Oscillator", neurons=nl(100))
        nengo.Connection(input, T.input)

        A = nengo.Ensemble(nl(100), label='A', dimensions=2)
        nengo.Connection(A, A, synapse=tau,
                         transform=[[1, -freq*tau], [freq*tau, 1]])
        nengo.Connection(input, A)

        in_probe = nengo.Probe(input, "output")
        A_probe = nengo.Probe(A, "decoded_output", synapse=0.01)
        T_probe = nengo.Probe(T.ensemble, "decoded_output", synapse=0.01)

    sim = Simulator(model)
    sim.run(3.0)

    with Plotter(Simulator, nl) as plt:
        t = sim.trange()
        plt.plot(t, sim.data[A_probe], label='Manual')
        plt.plot(t, sim.data[T_probe], label='Template')
        plt.plot(t, sim.data[in_probe], 'k', label='Input')
        plt.legend(loc=0)
        plt.savefig('test_oscillator.test_oscillator.pdf')
        plt.close()

    assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.3
Пример #17
0
def test_function():
    f = piecewise({0: np.sin, 0.5: np.cos})
    assert np.allclose(f(0), [np.sin(0)])
    assert np.allclose(f(0.25), [np.sin(0.25)])
    assert np.allclose(f(0.4999), [np.sin(0.4999)])
    assert np.allclose(f(0.5), [np.cos(0.5)])
    assert np.allclose(f(0.75), [np.cos(0.75)])
    assert np.allclose(f(1.0), [np.cos(1.0)])
Пример #18
0
def test_function():
    f = piecewise({0: np.sin, 0.5: np.cos})
    assert np.allclose(f(0), [np.sin(0)])
    assert np.allclose(f(0.25), [np.sin(0.25)])
    assert np.allclose(f(0.4999), [np.sin(0.4999)])
    assert np.allclose(f(0.5), [np.cos(0.5)])
    assert np.allclose(f(0.75), [np.cos(0.75)])
    assert np.allclose(f(1.0), [np.cos(1.0)])
Пример #19
0
def test_lists():
    f = piecewise({0.5: [1, 0], 1.0: [0, 1]})
    assert np.allclose(f(-10), [0, 0])
    assert np.allclose(f(0), [0, 0])
    assert np.allclose(f(0.25), [0, 0])
    assert np.allclose(f(0.5), [1, 0])
    assert np.allclose(f(0.75), [1, 0])
    assert np.allclose(f(1.0), [0, 1])
    assert np.allclose(f(1.5), [0, 1])
    assert np.allclose(f(100), [0, 1])
Пример #20
0
def test_basic():
    f = piecewise({0.5: 1, 1.0: 0})
    assert np.allclose(f(-10), [0])
    assert np.allclose(f(0), [0])
    assert np.allclose(f(0.25), [0])
    assert np.allclose(f(0.5), [1])
    assert np.allclose(f(0.75), [1])
    assert np.allclose(f(1.0), [0])
    assert np.allclose(f(1.5), [0])
    assert np.allclose(f(100), [0])
Пример #21
0
def test_lists():
    f = piecewise({0.5: [1, 0], 1.0: [0, 1]})
    assert np.allclose(f(-10), [0, 0])
    assert np.allclose(f(0), [0, 0])
    assert np.allclose(f(0.25), [0, 0])
    assert np.allclose(f(0.5), [1, 0])
    assert np.allclose(f(0.75), [1, 0])
    assert np.allclose(f(1.0), [0, 1])
    assert np.allclose(f(1.5), [0, 1])
    assert np.allclose(f(100), [0, 1])
Пример #22
0
def test_basic():
    f = piecewise({0.5: 1, 1.0: 0})
    assert np.allclose(f(-10), [0])
    assert np.allclose(f(0), [0])
    assert np.allclose(f(0.25), [0])
    assert np.allclose(f(0.5), [1])
    assert np.allclose(f(0.75), [1])
    assert np.allclose(f(1.0), [0])
    assert np.allclose(f(1.5), [0])
    assert np.allclose(f(100), [0])
Пример #23
0
def test_integrators(net):
    with net:
        piecewise_f = piecewise({0: 0, 0.2: 0.5, 1: 0, 2: -1, 3: 0, 4: 1, 5: 0})
        piecewise_inp = nengo.Node(piecewise_f)
        nengo.Connection(piecewise_inp, net.pre_integrator.input)
        input_probe = nengo.Probe(piecewise_inp)
        pre_probe = nengo.Probe(net.pre_integrator.ensemble, synapse=0.01)
        post_probe = nengo.Probe(net.post_integrator.ensemble, synapse=0.01)
    with nengo.Simulator(net) as sim:
        sim.run(6)
    plt.plot(sim.trange(), sim.data[input_probe], color='k')
    plt.plot(sim.trange(), sim.data[pre_probe], color='b')
    plt.plot(sim.trange(), sim.data[post_probe], color='g')
Пример #24
0
def test_function_list():
    def func1(t):
        return t, t ** 2, t ** 3

    def func2(t):
        return t ** 4, t ** 5, t ** 6

    f = piecewise({0: func1, 0.5: func2})
    assert np.allclose(f(0), func1(0))
    assert np.allclose(f(0.25), func1(0.25))
    assert np.allclose(f(0.4999), func1(0.4999))
    assert np.allclose(f(0.5), func2(0.5))
    assert np.allclose(f(0.75), func2(0.75))
    assert np.allclose(f(1.0), func2(1.0))
Пример #25
0
def test_function_list():
    def func1(t):
        return t, t**2, t**3

    def func2(t):
        return t**4, t**5, t**6

    f = piecewise({0: func1, 0.5: func2})
    assert np.allclose(f(0), func1(0))
    assert np.allclose(f(0.25), func1(0.25))
    assert np.allclose(f(0.4999), func1(0.4999))
    assert np.allclose(f(0.5), func2(0.5))
    assert np.allclose(f(0.75), func2(0.75))
    assert np.allclose(f(1.0), func2(1.0))
Пример #26
0
def test_oscillator(Simulator, nl):
    model = nengo.Network(label='Oscillator', seed=789)
    with model:
        model.config[nengo.Ensemble].neuron_type = nl()
        inputs = {0: [1, 0], 0.5: [0, 0]}
        input = nengo.Node(piecewise(inputs), label='Input')

        tau = 0.1
        freq = 5
        T = nengo.networks.Oscillator(tau,
                                      freq,
                                      label="Oscillator",
                                      n_neurons=100)
        nengo.Connection(input, T.input)

        A = nengo.Ensemble(100, dimensions=2)
        nengo.Connection(A,
                         A,
                         synapse=tau,
                         transform=[[1, -freq * tau], [freq * tau, 1]])
        nengo.Connection(input, A)

        in_probe = nengo.Probe(input)
        A_probe = nengo.Probe(A, synapse=0.01)
        T_probe = nengo.Probe(T.ensemble, synapse=0.01)

    sim = Simulator(model)
    sim.run(3.0)

    with Plotter(Simulator, nl) as plt:
        t = sim.trange()
        plt.plot(t, sim.data[A_probe], label='Manual')
        plt.plot(t, sim.data[T_probe], label='Template')
        plt.plot(t, sim.data[in_probe], 'k', label='Input')
        plt.legend(loc=0)
        plt.savefig('test_oscillator.test_oscillator.pdf')
        plt.close()

    assert rmse(sim.data[A_probe], sim.data[T_probe]) < 0.3
Пример #27
0
def test_invalid_length():
    with pytest.raises(Exception):
        f = piecewise({0.5: [1, 0], 1.0: [1, 0, 0]})
        assert f
Пример #28
0
def test_invalid_key():
    with pytest.raises(TypeError):
        f = piecewise({0.5: 1, 1: 0, 'a': 0.2})
        assert f
Пример #29
0
def test_controlledoscillator(Simulator, plt, rng, seed, outfile):
    f_max = 2
    T = 2   # time to hold each input for
    stims = np.array([1, 0.5, 0, -0.5, -1])  # control signal
    tau = 0.1

    with nengo.Network(seed=seed) as model:
        state = nengo.Ensemble(n_neurons=500, dimensions=3, radius=1.7)

        def feedback(x):
            x0, x1, f = x
            w = f * f_max * 2 * np.pi
            return x0 + w * tau * x1, x1 - w * tau * x0
        nengo.Connection(state, state[:2], function=feedback, synapse=tau)

        freq = nengo.Ensemble(n_neurons=100, dimensions=1)
        nengo.Connection(freq, state[2], synapse=tau)

        kick = nengo.Node(lambda t: 1 if t < 0.08 else 0)
        nengo.Connection(kick, state[0])

        control = piecewise({i * T: stim for i, stim in enumerate(stims)})
        freq_control = nengo.Node(control)

        nengo.Connection(freq_control, freq)

        p_state = nengo.Probe(state, synapse=0.03)

        if 'spinnaker' in Simulator.__module__:
            nengo_spinnaker.add_spinnaker_params(model.config)
            model.config[kick].function_of_time = True
            model.config[freq_control].function_of_time = True

    sim = Simulator(model)
    sim.run(len(stims) * T)

    data = sim.data[p_state][:, 1]

    ideal_freqs = f_max * stims  # target frequencies

    dt = 0.001
    steps = int(T / dt)
    freqs = np.fft.fftfreq(steps, d=dt)

    # compute fft for each input
    data.shape = len(stims), steps
    fft = np.fft.fft(data, axis=1)

    # compute ideal fft for each input
    ideal_data = np.zeros_like(data)
    for i in range(len(stims)):
        ideal_data[i] = np.cos(2 * np.pi
                               * ideal_freqs[i]
                               * np.arange(steps) * dt)
    ideal_fft = np.fft.fft(ideal_data, axis=1)

    # only consider the magnitude
    fft = np.abs(fft)
    ideal_fft = np.abs(ideal_fft)

    # compute the normalized dot product between the actual and ideal ffts
    score = np.zeros(len(stims))
    for i in range(len(stims)):
        score[i] = np.dot(fft[i] / np.linalg.norm(fft[i]),
                          ideal_fft[i] / np.linalg.norm(ideal_fft[i]))

    outfile.write('"n_neurons": %d,\n' % sum(
        e.n_neurons for e in model.all_ensembles))
    outfile.write('"simtime": %f,\n' % (len(stims) * T))
    outfile.write('"score": %f,\n' % np.mean(score))

    figsize = (onecolumn, 4.0) if horizontal else (onecolumn * 2, 4.0)
    setup(figsize=figsize)
    lines = []
    if type(plt).__name__ != 'Mock':
        for i, y in enumerate(np.fft.fftshift(fft, axes=1)):
            lines.append(plt.stem(np.fft.fftshift(freqs), y))
            marker, stem, base = lines[-1]
            marker.set_color(colors[i])
            marker.set_markersize(10.0)
            for s in stem:
                s.set_color(colors[i])
                s.set_linewidth(1.0)
            base.set_visible(False)
    plt.xlim(-f_max * 2, f_max * 2)
    plt.xlabel('Frequency (Hz)')
    plt.ylabel('Power of decoded value')
    plt.legend(lines, ['%gHz' % f for f in ideal_freqs],
               loc='best', prop={'size': 8})
    sns.despine()
    plt.saveas = 'results-3.svg'

    if hasattr(sim, 'close'):
        sim.close()
Пример #30
0
def test_invalid_function_length():
    with pytest.raises(ValidationError):
        f = piecewise({0.5: 0, 1.0: lambda t: [t, t**2]})
        assert f
Пример #31
0
def test_invalid_key():
    with pytest.raises(ValidationError):
        f = piecewise({0.5: 1, 1: 0, 'a': 0.2})
        assert f
Пример #32
0
from nengo.utils.functions import piecewise

model = nengo.Network(label="Inhibitory Gating")

n_neurons = 30

with model:
    A = nengo.Ensemble(n_neurons, dimensions=1, label="A")
    B = nengo.Ensemble(n_neurons, dimensions=1, label="B")
    C = nengo.Ensemble(n_neurons, dimensions=1, label="C")

    sin = nengo.Node(np.sin, label="sin")
    inhib = nengo.Node(piecewise({
        0: 0,
        2.5: 1,
        5: 0,
        7.5: 1,
        10: 0,
        12.5: 1
    }),
                       label="inhibition")

    nengo.Connection(sin, A)
    nengo.Connection(sin, B)
    nengo.Connection(inhib, A.neurons, transform=[[-2.5]] * n_neurons)
    nengo.Connection(inhib, C)
    nengo.Connection(C, B.neurons, transform=[[-2.5]] * n_neurons)

    sin_probe = nengo.Probe(sin)
    inhib_probe = nengo.Probe(inhib)
    A_probe = nengo.Probe(A, synapse=0.01)
    B_probe = nengo.Probe(B, synapse=0.01)
import nengo
import numpy as np
from nengo.utils.functions import piecewise

model = nengo.Network(label="Inhibitory Gating")

n_neurons = 30

with model:
    A = nengo.Ensemble(n_neurons, dimensions=1, label="A")
    B = nengo.Ensemble(n_neurons, dimensions=1, label="B")
    C = nengo.Ensemble(n_neurons, dimensions=1, label="C")

    sin = nengo.Node(np.sin, label="sin")
    inhib = nengo.Node(
        piecewise({0: 0, 2.5: 1, 5: 0, 7.5: 1, 10: 0, 12.5: 1}),
        label="inhibition")

    nengo.Connection(sin, A)
    nengo.Connection(sin, B)
    nengo.Connection(inhib, A.neurons, transform=[[-2.5]] * n_neurons)
    nengo.Connection(inhib, C)
    nengo.Connection(C, B.neurons, transform=[[-2.5]] * n_neurons)

    sin_probe = nengo.Probe(sin)
    inhib_probe = nengo.Probe(inhib)
    A_probe = nengo.Probe(A, synapse=0.01)
    B_probe = nengo.Probe(B, synapse=0.01)
    C_probe = nengo.Probe(C, synapse=0.01)

Пример #34
0
def test_invalid_length():
    with pytest.raises(Exception):
        f = piecewise({0.5: [1, 0], 1.0: [1, 0, 0]})
        assert f
Пример #35
0
from nengo.utils.functions import piecewise

DURATION = 5.0


def product(x):
    return x[0] * x[1]


def square(x):
    return x[0] * x[0]


model = nengo.Network(label="sum")
with model:
    input0 = nengo.Node(piecewise({0: -0.75, 1.25: 0.50, 2.5: -0.75, 3.75: 0}))
    input1 = nengo.Node(piecewise({0: 1.00, 1.25: 0.25, 2.5: -0.25, 3.75: 0}))
    ensemble0 = nengo.Ensemble(100, dimensions=1, radius=1)
    ensemble1 = nengo.Ensemble(100, dimensions=1, radius=1)
    ensemble_inp_2d = nengo.Ensemble(100, dimensions=2, radius=2)
    ensemble_prod = nengo.Ensemble(100, dimensions=1, radius=1)
    ensemble_sqr = nengo.Ensemble(100, dimensions=1, radius=1)
    nengo.Connection(input0, ensemble0)
    nengo.Connection(input1, ensemble1)
    nengo.Connection(ensemble0, ensemble_inp_2d[0])
    nengo.Connection(ensemble1, ensemble_inp_2d[1])
    nengo.Connection(ensemble_inp_2d, ensemble_prod, function=product)
    nengo.Connection(ensemble0, ensemble_sqr, function=square)
    input0_probe = nengo.Probe(input0)
    input1_probe = nengo.Probe(input1)
    ensemble0_probe = nengo.Probe(ensemble0, synapse=0.01)
Пример #36
0
import nengo
tau = 0.1
model = nengo.Model('Integrator')
integrator = nengo.networks.Integrator(tau,
                                       neurons=nengo.LIF(100),
                                       dimensions=1)
from nengo.utils.functions import piecewise
input = nengo.Node(piecewise({0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}))
nengo.Connection(input, integrator.input, filter=tau)
# (or any other linear system).

# Create the model object
import nengo
from nengo.utils.functions import piecewise
import matplotlib.pyplot as plt
import numpy as np


model = nengo.Network(label='Oscillator')
with model:
    # Create the ensemble for the oscillator
    neurons = nengo.Ensemble(200, dimensions=2, label="neurons")

    # Create an input signal
    input = nengo.Node(piecewise({0: [1, 0], 0.1: [0, 0]}), label="input")
    
    # Connect the input signal to the neural ensemble
    nengo.Connection(input, neurons)

    # Create the feedback connection
    nengo.Connection(neurons, neurons, transform=[[1, 1], [-1, 1]], synapse=0.1)
    
    input_probe = nengo.Probe(input, 'output')
    neuron_probe = nengo.Probe(neurons, 'decoded_output', synapse=0.1)
    
    
# start the simulator
sim = nengo.Simulator(model)

# dynamic plotting
Пример #38
0
    # The ensemble for the oscillator
    oscillator = nengo.Ensemble(500, dimensions=3, radius=1.7, label="oscillator")

    # The feedback connection
    def feedback(x):
        x0, x1, w = x  # These are the three variables stored in the ensemble
        return x0 + w*w_max*tau*x1, x1 - w*w_max*tau*x0, 0
    nengo.Connection(oscillator, oscillator, function=feedback, synapse=tau)

    # The ensemble for controlling the speed of oscillation
    frequency = nengo.Ensemble(100, dimensions=1, label="frequency")

    nengo.Connection(frequency, oscillator[2])

    # We need a quick input at the beginning to start the oscillator
    initial = nengo.Node(piecewise({0: [1, 0, 0], 0.15: [0, 0, 0]}), label="input")
    nengo.Connection(initial, oscillator)

    # Vary the speed over time
    input_frequency = nengo.Node(
        piecewise({0: 1, 1: 0.5, 2: 0, 3: -0.5, 4: -1}), label="frequency control")

    nengo.Connection(input_frequency, frequency)


    # Indicate which values to record
    oscillator_probe = nengo.Probe(oscillator, synapse=0.03)



import nengo_gui
Пример #39
0
def test_invalid_function_length():
    with pytest.raises(Exception):
        f = piecewise({0.5: 0, 1.0: lambda t: [t, t ** 2]})
        assert f
Пример #40
0
# more directly to the differential equation used to describe an integrator:
# $\dot{x} = \mathrm{Ax}(t) + \mathrm{Bu}(t)$ The control in this circuit is
# A in that equation. This is also the controlled integrator described in the
# book How to build a brain.

import nengo
from nengo.utils.functions import piecewise

model = nengo.Network(label='Controlled Integrator 2')
with model:
    # Make a population with 225 LIF neurons representing a 2
    # dimensional signal, with a larger radius to accommodate large inputs
    A = nengo.Ensemble(225, dimensions=2, radius=1.5, label="A")

    # Create a piecewise step function for input
    input_func = piecewise(
        {0.2: 5, 0.3: 0, 0.44: -10, 0.54: 0, 0.8: 5, 0.9: 0})
    inp = nengo.Node(output=input_func, label="input")

    # Connect the Input signal to ensemble A.
    tau = 0.1
    nengo.Connection(inp, A, transform=[[tau], [0]], synapse=0.1)

    # Another piecewise function that changes half way through the run
    control_func = piecewise({0: 0, 0.6: -0.5})
    control = nengo.Node(output=control_func, label="control")

    # Connect the "Control" signal to the second of A's two input channels
    nengo.Connection(control, A[1], synapse=0.005)

    # Note the changes from the previous example to the function being defined.
    nengo.Connection(A, A[0],
Пример #41
0
        return -x[0] * x[1]

    # INPUTS / OUTPUTS #
# Amy
    stim_amyg = nengo.Node([1])

    # OFC
    possible_stim = np.vstack(
        (np.linspace(0.1, 0.9, num=7), np.linspace(0.05, 0.6, num=7) * (-1)))
    all_stim = input_stim(possible_stim, n_trials)  # indicate number of trials
    cur_dic = stim_time(all_stim, len_stim, len_pause,
                        len_fix)  # (len_stim, len_pause,len_fix)
    # mod((length of stim),(number of features plus 1))!=0
    cur_dic = collections.OrderedDict(sorted(cur_dic.items()))

    stim_ofc = nengo.Node(piecewise(cur_dic))

    # ENSEMBLES #
    # AMYG
    amyg = nengo.Ensemble(N,
                          1,
                          radius=brad,
                          max_rates=get_maxrates(N, 100, 100),
                          neuron_type=neurontype)

    # OFC
    ofc = nengo.Ensemble(N,
                         2,
                         max_rates=get_maxrates(N, 100, 100),
                         radius=brad,
                         neuron_type=neurontype)
        c1 = scipy.special.binom(n, k)
        c2 = scipy.special.binom((n+k-1)/2, n)
        coeffs.append(c1 * c2)
    def L(x):
        accumulator = np.zeros(x.shape)
        argument = np.ones(x.shape)
        for k in range(n+1):
            accumulator += np.multiply(argument, coeffs[k])
            argument = np.multiply(argument, x)
        return 2.0**n * accumulator
    return L

model = nengo.Network(label='Integrator')
with model:
    A = nengo.Ensemble(100, dimensions=1)
    input = nengo.Node(piecewise({0:0, 0.2:1, 1:0, 2:-2, 3:0, 4:1, 5:0}))
    tau = 0.1
    conn_recurrent = nengo.Connection(A, A, transform=[[1]], synapse=tau)
    conn_input = nengo.Connection(input, A, transform=[[tau]], synapse=tau)
    input_probe = nengo.Probe(input)
    A_probe = nengo.Probe(A, synapse=0.01)

sim = nengo.Simulator(model)
# find 1-D principal components and plot

eval_points_in = np.linspace(-2.0, 2.0, 50)
eval_points_in = np.ndarray(shape=(50,1), buffer=eval_points_in)
eval_points, activities = tuning_curves(A, sim, eval_points_in)
#plt.figure()
#plt.title("Tuning curves")
#plt.plot(eval_points, activities)
Пример #43
0
        pre_ensemble = nengo.Ensemble(100, dimensions=1)
        nengo.Connection(pre_ensemble, pre_ensemble, synapse=0.1)
        nengo.Connection(pre_input, pre_ensemble, synapse=None, transform=0.1)
    with nengo.Network() as post_integrator:
        post_input = nengo.Node(size_in=1)
        post_ensemble = nengo.Ensemble(100, dimensions=1)
        nengo.Connection(post_ensemble, post_ensemble, synapse=0.1)
        nengo.Connection(post_input, post_ensemble, synapse=None, transform=0.1)
    nengo.Connection(pre_ensemble, post_input)


# In[ ]:

# Test the integrators by giving piecewise input and plotting
with net:
    piecewise_f = piecewise({0: 0, 0.2: 0.5, 1: 0, 2: -1, 3: 0, 4: 1, 5: 0})
    piecewise_inp = nengo.Node(piecewise_f)
    nengo.Connection(piecewise_inp, pre_input)
    input_probe = nengo.Probe(piecewise_inp)
    pre_probe = nengo.Probe(pre_ensemble, synapse=0.01)
    post_probe = nengo.Probe(post_ensemble, synapse=0.01)
with nengo.Simulator(net) as sim:
    sim.run(6)
plt.plot(sim.trange(), sim.data[input_probe], color='k', label="input")
plt.plot(sim.trange(), sim.data[pre_probe], color='b', label="pre integrator")
plt.plot(sim.trange(), sim.data[post_probe], color='g', label="post integrator")
plt.legend(loc='best');


# Note that the `with` statements
# are not just cosmetic;
Пример #44
0
# template which can also be used to quickly construct a harmonic oscillator
# (or any other linear system).

# Create the model object
import nengo
from nengo.utils.functions import piecewise
import matplotlib.pyplot as plt
import numpy as np

model = nengo.Network(label='Oscillator')
with model:
    # Create the ensemble for the oscillator
    neurons = nengo.Ensemble(200, dimensions=2, label="neurons")

    # Create an input signal
    input = nengo.Node(piecewise({0: [1, 0], 0.1: [0, 0]}), label="input")

    # Connect the input signal to the neural ensemble
    nengo.Connection(input, neurons)

    # Create the feedback connection
    nengo.Connection(neurons,
                     neurons,
                     transform=[[1, 1], [-1, 1]],
                     synapse=0.1)

    input_probe = nengo.Probe(input, 'output')
    neuron_probe = nengo.Probe(neurons, 'decoded_output', synapse=0.1)

# start the simulator
sim = nengo.Simulator(model)
Пример #45
0
def test_invalid_length():
    with pytest.raises(ValidationError):
        f = piecewise({0.5: [1, 0], 1.0: [1, 0, 0]})
        assert f
Пример #46
0
    manual = nengo.Node([0, 0])

    #### actions / rewards
    actions = nengo.Ensemble(100, 2, radius=1.4)  # which action to choose
    errors = nengo.networks.EnsembleArray(n_neurons=50, n_ensembles=2)
    act_times = {0: 1}
    pause = 0.5
    choice = 0.2
    time = 0
    for i in range(500):
        act_times[time] = 1
        time += pause
        act_times[time] = 0
        time += choice

    act = nengo.Node(piecewise(act_times))
    nengo.Connection(act,
                     actions.neurons,
                     transform=-2 * np.ones((actions.n_neurons, 1)))
    nengo.Connection(actions, reward)
    nengo.Connection(reward, errors.input, transform=-1)
    nengo.Connection(manual, actions)

    #### input to basal ganglia
    # random_thoughts = nengo.Node(np.sin)
    state = nengo.Ensemble(100, 2, radius=2)
    #state_integrator = nengo.Ensemble(100,1,radius=2)
    norm_state = nengo.Ensemble(100, 2, radius=2)
    # nengo.Connection(random_thoughts, state)
    nengo.Connection(state, norm_state, function=normalize)
Пример #47
0
from __future__ import division
from nengo.utils.functions import piecewise

import numpy as np
import nengo 
import matplotlib.pyplot as plt
import raphan_matrices as rmat

# MODEL PARAMETERS
# =====
TAU_RECUR = 0.1
input_func = input_func = piecewise({0: 0, 0.2: 5, 0.3: 0, 0.44: -10, 0.54: 0, 0.8: 5, 0.9: 0})
control_func = piecewise({0: 1, 0.6: 0.5}) # function to define integrator behaviour

model = nengo.Network(label='1dinteg')

with model:
    A = nengo.Ensemble(200, dimensions=2, radius=1.5)

    inp = nengo.Node(input_func)
    control = nengo.Node(output=control_func)

    # wire the stimulus input
    nengo.Connection(inp, A, transform=[[TAU_RECUR], [0]], synapse=TAU_RECUR)
    # wire the control quality input  
    nengo.Connection(control, A[1], synapse=0.005)

    # set up the recurrent input
    nengo.Connection(A, A[0],
                     function = lambda x: x[0] * x[1],
                     synapse=TAU_RECUR)
Пример #48
0
import nengo
tau = 0.1  # Post-synaptic time constant for feedback\n",
w_max = 10  # Maximum frequency is w_max/(2*pi)\n",
model = nengo.Model('Controlled Oscillator')
oscillator = nengo.Ensemble(nengo.LIF(500), dimensions=3, radius=1.7)


def feedback(x):
    x0, x1, w = x  # These are the three variables stored in the ensemble\n",
    return x0 + w * w_max * tau * x1, x1 - w * w_max * tau * x0, 0


nengo.Connection(oscillator, oscillator, function=feedback, filter=tau)
frequency = nengo.Ensemble(nengo.LIF(100), dimensions=1)
nengo.Connection(frequency, oscillator, transform=[[0], [0], [1]])

from nengo.utils.functions import piecewise

initial = nengo.Node(piecewise({0: [1, 0, 0], 0.15: [0, 0, 0]}))
nengo.Connection(initial, oscillator)
input_frequency = nengo.Node(piecewise({0: 1, 1: 0.5, 2: 0, 3: -0.5, 4: -1}))
nengo.Connection(input_frequency, frequency)
import nengo
tau = 0.1   # Post-synaptic time constant for feedback\n",
w_max = 10  # Maximum frequency is w_max/(2*pi)\n",
model = nengo.Model('Controlled Oscillator')
oscillator = nengo.Ensemble(nengo.LIF(500), dimensions=3, radius=1.7)

def feedback(x):
    x0, x1, w = x  # These are the three variables stored in the ensemble\n",
    return x0 + w*w_max*tau*x1, x1 - w*w_max*tau*x0, 0

nengo.Connection(oscillator, oscillator, function=feedback, filter=tau)
frequency = nengo.Ensemble(nengo.LIF(100), dimensions=1)
nengo.Connection(frequency, oscillator, transform=[[0], [0], [1]])

from nengo.utils.functions import piecewise

initial = nengo.Node(piecewise({0: [1, 0, 0], 0.15: [0, 0, 0]}))
nengo.Connection(initial, oscillator)
input_frequency = nengo.Node(piecewise({0: 1, 1: 0.5, 2: 0, 3: -0.5, 4: -1}))
nengo.Connection(input_frequency, frequency)
Пример #50
0
import nengo

model = nengo.Model("Inhibitory Gating")
n_neurons = 30
A = nengo.Ensemble(nengo.LIF(n_neurons), dimensions=1)
B = nengo.Ensemble(nengo.LIF(n_neurons), dimensions=1)
C = nengo.Ensemble(nengo.LIF(n_neurons), dimensions=1)

import numpy as np
from nengo.utils.functions import piecewise

sin = nengo.Node(output=np.sin)
inhib = nengo.Node(output=piecewise({
    0: 0,
    2.5: 1,
    5: 0,
    7.5: 1,
    10: 0,
    12.5: 1
}))

nengo.Connection(sin, A)
nengo.Connection(sin, B)
nengo.Connection(inhib, A.neurons, transform=[[-2.5]] * n_neurons)
nengo.Connection(inhib, C)
nengo.Connection(C, B.neurons, transform=[[-2.5]] * n_neurons)
Пример #51
0
import nengo

model = nengo.Model('Oscillator')
neurons = nengo.Ensemble(nengo.LIF(200), dimensions=2)

from nengo.utils.functions import piecewise

input = nengo.Node(output=piecewise({0: [1, 0], 0.1: [0, 0]}))
nengo.Connection(input, neurons)
nengo.Connection(neurons, neurons, transform=[[1, 1], [-1, 1]], filter=0.1)
Пример #52
0
# This next two lines make all of the encoders in the Combined population point at the
# corners of the cube. This improves the quality of the computation.
from nengo.dists import Choice
# Comment out the line below for 'normal' encoders
combined.encoders = Choice([[1, 1], [-1, 1], [1, -1], [-1, -1]])

# ## Step 2: Provide input to the model

# We will use two varying scalar values for the two input signals that drive activity in ensembles A and B.

# In[ ]:

from nengo.utils.functions import piecewise
with model:
    # Create a piecewise step function for input
    inputA = nengo.Node(piecewise({0: 0, 2.5: 10, 4: -10}))
    inputB = nengo.Node(piecewise({0: 10, 1.5: 2, 3: 0, 4.5: 2}))

    correct_ans = piecewise({0: 0, 1.5: 0, 2.5: 20, 3: 0, 4: 0, 4.5: -20})

# ## Step 3: Connect the elements of the model

# In[ ]:

with model:
    # Connect the input nodes to the appropriate ensembles
    nengo.Connection(inputA, A)
    nengo.Connection(inputB, B)

    # Connect input ensembles A and B to the 2D combined ensemble
    nengo.Connection(A, combined[0])
from nengo.utils.functions import piecewise

__author__ = 'bogdanp'

import nengo
import nengo.spa as spa

model = nengo.Network("Oscillator network")

with model:
    input = nengo.Node(piecewise({0: [1, 0], 0.1: [0, 0]}))
    osc = nengo.networks.Oscillator(1, 1, 100)
    nengo.Connection(input, osc.input)


Пример #54
0
import nengo

model = nengo.Model('Integrator')
A = nengo.Ensemble(nengo.LIF(100), dimensions=1, label='Integrator')

from nengo.utils.functions import piecewise
input = nengo.Node(piecewise({0: 0, 0.2: 1, 1: 0, 2: -2, 3: 0, 4: 1, 5: 0}), label='Piecewise input')

tau = 0.1
nengo.Connection(A, A, transform=[[1]], filter=tau) # Using a long time constant for stability\n"
nengo.Connection(input, A, transform=[[tau]], filter=tau) # The same time constant as recurrent to make it more 'ideal'"
Пример #55
0
def test_invalid_key():
    with pytest.raises(ValidationError):
        f = piecewise({0.5: 1, 1: 0, "a": 0.2})
        assert f
Пример #56
0
def test_invalid_length():
    with pytest.raises(ValidationError):
        f = piecewise({0.5: [1, 0], 1.0: [1, 0, 0]})
        assert f
# controlled integrator. We create a Network, and then we create a population
# of neurons (called an *ensemble*). This population of neurons will
# represent the state of our integrator, and the connections between
# the neurons in the ensemble will define the dynamics of our integrator.

import nengo
from nengo.utils.functions import piecewise

model = nengo.Network(label='Controlled Integrator')
with model:
    # Make a population with 225 LIF neurons representing a 2 dimensional
    # signal, with a larger radius to accommodate large inputs
    A = nengo.Ensemble(225, dimensions=2, radius=1.5, label="A")

    # Create a piecewise step function for input
    input_func = piecewise(
        {0: 0, 0.2: 5, 0.3: 0, 0.44: -10, 0.54: 0, 0.8: 5, 0.9: 0})

    # Define an input signal within our model
    inp = nengo.Node(input_func, label="input")

    # Connect the Input signal to ensemble A.
    # The `transform` argument means "connect real-valued signal "Input" to the
    # first of the two input channels of A."
    tau = 0.1
    nengo.Connection(inp, A, transform=[[tau], [0]], synapse=tau)

    # Another piecewise step that changes half way through the run
    control_func = piecewise({0: 1, 0.6: 0.5})
    control = nengo.Node(output=control_func, label="control")

    # Connect the "Control" signal to the second of A's two input channels.
Пример #58
0
import nengo

model = nengo.Model("Inhibitory Gating")
n_neurons = 30
A = nengo.Ensemble(nengo.LIF(n_neurons), dimensions=1)
B = nengo.Ensemble(nengo.LIF(n_neurons), dimensions=1)
C = nengo.Ensemble(nengo.LIF(n_neurons), dimensions=1)

import numpy as np
from nengo.utils.functions import piecewise

sin = nengo.Node(output=np.sin)
inhib = nengo.Node(output=piecewise({0: 0, 2.5: 1, 5: 0, 7.5: 1, 10: 0, 12.5: 1}))

nengo.Connection(sin, A)
nengo.Connection(sin, B)
nengo.Connection(inhib, A.neurons, transform=[[-2.5]] * n_neurons)
nengo.Connection(inhib, C)
nengo.Connection(C, B.neurons, transform=[[-2.5]] * n_neurons)