def test_script(self):
"""
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("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)
print spikes
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(
weights=weight_to_spike, delays=delay)))
populations[1].record()
p.run(1000)
spikes = populations[1].getSpikes(compatible_output=True)
if spikes is not None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.xlabel('Time/ms')
pylab.ylabel('spikes')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
p.end()
def test_recording_numerious_element(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 20 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
boxed_array = numpy.zeros(shape=(0, 2))
spike_array = list()
for neuron_id in range(0, n_neurons):
spike_array.append(list())
for random_time in range(0, 20):
random_time2 = random.randint(0, 5000)
boxed_array = numpy.append(boxed_array,
[[neuron_id, random_time2]],
axis=0)
spike_array[neuron_id].append(random_time)
spike_array_params = {'spike_times': spike_array}
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(n_neurons,
p.SpikeSourceArray,
spike_array_params,
label='inputSpikes_1'))
projections.append(
p.Projection(populations[1], populations[0],
p.OneToOneConnector()))
populations[1].record()
p.run(5000)
spike_array_spikes = populations[1].getSpikes()
boxed_array = boxed_array[numpy.lexsort(
(boxed_array[:, 1], boxed_array[:, 0]))]
numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
p.end()
def test_recording_numerious_element_over_limit(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 2000 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
boxed_array = numpy.zeros(shape=(0, 2))
spike_array = list()
for neuron_id in range(0, n_neurons):
spike_array.append(list())
for random_time in range(0, 200000):
random_time2 = random.randint(0, 50000)
boxed_array = numpy.append(
boxed_array, [[neuron_id, random_time2]], axis=0)
spike_array[neuron_id].append(random_time)
spike_array_params = {'spike_times': spike_array}
populations.append(p.Population(n_neurons, p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(p.Population(n_neurons, p.SpikeSourceArray,
spike_array_params,
label='inputSpikes_1'))
projections.append(p.Projection(populations[1], populations[0],
p.OneToOneConnector()))
populations[1].record()
p.run(50000)
spike_array_spikes = populations[1].getSpikes()
boxed_array = boxed_array[numpy.lexsort((boxed_array[:, 1],
boxed_array[:, 0]))]
numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
p.end()
def test_recording_1_element(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 200 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
spike_array = {'spike_times': [[0]]}
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spike_array,
label='inputSpikes_1'))
projections.append(
p.Projection(populations[1], populations[0],
p.AllToAllConnector()))
populations[1].record()
p.run(5000)
spike_array_spikes = populations[1].getSpikes()
boxed_array = numpy.zeros(shape=(0, 2))
boxed_array = numpy.append(boxed_array, [[0, 0]], axis=0)
numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
p.end()
def test_get_weights(self):
# Population parameters
cell_params = {
'cm': 0.2, # nF
'i_offset': 0.2,
'tau_m': 20.0,
'tau_refrac': 5.0,
'tau_syn_E': 5.0,
'tau_syn_I': 10.0,
'v_reset': -60.0,
'v_rest': -60.0,
'v_thresh': -50.0
}
# Reduce number of neurons to simulate on each core
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 10)
# Build inhibitory plasticity model
stdp_model = sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(tau_plus=20.0,
tau_minus=12.7,
nearest=True),
weight_dependence=sim.AdditiveWeightDependence(w_min=0.0,
w_max=1.0,
A_plus=0.05),
mad=True)
# Build plastic network
plastic_ex_pop, plastic_ie_projection =\
self.build_network(sim.SynapseDynamics(slow=stdp_model),
cell_params)
# Run simulation
sim.run(1000)
# Get plastic spikes and save to disk
plastic_spikes = plastic_ex_pop.getSpikes(compatible_output=True)
#numpy.save("plastic_spikes.npy", plastic_spikes)
plastic_weights = plastic_ie_projection.getWeights(format="array")
# mean_weight = numpy.average(plastic_weights)
# End simulation on SpiNNaker
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("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()
p.run(5000)
spikes = populations[1].getSpikes()
print spikes
p.end()
def test_get_weights(self):
# Population parameters
cell_params = {
'cm': 0.2, # nF
'i_offset': 0.2,
'tau_m': 20.0,
'tau_refrac': 5.0,
'tau_syn_E': 5.0,
'tau_syn_I': 10.0,
'v_reset': -60.0,
'v_rest': -60.0,
'v_thresh': -50.0
}
# Reduce number of neurons to simulate on each core
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100)
# Build inhibitory plasticity model
stdp_model = sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(
tau_plus=20.0, tau_minus=12.7, nearest=True),
weight_dependence=sim.AdditiveWeightDependence(
w_min=0.0, w_max=1.0, A_plus=0.05),
mad=True
)
# Build plastic network
plastic_ex_pop, plastic_ie_projection =\
self.build_network(sim.SynapseDynamics(slow=stdp_model),
cell_params)
# Run simulation
sim.run(10000)
# Get plastic spikes and save to disk
plastic_spikes = plastic_ex_pop.getSpikes(compatible_output=True)
#numpy.save("plastic_spikes.npy", plastic_spikes)
plastic_weights = plastic_ie_projection.getWeights(format="array")
# mean_weight = numpy.average(plastic_weights)
# End simulation on SpiNNaker
sim.end()
def simulate(self, spinnaker, input_spike_times):
# Cell parameters
cell_params = {
'tau_m': 20.0,
'v_rest': -60.0,
'v_reset': -60.0,
'v_thresh': -40.0,
'tau_syn_E': 2.0,
'tau_syn_I': 2.0,
'tau_refrac': 2.0,
'cm': 0.25,
'i_offset': 0.0,
}
rng = p.NumpyRNG(seed=28375)
v_init = p.RandomDistribution('uniform', [-60, -40], rng)
p.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)
pop = p.Population(1, p.IF_curr_exp, cell_params, label='population')
pop.randomInit(v_init)
pop.record()
pop.record_v()
noise = p.Population(1, p.SpikeSourceArray,
{"spike_times": input_spike_times})
p.Projection(noise,
pop,
p.OneToOneConnector(weights=0.4, delays=1),
target='excitatory')
# Simulate
p.run(self.simtime)
pop_voltages = pop.get_v(compatible_output=True)
pop_spikes = pop.getSpikes(compatible_output=True)
p.end()
return pop_voltages, pop_spikes
def main():
# setup timestep of simulation and minimum and maximum synaptic delays
Frontend.setup(timestep=simulationTimestep, min_delay=minSynapseDelay, max_delay=maxSynapseDelay, threads=4)
# create a spike sources
retinaLeft = createSpikeSource("RetL")
retinaRight = createSpikeSource("RetR")
# create network and attach the spike sources
network, (liveConnectionNetwork, liveConnectionRetinas) = createCooperativeNetwork(retinaLeft=retinaLeft, retinaRight=retinaRight)
# non-blocking run for time in milliseconds
print "Simulation started..."
Frontend.run(simulationTime)
print "Simulation ended."
# plot results
#
# plotExperiment(retinaLeft, retinaRight, network)
# finalise program and simulation
Frontend.end()
def test_recording_1_element(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 200 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
spike_array = {'spike_times': [[0]]}
populations.append(p.Population(n_neurons, p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
label='inputSpikes_1'))
projections.append(p.Projection(populations[0], populations[0],
p.OneToOneConnector()))
populations[1].record()
p.run(5000)
spike_array_spikes = populations[1].getSpikes()
boxed_array = numpy.zeros(shape=(0, 2))
boxed_array = numpy.append(boxed_array, [[0, 0]], axis=0)
numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
p.end()
def simulate(self, spinnaker, input_spike_times):
# Cell parameters
cell_params = {
'tau_m': 20.0,
'v_rest': -60.0,
'v_reset': -60.0,
'v_thresh': -40.0,
'tau_syn_E': 2.0,
'tau_syn_I': 2.0,
'tau_refrac': 2.0,
'cm': 0.25,
'i_offset': 0.0,
}
rng = p.NumpyRNG(seed=28375)
v_init = p.RandomDistribution('uniform', [-60, -40], rng)
p.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)
pop = p.Population(1, p.IF_curr_exp, cell_params, label='population')
pop.randomInit(v_init)
pop.record()
pop.record_v()
noise = p.Population(1, p.SpikeSourceArray,
{"spike_times": input_spike_times})
p.Projection(noise, pop, p.OneToOneConnector(weights=0.4, delays=1),
target='excitatory')
# Simulate
p.run(self.simtime)
pop_voltages = pop.get_v(compatible_output=True)
pop_spikes = pop.getSpikes(compatible_output=True)
p.end()
return pop_voltages, pop_spikes
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("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()
p.run(5000)
spikes = populations[1].getSpikes()
print spikes
p.end()
def main():
# setup timestep of simulation and minimum and maximum synaptic delays
Frontend.setup(timestep=simulationTimestep, min_delay=minSynapseDelay, max_delay=maxSynapseDelay, threads=4)
# create a spike sources
retinaLeft = createSpikeSource("RetL")
retinaRight = createSpikeSource("RetR")
# create network and attach the spike sources
network = createCooperativeNetwork(retinaLeft=retinaLeft, retinaRight=retinaRight)
# run simulation for time in milliseconds
print "Simulation started..."
Frontend.run(simulationTime)
# print network[0][1].label
# spikeList = network[0][1].getSpikes()
# print spikeList
# finalise program and simulation
Frontend.end()
print "Simulation ended."
from NetworkVisualiser import logFile
logFile.close()
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(weights=weight_to_spike)
projection = sim.Projection(stimulation, target, connector)
target.record()
sim.run(run_time)
spikes = target.getSpikes(compatible_output=True)
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()
post_pop,
sim.OneToOneConnector(weights=start_w),
synapse_dynamics=sim.SynapseDynamics(slow=stdp_model)))
print("Simulating for %us" % (sim_time / 1000))
# Run simulation
sim.run(sim_time)
# Read weights from each parameter value being tested
weights = []
for projection_delta_t in projections:
weights.append([p.getWeights()[0] for p in projection_delta_t])
# End simulation on SpiNNaker
sim.end(stop_on_board=True)
#-------------------------------------------------------------------
# Plotting
#-------------------------------------------------------------------
# Sjostrom et al. (2001) experimental data
data_w = [[-0.29, -0.41, -0.34, 0.56, 0.75], [-0.04, 0.14, 0.29, 0.53, 0.56]]
data_e = [[0.08, 0.11, 0.1, 0.32, 0.19], [0.05, 0.1, 0.14, 0.11, 0.26]]
# Plot Frequency response
figure, axis = pylab.subplots()
axis.set_xlabel("Frequency/Hz")
axis.set_ylabel(r"$(\frac{\Delta w_{ij}}{w_{ij}})$",
rotation="horizontal",
size="xx-large")
projections.append(spynn.Projection(pop_spikes_in_1, pop_spikes_out_1,spynn.OneToOneConnector(weights=weight_to_spike)))
projections.append(spynn.Projection(pop_spikes_in_2, pop_spikes_out_2,spynn.OneToOneConnector(weights=weight_to_spike)))
spynn.run(runTimeMs + 1000) #add extra second to get all downstream spikes
spikes1 = pop_spikes_out_1.getSpikes(compatible_output=True)
spikes2 = pop_spikes_out_2.getSpikes(compatible_output=True)
#For raster plot of all together, we need to convert neuron ids to be global not local to each pop
for j in spikes2:
j[0]=j[0] + nNeurons1
totalSpikes = len(spikes1) + len(spikes1)
print 'Total spikes generated: ' , totalSpikes
if totalSpikes > 0:
print "Last spike pop 1: " , spikes1[len(spikes1) - 1]
print "Last spike pop 2: " , spikes2[len(spikes2) - 1]
#print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes1], [i[0] for i in spikes1], "k,") #black pixels
pylab.plot([i[1] for i in spikes2], [i[0] for i in spikes2], "k,") #black pixels
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('Raster Plot')
pylab.show()
else:
print "No spikes received"
spynn.end()
import spynnaker.pyNN as sim
sim.setup(timestep=1.0, min_delay=1.0, max_delay=1.0)
simtime = 1000
pg_pop1 = sim.Population(2, sim.SpikeSourcePoisson,
{'rate': 10.0, 'start':0,
'duration':simtime}, label="pg_pop1")
pg_pop2 = sim.Population(2, sim.SpikeSourcePoisson,
{'rate': 10.0, 'start':0,
'duration':simtime}, label="pg_pop2")
pg_pop1.record()
pg_pop2.record()
sim.run(simtime)
spikes1 = pg_pop1.getSpikes(compatible_output=True)
spikes2 = pg_pop2.getSpikes(compatible_output=True)
print spikes1
print spikes2
sim.end()
def run(): Frontend.run(run_time) Frontend.end()
# Create a condition to avoid overlapping prints
print_condition = Condition()
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
spikes_backward = pop_backward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0 or len(spikes_backward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
[i[0] for i in spikes_forward], "b.")
if len(spikes_backward) != 0:
pylab.plot([i[1] for i in spikes_backward],
[i[0] for i in spikes_backward], "r.")
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Clear data structures on spiNNaker to leave the machine in a clean state for
# future executions
Frontend.end()
def __init__(self):
# initial call to set up the front end (pynn requirement)
Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
# neurons per population and the length of runtime in ms for the
# simulation, as well as the expected weight each spike will contain
self.n_neurons = 100
run_time = 100000
weight_to_spike = 2.0
# neural parameters of the IF_curr model used to respond to injected
# spikes.
# (cell params for a synfire chain)
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
}
##################################
# Parameters for the injector population. This is the minimal set of
# parameters required, which is for a set of spikes where the key is
# not important. Note that a virtual key *will* be assigned to the
# population, and that spikes sent which do not match this virtual key
# will be dropped; however, if spikes are sent using 16-bit keys, they
# will automatically be made to match the virtual key. The virtual
# key assigned can be obtained from the database.
##################################
cell_params_spike_injector = {
# The port on which the spiNNaker machine should listen for
# packets. Packets to be injected should be sent to this port on
# the spiNNaker machine
'port': 12345
}
##################################
# Parameters for the injector population. Note that each injector
# needs to be given a different port. The virtual key is assigned
# here, rather than being allocated later. As with the above, spikes
# injected need to match this key, and this will be done automatically
# with 16-bit keys.
##################################
cell_params_spike_injector_with_key = {
# The port on which the spiNNaker machine should listen for
# packets. Packets to be injected should be sent to this port on
# the spiNNaker machine
'port': 12346,
# This is the base key to be used for the injection, which is used
# to allow the keys to be routed around the spiNNaker machine.
# This assignment means that 32-bit keys must have the high-order
# 16-bit set to 0x7; This will automatically be prepended to
# 16-bit keys.
'virtual_key': 0x70000
}
# create synfire populations (if cur exp)
pop_forward = Frontend.Population(self.n_neurons,
Frontend.IF_curr_exp,
cell_params_lif,
label='pop_forward')
pop_backward = Frontend.Population(self.n_neurons,
Frontend.IF_curr_exp,
cell_params_lif,
label='pop_backward')
# Create injection populations
injector_forward = Frontend.Population(
self.n_neurons,
ExternalDevices.SpikeInjector,
cell_params_spike_injector_with_key,
label='spike_injector_forward')
injector_backward = Frontend.Population(
self.n_neurons,
ExternalDevices.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(weights=weight_to_spike))
Frontend.Projection(
injector_backward, pop_backward,
Frontend.OneToOneConnector(weights=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, self.n_neurons - 1):
loop_forward.append(
(i, (i + 1) % self.n_neurons, weight_to_spike, 3))
loop_backward.append(
((i + 1) % self.n_neurons, i, weight_to_spike, 3))
Frontend.Projection(pop_forward, pop_forward,
Frontend.FromListConnector(loop_forward))
Frontend.Projection(pop_backward, pop_backward,
Frontend.FromListConnector(loop_backward))
# record spikes from the synfire chains so that we can read off valid
# results in a safe way afterwards, and verify the behavior
pop_forward.record()
pop_backward.record()
# Activate the sending of live spikes
ExternalDevices.activate_live_output_for(
pop_forward,
database_notify_host="localhost",
database_notify_port_num=19996)
ExternalDevices.activate_live_output_for(
pop_backward,
database_notify_host="localhost",
database_notify_port_num=19996)
# set up gui
from multiprocessing import Process
p = Process(target=GUI, args=[self.n_neurons])
p.start()
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
spikes_backward = pop_backward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0 or len(spikes_backward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
[i[0] for i in spikes_forward], "b.")
if len(spikes_backward) != 0:
pylab.plot([i[1] for i in spikes_backward],
[i[0] for i in spikes_backward], "r.")
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Clear data structures on spiNNaker to leave the machine in a clean
# state for future executions
Frontend.end()
p.join()
projections.append(frontend.Projection(
populations[1], populations[0],
frontend.OneToOneConnector(weights=weight_to_spike)))
connections = list()
for i in range(0, nNeurons - 1):
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, 3)
connections.append(singleConnection)
projections.append(frontend.Projection(populations[0], populations[0],
frontend.FromListConnector(connections)))
frontend.run(run_time)
spikes = populations[0].getSpikes(compatible_output=True)
if spikes is not None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
frontend.end()
else:
print "No spikes received"
# Make some graphs
if v != None:
ticks = len(v) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, nNeurons, 20):
v_for_neuron = v[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in v_for_neuron],
[i[2] for i in v_for_neuron])
pylab.show()
if gsyn != None:
ticks = len(gsyn) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, nNeurons, 20):
gsyn_for_neuron = gsyn[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in gsyn_for_neuron],
[i[2] for i in gsyn_for_neuron])
pylab.show()
p.end(stop_on_board=False)
def test_inhibitory_connector_memory(self):
p.setup(timestep=0.1, min_delay=1, max_delay=10.0)
weight_to_spike = 10
delay = 1
cell_params_lif = {
'cm': 0.25,
'i_offset': 0.0,
'tau_m': 20.0,
'tau_refrac': 1.0,
'tau_syn_E': 5.0,
'tau_syn_I': 8.0,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -50.0
}
spike_array = {'spike_times': [0]}
mem_access = {'spike_times': [10]}
p_initial_spike = p.Population(1,
p.SpikeSourceArray,
spike_array,
label="Initial spike pop")
p_mem = p.Population(1, p.IF_curr_exp, cell_params_lif, label="Memory")
p_out = p.Population(1, p.IF_curr_exp, cell_params_lif, label="Output")
p_bridge = p.Population(1,
p.IF_curr_exp,
cell_params_lif,
label="Bridge")
p_inhibitor = p.Population(1,
p.IF_curr_exp,
cell_params_lif,
label="Inhibitor")
p_access = p.Population(1,
p.SpikeSourceArray,
mem_access,
label="Access memory spike pop")
p_out.record()
p_mem.record()
p_inhibitor.record()
p_initial_spike.record()
p_access.record()
pr_initial_spike1 = p.Projection(
p_initial_spike, p_mem,
p.OneToOneConnector(weight_to_spike, delay))
pr_initial_spike2 = p.Projection(
p_initial_spike, p_inhibitor,
p.OneToOneConnector(weight_to_spike, delay))
pr_mem_access = p.Projection(p_access,
p_inhibitor,
p.OneToOneConnector(
weight_to_spike, delay),
target='inhibitory')
pr_inhibitor_self = p.Projection(
p_inhibitor, p_inhibitor,
p.OneToOneConnector(weight_to_spike, delay))
pr_inhibitor_bridge = p.Projection(p_inhibitor,
p_bridge,
p.OneToOneConnector(
weight_to_spike, delay),
target='inhibitory')
pr_mem_self = p.Projection(p_mem, p_mem,
p.OneToOneConnector(weight_to_spike, delay))
pr_mem_bridge = p.Projection(
p_mem, p_bridge, p.OneToOneConnector(weight_to_spike, delay))
pr_bridge_output = p.Projection(
p_bridge, p_out, p.OneToOneConnector(weight_to_spike, delay))
pr_bridge_inhibitor = p.Projection(
p_bridge, p_inhibitor, p.OneToOneConnector(weight_to_spike, delay))
p_mem.record_v()
p_mem.record_gsyn()
p_mem.record()
p.run(30)
v = None
gsyn = None
spikes = None
v = p_mem.get_v(compatible_output=True)
gsyn = p_mem.get_gsyn(compatible_output=True)
spikes = p_mem.getSpikes(compatible_output=True)
if spikes != None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.xlabel('Time/ms')
pylab.ylabel('spikes')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Make some graphs
ticks = len(v) / 1
if v != None:
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, 1, 20):
v_for_neuron = v[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[1] for i in v_for_neuron],
[i[2] for i in v_for_neuron])
pylab.show()
if gsyn != None:
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, 1, 20):
gsyn_for_neuron = gsyn[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[1] for i in gsyn_for_neuron],
[i[2] for i in gsyn_for_neuron])
pylab.show()
p.end()
pylab.show()
else:
print "No spikes received"
# Make some graphs
if v != None:
ticks = len(v) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, nNeurons, 20):
v_for_neuron = v[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[1] for i in v_for_neuron], [i[2] for i in v_for_neuron])
pylab.show()
if gsyn != None:
ticks = len(gsyn) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, nNeurons, 20):
gsyn_for_neuron = gsyn[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[1] for i in gsyn_for_neuron],
[i[2] for i in gsyn_for_neuron])
pylab.show()
p.end(stop_on_board=False)
spynn.Projection(pop_spikes_in_2, pop_spikes_out_2,
spynn.OneToOneConnector(weights=weight_to_spike)))
spynn.run(runTimeMs + 1000) #add extra second to get all downstream spikes
spikes1 = pop_spikes_out_1.getSpikes(compatible_output=True)
spikes2 = pop_spikes_out_2.getSpikes(compatible_output=True)
#For raster plot of all together, we need to convert neuron ids to be global not local to each pop
for j in spikes2:
j[0] = j[0] + nNeurons1
totalSpikes = len(spikes1) + len(spikes1)
print 'Total spikes generated: ', totalSpikes
if totalSpikes > 0:
print "Last spike pop 1: ", spikes1[len(spikes1) - 1]
print "Last spike pop 2: ", spikes2[len(spikes2) - 1]
#print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes1], [i[0] for i in spikes1],
"k,") #black pixels
pylab.plot([i[1] for i in spikes2], [i[0] for i in spikes2],
"k,") #black pixels
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('Raster Plot')
pylab.show()
else:
print "No spikes received"
spynn.end()
def test_something(self):
#!/usr/bin/python
import pylab
import spynnaker.pyNN as p
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
nNeurons = 200 # number of neurons in each population
p.set_number_of_neurons_per_core("IF_curr_exp", nNeurons / 2)
cell_params_lif = {'cm' : 0.25, # nF
'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 = 2.0
delay = 17
loop_connections = list()
for i in range(0, nNeurons):
single_connection = (i, ((i + 1) % nNeurons),
weight_to_spike, delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(p.Population(nNeurons, p.IF_curr_exp,
cell_params_lif, label='pop_1'))
populations.append(p.Population(1, p.SpikeSourceArray,
spike_array, label='inputSpikes_1'))
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
#populations[0].record_gsyn()
#populations[0].record(visualiser_mode=p.VISUALISER_MODES.RASTER)
p.run(5000)
v = None
gsyn = None
spikes = None
v = populations[0].get_v(compatible_output=True)
#assert(v == )
#gsyn = populations[0].get_gsyn(compatible_output=True)
#spikes = populations[0].getSpikes(compatible_output=True)
if spikes is not None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.xlabel('Time/ms')
pylab.ylabel('spikes')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Make some graphs
if v is not None:
ticks = len(v) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, nNeurons, 20):
v_for_neuron = v[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in v_for_neuron],
[i[2] for i in v_for_neuron])
pylab.show()
if gsyn is not None:
ticks = len(gsyn) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, nNeurons, 20):
gsyn_for_neuron = gsyn[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in gsyn_for_neuron],
[i[2] for i in gsyn_for_neuron])
pylab.show()
p.end(stop_on_board=True)
def test_something(self):
#!/usr/bin/python
import pylab
import spynnaker.pyNN as p
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
nNeurons = 200 # number of neurons in each population
p.set_number_of_neurons_per_core("IF_curr_exp", nNeurons / 2)
cell_params_lif = {
'cm': 0.25, # nF
'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 = 2.0
delay = 17
loop_connections = list()
for i in range(0, nNeurons):
single_connection = (i, ((i + 1) % nNeurons), weight_to_spike,
delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(
p.Population(nNeurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spike_array,
label='inputSpikes_1'))
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
#populations[0].record_gsyn()
#populations[0].record(visualiser_mode=p.VISUALISER_MODES.RASTER)
p.run(5000)
v = None
gsyn = None
spikes = None
v = populations[0].get_v(compatible_output=True)
#assert(v == )
#gsyn = populations[0].get_gsyn(compatible_output=True)
#spikes = populations[0].getSpikes(compatible_output=True)
if spikes is not None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.xlabel('Time/ms')
pylab.ylabel('spikes')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Make some graphs
if v is not None:
ticks = len(v) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, nNeurons, 20):
v_for_neuron = v[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[1] for i in v_for_neuron],
[i[2] for i in v_for_neuron])
pylab.show()
if gsyn is not None:
ticks = len(gsyn) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, nNeurons, 20):
gsyn_for_neuron = gsyn[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[1] for i in gsyn_for_neuron],
[i[2] for i in gsyn_for_neuron])
pylab.show()
p.end(stop_on_board=True)
def test_get_voltage(self):
"""
test that tests the getting of v from a pre determined recording
:return:
"""
p.setup(timestep=1, min_delay=1.0, max_delay=14.40)
n_neurons = 200 # number of neurons in each population
runtime = 500
p.set_number_of_neurons_per_core("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()
weight_to_spike = 2.0
delay = 1.7
loop_connections = list()
for i in range(0, n_neurons):
single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spike_array,
label='inputSpikes_1'))
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
p.run(runtime)
v = populations[0].get_v(compatible_output=True)
current_file_path = os.path.dirname(os.path.abspath(__file__))
current_file_path = os.path.join(current_file_path, "v.data")
pre_recorded_data = p.utility_calls.read_in_data_from_file(
current_file_path, 0, n_neurons, 0, runtime)
p.end()
for spike_element, read_element in zip(v, pre_recorded_data):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
self.assertEqual(round(spike_element[2], 1),
round(read_element[2], 1))
def end(self):
# finalise program and simulation
ps.end()
else:
print "No spikes received"
# Make some graphs
if v is not None:
ticks = len(v) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, nNeurons, 20):
v_for_neuron = v[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in v_for_neuron],
[i[2] for i in v_for_neuron])
pylab.show()
if gsyn is not None:
ticks = len(gsyn) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, nNeurons, 20):
gsyn_for_neuron = gsyn[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in gsyn_for_neuron],
[i[2] for i in gsyn_for_neuron])
pylab.show()
p.end(stop_on_board=True)
label='post_1')
connectionsOn = sim.Projection(
ON_pop, post_pop,
sim.FromListConnector(convert_weights_to_list(weights_import, delay)))
#inhibitory between the neurons
connection_I = sim.Projection(post_pop,
post_pop,
sim.AllToAllConnector(weights=0.08, delays=1),
target='inhibitory')
post_pop.record()
sim.run(simtime)
# == Get the Simulated Data =================================================
post_spikes = post_pop.getSpikes(compatible_output=True)
sim.end()
def GetFiringPattern(spike, low, high):
spikeT = np.transpose(spike)
time_stamp = spikeT[1]
target_index = ((time_stamp - low) >= 0) & ((time_stamp - high) < 0)
firingTable = np.unique(spikeT[0][target_index])
firingRate = len(np.unique(spikeT[0][target_index]))
return firingRate, firingTable
print Fire_rate
for jj in range(0, 4):
print GetFiringPattern(post_spikes, 200 * jj, 200 * (jj + 1))
def test_script(self):
"""
test that tests the printing of v from a pre determined recording
:return:
"""
p.setup(timestep=0.1, min_delay=1.0, max_delay=14.0)
n_neurons = 128 * 128 # number of neurons in each population
p.set_number_of_neurons_per_core("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 = 1.7
spikes = read_spikefile('test.spikes', n_neurons)
print spikes
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(weights=weight_to_spike, delays=delay)))
populations[1].record()
p.run(100)
spikes = populations[1].getSpikes(compatible_output=True)
if spikes is not None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.xlabel('Time/ms')
pylab.ylabel('spikes')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
p.end()
def test_get_spikes(self):
"""
test for get spikes
:return:
"""
p.setup(timestep=1, min_delay=1.0, max_delay=14.40)
n_neurons = 200 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
weight_to_spike = 2.0
delay = 1.7
loop_connections = list()
for i in range(0, n_neurons):
single_connection = (i, ((i + 1) % n_neurons), weight_to_spike, delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(p.Population(n_neurons, p.IF_curr_exp, cell_params_lif,
label='pop_1'))
populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
label='inputSpikes_1'))
projections.append(p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
p.run(500)
spikes = populations[0].getSpikes(compatible_output=True)
pre_recorded_spikes = [
[0, 3.5], [1, 6.7], [2, 9.9], [3, 13.1], [4, 16.3],
[5, 19.5], [6, 22.7], [7, 25.9], [8, 29.1],
[9, 32.3], [10, 35.5], [11, 38.7], [12, 41.9],
[13, 45.1], [14, 48.3], [15, 51.5], [16, 54.7],
[17, 57.9], [18, 61.1], [19, 64.3], [20, 67.5],
[21, 70.7], [22, 73.9], [23, 77.1], [24, 80.3],
[25, 83.5], [26, 86.7], [27, 89.9], [28, 93.1],
[29, 96.3], [30, 99.5], [31, 102.7], [32, 105.9],
[33, 109.1], [34, 112.3], [35, 115.5], [36, 118.7],
[37, 121.9], [38, 125.1], [39, 128.3], [40, 131.5],
[41, 134.7], [42, 137.9], [43, 141.1], [44, 144.3],
[45, 147.5], [46, 150.7], [47, 153.9], [48, 157.1],
[49, 160.3], [50, 163.5], [51, 166.7], [52, 169.9],
[53, 173.1], [54, 176.3], [55, 179.5], [56, 182.7],
[57, 185.9], [58, 189.1], [59, 192.3], [60, 195.5]]
p.end()
for spike_element, read_element in zip(spikes, pre_recorded_spikes):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
def main():
minutes = 1
seconds = 30
milliseconds = 1000
run_time = minutes * seconds * milliseconds
weight_to_spike = 4.0
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_32
cam_res = int(mode)
polarity = ExternalDvsEmulatorDevice.MERGED_POLARITY
output_type = ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN_THR
history_weight = 1.0
cam_fps = 30
behaviour = VirtualCam.BEHAVE_ATTENTION
vcam = VirtualCam("./mnist/", fps=cam_fps, resolution=cam_res, behaviour=behaviour)
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": vcam,
#'device_id': 0,
}
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(weights=weight_to_spike)
projection = sim.Projection(stimulation, target, connector)
target.record()
sim.run(run_time)
spikes = target.getSpikes(compatible_output=True)
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()
print("Converting spikes into video")
s2v = SpikesToVideo(
cam_res,
spikes,
fps=cam_fps,
# fourcc='MJPG',
scale=2,
)
pynn.Projection(reservoir, readout_neurons,
pynn.AllToAllConnector(weights=0.5, delays=1))
readout_neurons.record()
readout_neurons.record_v()
# run the network and measure the time it takes
timer.start()
pynn.run(simulation_time)
simCPUTime = timer.diff()
spikes = readout_neurons.getSpikes()
pynn.end()
# Plot
import pylab
spike_times = [spike[1] for spike in spikes]
spike_ids = [spike[0] for spike in spikes]
pylab.plot(spike_times, spike_ids, ".")
pylab.xlabel('Time (ms)')
pylab.ylabel('Neuron ID')
pylab.title('Spike Plot')
pylab.xlim(xmin=0)
pylab.show()
writeCPUTime = timer.diff()
projections[-1].append(sim.Projection(pre_pop, post_pop, sim.OneToOneConnector(weights = start_w),
synapse_dynamics = sim.SynapseDynamics(slow = stdp_model)
))
print("Simulating for %us" % (sim_time / 1000))
# Run simulation
sim.run(sim_time)
# Read weights from each parameter value being tested
weights = []
for projection_delta_t in projections:
weights.append([p.getWeights()[0] for p in projection_delta_t])
# End simulation on SpiNNaker
sim.end(stop_on_board=True)
#-------------------------------------------------------------------
# Plotting
#-------------------------------------------------------------------
# Sjostrom et al. (2001) experimental data
data_w = [
[ -0.29, -0.41, -0.34, 0.56, 0.75 ],
[ -0.04, 0.14, 0.29, 0.53, 0.56 ]
]
data_e = [
[ 0.08, 0.11, 0.1, 0.32, 0.19 ],
[ 0.05, 0.1, 0.14, 0.11, 0.26 ]
]
# Plot Frequency response
def estimate_kb(cell_params_lif):
cell_para = copy.deepcopy(cell_params_lif)
random.seed(0)
p.setup(timestep=1.0, min_delay=1.0, max_delay=16.0)
run_s = 10.
runtime = 1000. * run_s
max_rate = 1000.
ee_connector = p.OneToOneConnector(weights=1.0, delays=2.0)
pop_list = []
pop_output = []
pop_source = []
x = np.arange(0., 1.01, 0.1)
count = 0
trail = 10
for i in x:
for j in range(trail): #trails for average
pop_output.append(p.Population(1, p.IF_curr_exp, cell_para))
poisson_spikes = poisson_generator(i * max_rate, 0, runtime)
pop_source.append(
p.Population(1, p.SpikeSourceArray,
{'spike_times': poisson_spikes}))
p.Projection(pop_source[count],
pop_output[count],
ee_connector,
target='excitatory')
pop_output[count].record()
count += 1
count = 0
for i in x:
cell_para['i_offset'] = i
pop_list.append(p.Population(1, p.IF_curr_exp, cell_para))
pop_list[count].record()
count += 1
pop_list[count - 1].record_v()
p.run(runtime)
rate_I = np.zeros(count)
rate_P = np.zeros(count)
rate_P_max = np.zeros(count)
rate_P_min = np.ones(count) * 1000.
for i in range(count):
spikes = pop_list[i].getSpikes(compatible_output=True)
rate_I[i] = len(spikes) / run_s
for j in range(trail):
spikes = pop_output[i * trail +
j].getSpikes(compatible_output=True)
spike_num = len(spikes) / run_s
rate_P[i] += spike_num
if spike_num > rate_P_max[i]:
rate_P_max[i] = spike_num
if spike_num < rate_P_min[i]:
rate_P_min[i] = spike_num
rate_P[i] /= trail
'''
#plot_spikes(spikes, 'Current = 10. mA')
plt.plot(x, rate_I, label='current',)
plt.plot(x, rate_P, label='Poisson input')
plt.fill_between(x, rate_P_min, rate_P_max, facecolor = 'green', alpha=0.3)
'''
x0 = np.where(rate_P > 1.)[0][0]
x1 = 4
k = (rate_P[x1] - rate_P[x0]) / (x[x1] - x[x0])
'''
plt.plot(x, k*(x-x[x0])+rate_P[x0], label='linear')
plt.legend(loc='upper left', shadow=True)
plt.grid('on')
plt.show()
'''
p.end()
return k, x[x0], rate_P[x0]
def test_print_spikes(self):
machine_time_step = 0.1
p.setup(timestep=machine_time_step, min_delay=1.0, max_delay=14.40)
n_neurons = 20 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
weight_to_spike = 2.0
delay = 1.7
loop_connections = list()
for i in range(0, n_neurons):
single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spike_array,
label='inputSpikes_1'))
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
p.run(500)
spikes = populations[0].getSpikes(compatible_output=True)
current_file_path = os.path.dirname(os.path.abspath(__file__))
current_file_path = os.path.join(current_file_path, "spikes.data")
spike_file = populations[0].printSpikes(current_file_path)
spike_reader = p.utility_calls.read_spikes_from_file(
current_file_path,
min_atom=0,
max_atom=n_neurons,
min_time=0,
max_time=500)
read_in_spikes = spike_reader.spike_times
p.end()
os.remove(current_file_path)
for spike_element, read_element in zip(spikes, read_in_spikes):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
live_spikes_connection = SpynnakerLiveSpikesConnection(
receive_labels=None, local_port=19999, send_labels=["spike_injector_forward"])
# Set up callbacks to occur at the start of simulation
live_spikes_connection.add_start_callback("spike_injector_forward", send_input_forward)
# if not using the c visualiser, then a new spynnaker live spikes connection
# is created to define that there are python code which receives the
# outputted spikes.
live_spikes_connection = SpynnakerLiveSpikesConnection(
receive_labels=["pop_forward"], local_port=19996, send_labels=None)
# Set up callbacks to occur when spikes are received
live_spikes_connection.add_receive_callback("pop_forward", receive_spikes)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
[i[0] for i in spikes_forward], "b.")
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Clear data structures on spiNNaker to leave the machine in a clean state for
# future executions
Frontend.end()
def test_get_spikes(self):
"""
test for get spikes
:return:
"""
p.setup(timestep=0.1, min_delay=1.0, max_delay=14.40)
n_neurons = 200 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
weight_to_spike = 2.0
delay = 1.7
loop_connections = list()
for i in range(0, n_neurons):
single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spike_array,
label='inputSpikes_1'))
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
p.run(500)
spikes = populations[0].getSpikes(compatible_output=True)
pre_recorded_spikes = [[0, 3.5], [1, 6.7], [2, 9.9], [3, 13.1],
[4, 16.3], [5, 19.5], [6, 22.7], [7, 25.9],
[8, 29.1], [9, 32.3], [10, 35.5], [11, 38.7],
[12, 41.9], [13, 45.1], [14, 48.3], [15, 51.5],
[16, 54.7], [17, 57.9], [18, 61.1], [19, 64.3],
[20, 67.5], [21, 70.7], [22, 73.9], [23, 77.1],
[24, 80.3], [25, 83.5], [26, 86.7], [27, 89.9],
[28, 93.1], [29, 96.3], [30, 99.5], [31, 102.7],
[32, 105.9], [33, 109.1], [34, 112.3],
[35, 115.5], [36, 118.7], [37, 121.9],
[38, 125.1], [39, 128.3], [40, 131.5],
[41, 134.7], [42, 137.9], [43, 141.1],
[44, 144.3], [45, 147.5], [46, 150.7],
[47, 153.9], [48, 157.1], [49, 160.3],
[50, 163.5], [51, 166.7], [52, 169.9],
[53, 173.1], [54, 176.3], [55, 179.5],
[56, 182.7], [57, 185.9], [58, 189.1],
[59, 192.3], [60, 195.5]]
p.end()
for spike_element, read_element in zip(spikes, pre_recorded_spikes):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
def test_get_voltage(self):
"""
test that tests the getting of v from a pre determined recording
:return:
"""
p.setup(timestep=0.1, min_delay=1.0, max_delay=14.40)
n_neurons = 200 # number of neurons in each population
runtime = 500
p.set_number_of_neurons_per_core("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()
weight_to_spike = 2.0
delay = 1.7
loop_connections = list()
for i in range(0, n_neurons):
single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(p.Population(n_neurons, p.IF_curr_exp, cell_params_lif,
label='pop_1'))
populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
label='inputSpikes_1'))
projections.append(p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
p.run(runtime)
v = populations[0].get_v(compatible_output=True)
current_file_path = os.path.dirname(os.path.abspath(__file__))
current_file_path = os.path.join(current_file_path, "v.data")
pre_recorded_data = p.utility_calls.read_in_data_from_file(
current_file_path, 0, n_neurons, 0, runtime)
p.end()
for spike_element, read_element in zip(v, pre_recorded_data):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
self.assertEqual(round(spike_element[2], 1),
round(read_element[2], 1))
def start_sim(self,sim_time):
#simulation setup
self.simtime = sim_time
sim.setup(timestep=self.setup_cond["timestep"], min_delay=self.setup_cond["min_delay"], max_delay=self.setup_cond["max_delay"])
#initialise the neuron population
spikeArrayOn = {'spike_times': self.in_spike}
pre_pop = sim.Population(self.pre_pop_size, sim.SpikeSourceArray,
spikeArrayOn, label='inputSpikes_On')
post_pop= sim.Population(self.post_pop_size,sim.IF_curr_exp,
self.cell_params_lif, label='post_1')
stdp_model = sim.STDPMechanism(timing_dependence=sim.SpikePairRule(tau_plus= self.stdp_param["tau_plus"],
tau_minus= self.stdp_param["tau_minus"],
nearest=True),
weight_dependence=sim.MultiplicativeWeightDependence(w_min= self.stdp_param["w_min"],
w_max= self.stdp_param["w_max"],
A_plus= self.stdp_param["A_plus"],
A_minus= self.stdp_param["A_minus"]))
#initialise connectiviity of neurons
#exitatory connection between pre-synaptic and post-synaptic neuron population
if(self.inhibitory_spike_mode):
connectionsOn = sim.Projection(pre_pop, post_pop, sim.AllToAllConnector(weights = self.I_syn_weight,delays=1,
allow_self_connections=False),
target='inhibitory')
else:
if(self.STDP_mode):
if(self.allsameweight):
connectionsOn = sim.Projection(pre_pop, post_pop,
sim.AllToAllConnector(weights = self.E_syn_weight,delays=1),
synapse_dynamics=sim.SynapseDynamics(slow=stdp_model),target='excitatory')
else:
connectionsOn = sim.Projection(pre_pop, post_pop,
sim.FromListConnector(self.conn_list),
synapse_dynamics=sim.SynapseDynamics(slow=stdp_model),target='excitatory')
else:
if(self.allsameweight):
connectionsOn = sim.Projection(pre_pop, post_pop, sim.AllToAllConnector(weights = self.E_syn_weight,delays=1),
target='excitatory')
else:
connectionsOn = sim.Projection(pre_pop, post_pop, sim.FromListConnector(self.conn_list),
target='excitatory')
#sim.Projection.setWeights(self.E_syn_weight)
#inhibitory between the neurons post-synaptic neuron population
connection_I = sim.Projection(post_pop, post_pop, sim.AllToAllConnector(weights = self.I_syn_weight,delays=1,
allow_self_connections=False),
target='inhibitory')
pre_pop.record()
post_pop.record()
post_pop.record_v()
sim.run(self.simtime)
self.pre_spikes = pre_pop.getSpikes(compatible_output=True)
self.post_spikes = post_pop.getSpikes(compatible_output=True)
self.post_spikes_v = post_pop.get_v(compatible_output=True)
self.trained_weights = connectionsOn.getWeights(format='array')
sim.end()
#print self.conn_list
#print self.trained_weights
'''scipy.io.savemat('trained_weight.mat',{'initial_weight':self.init_weights,
'trained_weight':self.trained_weights
})'''
scipy.io.savemat('trained_weight0.mat',{'trained_weight':self.trained_weights
})
ExternalDevices.activate_live_output_for(populations[0])
projections.append(
FrontEnd.Projection(populations[1], populations[0], FrontEnd.OneToOneConnector(weights=weight_to_spike))
)
loopConnections = list()
for i in range(0, nNeurons - 1):
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, 3)
loopConnections.append(singleConnection)
projections.append(FrontEnd.Projection(populations[0], populations[0], FrontEnd.FromListConnector(loopConnections)))
FrontEnd.run(run_time)
spikes = populations[0].getSpikes(compatible_output=True)
if spikes is not None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.ylabel("neuron id")
pylab.xlabel("Time/ms")
pylab.title("spikes")
pylab.show()
else:
print "No spikes received"
FrontEnd.end()
def test_print_spikes(self):
machine_time_step = 0.1
p.setup(timestep=machine_time_step, min_delay=1.0, max_delay=14.40)
n_neurons = 20 # number of neurons in each population
p.set_number_of_neurons_per_core("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()
weight_to_spike = 2.0
delay = 1.7
loop_connections = list()
for i in range(0, n_neurons):
single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
spike_array = {'spike_times': [[0]]}
populations.append(p.Population(n_neurons, p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
label='inputSpikes_1'))
projections.append(p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
p.run(500)
spikes = populations[0].getSpikes(compatible_output=True)
current_file_path = os.path.dirname(os.path.abspath(__file__))
current_file_path = os.path.join(current_file_path, "spikes.data")
spike_file = populations[0].printSpikes(current_file_path)
spike_reader = p.utility_calls.read_spikes_from_file(
current_file_path, min_atom=0, max_atom=n_neurons,
min_time=0, max_time=500)
read_in_spikes = spike_reader.spike_times
p.end()
os.remove(current_file_path)
for spike_element, read_element in zip(spikes, read_in_spikes):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Make some graphs
if v is not None:
ticks = len(v) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, nNeurons, 20):
v_for_neuron = v[pos * ticks: (pos + 1) * ticks]
pylab.plot([i[2] for i in v_for_neuron])
pylab.show()
if gsyn is not None:
ticks = len(gsyn) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, nNeurons, 20):
gsyn_for_neuron = gsyn[pos * ticks: (pos + 1) * ticks]
pylab.plot([i[2] for i in gsyn_for_neuron])
pylab.show()
p.end()
def __init__(self):
# initial call to set up the front end (pynn requirement)
Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
use_c_visualiser = True
use_spike_injector = True
# neurons per population and the length of runtime in ms for the
# simulation, as well as the expected weight each spike will contain
self.n_neurons = 100
# set up gui
p = None
if use_spike_injector:
from multiprocessing import Process
from multiprocessing import Event
ready = Event()
p = Process(target=GUI, args=[self.n_neurons, ready])
p.start()
ready.wait()
# different runtimes for demostration purposes
run_time = None
if not use_c_visualiser and not use_spike_injector:
run_time = 1000
elif use_c_visualiser and not use_spike_injector:
run_time = 10000
elif use_c_visualiser and use_spike_injector:
run_time = 100000
elif not use_c_visualiser and use_spike_injector:
run_time = 10000
weight_to_spike = 2.0
# neural parameters of the IF_curr model used to respond to injected
# spikes.
# (cell params for a synfire chain)
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
}
##################################
# Parameters for the injector population. This is the minimal set of
# parameters required, which is for a set of spikes where the key is
# not important. Note that a virtual key *will* be assigned to the
# population, and that spikes sent which do not match this virtual key
# will be dropped; however, if spikes are sent using 16-bit keys, they
# will automatically be made to match the virtual key. The virtual
# key assigned can be obtained from the database.
##################################
cell_params_spike_injector = {
# The port on which the spiNNaker machine should listen for
# packets. Packets to be injected should be sent to this port on
# the spiNNaker machine
'port': 12345
}
##################################
# Parameters for the injector population. Note that each injector
# needs to be given a different port. The virtual key is assigned
# here, rather than being allocated later. As with the above, spikes
# injected need to match this key, and this will be done automatically
# with 16-bit keys.
##################################
cell_params_spike_injector_with_key = {
# The port on which the spiNNaker machine should listen for
# packets. Packets to be injected should be sent to this port on
# the spiNNaker machine
'port': 12346,
# This is the base key to be used for the injection, which is used
# to allow the keys to be routed around the spiNNaker machine.
# This assignment means that 32-bit keys must have the high-order
# 16-bit set to 0x7; This will automatically be prepended to
# 16-bit keys.
'virtual_key': 0x70000
}
# create synfire populations (if cur exp)
pop_forward = Frontend.Population(
self.n_neurons, Frontend.IF_curr_exp,
cell_params_lif, label='pop_forward')
pop_backward = Frontend.Population(
self.n_neurons, Frontend.IF_curr_exp,
cell_params_lif, label='pop_backward')
# Create injection populations
injector_forward = None
injector_backward = None
if use_spike_injector:
injector_forward = Frontend.Population(
self.n_neurons, ExternalDevices.SpikeInjector,
cell_params_spike_injector_with_key,
label='spike_injector_forward')
injector_backward = Frontend.Population(
self.n_neurons, ExternalDevices.SpikeInjector,
cell_params_spike_injector, label='spike_injector_backward')
else:
spike_times = []
for _ in range(0, self.n_neurons):
spike_times.append([])
spike_times[0] = [0]
spike_times[20] = [(run_time / 100) * 20]
spike_times[40] = [(run_time / 100) * 40]
spike_times[60] = [(run_time / 100) * 60]
spike_times[80] = [(run_time / 100) * 80]
cell_params_forward = {'spike_times': spike_times}
spike_times_backwards = []
for _ in range(0, self.n_neurons):
spike_times_backwards.append([])
spike_times_backwards[0] = [(run_time / 100) * 80]
spike_times_backwards[20] = [(run_time / 100) * 60]
spike_times_backwards[40] = [(run_time / 100) * 40]
spike_times_backwards[60] = [(run_time / 100) * 20]
spike_times_backwards[80] = [0]
cell_params_backward = {'spike_times': spike_times_backwards}
injector_forward = Frontend.Population(
self.n_neurons, Frontend.SpikeSourceArray,
cell_params_forward,
label='spike_injector_forward')
injector_backward = Frontend.Population(
self.n_neurons, Frontend.SpikeSourceArray,
cell_params_backward, label='spike_injector_backward')
# Create a connection from the injector into the populations
Frontend.Projection(
injector_forward, pop_forward,
Frontend.OneToOneConnector(weights=weight_to_spike))
Frontend.Projection(
injector_backward, pop_backward,
Frontend.OneToOneConnector(weights=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, self.n_neurons - 1):
loop_forward.append((i, (i + 1) %
self.n_neurons, weight_to_spike, 3))
loop_backward.append(((i + 1) %
self.n_neurons, i, weight_to_spike, 3))
Frontend.Projection(pop_forward, pop_forward,
Frontend.FromListConnector(loop_forward))
Frontend.Projection(pop_backward, pop_backward,
Frontend.FromListConnector(loop_backward))
# record spikes from the synfire chains so that we can read off valid
# results in a safe way afterwards, and verify the behavior
pop_forward.record()
pop_backward.record()
# Activate the sending of live spikes
ExternalDevices.activate_live_output_for(
pop_forward, database_notify_host="localhost",
database_notify_port_num=19996)
ExternalDevices.activate_live_output_for(
pop_backward, database_notify_host="localhost",
database_notify_port_num=19996)
if not use_c_visualiser:
# if not using the c visualiser, then a new spynnaker live spikes
# connection is created to define that there are python code which
# receives the outputted spikes.
live_spikes_connection_receive = SpynnakerLiveSpikesConnection(
receive_labels=["pop_forward", "pop_backward"],
local_port=19999, send_labels=None)
# Set up callbacks to occur when spikes are received
live_spikes_connection_receive.add_receive_callback(
"pop_forward", receive_spikes)
live_spikes_connection_receive.add_receive_callback(
"pop_backward", receive_spikes)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
spikes_backward = pop_backward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0 or len(spikes_backward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
[i[0] for i in spikes_forward], "b.")
if len(spikes_backward) != 0:
pylab.plot([i[1] for i in spikes_backward],
[i[0] for i in spikes_backward], "r.")
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Clear data structures on spiNNaker to leave the machine in a clean
# state for future executions
Frontend.end()
if use_spike_injector:
p.join()
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Make some graphs
if v is not None:
ticks = len(v) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, nNeurons, 20):
v_for_neuron = v[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[2] for i in v_for_neuron])
pylab.show()
if gsyn is not None:
ticks = len(gsyn) / nNeurons
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, nNeurons, 20):
gsyn_for_neuron = gsyn[pos * ticks:(pos + 1) * ticks]
pylab.plot([i[2] for i in gsyn_for_neuron])
pylab.show()
p.end()
def test_inhibitory_connector_memory(self):
p.setup(timestep=0.1, min_delay=1, max_delay=10.0)
weight_to_spike = 10
delay = 1
cell_params_lif = {
'cm' : 0.25,
'i_offset' : 0.0,
'tau_m' : 20.0,
'tau_refrac': 1.0,
'tau_syn_E' : 5.0,
'tau_syn_I' : 8.0,
'v_reset' : -70.0,
'v_rest' : -65.0,
'v_thresh' : -50.0
}
spike_array = {'spike_times':[0]}
mem_access = {'spike_times':[10]}
p_initial_spike = p.Population(1,p.SpikeSourceArray,spike_array,label="Initial spike pop")
p_mem = p.Population(1,p.IF_curr_exp, cell_params_lif, label="Memory")
p_out = p.Population(1,p.IF_curr_exp, cell_params_lif, label="Output")
p_bridge = p.Population(1,p.IF_curr_exp, cell_params_lif, label="Bridge")
p_inhibitor = p.Population(1,p.IF_curr_exp, cell_params_lif, label="Inhibitor")
p_access = p.Population(1,p.SpikeSourceArray, mem_access, label="Access memory spike pop")
p_out.record()
p_mem.record()
p_inhibitor.record()
p_initial_spike.record()
p_access.record()
pr_initial_spike1 = p.Projection(p_initial_spike,p_mem,p.OneToOneConnector(weight_to_spike,delay))
pr_initial_spike2 = p.Projection(p_initial_spike,p_inhibitor,p.OneToOneConnector(weight_to_spike,delay))
pr_mem_access = p.Projection(p_access,p_inhibitor,p.OneToOneConnector(weight_to_spike,delay), target= 'inhibitory')
pr_inhibitor_self = p.Projection(p_inhibitor,p_inhibitor,p.OneToOneConnector(weight_to_spike,delay))
pr_inhibitor_bridge = p.Projection(p_inhibitor,p_bridge,p.OneToOneConnector(weight_to_spike,delay), target= 'inhibitory')
pr_mem_self = p.Projection(p_mem,p_mem,p.OneToOneConnector(weight_to_spike,delay))
pr_mem_bridge = p.Projection(p_mem,p_bridge,p.OneToOneConnector(weight_to_spike,delay))
pr_bridge_output = p.Projection(p_bridge,p_out,p.OneToOneConnector(weight_to_spike,delay))
pr_bridge_inhibitor = p.Projection(p_bridge,p_inhibitor,p.OneToOneConnector(weight_to_spike,delay))
p_mem.record_v()
p_mem.record_gsyn()
p_mem.record()
p.run(30)
v = None
gsyn = None
spikes = None
v = p_mem.get_v(compatible_output=True)
gsyn = p_mem.get_gsyn(compatible_output=True)
spikes = p_mem.getSpikes(compatible_output=True)
if spikes != None:
print spikes
pylab.figure()
pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
pylab.xlabel('Time/ms')
pylab.ylabel('spikes')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Make some graphs
ticks = len(v) / 1
if v != None:
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('v')
pylab.title('v')
for pos in range(0, 1, 20):
v_for_neuron = v[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in v_for_neuron],
[i[2] for i in v_for_neuron])
pylab.show()
if gsyn != None:
pylab.figure()
pylab.xlabel('Time/ms')
pylab.ylabel('gsyn')
pylab.title('gsyn')
for pos in range(0, 1, 20):
gsyn_for_neuron = gsyn[pos * ticks : (pos + 1) * ticks]
pylab.plot([i[1] for i in gsyn_for_neuron],
[i[2] for i in gsyn_for_neuron])
pylab.show()
p.end()