def construct_layer(cell_params_lif, pop_list_in, mode, k_size, w_layer): max_F = 140. #150. max_curr = 1. #1. syn = 5.*0.96 in_num = len(pop_list_in) #populations number in previous layer in_size = int(np.sqrt(pop_list_in[0].size)) #in_size*in_size = neuron_num per pop in the previous layer pop_layer = [] if mode > 0: #convoluational layer out_num = mode #populations number in current layer #print in_num, out_num out_size = in_size - k_size + 1 for j in range(out_num): pop_layer.append(p.Population(out_size*out_size, p.IF_curr_exp, cell_params_lif)) for i in range(in_num): conv_pops(pop_list_in[i], pop_layer[j], w_layer[i][j])# * 1000./max_F * max_curr / syn) elif mode == 0: #pooling layer out_num = in_num #populations number in current layer #print in_num, out_num out_size = in_size/k_size for j in range(out_num): pop_layer.append(p.Population(out_size*out_size, p.IF_curr_exp, cell_params_lif)) pool_pops(pop_list_in[j], pop_layer[j], w_layer[0][0])# * 1000./max_F * max_curr / syn) elif mode == -1: #top layer out_size = k_size #print out_size pop_layer.append(p.Population(out_size, p.IF_curr_exp, cell_params_lif)) out_pops(pop_list_in, pop_layer[0], w_layer)# * 1000./max_F * max_curr / syn) return pop_layer
def run_test(w_list, cell_para, spike_source_data): pop_list = [] p.setup(timestep=1.0, min_delay=1.0, max_delay=3.0) #input poisson layer input_size = w_list[0].shape[0] pop_in = p.Population(input_size, p.SpikeSourceArray, {'spike_times': []}) for j in range(input_size): pop_in[j].spike_times = spike_source_data[j] pop_list.append(pop_in) for w in w_list: pos_w = np.copy(w) pos_w[pos_w < 0] = 0 neg_w = np.copy(w) neg_w[neg_w > 0] = 0 output_size = w.shape[1] pop_out = p.Population(output_size, p.IF_curr_exp, cell_para) p.Projection(pop_in, pop_out, p.AllToAllConnector(weights=pos_w), target='excitatory') p.Projection(pop_in, pop_out, p.AllToAllConnector(weights=neg_w), target='inhibitory') pop_list.append(pop_out) pop_in = pop_out pop_out.record() run_time = np.ceil(np.max(spike_source_data)[0] / 1000.) * 1000 p.run(run_time) spikes = pop_out.getSpikes(compatible_output=True) return spikes
def test_nest_dense_normalisation(): p1 = pynn.Population(12, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) p2 = pynn.Population(10, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) l = v.Dense(p1, p2, v.ReLU(), weights=1) m = v.Model(l) out = m.predict(np.ones(12) * 12, 50) assert np.allclose(np.ones(10), out, atol=0.1)
def test_nest_dense_create(): p1 = pynn.Population(12, pynn.IF_cond_exp()) p2 = pynn.Population(10, pynn.IF_cond_exp()) d = v.Dense(p1, p2, v.ReLU()) expected_weights = np.ones((12, 10)) actual_weights = d.projection.get('weight', format='array') assert not np.allclose(actual_weights, expected_weights) # Should be normal distributed assert abs(actual_weights.sum()) <= 24
def test_nest_dense_shape(): p1 = pynn.Population(12, pynn.SpikeSourcePoisson(rate = 10)) p2 = pynn.Population(10, pynn.IF_cond_exp()) d = v.Dense(p1, p2, v.ReLU(), weights = 1) pynn.run(1000) d.store_spikes() assert d.input.shape == (12,) assert d.output.shape[0] == 10
def test_replicate_assert_size(): p1 = pynn.Population(6, pynn.IF_cond_exp()) p2 = pynn.Population(6, pynn.IF_cond_exp()) p3 = pynn.Population(5, pynn.IF_cond_exp()) with pytest.raises(ValueError): v.Replicate(p1, (p2, p3)) with pytest.raises(ValueError): v.Replicate(p1, (p3, p2))
def test_nest_model_predict_active(): p1 = pynn.Population(2, pynn.IF_cond_exp()) p2 = pynn.Population(2, pynn.IF_cond_exp()) l = v.Dense(p1, p2, v.ReLU(), decoder=v.spike_count, weights=1) m = v.Model(l) out = m.predict(np.array([1, 1]), 1000) assert len(out) == 2 assert abs(out[0] - out[1]) <= 10 # Must be approx same spikes
def test_nest_model_linear_scaling(): p1 = pynn.Population(2, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) p2 = pynn.Population(2, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) l1 = v.Dense(p1, p2, v.ReLU(), decoder=v.spike_count, weights=1) m = v.Model(l1) xs = np.array([12, 12]) out = m.predict(xs, 50) assert np.allclose([38, 38], out)
def test_nest_model_predict_inactive(): p1 = pynn.Population(2, pynn.IF_cond_exp()) p2 = pynn.Population(2, pynn.IF_cond_exp()) l = v.Dense(p1, p2, v.ReLU(), decoder=v.spike_count) m = v.Model(l) out = m.predict(np.array([0, 0]), 10) assert len(out) == 2 assert out.sum() < 10
def test_nest_projection_gaussian(): p1 = pynn.Population(2, pynn.IF_cond_exp()) p2 = pynn.Population(2, pynn.IF_cond_exp()) c = pynn.Projection(p1, p2, pynn.AllToAllConnector(allow_self_connections=False)) c.set(weight=pynn.random.RandomDistribution('normal', mu=0.5, sigma=0.1)) weights = c.get('weight', format='array') assert len(weights[weights == 0]) < 1
def test_replicate_can_replicate(): p1 = pynn.Population(6, pynn.IF_cond_exp(i_offset=10)) p2 = pynn.Population(6, pynn.IF_cond_exp()) p3 = pynn.Population(6, pynn.IF_cond_exp()) l = v.Replicate(p1, (p2, p3), v.ReLU(), weights=(1, 1)) pynn.run(1000) l.store_spikes() expected = np.ones((2, 6)) assert np.allclose(expected, l.get_output())
def setUp(self): sim.setup() self.p1 = sim.Population(7, sim.IF_cond_exp()) self.p2 = sim.Population(4, sim.IF_cond_exp()) self.p3 = sim.Population(5, sim.IF_curr_alpha()) self.syn_rnd = sim.StaticSynapse(weight=0.123, delay=0.5) self.syn_a2a = sim.StaticSynapse(weight=0.456, delay=0.4) self.random_connect = sim.FixedNumberPostConnector(n=2) self.all2all = sim.AllToAllConnector()
def test_nest_dense_chain(): p1 = pynn.Population(12, pynn.SpikeSourcePoisson(rate = 100)) p2 = pynn.Population(10, pynn.IF_cond_exp()) p3 = pynn.Population(2, pynn.IF_cond_exp()) p3.record('spikes') d1 = v.Dense(p1, p2, v.ReLU()) d2 = v.Dense(p2, p3, v.ReLU()) pynn.run(1000) assert len(p3.get_data().segments[-1].spiketrains) > 0
def test_nest_dense_reduced_weight_fire(): p1 = pynn.Population(1, pynn.IF_cond_exp(i_offset=10)) p2 = pynn.Population(2, pynn.IF_cond_exp()) d = v.Dense(p1, p2, v.ReLU(), weights = np.array([[1, 0]])) pynn.run(1000) spiketrains1 = p1.get_data().segments[-1].spiketrains spiketrains2 = p2.get_data().segments[-1].spiketrains assert spiketrains1[0].size > 0 assert spiketrains2[0].size > 0 assert spiketrains2[1].size == 0
def test_replicate_create(): p1 = pynn.Population(6, pynn.IF_cond_exp()) p2 = pynn.Population(6, pynn.IF_cond_exp()) p3 = pynn.Population(6, pynn.IF_cond_exp()) l = v.Replicate(p1, (p2, p3), v.ReLU(), weights=(1, 1)) pynn.run(1000) l.store_spikes() assert l.layer1.input.shape == (6, 0) assert l.layer2.input.shape == (6, 0) assert l.get_output().shape == (2, 6)
def test_nest_create_input_populations(): p1 = pynn.Population(2, pynn.IF_cond_exp()) p2 = pynn.Population(2, pynn.IF_cond_exp()) l = v.Dense(p1, p2, v.ReLU()) m = v.Model(l) assert len(m.input_populations) == 2 inp = np.array([1, 0.2]) m.set_input(inp) assert m.input_populations[0].get('i_offset') == 1 assert m.input_populations[1].get('i_offset') == 0.2
def test_ticket244(): nest = pyNN.nest nest.setup(threads=4) p1 = nest.Population(4, nest.IF_curr_exp()) p1.record('spikes') poisson_generator = nest.Population(3, nest.SpikeSourcePoisson(rate=1000.0)) conn = nest.OneToOneConnector() syn = nest.StaticSynapse(weight=1.0) nest.Projection(poisson_generator, p1.sample(3), conn, syn, receptor_type="excitatory") nest.run(15) p1.get_data()
def test_nest_model_spike_normalisation(): p1 = pynn.Population(2, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) p2 = pynn.Population(4, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) p3 = pynn.Population(4, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) l1 = v.Dense(p1, p2, decoder=v.spike_rate(50), weights=1) l2 = v.Dense(p2, p3, decoder=v.spike_rate(50), weights=1) m = v.Model(l1, l2) m.predict([12, 12], 50) for rate in np.concatenate((l1.get_output(), l2.get_output())): assert rate > 0 assert rate < 1
def test_ticket240(): nest = pyNN.nest nest.setup(threads=4) parameters = {'Tau_m': 17.0} p1 = nest.Population(4, nest.IF_curr_exp()) p2 = nest.Population(5, nest.native_cell_type("ht_neuron")(**parameters)) conn = nest.AllToAllConnector() syn = nest.StaticSynapse(weight=1.0) prj = nest.Projection(p1, p2, conn, syn, receptor_type='AMPA') # This should be a nonstandard receptor type but I don't know of one to use. connections = prj.get(('weight',), format='list') assert len(connections) > 0
def test_nest_dense_backprop(): p1 = pynn.Population(4, pynn.IF_cond_exp()) p2 = pynn.Population(2, pynn.IF_cond_exp()) l = v.Dense(p1, p2, v.UnitActivation(), weights = 1, decoder = lambda x: x) old_weights = l.get_weights() l.input_cache = np.ones((1, 4)) # Mock spikes errors = l.backward(np.array([[0, 1]]), lambda w, g, b, bg: (w - g, b - bg)) expected_errors = np.zeros((2, 4)) + 4 assert np.allclose(errors, expected_errors) expected_weights = np.tile([1, -3], (4, 1)) assert np.allclose(l.get_weights(), expected_weights)
def test_nest_input_projection(): p1 = pynn.Population(2, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) p2 = pynn.Population(2, pynn.IF_cond_exp(**v.DEFAULT_NEURON_PARAMETERS)) l = v.Dense(p1, p2, v.ReLU(), weights=1) m = v.Model(l) t = v.LinearTranslation() assert np.allclose(l.get_weights(), np.ones((2, 2))) assert m.input_projection[0].weight == t.weights(1, 1) assert m.input_projection[1].weight == t.weights(1, 1) m.predict([1, 1], 50) spiketrains = l.output assert abs(len(spiketrains[0]) - len(spiketrains[1])) <= 20
def test_nest_dense_projection(): p1 = pynn.Population(12, pynn.SpikeSourcePoisson(rate = 10)) p2 = pynn.Population(10, pynn.IF_cond_exp()) p2.record('spikes') d = v.Dense(p1, p2, v.ReLU(), weights = 1) pynn.run(1000) spiketrains = p2.get_data().segments[-1].spiketrains assert len(spiketrains) == 10 avg_len = np.array(list(map(len, spiketrains))).mean() # Should have equal activation for train in spiketrains: assert abs(len(train) - avg_len) <= 1
def test_nest_dense_restore(): p1 = pynn.Population(12, pynn.IF_cond_exp()) p2 = pynn.Population(10, pynn.IF_cond_exp()) d = v.Dense(p1, p2, v.ReLU(), weights = 2) d.set_weights(-1) t = v.LinearTranslation() assert np.array_equal(d.projection.get('weight', format='array'), t.weights(np.ones((12, 10)) * -1, 12)) d.projection.set(weight = 1) # Simulate reset() assert np.array_equal(d.projection.get('weight', format='array'), np.ones((12, 10))) d.restore_weights() assert np.array_equal(d.projection.get('weight', format='array'), t.weights(np.ones((12, 10)) * -1, 12))
def test_nest_model_backwards(): p1 = pynn.Population(2, pynn.IF_cond_exp()) p2 = pynn.Population(3, pynn.IF_cond_exp()) l1 = v.Dense(p1, p2, v.ReLU(), decoder=v.spike_count_linear, weights=1) m = v.Model(l1) xs = np.array([12, 12]) spikes = m.predict(xs, 50) def l(w, g, b, bg): return w - g, b - bg m.backward([0, 1, 1], l) # no learning rate expected_weights = np.array([[1, 0, 0], [1, 0, 0]]) assert np.allclose(l1.get_weights(), expected_weights, atol=0.2)
def run_sim(ncell): print "Cells: ", ncell setup0 = time.time() sim.setup(timestep=0.1) hh_cell_type = sim.HH_cond_exp() hh = sim.Population(ncell, hh_cell_type) pulse = sim.DCSource(amplitude=0.5, start=20.0, stop=80.0) pulse.inject_into(hh) hh.record('v') setup1 = time.time() t0 = time.time() sim.run(100.0) v = hh.get_data() sim.end() t1 = time.time() setup_total = setup1 - setup0 run_total = t1 - t0 print "Setup: ", setup_total print "Run: ", run_total print "Total sim time: ", setup_total + run_total return run_total
def create_empty_input_layers_for_scales(target: np.array, scales: [float])\ -> Dict[float, List[Layer]]: """ Creates empty input layers from the target image shape for every scale in the passed list. Parameters: `target`: The target image from which to compute the gabor filters and create the input layers `scales`: A list of the scales for which to create input layers Returns: A dictionary which contains for each scale a list of four input layers, one for each orientation """ input_layers = {} feature_names = cm.get_gabor_feature_names() for size in scales: print('Creating input layers for size', size) n = round(target.shape[0] * size) m = round(target.shape[1] * size) input_layers[size] = [Layer(sim.Population(n * m, sim.IF_curr_exp(), label=feature_name), (n, m))\ for feature_name in feature_names] return input_layers
def create_C2_layers(S2_layers: Dict[float, Sequence[Layer]], s2_prototype_cells: int) -> List[sim.Population]: """ Creates the populations of the C2 layer, one for each S2 prototype cell, containing only a single cell which max-pools the spikes of all layers of a prototype. Parameters: `S2_layers`: A dictionary containing for each scale a list of S2 layers, one for each prototype cell `s2_prototype_cells`: The number of S2 prototype cells Returns: A list of populations of size one, one population for each prototype cell """ no_inh_w = 17.15 # synapse weight without S2 inhibitions with_inh_w = 4 * no_inh_w # synapse weight with S2 inhibitions C2_populations = [sim.Population(1, sim.IF_curr_exp(), label=str(prot))\ for prot in range(s2_prototype_cells)] total_connections = sum( map(lambda ll: ll[0].shape[0] * ll[0].shape[1], S2_layers.values())) for s2ll in S2_layers.values(): for prot in range(s2_prototype_cells): sim.Projection( s2ll[prot].population, C2_populations[prot], sim.AllToAllConnector(), sim.StaticSynapse(weight=with_inh_w / total_connections)) return C2_populations
def test_record_native_model(): if not have_nest: raise SkipTest nest = pyNN.nest from pyNN.random import RandomDistribution init_logging(logfile=None, debug=True) nest.setup() parameters = {'tau_m': 17.0} n_cells = 10 p1 = nest.Population(n_cells, nest.native_cell_type("ht_neuron")(**parameters)) p1.initialize(V_m=-70.0, Theta=-50.0) p1.set(theta_eq=-51.5) #assert_arrays_equal(p1.get('theta_eq'), -51.5*numpy.ones((10,))) assert_equal(p1.get('theta_eq'), -51.5) print(p1.get('tau_m')) p1.set(tau_m=RandomDistribution('uniform', low=15.0, high=20.0)) print(p1.get('tau_m')) current_source = nest.StepCurrentSource( times=[50.0, 110.0, 150.0, 210.0], amplitudes=[0.01, 0.02, -0.02, 0.01]) p1.inject(current_source) p2 = nest.Population( 1, nest.native_cell_type("poisson_generator")(rate=200.0)) print("Setting up recording") p2.record('spikes') p1.record('V_m') connector = nest.AllToAllConnector() syn = nest.StaticSynapse(weight=0.001) prj_ampa = nest.Projection(p2, p1, connector, syn, receptor_type='AMPA') tstop = 250.0 nest.run(tstop) vm = p1.get_data().segments[0].analogsignals[0] n_points = int(tstop / nest.get_time_step()) + 1 assert_equal(vm.shape, (n_points, n_cells)) assert vm.max() > 0.0 # should have some spikes
def test_nest_dense_increased_weight_fire(): p1 = pynn.Population(1, pynn.SpikeSourcePoisson(rate = 1)) p2 = pynn.Population(1, pynn.IF_cond_exp()) p2.record('spikes') d = v.Dense(p1, p2, v.ReLU(), weights = 2) pynn.run(1000) spiketrains = p2.get_data().segments[-1].spiketrains count1 = spiketrains[0].size pynn.reset() p1 = pynn.Population(1, pynn.SpikeSourcePoisson(rate = 1)) p2 = pynn.Population(1, pynn.IF_cond_exp()) p2.record('spikes') d = v.Dense(p1, p2, v.ReLU(), weights = 2) pynn.run(1000) spiketrains = p2.get_data().segments[-1].spiketrains count2 = spiketrains[0].size assert count2 >= count1 * 2
def create_empty_spike_source_layer_with_shape(shape): """ Creates a spike source layer with the given shape and its firing rates set to zero. This is also a helper function of create_spike_source_layer_from(). """ spike_source_layer = sim.Population( size=shape[0] * shape[1], cellclass=sim.SpikeSourcePoisson(rate=0)) return Layer(spike_source_layer, shape)