In [1]:

    

import nengo
import nengo.spa as spa

D = 16
vocab = spa.Vocabulary(D)
N = 50

tau_i = 0.03
strength_i = 20
n_layers = 4

model = nengo.Network()
with model:
    stim = nengo.Node(vocab.parse('A').v)
    stim_permute = nengo.Node(lambda t: vocab.parse('P1').v if t<0.5 else vocab.parse('P2').v)
    
    state = nengo.Ensemble(n_neurons=D * 30, dimensions=D)
    result = nengo.Ensemble(n_neurons=D * 30, dimensions=D)
    permute = nengo.Ensemble((D / 2) * n_layers, dimensions=D)
    
    nengo.Connection(stim, state)
    nengo.Connection(stim_permute, permute)
    
    def swap(in_a, in_b, out_a, out_b, control, control_index):
        ens_aa = nengo.Ensemble(n_neurons=N, dimensions=1)
        ens_ab = nengo.Ensemble(n_neurons=N, dimensions=1)
        ens_ba = nengo.Ensemble(n_neurons=N, dimensions=1)
        ens_bb = nengo.Ensemble(n_neurons=N, dimensions=1)
        nengo.Connection(in_a, ens_aa)
        nengo.Connection(in_a, ens_ab)
        nengo.Connection(in_b, ens_ba)
        nengo.Connection(in_b, ens_bb)
        nengo.Connection(ens_aa, out_a)
        nengo.Connection(ens_ab, out_b)
        nengo.Connection(ens_ba, out_a)
        nengo.Connection(ens_bb, out_b)
        switch = nengo.Ensemble(n_neurons=N, dimensions=1, 
                                intercepts=nengo.utils.distributions.Uniform(-0.9, -0.4),
                                encoders=nengo.utils.distributions.Choice([[1]]))
        nengo.Connection(switch, ens_ab.neurons, transform=[[-strength_i]] * N, synapse=tau_i)
        nengo.Connection(switch, ens_ba.neurons, transform=[[-strength_i]] * N, synapse=tau_i)
        
        t = np.zeros((N, control.size_out))
        t[:,control_index] = -strength_i
        nengo.Connection(control, ens_aa.neurons, transform=t, synapse=tau_i)
        nengo.Connection(control, ens_bb.neurons, transform=t, synapse=tau_i)
        nengo.Connection(control, switch.neurons, transform=t, synapse=tau_i)
    
    layers = [nengo.Node(None, size_in=D, size_out=D) for i in range(n_layers + 1)]
    nengo.Connection(state, layers[0], synapse=None)
    nengo.Connection(layers[-1], result, synapse=None)
    
    for layer in range(n_layers):
        order = np.random.permutation(np.arange(D))
        for i in range(D / 2):
            swap(layers[layer][order[i*2]], layers[layer][order[i*2 + 1]], 
                 layers[layer+1][order[i*2]], layers[layer+1][order[i*2+1]], 
                 permute.neurons, i + (D/2) * layer)
        
        
    p_result = nengo.Probe(result, synapse=0.03)
    p_state = nengo.Probe(state, synapse=0.03)
    
    
sim = nengo.Simulator(model)
sim.run(1)


    

    




c:\users\terry\documents\github\nengo\nengo\node.py:22: UserWarning: 'Node.size_out' is being overwritten with 'Node.size_in' since 'Node.output=None'
  warnings.warn("'Node.size_out' is being overwritten with "

In [2]:

    

plot(sim.data[p_state])
title('original')
show()
plot(sim.data[p_result])
title('permuted')
show()


    

In [ ]: