def testAllToAll(self):
for srcP in [self.source5, self.source22, self.target33]:
for tgtP in [self.target6, self.target33]:
if srcP == tgtP:
prj = sim.Projection(
srcP, tgtP,
sim.AllToAllConnector(allow_self_connections=False,
weights=1.234))
else:
prj = sim.Projection(srcP, tgtP,
sim.AllToAllConnector(weights=1.234))
weights = prj._connections.W.toarray().flatten().tolist()
self.assertEqual(weights, [1.234] * len(prj))
def testFixedProbability(self):
"""For all connections created with "fixedProbability"..."""
for srcP in [self.source5, self.source22]:
for tgtP in [self.target1, self.target6, self.target33]:
prj1 = sim.Projection(srcP,
tgtP,
sim.FixedProbabilityConnector(0.5),
rng=random.NumpyRNG(12345))
prj2 = sim.Projection(srcP,
tgtP,
sim.FixedProbabilityConnector(0.5),
rng=random.NativeRNG(12345))
for prj in prj1, prj2:
assert (0 < len(prj) < len(srcP) * len(tgtP)
), 'len(prj) = %d, len(srcP)*len(tgtP) = %d' % (
len(prj), len(srcP) * len(tgtP))
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_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 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 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_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 testDistanceDependentProbability(self):
"""For all connections created with "distanceDependentProbability"..."""
# Test should be improved..."
for rngclass in (random.NumpyRNG, random.NativeRNG):
for expr in ('exp(-d)', 'd < 0.5'):
#rngclass = random.NumpyRNG
#expr = 'exp(-d)'
prj = sim.Projection(self.source33,
self.target33,
sim.DistanceDependentProbabilityConnector(
d_expression=expr),
rng=rngclass(12345))
assert (0 < len(prj) <=
len(self.source33) * len(self.target33)), len(prj)
self.assertRaises(ZeroDivisionError,
sim.DistanceDependentProbabilityConnector,
d_expression="d/0.0")
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 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
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')
# facilitating_synapse_ie = sim.TsodyksMarkramSynapse(weight = w_ie, delay = 0.5, U = 0.04, tau_rec = 100.0, tau_facil = 1000)
# facilitating_synapse_ei = sim.TsodyksMarkramSynapse(weight = w_ei, delay = 0.5, U = 0.04, tau_rec = 100.0, tau_facil = 1000)
# # connect the neuronal network
# E_E_connections = sim.Projection(Pexc, Pexc, connector_ee, depressing_synapse_ee, receptor_type = 'excitatory', label = "excitatory to excitatory") # excitatory to excitatory connection
# I_I_connections = sim.Projection(Pinh, Pinh, connector_ii, depressing_synapse_ii, receptor_type = 'inhibitory', label = "inhibitory to inhibitory") # inhibitory to inhibitory connection
# E_I_connections = sim.Projection(Pexc, Pinh, connector_ie, facilitating_synapse_ie, receptor_type = 'excitatory', label = "excitatory to inhibitory") # from excitatory to inhibitory connection
# I_E_connections = sim.Projection(Pinh, Pexc, connector_ei, facilitating_synapse_ei, receptor_type = 'inhibitory', label = "inhibitory to excitatory") # from inhibitory to excitatory
# ==========injecting neuron currents OR connect to the input signal=======================
syn = sim.StaticSynapse(weight=weight_ini, delay=0.5)
Ie_E_connections = sim.Projection(
Excinp,
Pexc,
sim.FixedProbabilityConnector(p_connect=0.5),
syn,
receptor_type='excitatory',
label="excitatory input to excitatory neurons")
Ii_E_connections = sim.Projection(
Inhinp,
Pexc,
sim.FixedProbabilityConnector(p_connect=0.5),
syn,
receptor_type='inhibitory',
label="inhibitory input to excitatory neurons")
Ie_I_connections = sim.Projection(
Excinp,
Pinh,
sim.FixedProbabilityConnector(p_connect=0.5),
syn,
{'spike_times': []})
spikeSourcePlastic = sim.Population(1, sim.SpikeSourceArray,
{'spike_times': stimulusPlastic})
assert (spikeSourceStim != None)
assert (spikeSourcePlastic != None)
# configure stdp
stdp = sim.STDPMechanism(weight = 0.2, # this is the initial value of the weight
timing_dependence = sim.SpikePairRule(tau_plus = 20.0, tau_minus = 20.0,
A_plus = 0.01, A_minus = 0.012),\
weight_dependence = sim.AdditiveWeightDependence(w_min = 0, w_max = 0.04))
# connect stimulus
sim.Projection(spikeSourceStim,
neuron,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.04, delay=timingPrePostStim),
receptor_type='excitatory')
# create plastic synapse
prj = sim.Projection(spikeSourcePlastic, neuron, sim.AllToAllConnector(), stdp)
weightBefore = prj.get('weight', format='list')
prj.set(weight=0.15)
print weightBefore
neuron.record('spikes')
lastInputSpike = np.max(np.concatenate((stimulus, stimulusPlastic)))
runtime = lastInputSpike + stimulusOffset
sim.run(runtime)
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'
W_c = 0.5 # scaling factor of weight
w_ee = W_c * 1
# type of synaptic connection
# syn = sim.StaticSynapse(weight = 0.05, delay = 0.5)
depressing_synapse_ee = sim.TsodyksMarkramSynapse(weight=w_ee,
delay=0.2,
U=0.5,
tau_rec=800.0,
tau_facil=0.01)
# connect the neuronal network
E_E_connections = sim.Projection(
Pexc,
Pexc,
connector_ee,
depressing_synapse_ee,
receptor_type='excitatory',
label="excitatory to excitatory") # excitatory to excitatory connection
# ==========injecting neuron currents OR connect to the input signal=======================
syn = sim.StaticSynapse(weight=weight_inp[0], delay=0.5)
Ie_E_connections = sim.Projection(
Excinp,
Pexc,
sim.FixedProbabilityConnector(p_connect=0.5),
syn,
receptor_type='excitatory',
label="excitatory input to excitatory neurons")
Ii_E_connections = sim.Projection(
def main():
## Uninteresting setup, start up the visu process,...
logfile = make_logfile_name()
ensure_dir(logfile)
f_h = logging.FileHandler(logfile)
f_h.setLevel(SUBDEBUG)
d_h = logging.StreamHandler()
d_h.setLevel(INFO)
utils.configure_loggers(debug_handler=d_h, file_handler=f_h)
parent_conn, child_conn = multiprocessing.Pipe()
p = multiprocessing.Process(target=visualisation.visualisation_process_f,
name="display_process",
args=(child_conn, LOGGER))
p.start()
pynnn.setup(timestep=SIMU_TIMESTEP)
init_logging("logfile", debug=True)
LOGGER.info("Simulation started with command: %s", sys.argv)
## Network setup
# First population
p1 = pynnn.Population(100,
pynnn.IF_curr_alpha,
structure=pynnn.space.Grid2D())
p1.set({'tau_m': 20, 'v_rest': -65})
# Second population
p2 = pynnn.Population(20,
pynnn.IF_curr_alpha,
cellparams={
'tau_m': 15.0,
'cm': 0.9
})
# Projection 1 -> 2
prj1_2 = pynnn.Projection(
p1,
p2,
pynnn.AllToAllConnector(allow_self_connections=False),
target='excitatory')
# I may need to make own PyNN Connector class. Otherwise, this is
# neat: exponentially decaying probability of connections depends
# on distance. Distance is only calculated using x and y, which
# are on a toroidal topo with boundaries at 0 and 500.
connector = pynnn.DistanceDependentProbabilityConnector(
"exp(-abs(d))",
space=pynnn.Space(axes='xy',
periodic_boundaries=((0, 500), (0, 500), None)))
# Alternately, the powerful connection set algebra (python CSA
# module) can be used.
weight_distr = pynnn.RandomDistribution(distribution='gamma',
parameters=[1, 0.1])
prj1_2.randomizeWeights(weight_distr)
# This one is in NEST but not in Brian:
# source = pynnn.NoisyCurrentSource(
# mean=100, stdev=50, dt=SIMU_TIMESTEP,
# start=10.0, stop=SIMU_DURATION, rng=pynnn.NativeRNG(seed=100))
source = pynnn.DCSource(start=10.0, stop=SIMU_DURATION, amplitude=100)
source.inject_into(list(p1.sample(50).all()))
p1.record(to_file=False)
p2.record(to_file=False)
## Build and send the visualizable network structure
adapter = pynn_to_visu.PynnToVisuAdapter(LOGGER)
adapter.add_pynn_population(p1)
adapter.add_pynn_population(p2)
adapter.add_pynn_projection(p1, p2, prj1_2.connection_manager)
adapter.commit_structure()
parent_conn.send(adapter.output_struct)
# Number of chunks to run the simulation:
n_chunks = SIMU_DURATION // SIMU_TO_VISU_MESSAGE_PERIOD
last_chunk_duration = SIMU_DURATION % SIMU_TO_VISU_MESSAGE_PERIOD
# Run the simulator
for visu_i in xrange(n_chunks):
pynnn.run(SIMU_TO_VISU_MESSAGE_PERIOD)
parent_conn.send(adapter.make_activity_update_message())
LOGGER.debug("real current p1 spike counts: %s",
p1.get_spike_counts().values())
if last_chunk_duration > 0:
pynnn.run(last_chunk_duration)
parent_conn.send(adapter.make_activity_update_message())
# Cleanup
pynnn.end()
# Wait for the visualisation process to terminate
p.join(VISU_PROCESS_JOIN_TIMEOUT)
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')
Pexc[5:6].record('v')
for i in range(no_run):
sim.run_until(run_time * (i + 1))
print('the time is %.1f' %(run_time * (i + 1)))
spikes = Excinp.get_data()
spike = Pexc.get_data()
# print connection.get('weight',format = 'array')
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,
sim.ArrayConnector(connector1_1),
syn_1_1,
receptor_type='excitatory')
prj_1_2 = sim.Projection(In_1,
Out_2,
sim.ArrayConnector(connector1_2),
syn_1_2,
receptor_type='excitatory')
prj_2_1 = sim.Projection(In_2,
Out_1,
sim.ArrayConnector(connector2_1),
syn_2_1,
receptor_type='excitatory')
prj_2_2 = sim.Projection(In_2,
Out_2,
sim.ArrayConnector(connector2_2),
def testOneToOne(self):
"""For all connections created with "OneToOne" ..."""
prj = sim.Projection(self.source33, self.target33,
sim.OneToOneConnector(weights=0.5))
self.assertEqual(prj._connections.W.getnnz(), self.target33.cell.size)
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]
facilitating_synapse_ie = sim.TsodyksMarkramSynapse(weight=w_ie,
delay=0.5,
U=0.04,
tau_rec=100.0,
tau_facil=1000)
facilitating_synapse_ei = sim.TsodyksMarkramSynapse(weight=w_ei,
delay=0.5,
U=0.04,
tau_rec=100.0,
tau_facil=1000)
# connect the neuronal network
E_E_connections = sim.Projection(
Pexc,
Pexc,
connector_ee,
depressing_synapse_ee,
receptor_type='excitatory',
label="excitatory to excitatory") # excitatory to excitatory connection
I_I_connections = sim.Projection(
Pinh,
Pinh,
connector_ii,
depressing_synapse_ii,
receptor_type='inhibitory',
label="inhibitory to inhibitory") # inhibitory to inhibitory connection
E_I_connections = sim.Projection(Pexc,
Pinh,
connector_ie,
facilitating_synapse_ie,
receptor_type='excitatory',
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
rng = NumpyRNG(seed=64754)
sparse_connectivity = sim.FixedProbabilityConnector(0.1, rng=rng)
weight_distr = RandomDistribution('normal', [0.01, 1e-3], rng=rng)
facilitating = sim.TsodyksMarkramSynapse(U=0.04,
tau_rec=100.0,
tau_facil=1000.0,
weight=weight_distr,
delay=lambda d: 0.1 + d / 100.0)
space = Space(axes='xy')
#specifying periodic boundary conditions
#space = Space(periodic_boundaries=((0,500), (0,500), None))
#calculates distance on the surface of a torus of circumference 500 µm
#(wrap-around in the x- and y-dimensions but not z)
# 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)
static_synapse = sim.StaticSynapse(weight=0.05, delay=0.5)
Input_E_connection = sim.Projection(Excinp,
Pexc,
sim.AllToAllConnector(),
static_synapse,
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')
Pexc[5:6].record('v')
for i in range(no_run):
# 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(3, cell_type, label = "excitotary neurons") # excitatory neuron population
# ==========generate OR read in the input spikes data=====================
noSpikes = 20 # number of spikes per chanel per simulation run
stimSpikes = RandomDistribution('uniform', low = 0, high = 500, rng = NumpyRNG(seed = 72386)).next(noSpikes) # generate a time uniform distributed signal with Exc_in + Inh_in chanels and noSpikes for each chanel
Excinp = sim.Population(3, sim.SpikeSourceArray(spike_times = stimSpikes))
syn = sim.StaticSynapse(weight = 0.05, delay = 0.5)
Ie_A_connections = sim.Projection(Excinp, Pexc, sim.FixedProbabilityConnector(p_connect = 0.5), syn, receptor_type = 'excitatory', label = "excitatory input")
for i in range(ite_no):
sim.run(100)
# ==========write the data======================
sim.reset()
Ie_A_connections.set(weight = (i + 2) * 0.05)
print Ie_A_connections.get('weight', format = 'list')
# Ie_A_connections.set(weight = 0.02)
# print Ie_A_connections.get('weight', format = 'list')
# sim.run(200)
# sim.reset()
