In [5]:

    

import nengo

N = 50
D = 1
seed = 7
tau = 0.1
L = 5

train_model = nengo.Network()
with train_model:
    state = nengo.Ensemble(n_neurons=N, dimensions=D, seed=seed)
    train_signal = nengo.Node(nengo.processes.WhiteNoise(duration=L, high=10).f(), size_out=D)
    nengo.Connection(train_signal, state, synapse=None)
    
    probe_signal = nengo.Probe(train_signal, synapse=None)
    spikes = nengo.Probe(state.neurons)#, synapse=tau)


    

In [6]:

    

sim = nengo.Simulator(train_model)
sim.run(L)


    

    




Simulation finished in 0:00:01.                                                 

In [7]:

    

import pylab

pylab.plot(sim.trange(), sim.data[probe_signal])
pylab.show()


    

In [ ]:

    

import nengo.utils.matplotlib
nengo.utils.matplotlib.rasterplot(sim.trange(), sim.data[spikes], use_eventplot=True)
pylab.plot(sim.trange(), sim.data[probe_signal]*10 + 10)
pylab.xlim(0,0.5)
pylab.ylim(0,20)
pylab.show()


    

In [26]:

    

solver = nengo.solvers.LstsqL2(reg=0.1)

target = sim.data[probe_signal]**2
target = nengo.synapses.filt(target, nengo.synapses.Lowpass(tau), dt=0.001)

decoder, info = solver(sim.data[spikes], target)


    

In [27]:

    

plot(sim.trange(), numpy.dot(sim.data[spikes], decoder))
plot(sim.trange(), target)
show()


    

In [32]:

    

model = nengo.Network()
with model:
    state = nengo.Ensemble(n_neurons=N, dimensions=D, seed=seed)
    test_signal = nengo.Node(nengo.processes.WhiteNoise(duration=L, high=10).f(), size_out=D)
    nengo.Connection(test_signal, state, synapse=None)
    
    out1 = nengo.Ensemble(n_neurons=50, dimensions=D, seed=2)
    out2 = nengo.Ensemble(n_neurons=50, dimensions=D, seed=2)
    
    nengo.Connection(state, out1, function = lambda x: x**2)
    nengo.Connection(state.neurons, out2, transform=decoder.T)
    
    probe1 = nengo.Probe(out1, synapse=tau)
    probe2 = nengo.Probe(out2, synapse=tau)


    

In [34]:

    

sim2 = nengo.Simulator(model)
sim2.run(5)


    

    




Simulation finished in 0:00:10.                                                 

In [35]:

    

plot(sim2.trange(), sim2.data[probe1])
plot(sim2.trange(), sim2.data[probe2])
show()


    

In [39]:

    

import nengo

N = 500
D = 1
seed = 7
tau = 0.1
L = 10

train_model = nengo.Network()
with train_model:
    state = nengo.Ensemble(n_neurons=N, dimensions=D, seed=seed)#, neuron_type=nengo.Sigmoid())
    train_signal = nengo.Node(nengo.processes.WhiteNoise(duration=L, high=3).f(), size_out=D)
    nengo.Connection(train_signal, state, synapse=None)

    probe_signal = nengo.Probe(train_signal, synapse=None)
    spikes = nengo.Probe(state.neurons, synapse=tau)
    
    weights = numpy.random.uniform(-0.5, 0.5, size=(N, N))
    scale = 1.0 / numpy.max(numpy.abs(numpy.linalg.eigvals(weights)**2))
    weights *= scale
    nengo.Connection(state.neurons, state.neurons, transform=weights / 50, synapse=tau)


    

In [40]:

    

sim = nengo.Simulator(train_model)
sim.run(L)
plot(sim.trange(), sim.data[probe_signal])
show()
plot(sim.trange(), sim.data[spikes])
show()


    

    




Simulation finished in 0:00:05.                                                 






    













    

In [41]:

    

solver = nengo.solvers.LstsqL2(reg=0.02)

target = numpy.roll(sim.data[probe_signal], 100)
target = nengo.synapses.filt(target, nengo.synapses.Lowpass(tau), dt=0.001)

N = len(target) / 2
decoder, info = solver(sim.data[spikes][:N], target[:N])

plot(sim.trange(), numpy.dot(sim.data[spikes], decoder))
plot(sim.trange(), target)
plot(sim.trange(), nengo.synapses.filt(sim.data[probe_signal], nengo.synapses.Lowpass(tau), dt=0.001))
show()


    

In [42]:

    

def compute_error(roll):
    solver = nengo.solvers.LstsqL2(reg=0.02)
    
    target = numpy.roll(sim.data[probe_signal], roll)
    target = nengo.synapses.filt(target, nengo.synapses.Lowpass(tau), dt=0.001)
    
    N = len(target) / 2
    decoder, info = solver(sim.data[spikes][:N], target[:N])
    
    predict = numpy.dot(sim.data[spikes][N:], decoder)
    
    rms = nengo.utils.numpy.rms(target[N:] - predict, axis=0)
    
    return rms#info['rmses'][0]


    

In [43]:

    

rolls = range(-200, 401, 20)
errors = [compute_error(r) for r in rolls]


    

In [44]:

    

plot(numpy.array(rolls)*0.001, errors)
show()


    

In [ ]: