def generate_data():
spikesTrain = []
organisedData = {}
for i in range(input_class):
for j in range(input_len):
neuid = (i, j)
organisedData[neuid] = []
for i in range(input_len):
for j in range(output_size):
neuid = (j, i)
organisedData[neuid].append(j * input_len * v_co * 5 + i * v_co)
organisedData[neuid].append(j * input_len * v_co * 5 +
input_len * v_co * 1 + i * v_co)
organisedData[neuid].append(j * input_len * v_co * 5 +
input_len * v_co * 2 + i * v_co)
organisedData[neuid].append(j * input_len * v_co * 5 +
input_len * v_co * 3 + i * v_co)
organisedData[neuid].append(j * input_len * v_co * 5 +
input_len * v_co * 4 + i * v_co)
organisedData[neuid].append(input_len * v_co * (3 * 5 + j) +
i * v_co)
#organisedData[neuid].append(i*v_co+2)
# if neuid not in organisedData:
# organisedData[neuid]=[i*v_co]
# else:
# organisedData[neuid].append(i*v_co)
for i in range(input_class):
for j in range(input_len):
neuid = (i, j)
organisedData[neuid].sort()
spikesTrain.append(organisedData[neuid])
runTime = int(max(max(spikesTrain)))
sim.setup(timestep=1)
noise = sim.Population(input_size, sim.SpikeSourcePoisson(), label='noise')
noise.record(['spikes']) #noise
sim.run(runTime)
neonoise = noise.get_data(["spikes"])
spikesnoise = neonoise.segments[0].spiketrains #noise
sim.end()
for i in range(input_size):
for noisespike in spikesnoise[i]:
spikesTrain[i].append(noisespike)
spikesTrain[i].sort()
return spikesTrain
# +-------------------------------------------------------------------+
# | 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)))
# 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)))
IAddPost.append(
sim.Population(
pop_size,
sim.SpikeSourcePoisson(rate=in_rate,
try:
import pyNN.spiNNaker as p
except Exception as e:
import spynnaker8 as p
# set up the tools
p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0)
# set up the virtual chip coordinates for the motor
connected_chip_coords = {'x': 0, 'y': 0}
link = 4
populations = list()
projections = list()
input_population = p.Population(6, p.SpikeSourcePoisson(rate=10))
control_population = p.Population(6, p.IF_curr_exp())
motor_device = p.Population(
6, p.external_devices.MunichMotorDevice(spinnaker_link_id=0))
p.Projection(input_population,
control_population,
p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=5.0))
p.external_devices.activate_live_output_to(control_population, motor_device)
p.run(1000)
p.end()
sim.setup(timestep=1.0, min_delay=1.0)
# create cells
cell_params = {
'cm': 0.25,
'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.0
}
neurons = sim.Population(100, sim.IF_cond_exp(**cell_params))
inputs = sim.Population(100, sim.SpikeSourcePoisson(rate=0.0))
# set input firing rates as a linear function of cell index
input_firing_rates = np.linspace(0.0, 1000.0, num=inputs.size)
inputs.set(rate=input_firing_rates)
# create one-to-one connections
wiring = sim.OneToOneConnector()
static_synapse = sim.StaticSynapse(weight=0.1, delay=2.0)
connections = sim.Projection(inputs, neurons, wiring, static_synapse)
# configure recording
neurons.record('spikes')
# run simulation
sim_duration = 10.0 # seconds
class MySpiNNakerLinkDevice(ApplicationSpiNNakerLinkVertex):
def __init__(
self, n_neurons, spinnaker_link_id, label=None):
ApplicationSpiNNakerLinkVertex.__init__(
self, n_neurons, spinnaker_link_id, label=label)
class MySpiNNakerLinkDeviceDataHolder(DataHolder):
def __init__(self, spinnaker_link_id, label=None):
DataHolder.__init__(
self, {"spinnaker_link_id": spinnaker_link_id, "label": label})
@staticmethod
def build_model():
return MySpiNNakerLinkDevice
p.setup(1.0)
poisson = p.Population(1, p.SpikeSourcePoisson(rate=100))
device = p.Population(1, MySpiNNakerLinkDeviceDataHolder(spinnaker_link_id=1))
p.external_devices.activate_live_output_to(poisson, device)
p.run(100)
p.end()
#cell defaults
cell_params = {
'v_thresh' : 1,
'tau_refrac' : refrac,
'v_reset' : 0,
'v_rest' : 0,
'cm' : 1,
'tau_m' : 1000,
'tau_syn_E' : 0.01,
'tau_syn_I' : 0.01
}
#create populations
layer1 = pynn.Population(1024, pynn.SpikeSourcePoisson(), label='InputLayer')
#layer1.record("spikes")
network.append(layer1)
layer2 = pynn.Population(3136, pynn.IF_curr_exp, cell_params, label='Conv1')
#layer2.record("spikes")
network.append(layer2)
layer3 = pynn.Population(4608, pynn.IF_curr_exp, cell_params, label='Conv2')
#layer3.record("spikes")
network.append(layer3)
layer4 = pynn.Population(1152, pynn.IF_curr_exp, cell_params, label='Conv3')
#layer4.record("spikes")
network.append(layer4)
import pyNN.spiNNaker as p
p.setup(1)
simtime = 500
pop_src = p.Population(1,
p.SpikeSourcePoisson(rate=50, start=0,
duration=simtime),
label="src")
pop_src.record("spikes")
for i in range(5):
p.run(100)
spikes = pop_src.get_data("spikes")
p.end()
print(spikes.segments[0].spiketrains)
import pyNN.spiNNaker as sim import pyNN.utility.plotting as plot import matplotlib.pyplot as plt sim.setup(timestep=1.0) sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100) # Define Input neuron input = sim.Population(1, sim.SpikeSourcePoisson(), label="Input") # Define output neuron pop_1 = sim.Population(1,sim.IF_curr_exp(),label="pop_1") # Connect Input Neuron with Output neuron input_proj=sim.Projection(input,pop_1,sim.OneToOneConnector(),synapse_type=sim.StaticSynapse(weight=5,delay=1)) pop_1.record(["spikes","v"]) input.record(["spikes"]) simtime = 30000 sim.run(simtime) # Input neuron neo_input=input.get_data(variables=["spikes"]) spikes_input=neo_input.segments[0].spiketrains print(spikes_input) print( len(spikes_input[0]) ) # Pop1 neuron neo_pop1=pop_1.get_data(variables=["spikes","v"])
if useSurfaceSegmentation:
LGNBright, LGNDark, V1, V2, V4Bright, V4Dark, SurfaceSegmentationOn, SurfaceSegmentationOff = network
elif useBoundarySegmentation:
LGNBright, LGNDark, V1, V2, V4Bright, V4Dark, BoundarySegmentationOnInter3, BoundarySegmentationOn, BoundarySegmentationOff = network
else:
LGNBright, LGNDark, V1, V2, V4Bright, V4Dark = network
LGNBright.record("spikes")
LGNDark.record("spikes")
V1.record("spikes")
V2.record("spikes")
V4Bright.record("spikes")
V4Dark.record("spikes")
if inputPoisson:
LGNBrightInput = sim.Population(ImageNumPixelRows * ImageNumPixelColumns,
sim.SpikeSourcePoisson())
LGNDarkInput = sim.Population(ImageNumPixelRows * ImageNumPixelColumns,
sim.SpikeSourcePoisson())
sim.Projection(LGNBrightInput, LGNBright, sim.OneToOneConnector(),
sim.StaticSynapse(weight=connections['brightInputToLGN']))
sim.Projection(LGNDarkInput, LGNDark, sim.OneToOneConnector(),
sim.StaticSynapse(weight=connections['darkInputToLGN']))
if numSegmentationLayers > 1:
if useBoundarySegmentation:
# BoundarySegmentationOnInter3.inject(sim.DCSource(amplitude=constantInput, start=0.0, stop=simTime))
BoundarySegmentationOnInter3.set('i_offset', 0.5)
########################################################################################
### Network is defined, now set up stimulus, segmentation signal and run everything! ###
########################################################################################
