def test_probeable(): net = nengo.Network() def check_learning_rule(learning_rule_type, expected, net=net): assert learning_rule_type.probeable == expected post = net.e if isinstance(learning_rule_type, Voja) else net.n transform = np.ones( (1, 10)) if isinstance(learning_rule_type, Voja) else 1.0 conn = nengo.Connection(net.n, post, transform=transform, learning_rule_type=learning_rule_type) assert conn.learning_rule.probeable == expected with net: net.e = nengo.Ensemble(10, 1) net.n = net.e.neurons check_learning_rule(nengo.PES(), ("error", "activities", "delta")) check_learning_rule(nengo.RLS(), ("pre_filtered", "error", "delta", "inv_gamma")) check_learning_rule( nengo.BCM(), ("theta", "pre_filtered", "post_filtered", "delta")) check_learning_rule(nengo.Oja(), ("pre_filtered", "post_filtered", "delta")) check_learning_rule(nengo.Voja(), ("post_filtered", "scaled_encoders", "delta"))
def test_set_learning_rule(): with nengo.Network(): a = nengo.Ensemble(10, 2) b = nengo.Ensemble(10, 2) nengo.Connection(a, b, learning_rule_type=nengo.PES()) nengo.Connection(a, b, learning_rule_type=nengo.PES(), solver=LstsqL2(weights=True)) nengo.Connection(a.neurons, b.neurons, learning_rule_type=nengo.PES()) nengo.Connection(a.neurons, b.neurons, learning_rule_type=nengo.Oja()) n = nengo.Node(output=lambda t, x: t * x, size_in=2) with pytest.raises(ValueError): nengo.Connection(n, a, learning_rule_type=nengo.PES())
def test_unsupervised_learning_rule(Simulator, nl_nodirect, learning_rule): n = 200 learned_vector = [0.5, -0.5] m = nengo.Network(seed=3902) with m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() u = nengo.Node(output=learned_vector) a = nengo.Ensemble(n, dimensions=2) u_learned = nengo.Ensemble(n, dimensions=2) initial_weights = np.random.random((a.n_neurons, u_learned.n_neurons)) nengo.Connection(u, a) nengo.Connection(a.neurons, u_learned.neurons, transform=initial_weights, learning_rule=nengo.Oja()) sim = Simulator(m) sim.run(1.)
def test_set_learning_rule(): with nengo.Network(): a = nengo.Ensemble(10, 2) b = nengo.Ensemble(10, 2) nengo.Connection(a, b, learning_rule_type=nengo.PES()) nengo.Connection( a, b, learning_rule_type=nengo.PES(), solver=LstsqL2(weights=True) ) nengo.Connection( a.neurons, b.neurons, learning_rule_type=nengo.PES(), transform=1 ) nengo.Connection( a.neurons, b.neurons, learning_rule_type=nengo.Oja(), transform=np.ones((10, 10)), ) n = nengo.Node(output=lambda t, x: t * x, size_in=2) with pytest.raises( ValidationError, match="'pre' must be of type 'Ensemble'.*PES" ): nengo.Connection(n, a, learning_rule_type=nengo.PES())
nengo.Probe(non_direct_probe.neurons) activate_direct_mode(model) for ens in direct_mode_ens: assert type(ens.neuron_type) is nengo.Direct for ens in non_direct_mode_ens: assert type(ens.neuron_type) is not nengo.Direct @pytest.mark.parametrize( "learning_rule, weights", ( (nengo.PES(), False), (nengo.BCM(), True), (nengo.Oja(), True), (nengo.Voja(), False), ), ) def test_activate_direct_mode_learning(RefSimulator, learning_rule, weights): with nengo.Network() as model: pre = nengo.Ensemble(10, 1) post = nengo.Ensemble(10, 1) conn = nengo.Connection(pre, post, solver=nengo.solvers.LstsqL2(weights=weights)) conn.learning_rule_type = learning_rule activate_direct_mode(model) with RefSimulator(model) as sim:
nengo.Connection(direct_mode_ens[0], direct_mode_ens[1]) nengo.Connection(non_direct_pre.neurons[0], direct_mode_ens[0]) nengo.Connection(direct_mode_ens[1], non_direct_post.neurons[0]) nengo.Probe(non_direct_probe.neurons) activate_direct_mode(model) for ens in direct_mode_ens: assert type(ens.neuron_type) is nengo.Direct for ens in non_direct_mode_ens: assert type(ens.neuron_type) is not nengo.Direct @pytest.mark.parametrize('learning_rule, weights', ((nengo.PES(), False), (nengo.BCM(), True), (nengo.Oja(), True), (nengo.Voja(), False))) def test_activate_direct_mode_learning(RefSimulator, learning_rule, weights): with nengo.Network() as model: pre = nengo.Ensemble(10, 1) post = nengo.Ensemble(10, 1) conn = nengo.Connection(pre, post, solver=nengo.solvers.LstsqL2(weights=weights)) conn.learning_rule_type = learning_rule activate_direct_mode(model) with RefSimulator(model) as sim: sim.run(0.01)
u_learned_p = nengo.Probe(u_learned, synapse=0.1) e_p = nengo.Probe(e, synapse=0.1) sim = Simulator(m) sim.run(1.) assert np.allclose(sim.data[u_learned_p][-1], learned_vector, atol=0.05) assert np.allclose(sim.data[e_p][-1], np.zeros(len(learned_vector)), atol=0.05) @pytest.mark.parametrize( 'learning_rule', [nengo.BCM(), nengo.Oja(), [nengo.Oja(), nengo.BCM()]]) def test_unsupervised_learning_rule(Simulator, nl_nodirect, learning_rule): n = 200 learned_vector = [0.5, -0.5] m = nengo.Network(seed=3902) with m: m.config[nengo.Ensemble].neuron_type = nl_nodirect() u = nengo.Node(output=learned_vector) a = nengo.Ensemble(n, dimensions=2) u_learned = nengo.Ensemble(n, dimensions=2) initial_weights = np.random.random((a.n_neurons, u_learned.n_neurons)) nengo.Connection(u, a) nengo.Connection(a.neurons,
for image in mnist: training_images.append(image) # follows the default model of creating a Nengo SNN model = nengo.Network() with model: # Cast input into the Nodes to be used as input stim = nengo.Node(nengo.processes.PresentInput(training_images, 0.1)) # Create the layer of input that takes in the data from my_spikes a = nengo.Ensemble(n_neurons=784, dimensions=1) # Create hidden layer b = nengo.Ensemble(n_neurons=1000, dimensions=1) # Create layer for output output = nengo.Ensemble(n_neurons=10, dimensions=1) # Connections made between the input neurons, and the output neurons to the trainer nengo.Connection(stim, a.neurons) conn_ab = nengo.Connection(a, b, solver=nengo.solvers.LstsqL2(weights=True)) conn_ab.learning_rule_type = nengo.Oja(learning_rate=6e-8) conn_boutput = nengo.Connection(b, output, solver=nengo.solvers.LstsqL2(weights=True)) conn_boutput.learning_rule_type = nengo.Oja(learning_rate=6e-8) pre_p = nengo.Probe(a, synapse=0.01) post_p = nengo.Probe(output, synapse=0.01) weights_p = nengo.Probe(conn_boutput, 'weights', synapse=0.01, sample_every=0.01)
B_f = Cycler(np.roll(SPs, -1), .5, 1, SP_duration, n_SPs * n_training_cycles).make_step() B = nengo.Ensemble(30 * D, D, intercepts=intercepts) B_inp = spa.Transcode(B_f, output_vocab=vocab) nengo.Connection(B_inp.output, B) B_out = spa.Transcode(input_vocab=vocab, output_vocab=vocab) nengo.Connection(B, B_out.input) connection = nengo.Connection( A.neurons, B.neurons, transform=np.zeros((B.n_neurons, A.n_neurons)), learning_rule_type=nengo.Oja( learning_rate=1e-8, # beta=0 # max_weight=.1, # min_weight=-.1, # bounds="none", ), # learning_rule_type=nengo.BCM( # learning_rate=5e-8, # ), ) connection = nengo.Connection( A.neurons, B.neurons, transform=np.zeros((B.n_neurons, A.n_neurons)), learning_rule_type=nengo.BCM( learning_rate=5e-11, # beta=0
n = v.shape[0] k = np.arange(n) + 1 l1norm = np.sum(v) summation = np.sum((v / l1norm) * ((n - k + 0.5) / n)) return 1 - 2 * summation print("Starting sparsity: {0}".format(sparsity_measure( sim.data[weights_p][0]))) print("Ending sparsity: {0}".format(sparsity_measure(sim.data[weights_p][-1]))) # ## What does Oja do? # In[ ]: conn.learning_rule_type = nengo.Oja(learning_rate=6e-8) # In[ ]: with nengo.Simulator(model) as sim: sim.run(20.0) # In[ ]: plt.figure(figsize=(12, 8)) plt.subplot(2, 1, 1) plt.plot(sim.trange(), sim.data[pre_p], label="Pre") plt.plot(sim.trange(), sim.data[post_p], label="Post") plt.ylabel("Decoded value") plt.ylim(-1.6, 1.6) plt.legend(loc="lower left")