def setup_2_layers_4_units_ff_net():
configure_scheduling()
pynnn.setup()
Tns.p1 = pynnn.Population(4,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.p2 = pynnn.Population(4,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.prj1_2 = pynnn.Projection(
Tns.p1,
Tns.p2,
pynnn.AllToAllConnector(allow_self_connections=False),
target='excitatory')
Tns.prj1_2.set("weight", 1)
Tns.max_weight = 34
Tns.rore1_update_p = 10
Tns.rore1_win_width = 200
Tns.rore2_update_p = 10
Tns.rore2_win_width = 200
Tns.rore1 = RectilinearOutputRateEncoder(Tns.p1, 2, 2, Tns.rore1_update_p,
Tns.rore1_win_width)
Tns.rore2 = RectilinearOutputRateEncoder(Tns.p2, 2, 2, Tns.rore2_update_p,
Tns.rore2_win_width)
common.pynn_utils.POP_ADAPT_DICT[(
Tns.p1, common.pynn_utils.RectilinearOutputRateEncoder)] = Tns.rore1
common.pynn_utils.POP_ADAPT_DICT[(
Tns.p2, common.pynn_utils.RectilinearOutputRateEncoder)] = Tns.rore2
enable_recording(Tns.p1, Tns.p2)
schedule_output_rate_calculation(Tns.p1)
schedule_output_rate_calculation(Tns.p2)
def setup_pynn_populations_with_1_to_1_connectivity():
pynnn.setup()
Tns.p1 = pynnn.Population(64,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.p2 = pynnn.Population(64,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.prj1_2 = pynnn.Projection(Tns.p1,
Tns.p2,
pynnn.OneToOneConnector(),
target='excitatory')
def test_adapter_keeps_unit_count():
"""Add_pynn_population and commit_structure result in consistent number of
units."""
assert A.num_units == 0
pop_size = 27
pynn_pop1 = pynnn.Population(pop_size, pynnn.IF_cond_alpha)
A.add_pynn_population(pynn_pop1, alias = "soilwork")
pynn_pop2 = pynnn.Population(pop_size, pynnn.IF_cond_alpha,
structure = pynnn.space.Grid3D())
A.add_pynn_population(pynn_pop2)
A.commit_structure()
assert A.num_units == pop_size * 2
def setup_pynn_populations_with_full_connectivity():
pynnn.setup()
Tns.p1 = pynnn.Population(4,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.p2 = pynnn.Population(4,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.prj1_2 = pynnn.Projection(
Tns.p1,
Tns.p2,
pynnn.AllToAllConnector(allow_self_connections=False),
target='excitatory')
def setup_pynn_populations():
pynnn.setup()
Tns.p1 = pynnn.Population(64,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.p2 = pynnn.Population(64,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
Tns.prj1_2 = pynnn.Projection(
Tns.p1,
Tns.p2,
pynnn.AllToAllConnector(allow_self_connections=False),
target='excitatory')
# Weights in nA as IF_curr_alpha uses current-based synapses
Tns.prj1_2.set("weight", 1)
Tns.max_weight = 33
def test_add_pynn_population_processes_all_units():
"""add_pynn_population checks the int value of each unit it's given."""
pop_size = 27
pynnn.simulator.ID.__int__.return_value = 1
pynn_pop1 = pynnn.Population(pop_size, pynnn.IF_cond_alpha)
A.add_pynn_population(pynn_pop1)
for u in pynn_pop1.all():
assert u.__int__.call_count == pop_size, \
"units missed in the 2D case"
pynnn.simulator.ID.__int__.reset_mock()
pynnn.simulator.ID.__int__.return_value = 1
pynn_pop2 = pynnn.Population(pop_size, pynnn.IF_cond_alpha,
structure = pynnn.space.Grid3D())
A.add_pynn_population(pynn_pop2, alias = "testmap")
for u in pynn_pop2.all():
assert u.__int__.call_count == pop_size, "units missed in the 3D case"
def run_sim(ncell):
print "Cells: ", ncell
setup0 = time.time()
sim.setup(timestep=0.1)
hh_cell_type = sim.HH_cond_exp()
hh = sim.Population(ncell, hh_cell_type)
pulse = sim.DCSource(amplitude=0.5, start=20.0, stop=80.0)
pulse.inject_into(hh)
hh.record('v')
setup1 = time.time()
t0 = time.time()
sim.run(100.0)
v = hh.get_data()
sim.end()
t1 = time.time()
setup_total = setup1 - setup0
run_total = t1 - t0
print "Setup: ", setup_total
print "Run: ", run_total
print "Total sim time: ", setup_total + run_total
return run_total
def test_partitioning(self):
p1 = sim.Population(5, sim.IF_cond_exp())
p2 = sim.Population(7, sim.IF_cond_exp())
a = p1 + p2[1:4]
# [0 2 3 4 5][x 1 2 3 x x x]
prj = sim.Projection(a, a, MockConnector(), synapse_type=self.syn)
presynaptic_indices = numpy.array([0, 3, 4, 6, 7])
partitions = prj._partition(presynaptic_indices)
self.assertEqual(len(partitions), 2)
assert_array_equal(partitions[0], numpy.array([0, 3, 4]))
assert_array_equal(partitions[1], numpy.array([2, 3]))
# [0 1 2 3 4][x 1 2 3 x]
self.assertEqual(prj._localize_index(0), (0, 0))
self.assertEqual(prj._localize_index(3), (0, 3))
self.assertEqual(prj._localize_index(5), (1, 1))
self.assertEqual(prj._localize_index(7), (1, 3))
def setup_and_fill_adapter():
setup_adapter()
Tns.pop_size = 27
Tns.pynn_pop1 = pynnn.Population(Tns.pop_size, pynnn.IF_cond_alpha)
Tns.ids1 = [int(u) for u in Tns.pynn_pop1.all()]
Tns.pynn_pop2 = pynnn.Population(Tns.pop_size, pynnn.IF_cond_alpha,
structure=pynnn.space.Grid3D())
Tns.ids2 = [int(u) for u in Tns.pynn_pop2.all()]
A.add_pynn_population(Tns.pynn_pop1)
Tns.pop2_alias = "testmap"
A.add_pynn_population(Tns.pynn_pop2, alias=Tns.pop2_alias)
Tns.pynn_proj1 = pynnn.Projection(Tns.pynn_pop1, Tns.pynn_pop2,
pynnn.OneToOneConnector())
Tns.pynn_proj2 = pynnn.Projection(Tns.pynn_pop2, Tns.pynn_pop1,
pynnn.AllToAllConnector())
A.add_pynn_projection(Tns.pynn_pop1, Tns.pynn_pop2,
Tns.pynn_proj1)
A.add_pynn_projection(Tns.pynn_pop2, Tns.pynn_pop1,
Tns.pynn_proj2)
def test_adapter_methods_call_check_open():
"""methods in the methods_checking_open list have called check_open"""
A.check_open = Mock(return_value=True)
pynn_pop1 = pynnn.Population(1, pynnn.IF_cond_alpha)
pynn_pop2 = pynnn.Population(1, pynnn.IF_cond_alpha)
pynn_prj = pynnn.Projection(
pynn_pop1, pynn_pop2,
pynnn.OneToOneConnector(),
target='excitatory')
pynn_u = pynn_pop1[0]
methods_checking_open = [
[A.assert_open, ()],
[A.commit_structure, ()],
[A.add_pynn_population, (pynn_pop1,)],
[A.add_pynn_projection, (pynn_pop1, pynn_pop1,
pynn_prj)]]
for m in methods_checking_open:
m[0](*m[1])
assert A.check_open.called, \
m[0].__name__ + " does not call check_open."
A.check_open.reset_mock()
def setUp(self):
sim.setup()
sim.Population.nPop = 0
sim.Projection.nProj = 0
self.target33 = sim.Population((3, 3), sim.IF_curr_alpha)
self.target6 = sim.Population((6, ), sim.IF_curr_alpha)
self.target1 = sim.Population((1, ), sim.IF_cond_exp)
self.source5 = sim.Population((5, ), sim.SpikeSourcePoisson)
self.source22 = sim.Population((2, 2), sim.SpikeSourcePoisson)
self.source33 = sim.Population((3, 3), sim.SpikeSourcePoisson)
self.expoisson33 = sim.Population((3, 3), sim.SpikeSourcePoisson,
{'rate': 100})
def generate_data(label):
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):
neuid = (label, i)
organisedData[neuid].append(i * v_co)
# 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
def train(label, untrained_weights=None):
organisedStim = {}
labelSpikes = []
spikeTimes = generate_data(label)
for i in range(output_size):
labelSpikes.append([])
labelSpikes[label] = [int(max(max(spikeTimes))) + 1]
if untrained_weights == None:
untrained_weights = RandomDistribution('uniform',
low=wMin,
high=wMaxInit).next(input_size *
output_size)
#untrained_weights = RandomDistribution('normal_clipped', mu=0.1, sigma=0.05, low=wMin, high=wMaxInit).next(input_size*output_size)
untrained_weights = np.around(untrained_weights, 3)
#saveWeights(untrained_weights, 'untrained_weightssupmodel1traj')
print("init!")
print "length untrained_weights :", len(untrained_weights)
if len(untrained_weights) > input_size:
training_weights = [[0 for j in range(output_size)]
for i in range(input_size)
] #np array? size 1024x25
k = 0
#for i in untrained_weights:
# training_weights[i[0]][i[1]]=i[2]
for i in range(input_size):
for j in range(output_size):
training_weights[i][j] = untrained_weights[k]
k += 1
else:
training_weights = untrained_weights
connections = []
for n_pre in range(input_size): # len(untrained_weights) = input_size
for n_post in range(
output_size
): # len(untrained_weight[0]) = output_size; 0 or any n_pre
connections.append((n_pre, n_post, training_weights[n_pre][n_post],
__delay__)) #index
runTime = int(max(max(spikeTimes))) + 100
#####################
sim.setup(timestep=1)
#def populations
layer1 = sim.Population(input_size,
sim.SpikeSourceArray, {'spike_times': spikeTimes},
label='inputspikes')
layer2 = sim.Population(output_size,
sim.IF_curr_exp,
cellparams=cell_params_lif,
label='outputspikes')
supsignal = sim.Population(output_size,
sim.SpikeSourceArray,
{'spike_times': labelSpikes},
label='supersignal')
#def learning rule
stdp = sim.STDPMechanism(
#weight=untrained_weights,
#weight=0.02, # this is the initial value of the weight
#delay="0.2 + 0.01*d",
timing_dependence=sim.SpikePairRule(tau_plus=tauPlus,
tau_minus=tauMinus,
A_plus=aPlus,
A_minus=aMinus),
#weight_dependence=sim.MultiplicativeWeightDependence(w_min=wMin, w_max=wMax),
weight_dependence=sim.AdditiveWeightDependence(w_min=wMin, w_max=wMax),
dendritic_delay_fraction=0)
#def projections
stdp_proj = sim.Projection(layer1,
layer2,
sim.FromListConnector(connections),
synapse_type=stdp)
inhibitory_connections = sim.Projection(
layer2,
layer2,
sim.AllToAllConnector(allow_self_connections=False),
synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__),
receptor_type='inhibitory')
stim_proj = sim.Projection(supsignal,
layer2,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(
weight=stimWeight, delay=__delay__))
layer1.record(['spikes'])
layer2.record(['v', 'spikes'])
supsignal.record(['spikes'])
sim.run(runTime)
print("Weights:{}".format(stdp_proj.get('weight', 'list')))
weight_list = [
stdp_proj.get('weight', 'list'),
stdp_proj.get('weight', format='list', with_address=False)
]
neo = layer2.get_data(["spikes", "v"])
spikes = neo.segments[0].spiketrains
v = neo.segments[0].filter(name='v')[0]
neostim = supsignal.get_data(["spikes"])
print(label)
spikestim = neostim.segments[0].spiketrains
neoinput = layer1.get_data(["spikes"])
spikesinput = neoinput.segments[0].spiketrains
plt.close('all')
pplt.Figure(pplt.Panel(v,
ylabel="Membrane potential (mV)",
xticks=True,
yticks=True,
xlim=(0, runTime)),
pplt.Panel(spikesinput,
xticks=True,
yticks=True,
markersize=2,
xlim=(0, runTime)),
pplt.Panel(spikestim,
xticks=True,
yticks=True,
markersize=2,
xlim=(0, runTime)),
pplt.Panel(spikes,
xticks=True,
xlabel="Time (ms)",
yticks=True,
markersize=2,
xlim=(0, runTime)),
title="Training" + str(label),
annotations="Training" +
str(label)).save('plot/' + str(trylabel) + str(label) +
'_training.png')
#plt.hist(weight_list[1], bins=100)
#plt.show()
plt.close('all')
print(wMax)
'''
plt.hist([weight_list[1][0:input_size], weight_list[1][input_size:input_size*2], weight_list[1][input_size*2:]], bins=20, label=['neuron 0', 'neuron 1', 'neuron 2'], range=(0, wMax))
plt.title('weight distribution')
plt.xlabel('Weight value')
plt.ylabel('Weight count')
'''
#plt.show()
#plt.show()
sim.end()
for i in weight_list[0]:
#training_weights[int(i[0])][int(i[1])]=float(i[2])
weight_list[1][int(i[0]) * output_size + int(i[1])] = i[2]
return weight_list[1]
def test(spikeTimes, trained_weights, label):
#spikeTimes = extractSpikes(sample)
runTime = int(max(max(spikeTimes))) + 100
##########################################
sim.setup(timestep=1)
pre_pop = sim.Population(input_size,
sim.SpikeSourceArray, {'spike_times': spikeTimes},
label="pre_pop")
post_pop = sim.Population(output_size,
sim.IF_curr_exp,
cell_params_lif,
label="post_pop")
'''
if len(untrained_weights)>input_size:
training_weights = [[0 for j in range(output_size)] for i in range(input_size)] #np array? size 1024x25
k=0
for i in untrained_weights:
training_weights[i[0]][i[1]]=i[2]
'''
if len(trained_weights) > input_size:
weigths = [[0 for j in range(output_size)]
for i in range(input_size)] #np array? size 1024x25
k = 0
for i in range(input_size):
for j in range(output_size):
weigths[i][j] = trained_weights[k]
k += 1
else:
weigths = trained_weights
connections = []
#k = 0
for n_pre in range(input_size): # len(untrained_weights) = input_size
for n_post in range(
output_size
): # len(untrained_weight[0]) = output_size; 0 or any n_pre
#connections.append((n_pre, n_post, weigths[n_pre][n_post]*(wMax), __delay__))
connections.append((n_pre, n_post, weigths[n_pre][n_post] *
(wMax) / max(trained_weights), __delay__)) #
#k += 1
prepost_proj = sim.Projection(
pre_pop,
post_pop,
sim.FromListConnector(connections),
synapse_type=sim.StaticSynapse(),
receptor_type='excitatory') # no more learning !!
#inhib_proj = sim.Projection(post_pop, post_pop, sim.AllToAllConnector(), synapse_type=sim.StaticSynapse(weight=inhibWeight, delay=__delay__), receptor_type='inhibitory')
# no more lateral inhib
post_pop.record(['v', 'spikes'])
sim.run(runTime)
neo = post_pop.get_data(['v', 'spikes'])
spikes = neo.segments[0].spiketrains
v = neo.segments[0].filter(name='v')[0]
f1 = pplt.Figure(
# plot voltage
pplt.Panel(v,
ylabel="Membrane potential (mV)",
xticks=True,
yticks=True,
xlim=(0, runTime + 100)),
# raster plot
pplt.Panel(spikes,
xlabel="Time (ms)",
xticks=True,
yticks=True,
markersize=2,
xlim=(0, runTime + 100)),
title='Test with label ' + str(label),
annotations='Test with label ' + str(label))
f1.save('plot/' + str(trylabel) + str(label) + '_test.png')
f1.fig.texts = []
print("Weights:{}".format(prepost_proj.get('weight', 'list')))
weight_list = [
prepost_proj.get('weight', 'list'),
prepost_proj.get('weight', format='list', with_address=False)
]
#predict_label=
sim.end()
return spikes
(run_time * i + start_time_3, run_time * i + stop_time_3)).next(
int((stop_time_3 - start_time_3) * rate_3 * 1e-3))
# spike_times_4 = RandomDistribution('uniform', (run_time * i + start_time_4, run_time * i + stop_time_4)).next(int((stop_time_3 - start_time_3) * rate_3 * 1e-3))
spike_time = np.concatenate((spike_times_1, spike_times_2, spike_times_3),
axis=0)
# print spike_time
# print type(spike_times_1)
spike_time_run = np.hstack((spike_time_run, spike_time))
# print spike_time_run
# ==========simulation setup=====================
sim.setup()
# ==========generate OR read in the input spikes data=====================
Excinp = sim.Population(Exc_in,
sim.SpikeSourceArray(spike_times=spike_time_run))
Inhinp = sim.Population(Inh_in,
sim.SpikeSourceArray(spike_times=spike_time_run))
# ==========create neuron population=====================
# todo: the initail parameters of neurons might be modified
cell_type_parameters = {'tau_refrac': 0.1, 'v_thresh': -50.0, 'tau_m': 20.0, 'tau_syn_E': 0.5, 'v_rest': -65.0,\
'cm': 1.0, 'v_reset': -65.0, 'tau_syn_I': 0.5, 'i_offset': 0.0}
# print(sim.IF_curr_alpha.default_parameters)
cell_type = sim.IF_cond_exp(**
cell_type_parameters) # neuron type of population
Pexc = sim.Population(
N_e, cell_type, label="excitotary neurons") # excitatory neuron population
Pinh = sim.Population(
N_i, cell_type,
(run_time * i + start_time_3, run_time * i + stop_time_3)).next(
int((stop_time_3 - start_time_3) * rate_3 * 1e-3))
# spike_times_4 = RandomDistribution('uniform', (run_time * i + start_time_4, run_time * i + stop_time_4)).next(int((stop_time_3 - start_time_3) * rate_3 * 1e-3))
spike_time = np.concatenate((spike_times_1, spike_times_2, spike_times_3),
axis=0)
# print spike_time
# print type(spike_times_1)
spike_time_run = np.hstack((spike_time_run, spike_time))
# print spike_time_run
# ==========simulation setup=====================
sim.setup()
# ==========generate OR read in the input spikes data=====================
Excinp = sim.Population(Exc_in,
sim.SpikeSourceArray(spike_times=spike_time_run))
Inhinp = sim.Population(Inh_in,
sim.SpikeSourceArray(spike_times=spike_time_run))
# # ==========create neuron population=====================
# # todo: the initail parameters of neurons might be modified
# cell_type_parameters = {'tau_refrac': 0.1, 'v_thresh': -50.0, 'tau_m': 20.0, 'tau_syn_E': 0.5, 'v_rest': -65.0,\
# 'cm': 1.0, 'v_reset': -65.0, 'tau_syn_I': 0.5, 'i_offset': 0.0}
# # print(sim.IF_curr_alpha.default_parameters)
# cell_type = sim.IF_cond_exp(**cell_type_parameters) # neuron type of population
# Pexc = sim.Population(N_e, cell_type, label = "excitotary neurons") # excitatory neuron population
# Pinh = sim.Population(N_i, cell_type, label = "inhibitatory neurons") # inhibitoty neuron population
# all_cells = sim.Assembly(Pexc, Pinh) # assembly for all neuron population for the purpose of data recording
# # todo: the Population structure
def test_add_pynn_population_sets_up_labels_and_aliases():
pynn_pop3 = pynnn.Population(1, pynnn.IF_cond_alpha)
A.add_pynn_population(pynn_pop3)
assert A.aliases[Tns.pynn_pop1.label] == Tns.pynn_pop1.label
assert A.aliases[Tns.pynn_pop2.label] == Tns.pop2_alias
assert A.aliases[pynn_pop3.label] == pynn_pop3.label
import pyNN.brian as sim
sim.setup()
p = sim.Population(5, sim.IF_cond_exp())
p.set(tau_m=15.0)
print(p.get('tau_m'))
p[0, 2, 4].set(tau_m=10)
print(p.get('tau_m'))
print(p[0].tau_m)
#random value
from pyNN.random import RandomDistribution, NumpyRNG
gbar_na_distr = RandomDistribution('normal', (20.0, 2.0),
rng=NumpyRNG(seed=85524))
p = sim.Population(7, sim.HH_cond_exp(gbar_Na=gbar_na_distr))
print(p.get('gbar_Na'))
print(p[0].gbar_Na)
#setting from an array
import numpy as np
p = sim.Population(6,
sim.SpikeSourcePoisson(rate=np.linspace(10.0, 20.0, num=6)))
print(p.get('rate'))
#using function to calculate
from numpy import sin, pi
p = sim.Population(8, sim.IF_cond_exp(i_offset=lambda i: sin(i * pi / 8)))
print(p.get('i_offset'))
runtime = 50
eta = 0.5 # learning rate
iter_no = 5 # learning iteration
source_rate = [20, 40]
w1_1 = 0.1
w1_2 = 0.1
w2_1 = 0.1
w2_2 = 0.1
# set up the classifier network
for i in range(len(training_label)):
# for i in range(1):
lg.info('iteration number %d' % i)
sim.setup()
In_1 = sim.Population(
10, sim.SpikeSourcePoisson(rate=source_rate[training_label[i]]))
In_2 = sim.Population(
10, sim.SpikeSourcePoisson(rate=source_rate[1 - training_label[i]]))
In = In_1 + In_2
Out_1 = sim.Population(10, sim.IF_cond_exp())
Out_2 = sim.Population(10, sim.IF_cond_exp())
Out = Out_1 + Out_2
syn_1_1 = sim.StaticSynapse(weight=w1_1, delay=0.5)
syn_1_2 = sim.StaticSynapse(weight=w1_2, delay=0.5)
syn_2_1 = sim.StaticSynapse(weight=w2_1, delay=0.5)
syn_2_2 = sim.StaticSynapse(weight=w2_2, delay=0.5)
prj_1_1 = sim.Projection(In_1,
Out_1,
weightStim = 8.0 # weight of stimulating synapses
timingPrePostStim = 0.3 # limit of precision of spiking in ms
stimulusOffset = 100.0 # offset from beginning and end of emulation in ms (should be larger than timingPrePostPlastic)
# prepare stimuli
stimulus = np.arange(stimulusOffset,
(noSpikePairs - 0.5) * intervalPairs + stimulusOffset,
intervalPairs)
stimulusPlastic = stimulus + timingPrePostStim - timingPrePostPlastic
# print stimulusPlastic
# print stimulus, (noSpikePairs - 0.5) * intervalPairs
# assert(len(stimulus) == noSpikePairs)
sim.setup()
# create postsynaptic neuron
neuron = sim.Population(1, sim.IF_curr_exp())
spikeSourceStim = None
spikeSourcePlastic = None
# place stimulating synapses above plastic synapse
if row < noStim:
if row > 0:
dummy = sim.Population(row, sim.SpikeSourceArray)
spikeSourcePlastic = sim.Population(1, sim.SpikeSourceArray,
{'spike_times': stimulusPlastic})
# create stimulating inputs
spikeSourceStim = sim.Population(noStim, sim.SpikeSourceArray,
{'spike_times': stimulus})
# place stimulating synapses below plastic synapse
def plot_signal(signal, index, colour='b'):
label = "Neuron %d " % index
plt.plot(signal.times, signal, colour, label=label)
plt.ylabel("%s (%s)" % (signal.name, signal.units._dimensionality.string))
plt.setp(plt.gca().get_xticklabels(), visible=False)
run_time = 500
no_run = 3
sim.setup()
# Excinp = sim.Population(10, sim.SpikeSourcePoisson(rate = 20.0, start = 0, duration = run_time))
stimSpikes = RandomDistribution('uniform', low=0, high=500.0).next([1, 10])
Excinp = sim.Population(10, sim.SpikeSourceArray(spike_times=stimSpikes[0, :]))
# cell_type_parameters = {'tau_refrac': 0.1, 'v_thresh': -50.0, 'tau_m': 20.0, 'tau_syn_E': 0.5, 'v_rest': -65.0,\
# 'cm': 1.0, 'v_reset': -65.0, 'tau_syn_I': 0.5, 'i_offset': 0.0}
# print(sim.IF_curr_alpha.default_parameters)
# cell_type = sim.IF_cond_exp(**cell_type_parameters) # neuron type of population
Pexc = sim.Population(10,
sim.EIF_cond_exp_isfa_ista(),
label="excitotary neurons")
# Pexc.set(tau_refrac = 0.1, v_thresh = -50.0, tau_m = 20.0, tau_syn_E = 0.5, v_rest = -65.0, \
# cm = 1.0, v_reset = -65, tau_syn_I = 0.5, i_offset = 0.0)
# Pexc.initialize(**cell_type_parameters)
# print Pexc.celltype.default_initial_values
# print Pexc.get('tau_m')
# syn = sim.StaticSynapse(weight = 0.05, delay = 0.5)
depressing_synapse_ee = sim.TsodyksMarkramSynapse(weight=0.05,
import pyNN.brian as sim
from pyNN.random import RandomDistribution, NumpyRNG
Exc_in = 32
Inh_in = 32
noSpikes = 20 # number of spikes per chanel per simulation run
stimSpikes = RandomDistribution(
'uniform', low=0, high=500.0, rng=NumpyRNG(seed=72386)
).next(
[Exc_in + Inh_in, noSpikes]
) # generate a time uniform distributed signal with Exc_in + Inh_in chanels and noSpikes for each chanel
# print stimSpikes
for i in range(Exc_in):
if i == 0:
Excinp = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i, :]))
else:
spike_source = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i, :]))
Excinp = Excinp + spike_source
for i in range(Inh_in):
if i == 0:
Inhinp = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i + Exc_in, :]))
else:
spike_source = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i + Exc_in, :]))
Inhinp = Inhinp + spike_source
# for p in Excinp.populations:
tc_parameters = ctx_parameters.copy()
tc_parameters.update({'a': 20.0, 'b': 0.0})
thalamocortical_type = sim.EIF_cond_exp_isfa_ista(**tc_parameters)
cortical_type = sim.EIF_cond_exp_isfa_ista(**ctx_parameters)
'''
populations
'''
#tec_cells=create(thalamocortical_type,n=100)
#tc_cells = Population(100, thalamocortical_type)
#ctx_cells = Population(500, cortical_type)
from pyNN.space import Grid2D, RandomStructure, Sphere
tc_cells = sim.Population(
100,
thalamocortical_type,
structure=RandomStructure(boundary=Sphere(radius=200.0)),
initial_values={'v': -70.0},
label="Thalamocortical neurons")
from pyNN.random import RandomDistribution
v_init = RandomDistribution('uniform', (-70.0, -60.0))
ctx_cells = sim.Population(500,
cortical_type,
structure=Grid2D(dx=10.0, dy=10.0),
initial_values={'v': v_init},
label="Cortical neurons")
pre = tc_cells[:50]
post = ctx_cells[:50]
excitatory_connections = sim.Projection(pre, post, sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.123))
#full example
from pyNN.space import Space
import pyNN.brian as sim
from pyNN.random import RandomDistribution, NumpyRNG
import numpy as np
import matplotlib.pyplot as plt
N_e = 75 # number of excitatory neurons
N_i = 25 # number of inhibitatory neurons
Exc_in = 32 # number of excitatory inputs
Inh_in = 32 # number of inhibitatory inputs
weight_ini = 0.16 # define the initial value of the input signal weight
run_time = 500 # define the simulation time per run
sim.setup()
# ==========generate OR read in the input spikes data=====================
Excinp = sim.Population(Exc_in, sim.SpikeSourcePoisson(rate=15))
Inhinp = sim.Population(Inh_in, sim.SpikeSourcePoisson(rate=15))
# ==========create neuron population=====================
# todo: the initail parameters of neurons might be modified
cell_type_parameters = {'tau_refrac': 0.1, 'v_thresh': -50.0, 'tau_m': 20.0, 'tau_syn_E': 0.5, 'v_rest': -65.0,\
'cm': 1.0, 'v_reset': -65.0, 'tau_syn_I': 0.5, 'i_offset': 0.0}
# print(sim.IF_curr_alpha.default_parameters)
cell_type = sim.IF_cond_exp(**
cell_type_parameters) # neuron type of population
Pexc = sim.Population(
N_e, cell_type, label="excitotary neurons") # excitatory neuron population
Pinh = sim.Population(
N_i, cell_type,
label="inhibitatory neurons") # inhibitoty neuron population
import pyNN.brian as sim
import numpy as np
import matplotlib.pyplot as plt
run_time = 500
no_run = 3
sim.setup()
Excinp = sim.Population(10, sim.SpikeSourcePoisson(rate = 20.0, start = 0, duration = run_time * no_run))
# cell_type_parameters = {'tau_refrac': 0.1, 'v_thresh': -50.0, 'tau_m': 20.0, 'tau_syn_E': 0.5, 'v_rest': -65.0,\
# 'cm': 1.0, 'v_reset': -65.0, 'tau_syn_I': 0.5, 'i_offset': 0.0}
# print(sim.IF_curr_alpha.default_parameters)
# cell_type = sim.IF_cond_exp(**cell_type_parameters) # neuron type of population
Pexc = sim.Population(10, sim.EIF_cond_exp_isfa_ista(), label = "excitotary neurons")
# Pexc.set(tau_refrac = 0.1, v_thresh = -50.0, tau_m = 20.0, tau_syn_E = 0.5, v_rest = -65.0, \
# cm = 1.0, v_reset = -65, tau_syn_I = 0.5, i_offset = 0.0)
# Pexc.initialize(**cell_type_parameters)
# print Pexc.celltype.default_initial_values
# print Pexc.get('tau_m')
# syn = sim.StaticSynapse(weight = 0.05, delay = 0.5)
# depressing_synapse_ee = sim.TsodyksMarkramSynapse(weight = 0.05, delay = 0.2, U = 0.5, tau_rec = 800.0, tau_facil = 0.01)
facilitating_synapse_ee = sim.TsodyksMarkramSynapse(weight = 0.05, delay = 0.5, U = 0.04, tau_rec = 100.0, tau_facil = 1000)
connection = sim.Projection(Excinp, Pexc, sim.AllToAllConnector(), facilitating_synapse_ee, receptor_type = 'excitatory')
# E_E_connection = sim.Projection(Pexc, Pexc, sim.FixedProbabilityConnector(p_connect = 0.5), depressing_synapse_ee, receptor_type = 'excitatory')
Excinp.record('spikes')
# Excinp[1].record('v')
Pexc.record('spikes')
Number_of_neurons_lsm = 125
Net_shape= (5,5,5) # 20x5=>layer, 6=>number of layers
Number_of_neurons_I = 10
Net_shape_I= (10,1,1)
## === Define parameters ========================================================
'''
cell_params = {
'tau_m' : 20.0, # (ms)
'tau_syn_E' : 2.0, # (ms)
'tau_syn_I' : 4.0, # (ms)
'e_rev_E' : 0.0, # (mV)
'e_rev_I' : -70.0, # (mV)
'tau_refrac' : 2.0, # (ms)
'v_rest' : -60.0, # (mV)
'v_reset' : -70.0, # (mV)
'v_thresh' : -50.0, # (mV)
'cm' : 0.5} # (nF)
dt = 0.1 # (ms)
syn_delay = 1.0 # (ms)
input_rate = 50.0 # (Hz)
simtime = 1000.0 # (ms)
}
'''
## === Build Networks ========================================================
Population = {}
Population['Input'] = sim.Population(Number_of_neurons_I, sim.IF_curr_exp())
Population['Liquid'] = sim.Population(Number_of_neurons_lsm, sim.IF_curr_exp())
# ==========generate OR read in the input spikes data=====================
noSpikes = 20 # number of spikes per chanel per simulation run
stimSpikes = RandomDistribution(
'uniform', low=0, high=run_time, rng=NumpyRNG(seed=72386)
).next(
[Exc_in + Inh_in, noSpikes]
) # generate a time uniform distributed signal with Exc_in + Inh_in chanels and noSpikes for each chanel
# todo: 64 chanel represents different data
sim.setup() # start buiding up the network topology
# ==========create the input signal neuron population==================
# form the Exc_in chanels excitatory inputs as a assembly Inhinp
for i in range(Exc_in):
if i == 0:
Excinp = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i, :]))
else:
spike_source = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i, :]))
Excinp = Excinp + spike_source
# form the Inh_in chanels excitatory inputs as a assembly Inhinp
for i in range(Inh_in):
if i == 0:
Inhinp = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i + Exc_in, :]))
else:
spike_source = sim.Population(
1, sim.SpikeSourceArray(spike_times=stimSpikes[i + Exc_in, :]))
Inhinp = Inhinp + spike_source
import pyNN.brian as sim # can of course replace `neuron` with `nest`, `brian`, etc.
import matplotlib.pyplot as plt
import numpy as np
sim.setup(timestep=0.01)
p_in = sim.Population(10, sim.SpikeSourcePoisson(rate=10.0), label="input")
p_out = sim.Population(10, sim.EIF_cond_exp_isfa_ista(), label="AdExp neurons")
syn = sim.StaticSynapse(weight=0.05)
random = sim.FixedProbabilityConnector(p_connect=0.5)
connections = sim.Projection(p_in,
p_out,
random,
syn,
receptor_type='excitatory')
p_in.record('spikes')
p_out.record('spikes') # record spikes from all neurons
p_out[0:2].record(['v', 'w', 'gsyn_exc'
]) # record other variables from first two neurons
for i in range(2):
sim.run(500.0)
spikes_in = p_in.get_data()
data_out = p_out.get_data()
sim.reset()
connections.set(weight=0.05)
sim.end()
print 'finish simulation'
import pyNN.brian as sim
sim.setup()
cell = sim.Population(1, sim.HH_cond_exp())
cell.record('v')
sim.run(100)
data = cell.get_data()
sim.end()
import pyNN.brian as sim
import numpy as np
training_data = np.loadtxt('training_data_0_1.txt', delimiter=',')
training_label = training_data[:, -1]
training_rate = training_data[:, 0:64]
# print training_rate[1, :]
inputpop = []
sim.setup()
for i in range(np.size(training_rate, 1)):
inputpop.append(
sim.Population(1, sim.SpikeSourcePoisson(rate=abs(training_rate[0,
i]))))
# print inputpop[0].get('rate')
# inputpop[0].set(rate = 8)
# print inputpop[0].get('rate')
pop = sim.Population(1, sim.IF_cond_exp(), label='exc')
prj1 = sim.Projection(inputpop[0],
pop,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=0.04, delay=0.5),
receptor_type='inhibitory')
print prj1.get('weight', format='list')
