def do_run(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp(i_offset=5.0), label="pop")
pop.record("spikes")
pop_2 = sim.Population(1, sim.IF_curr_exp(), label="pop_2")
proj = sim.Projection(
pop, pop_2, sim.AllToAllConnector(),
sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(),
weight_dependence=sim.AdditiveWeightDependence(),
weight=sim.RandomDistribution("uniform", low=0.3, high=0.7)))
proj_2 = sim.Projection(
pop, pop_2, sim.OneToOneConnector(),
sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(),
weight_dependence=sim.AdditiveWeightDependence(),
weight=sim.RandomDistribution("uniform", low=0.3, high=0.7)))
sim.run(100)
weights_1_1 = proj.get("weight", "list")
weights_1_2 = proj_2.get("weight", "list")
spikes_1 = pop.get_data("spikes").segments[0].spiketrains
sim.reset()
sim.run(100)
weights_2_1 = proj.get("weight", "list")
weights_2_2 = proj_2.get("weight", "list")
spikes_2 = pop.get_data("spikes").segments[1].spiketrains
sim.end()
assert(numpy.array_equal(weights_1_1, weights_2_1))
assert(numpy.array_equal(weights_1_2, weights_2_2))
assert(numpy.array_equal(spikes_1, spikes_2))
def do_run(self):
nNeurons = 2
p.setup(timestep=1.0, min_delay=1.0)
rng = NumpyRNG(seed=85524)
cm = p.RandomDistribution('uniform_int', [1, 4], rng=rng)
i_off = p.RandomDistribution('poisson', lambda_=3, rng=rng)
tau_m = p.RandomDistribution('gamma', [1.0, 1.0], rng=rng)
tau_re = p.RandomDistribution('vonmises', [1.0, 1.0], rng=rng)
tau_syn_E = p.RandomDistribution('exponential', [0.1], rng=rng)
tau_syn_I = p.RandomDistribution('binomial', [1, 0.5], rng=rng)
v_reset = p.RandomDistribution('lognormal', [1.0, 1.0], rng=rng)
v_rest = p.RandomDistribution('normal_clipped',
[-70.0, 1.0, -72.0, -68.0],
rng=rng)
v_thresh = p.RandomDistribution('normal_clipped_to_boundary',
[-55.0, 2.0, -57.0, -53.0],
rng=rng)
v_init = p.RandomDistribution('normal', [-65.0, 1.0], rng=rng)
cell_params_lif = {
'cm': cm,
'i_offset': i_off,
'tau_m': tau_m,
'tau_refrac': tau_re,
'tau_syn_E': tau_syn_E,
'tau_syn_I': tau_syn_I,
'v_reset': v_reset,
'v_rest': v_rest,
'v_thresh': v_thresh
}
pop_1 = p.Population(nNeurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1')
pop_1.initialize(v=v_init)
p.run(1)
# All this is really checking is that values get copied correctly
self.assertEqual(nNeurons, len(pop_1.get("cm")))
self.assertEqual(nNeurons, len(pop_1.get("i_offset")))
self.assertEqual(nNeurons, len(pop_1.get("tau_m")))
self.assertEqual(nNeurons, len(pop_1.get("tau_refrac")))
self.assertEqual(nNeurons, len(pop_1.get("tau_syn_E")))
self.assertEqual(nNeurons, len(pop_1.get("tau_syn_I")))
self.assertEqual(nNeurons, len(pop_1.get("v_reset")))
self.assertEqual(nNeurons, len(pop_1.get("v_rest")))
self.assertEqual(nNeurons, len(pop_1.get("v_thresh")))
p.end()
def test_run(self):
CELL_PARAMS_LIF = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0,
'tau_refrac': 2.0, 'tau_syn_E': 5.0,
'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0,
'v_thresh': -50.0}
p.setup(timestep=1, min_delay=1.0, max_delay=144)
pop = p.Population(1, IF_curr_exp(**CELL_PARAMS_LIF), label='pop_1')
rng = p.NumpyRNG(seed=28375)
v_init = p.RandomDistribution('uniform', [-60, -40], rng)
pop.initialize(v=v_init)
p.run(500)
def do_run(self):
sim.setup(1.0)
pre = sim.Population(2, sim.IF_curr_exp())
post = sim.Population(2, sim.IF_curr_exp())
nrng = sim.NumpyRNG(seed=1)
# Test case where weights are in list and delays given by random dist
list1 = [(0, 0, 2.1), (0, 1, 2.6), (1, 1, 3.2)]
proj1 = sim.Projection(
pre, post, sim.FromListConnector(list1, column_names=["weight"]),
sim.StaticSynapse(weight=0.5,
delay=sim.RandomDistribution('uniform', [1, 10],
rng=nrng)))
# Test case where delays are in list and weights given by random dist
list2 = [(0, 0, 2), (0, 1, 6), (1, 1, 3)]
proj2 = sim.Projection(
pre, post, sim.FromListConnector(list2, column_names=["delay"]),
sim.StaticSynapse(weight=sim.RandomDistribution('uniform',
[1.5, 3.5],
rng=nrng),
delay=4))
sim.run(1)
conns1 = proj1.get(["weight", "delay"], "list")
conns2 = proj2.get(["weight", "delay"], "list")
sim.end()
target1 = [(0, 0, 2.1, 8), (0, 1, 2.6, 6), (1, 1, 3.2, 4)]
target2 = [(0, 0, 1.7864, 2), (0, 1, 2.0823, 6), (1, 1, 2.4995, 3)]
# assertAlmostEqual doesn't work on lists, so loop required
for i in range(3):
for j in range(2):
self.assertAlmostEqual(conns1[i][j + 2],
target1[i][j + 2],
places=3)
self.assertAlmostEqual(conns2[i][j + 2],
target2[i][j + 2],
places=3)
def test_model_fail_to_set_neuron_param_random_distribution(self):
n_neurons = 5
range_low = -70
range_high = -50
value = sim.RandomDistribution('uniform', (range_low, range_high))
label = "pop_1"
sim.setup(timestep=1.0)
model = sim.IF_curr_exp(i_offset=value)
pop_1 = sim.Population(n_neurons, model, label=label)
values = pop_1.get('i_offset')
for value in values:
self.assertGreater(value, range_low)
self.assertLess(value, range_high)
def do_run(split, seed=None):
p.setup(1.0)
if split:
p.set_number_of_neurons_per_core(p.SpikeSourcePoisson, 27)
p.set_number_of_neurons_per_core(p.IF_curr_exp, 22)
inp = p.Population(100,
p.SpikeSourcePoisson(rate=100, seed=seed),
label="input")
pop = p.Population(100, p.IF_curr_exp, {}, label="pop")
p.Projection(inp,
pop,
p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=5))
pop.record("spikes")
inp.record("spikes")
p.run(100)
inp.set(rate=10)
# pop.set("cm", 0.25)
pop.set(tau_syn_E=1)
p.run(100)
pop_spikes1 = pop.spinnaker_get_data('spikes')
inp_spikes1 = inp.spinnaker_get_data('spikes')
p.reset()
inp.set(rate=0)
pop.set(i_offset=1.0)
vs = p.RandomDistribution("uniform", [-65.0, -55.0],
rng=NumpyRNG(seed=seed))
pop.initialize(v=vs)
p.run(100)
pop_spikes2 = pop.spinnaker_get_data('spikes')
inp_spikes2 = inp.spinnaker_get_data('spikes')
p.end()
return (pop_spikes1, inp_spikes1, pop_spikes2, inp_spikes2)
def run_bad_normal_clipping():
p.setup(timestep=1.0)
pop_1 = p.Population(4, p.IF_curr_exp(), label="pop_1")
input = p.Population(4, p.SpikeSourceArray(spike_times=[0]), label="input")
delays = p.RandomDistribution("normal_clipped",
mu=20,
sigma=1,
low=1,
high=6)
p.Projection(input,
pop_1,
p.AllToAllConnector(),
synapse_type=p.StaticSynapse(weight=5, delay=delays))
p.run(10)
p.end()
def __create_synfire_chain(n_neurons, cell_class, cell_params,
use_wrap_around_connections, weight_to_spike,
delay, spike_times, spike_times_list,
placement_constraint, randomise_v_init, seed,
constraint, input_class, rate, start_time,
duration, use_spike_connections):
""" This actually builds the synfire chain. """
populations = list()
projections = list()
loop_connections = list()
if use_wrap_around_connections:
for i in range(0, n_neurons):
single_connection = \
(i, ((i + 1) % n_neurons), weight_to_spike, delay)
loop_connections.append(single_connection)
else:
for i in range(0, n_neurons - 1):
single_connection = (i, i + 1, weight_to_spike, delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
run_count = 0
if spike_times_list is None:
spike_array = {'spike_times': spike_times}
else:
spike_array = {'spike_times': spike_times_list[run_count]}
populations.append(
p.Population(n_neurons, cell_class(**cell_params), label='pop_1'))
if placement_constraint is not None:
if len(placement_constraint) == 2:
(x, y) = placement_constraint
populations[0].add_placement_constraint(x=x, y=y)
else:
(x, y, proc) = placement_constraint
populations[0].add_placement_constraint(x=x, y=y, p=proc)
if randomise_v_init:
if seed is None:
v_init = p.RandomDistribution('uniform', [-60, -40])
else:
v_init = p.RandomDistribution('uniform', [-60, -40],
NumpyRNG(seed=seed))
populations[0].initialize(v=v_init)
if constraint is not None:
populations[0].set_constraint(constraint)
if input_class == SpikeSourceArray:
populations.append(
p.Population(1, input_class(**spike_array),
label='inputSSA_1'))
elif seed is None:
populations.append(
p.Population(1,
input_class(rate=rate,
start=start_time,
duration=duration),
label='inputSSP_1'))
else:
populations.append(
p.Population(1,
input_class(rate=rate,
start=start_time,
duration=duration),
label='inputSSP_1',
additional_parameters={"seed": seed}))
# handle projections
if use_spike_connections:
projections.append(
p.Projection(
populations[0], populations[0],
p.FromListConnector(loop_connections),
p.StaticSynapse(weight=weight_to_spike, delay=delay)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection),
p.StaticSynapse(weight=weight_to_spike, delay=1)))
return populations, projections, run_count
import numpy as np
from pyNN.utility.plotting import Figure, Panel
import pylab as plt
from functions import intercept_simulator, restore_simulator_from_file
start_time = plt.datetime.datetime.now()
v_reset = -65
v_thresh = -50
rngseed = 98766987
parallel_safe = True
rng = sim.NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
sim_time = 5000
coupling_multiplier = 2.
delay_distribution = sim.RandomDistribution('uniform', [1, 14], rng=rng)
cell_params_exc = {
'tau_m': 20.0,
'cm': 1.0,
'v_rest': -65.0,
'v_reset': -65.0,
'v_thresh': -50.0,
'tau_syn_E': 5.0,
'tau_syn_I': 15.0,
'tau_refrac': 0.3,
'i_offset': 0
}
cell_params_inh = {
'tau_m': 20.0,
mod_ampa_d2 = 0.2 ###00.156 in humphries nnet 2009
phi_max_dop = 5 ##(Scaled within 0 to 5)
phi_msn_dop = 0.55 * phi_max_dop
phi_fsi_dop = 0.75 * phi_max_dop
phi_stn_dop = 0.4 * phi_max_dop ###(Note that this is scaled between 0 and 16.67)
'''SETTING NETWORK CONDUCTANCE PARAMETERS'''
g_cort2strd1 = g_ampa
g_cort2strd2 = g_ampa * (1 - (mod_ampa_d2 * phi_msn_dop))
g_cort2fsi = g_ampa * (1 - (mod_ampa_d2 * phi_fsi_dop))
g_cort2stn = g_ampa * (1 - (mod_ampa_d2 * phi_stn_dop))
#################DEFINING DISTRIBUTION OF DELAY PARAMETERS
distr_strd1 = p.RandomDistribution("uniform", [9, 12])
distr_strd2 = p.RandomDistribution("uniform", [9, 12])
distr_stn = p.RandomDistribution("uniform", [9, 12])
distr_fsi = p.RandomDistribution("uniform", [9, 12])
pconn_cort2str = 0.15
pconn_cort2stn = 0.2
poplist_ch1 = [strd1_pop1, strd2_pop1, fsi1_pop1, stn_pop1]
poplist_ch2 = [strd1_pop2, strd2_pop2, fsi1_pop2, stn_pop2]
poplist_ch3 = [strd1_pop3, strd2_pop3, fsi1_pop3, stn_pop3]
g_pop = [g_cort2strd1, g_cort2strd2, g_cort2fsi, g_cort2stn]
def do_run(plot):
p.setup(timestep=1.0)
# n_pop = 2 # 60
nNeurons = 10 # 100
rng = p.NumpyRNG(seed=28374)
# rng1 = p.NumpyRNG(seed=12345)
# delay_distr = p.RandomDistribution('uniform', [5, 10], rng)
# weight_distr = p.RandomDistribution('uniform', [0, 2], rng1)
v_distr = p.RandomDistribution('uniform', [-55, -95], rng)
v_inits = []
for i in range(nNeurons):
v_inits.append(v_distr.next())
cell_params_lif_in = {
'tau_m': 32,
'v_init': -80,
'v_rest': -75,
'v_reset': -95,
'v_thresh': -55,
'tau_syn_E': 5,
'tau_syn_I': 10,
'tau_refrac': 20,
'i_offset': 1
}
cell_params_lif = {
'tau_m': 32,
'v_init': -80,
'v_rest': -75,
'v_reset': -95,
'v_thresh': -55,
'tau_syn_E': 5,
'tau_syn_I': 10,
'tau_refrac': 5,
'i_offset': 0
}
cell_params_ext_dev = {'port': 34567}
populations = list()
projections = list()
weight_to_spike = 20
populations.append(
p.Population(nNeurons,
p.IF_curr_exp(**cell_params_lif_in),
label='pop_%d' % 0))
populations[0].initialize(v=v_distr)
p.external_devices.activate_live_output_for(populations[0])
pop_external = p.Population(
nNeurons,
p.external_devices.SpikeInjector(**cell_params_ext_dev),
label='Babel_Dummy')
populations.append(
p.Population(nNeurons,
p.IF_curr_exp(**cell_params_lif),
label='pop_%d' % 1))
projections.append(
p.Projection(pop_external, populations[1], p.OneToOneConnector(),
p.StaticSynapse(weight=weight_to_spike, delay=10)))
# populations[0].record_v()
# at the moment is only possible to observe one population per core
populations[1].record(['v'])
for pop in populations:
pop.record(['spikes'], to_file=False)
# sends spike to the Monitoring application
# populations[i].record_variable('rate', save_to='eth')
# sends spike to the Monitoring application
p.run(10000)
# retrieving spike results and plotting...
id_accumulator = 0
shapes = []
if plot:
import matplotlib.pyplot as p_plot
for pop_o in populations:
data = numpy.asarray(
neo_convertor.convert_spikes(pop_o.get_data('spikes')))
print(data.shape)
shapes.append(data.shape)
if plot:
p_plot.scatter(data[:, 0],
data[:, 1] + id_accumulator,
color='green',
s=1)
id_accumulator = id_accumulator + pop_o.size
if plot:
p_plot.show()
return shapes
