def do_run():
"""
test that tests the printing of v from a pre determined recording
:return:
"""
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 128 * 128 # number of neurons in each population
p.set_number_of_neurons_per_core(p.IF_cond_exp, 256)
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,
'e_rev_E': 0.,
'e_rev_I': -80.
}
populations = list()
projections = list()
weight_to_spike = 0.035
delay = 17
spikes = read_spikefile('test.spikes', n_neurons)
spike_array = {'spike_times': spikes}
populations.append(p.Population(
n_neurons, p.SpikeSourceArray, spike_array,
label='inputSpikes_1'))
populations.append(p.Population(
n_neurons, p.IF_cond_exp, cell_params_lif, label='pop_1'))
projections.append(p.Projection(
populations[0], populations[1], p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=weight_to_spike, delay=delay)))
populations[1].record("spikes")
p.run(1000)
spikes = populations[1].spinnaker_get_data('spikes')
p.end()
return spikes
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 do_run(nNeurons):
p.setup(timestep=0.1, min_delay=1.0, max_delay=7.5)
p.set_number_of_neurons_per_core(p.IF_curr_exp, 100)
cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0,
'tau_refrac': 2.0, 'tau_syn_E': 6, 'tau_syn_I': 6,
'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -55.4}
populations = list()
projections = list()
weight_to_spike = 12
injection_delay = 1
delay = 1
spikeArray = {'spike_times': [[0, 10, 20, 30]]}
populations.append(p.Population(1, p.SpikeSourceArray, spikeArray,
label='pop_0'))
populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif,
label='pop_1'))
populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif,
label='pop_2'))
connector = p.AllToAllConnector()
synapse_type = p.StaticSynapse(weight=weight_to_spike,
delay=injection_delay)
projections.append(p.Projection(populations[0], populations[1], connector,
synapse_type=synapse_type))
connector = p.OneToOneConnector()
synapse_type = p.StaticSynapse(weight=weight_to_spike, delay=delay)
projections.append(p.Projection(populations[1], populations[2], connector,
synapse_type=synapse_type))
populations[1].record("v")
populations[1].record("spikes")
p.run(100)
neo = populations[1].get_data(["v", "spikes"])
v = neo_convertor.convert_data(neo, name="v")
spikes = neo_convertor.convert_spikes(neo)
p.end()
return (v, spikes)
def test_cause_error(self):
with self.assertRaises(ConfigurationException):
sim.setup(timestep=1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100)
pop_1 = sim.Population(1, sim.IF_curr_exp(), label="pop_1")
input = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(input,
pop_1,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
simtime = 10
sim.run(simtime)
pop_1.get_data(variables=["v"])
def test_levels(rates=(500, 1000), weights=(0.005, 0.0005)):
counter = 0
receive_pop = []
spike_input = []
p.setup(timestep=1, min_delay=1, max_delay=127)
p.set_number_of_neurons_per_core(p.IF_cond_exp, 10)
for rate in rates:
for weight in weights:
pop_size = 10
receive_pop.append(p.Population(pop_size, p.IF_cond_exp(
))) #, label="receive_pop{}-{}".format(rate, weight)))
receive_pop[counter].record(['spikes', 'v']) #["spikes"])
# Connect key spike injector to input population
spike_input.append(
p.Population(pop_size, p.SpikeSourcePoisson(rate=rate))
) #, label="input_connect{}-{}".format(rate, weight)))
p.Projection(spike_input[counter], receive_pop[counter],
p.OneToOneConnector(), p.StaticSynapse(weight=weight))
print "reached here 1"
runtime = 11000
counter += 1
p.run(runtime)
print "reached here 2"
for i in range(counter):
weight_index = i % len(weights)
rate_index = (i - weight_index) / len(weights)
print weight_index
print rate_index
# for j in range(receive_pop_size):
spikes = receive_pop[i].get_data('spikes').segments[0].spiketrains
v = receive_pop[i].get_data('v').segments[0].filter(name='v')[0]
plt.figure("rate = {} - weight = {}".format(rates[rate_index],
weights[weight_index]))
Figure(Panel(spikes, xlabel="Time (ms)", ylabel="nID", xticks=True),
Panel(v, ylabel="Membrane potential (mV)", yticks=True))
plt.show()
# End simulation
p.end()
def test_using_static_synapse_singles1(self):
sim.setup(timestep=1.0)
input = sim.Population(2, sim.SpikeSourceArray([0]), label="input")
pop = sim.Population(2, sim.IF_curr_exp(), label="pop")
conn = sim.Projection(
input, pop, sim.OneToOneConnector(),
sim.StaticSynapse(weight=[0.7, 0.3], delay=[3, 33]))
try:
sim.run(1)
except Exception:
self.known_issue(
"https://github.com/SpiNNakerManchester/sPyNNaker/issues/618")
weights = conn.get(['weight', 'delay'], 'list')
sim.end()
target = [(0, 0, 0.7, 3), (1, 1, 0.3, 33)]
for i in range(2):
for j in range(2):
self.assertAlmostEqual(weights[i][j], target[i][j], places=3)
def do_run():
# this test ensures there is too much dtcm used up, thus crashes during
# initisation
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
input_pop = p.Population(1024, p.SpikeSourcePoisson, {'rate': 10}, "input")
relay_on = p.Population(1024, p.IF_curr_exp, {}, "input")
t_rule_LGN = p.SpikePairRule(tau_plus=17, tau_minus=34, A_plus=0.01,
A_minus=0.0085)
w_rule_LGN = p.AdditiveWeightDependence(w_min=0.0, w_max=0.3)
stdp_model_LGN = p.STDPMechanism(timing_dependence=t_rule_LGN,
weight_dependence=w_rule_LGN, weight=1)
# TODO weights=1
p.Projection(input_pop, relay_on, p.OneToOneConnector(),
synapse_type=stdp_model_LGN, receptor_type="excitatory")
p.run(1000)
p.end()
def do_run_with_reset(self):
sim.setup(timestep=1.0)
runtime = 500
n_neurons = 10
spikegap = 50
spike_times = list(n for n in range(0, runtime, spikegap))
pop_src = sim.Population(n_neurons,
sim.SpikeSourceArray(spike_times),
label="src")
pop_lif = sim.Population(n_neurons, sim.IF_curr_exp(), label="lif")
weight = 5
delay = 5
# define the projection
sim.Projection(pop_src,
pop_lif,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=weight, delay=delay),
receptor_type="excitatory")
pop_lif.record("all")
sim.run(runtime // 2)
# add another population to ensure a hard reset
sim.Population(n_neurons, sim.IF_curr_exp(), label="lif2")
sim.reset()
sim.run(runtime // 2)
pps = pop_lif.get_data()
totalpackets = sum(
pps.segments[0].filter(name='packets-per-timestep')[0]) + sum(
pps.segments[1].filter(name='packets-per-timestep')[0])
assert (totalpackets == n_neurons * (runtime // spikegap))
sim.end()
def test_recording_poisson_spikes_rate_0(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 256 # number of neurons in each population
p.set_number_of_neurons_per_core(p.IF_curr_exp, n_neurons / 2)
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
}
populations = list()
projections = list()
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(n_neurons,
p.SpikeSourcePoisson, {'rate': 0},
label='inputSpikes_1'))
projections.append(
p.Projection(populations[1], populations[0],
p.OneToOneConnector()))
populations[1].record("spikes")
p.run(5000)
spikes = populations[1].get_data("spikes")
print(spikes)
p.end()
def no_change_v(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp, {}, label="pop")
inp = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(inp,
pop,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5))
pop.set(i_offset=1.0)
pop.set(tau_syn_E=1)
pop.record(["v"])
sim.run(5)
sim.reset()
inp.set(spike_times=[100])
sim.run(5)
v2 = pop.spinnaker_get_data('v')
self.check_from_65(v2)
sim.end()
def do_run():
p.setup(timestep=1.0)
inp = p.Population(1, p.SpikeSourceArray(spike_times=[0]))
out = p.Population(1, p.IF_curr_exp())
connector = p.OneToOneConnector()
proj_1 = p.Projection(inp, out, connector,
p.StaticSynapse(weight=2.0, delay=2.0))
proj_2 = p.Projection(inp, out, connector,
p.StaticSynapse(weight=1.0, delay=1.0))
p.run(1)
proj_1_list = proj_1.get(("weight", "delay"), "list")
proj_2_list = proj_2.get(("weight", "delay"), "list")
p.end()
return proj_1_list, proj_2_list
def do_run():
p.setup(timestep=1, min_delay=1)
spiker = p.Population(1,
p.SpikeSourceArray(spike_times=[[5, 25]]),
label='inputSSA')
if_pop = p.Population(1, p.IF_cond_exp(), label='pop')
if_pop.record("spikes")
if_pop.record("v")
runtime = 30
# Create projection with delay such that the second spike occurs after
# the run has finished
weight = 5.0
delay = 7
p.Projection(spiker,
if_pop,
p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=weight, delay=delay),
receptor_type="excitatory",
source=None,
space=None)
p.run(runtime)
all1 = if_pop.get_data(["spikes", "v"])
# Reset (to time=0) and run again
p.reset()
p.run(runtime)
all2 = if_pop.get_data(["spikes", "v"])
p.end()
return (all1, all2)
def do_run():
p.setup(timestep=1, min_delay=1, max_delay=15)
spiker = p.Population(1, p.SpikeSourceArray(spike_times=[[0]]),
label='inputSSA_1')
if_pop = p.Population(2, p.IF_cond_exp(), label='pop_1')
if_pop.record("spikes")
if_pop.record("v")
p.Projection(spiker, if_pop, p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=5.0, delay=1),
receptor_type="excitatory", source=None, space=None)
p.run(30)
all1 = if_pop.get_data(["spikes", "v"])
p.reset()
p.run(30)
all2 = if_pop.get_data(["spikes", "v"])
p.end()
return (all1, all2)
def recording_1_element(self):
sim.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 200
boxed_array = numpy.zeros(shape=(0, 2))
spike_array = list()
for neuron_id in range(0, n_neurons):
spike_array.append(list())
for counter in range(0, 50):
random_time = random.randint(0, 4999)
boxed_array = numpy.append(boxed_array,
[[neuron_id, random_time]],
axis=0)
spike_array[neuron_id].append(random_time)
spike_array_params = {'spike_times': spike_array}
pop1 = sim.Population(n_neurons, sim.IF_curr_exp, {}, label='pop_1')
pop1.record("all")
input = sim.Population(n_neurons,
sim.SpikeSourceArray,
spike_array_params,
label='inputSpikes_1')
input.record("spikes")
sim.Projection(input, pop1, sim.OneToOneConnector())
sim.run(5000)
spike_array_spikes = input.spinnaker_get_data("spikes")
boxed_array = boxed_array[numpy.lexsort(
(boxed_array[:, 1], boxed_array[:, 0]))]
for i in range(len(spike_array_spikes)):
numpy.testing.assert_array_equal(spike_array_spikes[i],
boxed_array[i])
numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
sim.end()
# Stimulating populations
pre_times = generate_fixed_frequency_test_data(f, start_time - 1,
num_pairs + 1)
post_times = generate_fixed_frequency_test_data(
f, start_time + t, num_pairs)
pre_stim = sim.Population(
1, sim.SpikeSourceArray(spike_times=[pre_times]))
post_stim = sim.Population(
1, sim.SpikeSourceArray(spike_times=[post_times]))
# Update simulation time
sim_time = max(sim_time, max(max(pre_times), max(post_times)) + 100)
# Connections between spike sources and neuron populations
ee_connector = sim.OneToOneConnector()
sim.Projection(pre_stim,
pre_pop,
ee_connector,
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=2))
sim.Projection(post_stim,
post_pop,
ee_connector,
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=2))
# **HACK**
param_scale = 0.5
# Plastic Connection between pre_pop and post_pop
def potentiation_and_depression(self):
p.setup(1)
runtime = 100
initial_run = 1000 # to negate any initial conditions
# STDP parameters
a_plus = 0.1
a_minus = 0.0375
tau_plus = 20
tau_minus = 64
plastic_delay = 1
initial_weight = 0.05
max_weight = 0.1
min_weight = 0
pre_spikes = [10, 50]
extra_spikes = [30]
for i in range(len(pre_spikes)):
pre_spikes[i] += initial_run
for i in range(len(extra_spikes)):
extra_spikes[i] += initial_run
# Spike source to send spike via plastic synapse
pre_pop = p.Population(1,
p.SpikeSourceArray, {'spike_times': pre_spikes},
label="pre")
# Spike source to send spike via static synapse to make
# post-plastic-synapse neuron fire
extra_pop = p.Population(1,
p.SpikeSourceArray,
{'spike_times': extra_spikes},
label="extra")
# Post-plastic-synapse population
post_pop = p.Population(1, p.IF_cond_exp(), label="post")
# Create projections
p.Projection(pre_pop,
post_pop,
p.OneToOneConnector(),
p.StaticSynapse(weight=0.1, delay=1),
receptor_type="excitatory")
p.Projection(extra_pop,
post_pop,
p.OneToOneConnector(),
p.StaticSynapse(weight=0.1, delay=1),
receptor_type="excitatory")
syn_plas = p.STDPMechanism(
timing_dependence=p.extra_models.SpikeNearestPairRule(
tau_plus=tau_plus,
tau_minus=tau_minus,
A_plus=a_plus,
A_minus=a_minus),
weight_dependence=p.AdditiveWeightDependence(w_min=min_weight,
w_max=max_weight),
weight=initial_weight,
delay=plastic_delay)
plastic_synapse = p.Projection(pre_pop,
post_pop,
p.OneToOneConnector(),
synapse_type=syn_plas,
receptor_type='excitatory')
# Record the spikes
post_pop.record("spikes")
# Run
p.run(initial_run + runtime)
# Get the weights
weights = plastic_synapse.get('weight', 'list', with_address=False)
# Get the spikes
post_spikes = numpy.array(
# pylint: disable=no-member
post_pop.get_data('spikes').segments[0].spiketrains[0].magnitude)
# End the simulation as all information gathered
p.end()
# Get the spikes and time differences that will be considered by
# the simulation (as the last pre-spike will be considered differently)
pre_spikes = numpy.array(pre_spikes)
last_pre_spike = pre_spikes[-1]
considered_post_spikes = post_spikes[post_spikes < last_pre_spike]
considered_post_spikes += plastic_delay
potentiation_times = list()
depression_times = list()
for time in pre_spikes:
post_times = considered_post_spikes[considered_post_spikes > time]
if len(post_times) > 0:
last_time = post_times[0]
potentiation_times.append(time - last_time)
post_times = considered_post_spikes[considered_post_spikes < time]
if len(post_times) > 0:
last_time = post_times[-1]
depression_times.append(last_time - time)
potentiation_times = numpy.array(potentiation_times)
depression_times = numpy.array(depression_times)
# Work out the weight according to the rules
potentiations = max_weight * a_plus * numpy.exp(
(potentiation_times / tau_plus))
depressions = max_weight * a_minus * numpy.exp(
(depression_times / tau_minus))
new_weight_exact = \
initial_weight + numpy.sum(potentiations) - numpy.sum(depressions)
# print("Pre neuron spikes at: {}".format(pre_spikes))
# print("Post-neuron spikes at: {}".format(post_spikes))
target_spikes = [1013, 1032, 1051, 1056]
self.assertListEqual(list(post_spikes), target_spikes)
# print("New weight exact: {}".format(new_weight_exact))
# print("New weight SpiNNaker: {}".format(weights))
self.assertTrue(numpy.allclose(weights, new_weight_exact, rtol=0.001))
# Presynaptic population - Input layer - Stimuli
pop_input = sim.Population(
n_neurons,
sim.SpikeSourceArray,
spikeArray,
# sim.SpikeSourcePoisson(), #(rate=1, duration=sim_time),
label='pop_input')
# Postsynaptic population
"""
Notes:
* Interesting property about this neuron model: voltage_based_synapses = True
* Initial voltage value = -70.0
"""
pop_output = sim.Population(n_neurons, sim.Izhikevich(), label='pop_output')
sim.Projection(pop_input, pop_output, sim.OneToOneConnector(),
sim.StaticSynapse(weight=20.0, delay=2))
# == Instrument the network ====================================================
# Record all to observe.
"""
Note:
Recordables of the Izhikevich neuron model are limited with voltage, spikes, and unit(mV/ms) of the population.
"""
pop_output.record("all")
# === Run the simulation =======================================================
sim.run(sim_time)
# Set the times at which to input a spike
spike_times = range(0, run_time, 100)
p.setup(time_step)
spikeArray = {"spike_times": spike_times}
input_pop = p.Population(1, p.SpikeSourceArray(**spikeArray), label="input")
myModelCurrExpParams = {"my_parameter": -70.0, "i_offset": i_offset}
my_model_pop = p.Population(1,
My_Model_Curr_Exp(**myModelCurrExpParams),
label="my_model_pop")
p.Projection(input_pop,
my_model_pop,
p.OneToOneConnector(),
receptor_type='excitatory',
synapse_type=p.StaticSynapse(weight=weight))
myModelCurrMySynapseTypeParams = {
"my_parameter": -70.0,
"i_offset": i_offset,
"my_ex_synapse_parameter": 0.5
}
my_model_my_synapse_type_pop = p.Population(
1,
My_Model_Curr_My_Synapse_Type(**myModelCurrMySynapseTypeParams),
label="my_model_my_synapse_type_pop")
p.Projection(input_pop,
my_model_my_synapse_type_pop,
p.OneToOneConnector(),
outputs = 2
p.setup(timestep=1.0, min_delay=1)
p.set_number_of_neurons_per_core(p.IF_cond_exp, 100)
input_model = gym.Pendulum(
encoding=encoding, time_increment=time_increment, pole_length=pole_length,
pole_angle=pole_angle, reward_based=reward_based,
force_increments=force_increments, max_firing_rate=max_firing_rate,
number_of_bins=number_of_bins, central=central,
rand_seed=[np.random.randint(0xffff) for i in range(4)], bin_overlap=3,
label='pendulum_pop')
pendulum_pop_size = input_model.neurons()
pendulum = p.Population(pendulum_pop_size, input_model)
null_pop = p.Population(4*number_of_bins, p.IF_cond_exp(), label='null')
p.Projection(pendulum, null_pop, p.OneToOneConnector(),
p.StaticSynapse(weight=0.09))
null_pop.record(['spikes', 'v', 'gsyn_exc'])
# null_pop.record(['spikes', 'v'])
# null_pops = []
# for i in range(4*number_of_bins):
# null_pops.append(p.Population(1, p.IF_cond_exp(),
# label='null {}'.format(i)))
# null_pops[i].record(['spikes', 'v'])
# p.Projection(pendulum, null_pops[i],
# p.FromListConnector([[i, 0, weight, 1]]))
arm_collection = []
# input_spikes = []
rate = 5
print('rate = ', rate)
def main():
minutes = 0
seconds = 30
milliseconds = 0
run_time = minutes * 60 * 1000 + seconds * 1000 + milliseconds
weight_to_spike = 4.
model = sim.IF_curr_exp
cell_params = {
'cm': 0.25, # nF
'i_offset': 0.0,
'tau_m': 10.0,
'tau_refrac': 2.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -55.4
}
# Available resolutions
# 16, 32, 64, 128
mode = ExternalDvsEmulatorDevice.MODE_64
cam_res = int(mode)
cam_fps = 90
frames_per_saccade = cam_fps / 3 - 1
polarity = ExternalDvsEmulatorDevice.MERGED_POLARITY
output_type = ExternalDvsEmulatorDevice.OUTPUT_TIME
history_weight = 1.0
behaviour = VirtualCam.BEHAVE_ATTENTION
# vcam = VirtualCam("./mnist", behaviour=behaviour, fps=cam_fps,
# resolution=cam_res, frames_per_saccade=frames_per_saccade)
cam_params = {
'mode': mode,
'polarity': polarity,
'threshold': 12,
'adaptive_threshold': False,
'fps': cam_fps,
'inhibition': False,
'output_type': output_type,
'save_spikes': "./spikes_from_cam.pickle",
'history_weight': history_weight,
'device_id': 0, # for an OpenCV webcam device
#'device_id': 'path/to/video/file', # to encode pre-recorded video
#'device_id': vcam,
}
if polarity == ExternalDvsEmulatorDevice.MERGED_POLARITY:
num_neurons = 2 * (cam_res**2)
else:
num_neurons = cam_res**2
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)
target = sim.Population(num_neurons, model, cell_params)
stimulation = sim.Population(num_neurons,
DvsEmulatorDevice,
cam_params,
label="Webcam population")
connector = sim.OneToOneConnector()
sim.Projection(stimulation,
target,
connector,
synapse_type=sim.StaticSynapse(weight=weight_to_spike))
target.record("spikes")
sim.run(run_time)
# spikes = target.getSpikes(compatible_output=True)
target_neo = target.get_data(variables=["spikes"])
spikes = target_neo.segments[0].spiketrains
sim.end()
#stimulation._vertex.stop()
print("Raster plot of the spikes that Spinnaker echoed back")
fig = pylab.figure()
spike_times = [spike_time for (neuron_id, spike_time) in spikes]
spike_ids = [neuron_id for (neuron_id, spike_time) in spikes]
pylab.plot(spike_times,
spike_ids,
".",
markerfacecolor="None",
markeredgecolor="Blue",
markersize=3)
pylab.show()
def _connect_spike_sources(self, retinae=None, verbose=False):
if verbose:
print "INFO: Connecting Spike Sources to Network."
global _retina_proj_l, _retina_proj_r
# left is 0--dimensionRetinaY-1; right is dimensionRetinaY--dimensionRetinaY*2-1
connListRetLBlockerL = []
connListRetLBlockerR = []
connListRetRBlockerL = []
connListRetRBlockerR = []
for y in range(0, self.dim_y):
connListRetLBlockerL.append(
(y, y, self.cell_params['synaptic']['wSaB'],
self.cell_params['synaptic']['dSaB']))
connListRetLBlockerR.append(
(y, y + self.dim_y, self.cell_params['synaptic']['wSzB'],
self.cell_params['synaptic']['dSzB']))
connListRetRBlockerL.append(
(y, y, self.cell_params['synaptic']['wSzB'],
self.cell_params['synaptic']['dSzB']))
connListRetRBlockerR.append(
(y, y + self.dim_y, self.cell_params['synaptic']['wSaB'],
self.cell_params['synaptic']['dSaB']))
retinaLeft = retinae['left'].pixel_columns
retinaRight = retinae['right'].pixel_columns
pixel = 0
for row in _retina_proj_l:
for pop in row:
ps.Projection(retinaLeft[pixel],
self.network[pop][1],
ps.OneToOneConnector(),
ps.StaticSynapse(
weight=self.cell_params['synaptic']['wSC'],
delay=self.cell_params['synaptic']['dSC']),
receptor_type='excitatory')
#ps.OneToOneConnector(weights=self.cell_params['synaptic']['wSC'],
# delays=self.cell_params['synaptic']['dSC']),
#target='excitatory')
ps.Projection(retinaLeft[pixel],
self.network[pop][0],
ps.FromListConnector(connListRetLBlockerL),
receptor_type='excitatory')
#target='excitatory')
ps.Projection(retinaLeft[pixel],
self.network[pop][0],
ps.FromListConnector(connListRetLBlockerR),
receptor_type='inhibitory')
#target='inhibitory')
pixel += 1
pixel = 0
for col in _retina_proj_r:
for pop in col:
ps.Projection(retinaRight[pixel],
self.network[pop][1],
ps.OneToOneConnector(),
ps.StaticSynapse(
weight=self.cell_params['synaptic']['wSC'],
delay=self.cell_params['synaptic']['dSC']),
receptor_type='excitatory')
#ps.OneToOneConnector(weights=self.cell_params['synaptic']['wSC'],
# delays=self.cell_params['synaptic']['dSC']),
#target='excitatory')
ps.Projection(retinaRight[pixel],
self.network[pop][0],
ps.FromListConnector(connListRetRBlockerR),
receptor_type='excitatory')
#target='excitatory')
ps.Projection(retinaRight[pixel],
self.network[pop][0],
ps.FromListConnector(connListRetRBlockerL),
receptor_type='inhibitory')
#target='inhibitory')
pixel += 1
def _interconnect_neurons_inhexc(self, network, verbose=False):
assert network is not None, \
"ERROR: Network is not initialised! Interconnecting for inhibitory and excitatory patterns failed."
if verbose and self.cell_params['topological']['radius_i'] < self.dim_x:
print "WARNING: Bad radius of inhibition. Uniquness constraint cannot be satisfied."
if verbose and 0 <= self.cell_params['topological'][
'radius_e'] > self.dim_x:
print "WARNING: Bad radius of excitation. "
# create lists with inhibitory along the Retina Right projective line
nbhoodInhL = []
nbhoodInhR = []
nbhoodExcX = []
nbhoodEcxY = []
# used for the triangular form of the matrix in order to remain within the square
if verbose:
print "INFO: Generating inhibitory and excitatory connectivity patterns."
# generate rows
limiter = self.max_disparity - self.min_disparity + 1
ensembleIndex = 0
while ensembleIndex < len(network):
if ensembleIndex / (self.max_disparity - self.min_disparity + 1) > \
(self.dim_x - self.min_disparity) - (self.max_disparity - self.min_disparity) - 1:
limiter -= 1
if limiter == 0:
break
nbhoodInhL.append(
[ensembleIndex + disp for disp in range(0, limiter)])
ensembleIndex += limiter
ensembleIndex = len(network)
# generate columns
nbhoodInhR = [[x] for x in nbhoodInhL[0]]
shiftGlob = 0
for x in nbhoodInhL[1:]:
shiftGlob += 1
shift = 0
for e in x:
if (shift + 1) % (self.max_disparity - self.min_disparity +
1) == 0:
nbhoodInhR.append([e])
else:
nbhoodInhR[shift + shiftGlob].append(e)
shift += 1
# generate all diagonals
for diag in map(None, *nbhoodInhL):
sublist = []
for elem in diag:
if elem is not None:
sublist.append(elem)
nbhoodExcX.append(sublist)
# generate all y-axis excitation
for x in range(0, self.dim_y):
for e in range(1, self.cell_params['topological']['radius_e'] + 1):
if x + e < self.dim_y:
nbhoodEcxY.append(
(x, x + e, self.cell_params['synaptic']['wCCe'],
self.cell_params['synaptic']['dCCe']))
if x - e >= 0:
nbhoodEcxY.append(
(x, x - e, self.cell_params['synaptic']['wCCe'],
self.cell_params['synaptic']['dCCe']))
# Store these lists as global parameters as they can be used to quickly match the spiking collector neuron
# with the corresponding pixel xy coordinates (same_disparity_indices)
# TODO: think of a better way to encode pixels: closed form formula would be perfect
# These are also used when connecting the spike sources to the network! (retina_proj_l, retina_proj_r)
global _retina_proj_l, _retina_proj_r, same_disparity_indices
_retina_proj_l = nbhoodInhL
_retina_proj_r = nbhoodInhR
same_disparity_indices = nbhoodExcX
if verbose:
print "INFO: Connecting neurons for internal excitation and inhibition."
for row in nbhoodInhL:
for pop in row:
for nb in row:
if nb != pop:
ps.Projection(
network[pop][1],
network[nb][1],
#ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCi'],
# delays=self.cell_params['synaptic']['dCCi']),
#target='inhibitory')
ps.OneToOneConnector(),
ps.StaticSynapse(
weight=self.cell_params['synaptic']['wCCi'],
delay=self.cell_params['synaptic']['dCCi']),
receptor_type='inhibitory')
for col in nbhoodInhR:
for pop in col:
for nb in col:
if nb != pop:
ps.Projection(
network[pop][1],
network[nb][1],
ps.OneToOneConnector(),
ps.StaticSynapse(
weight=self.cell_params['synaptic']['wCCi'],
delay=self.cell_params['synaptic']['dCCi']),
#ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCi'],
# delays=self.cell_params['synaptic']['dCCi']),
#target='inhibitory'
receptor_type='inhibitory')
for diag in nbhoodExcX:
for pop in diag:
for nb in range(
1, self.cell_params['topological']['radius_e'] + 1):
if diag.index(pop) + nb < len(diag):
ps.Projection(
network[pop][1],
network[diag[diag.index(pop) + nb]][1],
ps.OneToOneConnector(),
ps.StaticSynapse(
weight=self.cell_params['synaptic']['wCCe'],
delay=self.cell_params['synaptic']['dCCe']),
receptor_type='excitatory')
#ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCe'],
# delays=self.cell_params['synaptic']['dCCe']),
#target='excitatory')
if diag.index(pop) - nb >= 0:
ps.Projection(
network[pop][1],
network[diag[diag.index(pop) - nb]][1],
ps.OneToOneConnector(),
ps.StaticSynapse(
weight=self.cell_params['synaptic']['wCCe'],
delay=self.cell_params['synaptic']['dCCe']),
receptor_type='excitatory')
#ps.OneToOneConnector(weights=self.cell_params['synaptic']['wCCe'],
# delays=self.cell_params['synaptic']['dCCe']),
#target='excitatory')
for ensemble in network:
ps.Projection(ensemble[1],
ensemble[1],
ps.FromListConnector(nbhoodEcxY),
receptor_type='excitatory') #target='excitatory')
def do_run(seed=None):
random.seed(seed)
# SpiNNaker setup
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)
# +-------------------------------------------------------------------+
# | General Parameters |
# +-------------------------------------------------------------------+
# Population parameters
model = sim.IF_curr_exp
cell_params = {
'cm': 0.25,
'i_offset': 0.0,
'tau_m': 10.0,
'tau_refrac': 2.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -55.4
}
# Other simulation parameters
e_rate = 200
in_rate = 350
n_stim_test = 5
n_stim_pairing = 10
dur_stim = 20
pop_size = 40
ISI = 150.
start_test_pre_pairing = 200.
start_pairing = 1500.
start_test_post_pairing = 700.
simtime = start_pairing + start_test_post_pairing + \
ISI*(n_stim_pairing + n_stim_test) + 550. # let's make it 5000
# Initialisations of the different types of populations
IAddPre = []
IAddPost = []
# +-------------------------------------------------------------------+
# | Creation of neuron populations |
# +-------------------------------------------------------------------+
# Neuron populations
pre_pop = sim.Population(pop_size, model(**cell_params))
post_pop = sim.Population(pop_size, model(**cell_params))
# Test of the effect of activity of the pre_pop population on the post_pop
# population prior to the "pairing" protocol : only pre_pop is stimulated
for i in range(n_stim_test):
IAddPre.append(
sim.Population(
pop_size,
sim.SpikeSourcePoisson(rate=in_rate,
start=start_test_pre_pairing + ISI *
(i),
duration=dur_stim,
seed=random.randint(0, 100000000))))
# Pairing protocol : pre_pop and post_pop are stimulated with a 10 ms
# difference
for i in range(n_stim_pairing):
IAddPre.append(
sim.Population(
pop_size,
sim.SpikeSourcePoisson(rate=in_rate,
start=start_pairing + ISI * (i),
duration=dur_stim,
seed=random.randint(0, 100000000))))
IAddPost.append(
sim.Population(
pop_size,
sim.SpikeSourcePoisson(rate=in_rate,
start=start_pairing + ISI * (i) + 10.,
duration=dur_stim,
seed=random.randint(0, 100000000))))
# Test post pairing : only pre_pop is stimulated
# (and should trigger activity in Post)
for i in range(n_stim_test):
start = start_pairing + ISI * n_stim_pairing + \
start_test_post_pairing + ISI * i
IAddPre.append(
sim.Population(
pop_size,
sim.SpikeSourcePoisson(rate=in_rate,
start=start,
duration=dur_stim,
seed=random.randint(0, 100000000))))
# Noise inputs
INoisePre = sim.Population(pop_size,
sim.SpikeSourcePoisson(rate=e_rate,
start=0,
duration=simtime,
seed=random.randint(
0, 100000000)),
label="expoisson")
INoisePost = sim.Population(pop_size,
sim.SpikeSourcePoisson(rate=e_rate,
start=0,
duration=simtime,
seed=random.randint(
0, 100000000)),
label="expoisson")
# +-------------------------------------------------------------------+
# | Creation of connections |
# +-------------------------------------------------------------------+
# Connection parameters
JEE = 3.
# Connection type between noise poisson generator and
# excitatory populations
ee_connector = sim.OneToOneConnector()
# Noise projections
sim.Projection(INoisePre,
pre_pop,
ee_connector,
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=JEE * 0.05))
sim.Projection(INoisePost,
post_pop,
ee_connector,
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=JEE * 0.05))
# Additional Inputs projections
for i in range(len(IAddPre)):
sim.Projection(IAddPre[i],
pre_pop,
ee_connector,
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=JEE * 0.05))
for i in range(len(IAddPost)):
sim.Projection(IAddPost[i],
post_pop,
ee_connector,
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=JEE * 0.05))
# Plastic Connections between pre_pop and post_pop
stdp_model = sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(tau_plus=20.,
tau_minus=50.0,
A_plus=0.02,
A_minus=0.02),
weight_dependence=sim.AdditiveWeightDependence(w_min=0, w_max=0.9))
rng = NumpyRNG(seed=seed, parallel_safe=True)
plastic_projection = \
sim.Projection(pre_pop, post_pop, sim.FixedProbabilityConnector(
p_connect=0.5, rng=rng), synapse_type=stdp_model)
# +-------------------------------------------------------------------+
# | Simulation and results |
# +-------------------------------------------------------------------+
# Record spikes and neurons' potentials
pre_pop.record(['v', 'spikes'])
post_pop.record(['v', 'spikes'])
# Run simulation
sim.run(simtime)
weights = plastic_projection.get('weight', 'list')
pre_spikes = neo_convertor.convert_spikes(pre_pop.get_data('spikes'))
post_spikes = neo_convertor.convert_spikes(post_pop.get_data('spikes'))
# End simulation on SpiNNaker
sim.end()
return (pre_spikes, post_spikes, weights)
def run_script(simtime,
n_neurons,
run_split=1,
record_spikes=False,
spike_rate=None,
spike_rec_indexes=None,
spike_get_indexes=None,
record_v=False,
v_rate=None,
v_rec_indexes=None,
v_get_indexes=None,
record_exc=False,
exc_rate=None,
exc_rec_indexes=None,
exc_get_indexes=None,
record_inh=False,
inh_rate=None,
inh_rec_indexes=None,
inh_get_indexes=None,
file_prefix=""):
sim.setup(timestep=1)
pop_1 = sim.Population(n_neurons, sim.IF_curr_exp(), label="pop_1")
input1 = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(input1,
pop_1,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
input2 = sim.Population(n_neurons,
sim.SpikeSourcePoisson(rate=100.0),
label="Stim_Exc",
additional_parameters={"seed": 1})
sim.Projection(input2,
pop_1,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
if record_spikes:
if spike_rec_indexes is None:
pop_1.record(['spikes'], sampling_interval=spike_rate)
else:
view = PopulationView(pop_1, spike_rec_indexes)
view.record(['spikes'], sampling_interval=spike_rate)
if record_v:
if v_rec_indexes is None:
pop_1.record(['v'], sampling_interval=v_rate)
else:
view = PopulationView(pop_1, v_rec_indexes)
view.record(['v'], sampling_interval=v_rate)
if record_exc:
if exc_rec_indexes is None:
pop_1.record(['gsyn_exc'], sampling_interval=exc_rate)
else:
view = PopulationView(pop_1, exc_rec_indexes)
view.record(['gsyn_exc'], sampling_interval=exc_rate)
if record_inh:
if inh_rec_indexes is None:
pop_1.record(['gsyn_inh'], sampling_interval=inh_rate)
else:
view = PopulationView(pop_1, inh_rec_indexes)
view.record(['gsyn_inh'], sampling_interval=inh_rate)
for i in range(run_split):
sim.run(simtime / run_split)
if record_spikes:
if spike_get_indexes is None:
neo = pop_1.get_data("spikes")
else:
view = PopulationView(pop_1, spike_get_indexes)
neo = view.get_data("spikes")
spikes = neo.segments[0].spiketrains
spike_file = os.path.join(current_file_path,
file_prefix + "spikes.csv")
write_spikes(spikes, spike_file)
else:
spikes = None
if record_v:
if v_get_indexes is None:
neo = pop_1.get_data("v")
else:
view = PopulationView(pop_1, v_get_indexes)
neo = view.get_data("v")
v = neo.segments[0].filter(name='v')[0]
v_file = os.path.join(current_file_path, file_prefix + "v.csv")
numpy.savetxt(v_file, v, delimiter=',')
else:
v = None
if record_exc:
if exc_get_indexes is None:
neo = pop_1.get_data('gsyn_exc')
else:
view = PopulationView(pop_1, exc_get_indexes)
neo = view.get_data('gsyn_exc')
exc = neo.segments[0].filter(name='gsyn_exc')[0]
exc_file = os.path.join(current_file_path, file_prefix + "exc.csv")
numpy.savetxt(exc_file, exc, delimiter=',')
else:
exc = None
if record_inh:
if inh_get_indexes is None:
neo = pop_1.get_data('gsyn_inh')
else:
view = PopulationView(pop_1, inh_get_indexes)
neo = view.get_data('gsyn_inh')
inh = neo.segments[0].filter(name='gsyn_inh')[0]
inh_file = os.path.join(current_file_path, file_prefix + "inh.csv")
numpy.savetxt(inh_file, inh, delimiter=',')
else:
inh = None
sim.end()
return spikes, v, exc, inh
label='pop_backward')
# Create injection populations
injector_forward = Frontend.Population(
n_neurons,
Frontend.external_devices.SpikeInjector(
**cell_params_spike_injector_with_key),
label='spike_injector_forward')
injector_backward = Frontend.Population(
n_neurons,
Frontend.external_devices.SpikeInjector(**cell_params_spike_injector),
label='spike_injector_backward')
# Create a connection from the injector into the populations
Frontend.Projection(injector_forward, pop_forward,
Frontend.OneToOneConnector(),
Frontend.StaticSynapse(weight=weight_to_spike))
Frontend.Projection(injector_backward, pop_backward,
Frontend.OneToOneConnector(),
Frontend.StaticSynapse(weight=weight_to_spike))
# Synfire chain connections where each neuron is connected to its next neuron
# NOTE: there is no recurrent connection so that each chain stops once it
# reaches the end
loop_forward = list()
loop_backward = list()
for i in range(0, n_neurons - 1):
loop_forward.append((i, (i + 1) % n_neurons, weight_to_spike, 3))
loop_backward.append(((i + 1) % n_neurons, i, weight_to_spike, 3))
Frontend.Projection(pop_forward, pop_forward,
Frontend.FromListConnector(loop_forward))
def get_injector_label(self):
return "MyEthernetSensor"
def get_injector_parameters(self):
return {}
def get_translator(self):
return None
def get_database_connection(self):
return self._live_spikes_connection
p.setup(1.0)
ethernet_sensor = p.external_devices.EthernetSensorPopulation(
MyEthernetSensor())
ethernet_input_pop = p.Population(1, p.IF_curr_exp())
ethernet_input_pop.record("v")
p.Projection(ethernet_sensor, ethernet_input_pop, p.OneToOneConnector(),
p.StaticSynapse(weight=1.0))
p.run(1000)
print ethernet_input_pop.get_data("v").segments[0].filter(name='v')
p.end()
def do_run(nNeurons, neurons_per_core):
p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0)
p.set_number_of_neurons_per_core(p.IF_curr_exp, neurons_per_core)
nPopulations = 62
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}
populations = list()
projections = list()
weight_to_spike = 1.5
delay = 5
for i in range(0, nPopulations):
populations.append(p.Population(nNeurons, p.IF_curr_exp,
cell_params_lif,
label='pop_' + str(i)))
# print("++++++++++++++++")
# print("Added population %s" % (i))
# print("o-o-o-o-o-o-o-o-")
synapse_type = p.StaticSynapse(weight=weight_to_spike, delay=delay)
for i in range(0, nPopulations):
projections.append(p.Projection(populations[i],
populations[(i + 1) % nPopulations],
p.OneToOneConnector(),
synapse_type=synapse_type,
label="Projection from pop {} to pop "
"{}".format(i, (i + 1) %
nPopulations)))
# print("++++++++++++++++++++++++++++++++++++++++++++++++++++")
# print("Added projection from population %s to population %s" \
# % (i, (i + 1) % nPopulations))
# print("----------------------------------------------------")
# from pprint import pprint as pp
# pp(projections)
spikeArray = {'spike_times': [[0]]}
populations.append(p.Population(1, p.SpikeSourceArray, spikeArray,
label='inputSpikes_1'))
projections.append(p.Projection(populations[-1], populations[0],
p.AllToAllConnector(),
synapse_type=synapse_type))
for i in range(0, nPopulations):
populations[i].record("v")
populations[i].record("gsyn_exc")
populations[i].record("spikes")
p.run(1500)
''''
weights = projections[0].getWeights()
delays = projections[0].getDelays()
'''
neo = populations[0].get_data(["v", "spikes", "gsyn_exc"])
v = neo_convertor.convert_data(neo, name="v")
gsyn = neo_convertor.convert_data(neo, name="gsyn_exc")
spikes = neo_convertor.convert_spikes(neo)
p.end()
return (v, gsyn, spikes)
if rng is None:
seed = None
else:
seed = int(rng.next() * 1000)
stim_inh = sim.Population(n_inh,
sim.SpikeSourcePoisson(rate=1000.0,
seed=int(rng.next() * 1000)),
label="Stim_Inh")
# Create a one-to-one excitatory connection
# from the excitatory poisson stimulation population
# to the excitatory population with a weight of 0.1nA and a delay of 1.0ms
# TODO values
ex_proj = sim.Projection(stim_exc,
pop_exc,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=0.1, delay=1.0),
receptor_type="excitatory")
# Create a similar excitatory connection
# from the inhibitory poisson stimulation population
# to the inhibitory population.
in_proj = sim.Projection(stim_inh,
pop_inh,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=0.1, delay=1.0),
receptor_type="excitatory")
# Create an excitatory connection from the excitatory population
# to the inhibitory population
# with a fixed probability of connection of 0.1,
pynn.SpikeSourcePoisson(rate=10.0),
label="Poisson_pop_E")
Poiss_ext_I = pynn.Population(N_I,
pynn.SpikeSourcePoisson(rate=10.0),
label="Poisson_pop_I")
# Connectors
E_conn = pynn.FixedProbabilityConnector(epsilon)
I_conn = pynn.FixedProbabilityConnector(epsilon)
# Use random delays for the external noise and
# set the inital membrance voltage below the resting potential
# to avoid the overshoot of activity in the beginning of the simulation
rng = NumpyRNG(seed=1)
delay_distr = RandomDistribution('uniform', low=1.0, high=16.0, rng=rng)
Ext_conn = pynn.OneToOneConnector()
uniformDistr = RandomDistribution('uniform', low=-10, high=0, rng=rng)
E_pop.initialize(v=uniformDistr)
I_pop.initialize(v=uniformDistr)
# Projections
E_E = pynn.Projection(E_pop,
E_pop,
E_conn,
receptor_type="excitatory",
synapse_type=pynn.StaticSynapse(weight=J_E, delay=delay))
I_E = pynn.Projection(I_pop,
E_pop,
I_conn,
receptor_type="inhibitory",
def test_agent(arm1, arm2):
arm = [arm1, arm2]
print "arm = ", arm
connections = read_agent()
p.setup(timestep=1.0, min_delay=1, max_delay=127)
p.set_number_of_neurons_per_core(p.IF_cond_exp, 100)
bandit = p.Population(len(arm), Bandit(arm, exposure_time, reward_based=reward, label='bandit_pop'))
[in2e, in2i, e_size, e2e, e2i, i_size, i2e, i2i, e2out, i2out] = connections
if e_size > 0:
excite = p.Population(e_size, p.IF_cond_exp(), label='excite_pop')
excite_noise = p.Population(e_size, p.SpikeSourcePoisson(rate=noise_rate))
p.Projection(excite_noise, excite, p.OneToOneConnector(),
p.StaticSynapse(weight=noise_weight), receptor_type='excitatory')
excite.record('spikes')
if i_size > 0:
inhib = p.Population(i_size, p.IF_cond_exp(), label='inhib_pop')
inhib_noise = p.Population(i_size, p.SpikeSourcePoisson(rate=noise_rate))
p.Projection(inhib_noise, inhib, p.OneToOneConnector(),
p.StaticSynapse(weight=noise_weight), receptor_type='excitatory')
inhib.record('spikes')
if len(in2e) != 0:
p.Projection(bandit, excite, p.FromListConnector(in2e),
receptor_type='excitatory')
# p.Projection(starting_pistol, excite, p.FromListConnector(in2e),
# receptor_type='excitatory')
if len(in2i) != 0:
p.Projection(bandit, inhib, p.FromListConnector(in2i),
receptor_type='excitatory')
# p.Projection(starting_pistol, inhib, p.FromListConnector(in2i),
# receptor_type='excitatory')
if len(e2e) != 0:
p.Projection(excite, excite, p.FromListConnector(e2e),
receptor_type='excitatory')
if len(e2i) != 0:
p.Projection(excite, inhib, p.FromListConnector(e2i),
receptor_type='excitatory')
if len(i2e) != 0:
p.Projection(inhib, excite, p.FromListConnector(i2e),
receptor_type='inhibitory')
if len(i2i) != 0:
p.Projection(inhib, inhib, p.FromListConnector(i2i),
receptor_type='inhibitory')
if len(e2out) != 0:
p.Projection(excite, bandit, p.FromListConnector(e2out),
receptor_type='excitatory')
if len(i2out) != 0:
p.Projection(inhib, bandit, p.FromListConnector(i2out),
receptor_type='inhibitory')
simulator = get_simulator()
p.run(runtime)
scores = get_scores(game_pop=bandit, simulator=simulator)
print scores
print arm
e_spikes = excite.get_data('spikes').segments[0].spiketrains
i_spikes = inhib.get_data('spikes').segments[0].spiketrains
# v = receive_pop[i].get_data('v').segments[0].filter(name='v')[0]
plt.figure("[{}, {}] - {}".format(arm1, arm2, scores))
Figure(
Panel(e_spikes, xlabel="Time (ms)", ylabel="nID", xticks=True),
Panel(i_spikes, xlabel="Time (ms)", ylabel="nID", xticks=True)
)
plt.show()
p.end()
