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(
# 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)
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')
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
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]
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'
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)
weightAfter = prj.get('weight', format='list')
def setUp(self):
sim.setup()
self.syn = sim.StaticSynapse(weight=0.123, delay=0.5)
connector_ee = sim.FixedProbabilityConnector(
p_connect=p_ee) # connector algorithm
connector_ie = sim.FixedProbabilityConnector(p_connect=p_ie)
connector_ei = sim.FixedProbabilityConnector(p_connect=p_ei)
connector_ii = sim.FixedProbabilityConnector(p_connect=p_ii)
# connection weight
# todo: weight distribution according to position
W_c = 0.5 # scaling factor of weight
w_ee = W_c * 1
w_ie = 0.5 * W_c * 0.1
w_ei = W_c * 3
w_ii = 0.5 * W_c * 0.5
# type of synaptic connection
static_synapse_ee = sim.StaticSynapse(weight=w_ee, delay=0.2)
static_synapse_ii = sim.StaticSynapse(weight=w_ii, delay=0.2)
static_synapse_ie = sim.StaticSynapse(weight=w_ie, delay=0.5)
static_synapse_ei = sim.StaticSynapse(weight=w_ei, delay=0.5)
# connect the neuronal network
E_E_connections = sim.Projection(
Pexc,
Pexc,
connector_ee,
static_synapse_ee,
receptor_type='excitatory',
label="excitatory to excitatory") # excitatory to excitatory connection
I_I_connections = sim.Projection(
import pyNN.brian as sim
from pyNN.random import (NumpyRNG, RandomDistribution)
#import matplotlib.pyplot as plt
import numpy as np
sim.setup(timestep=0.01)
'''
Synapse types
'''
#=====Fixed synaptic weight=====
syn = sim.StaticSynapse(weight=0.04, delay=0.5)
#random
w = RandomDistribution('gamma', [10, 0.004], rng=NumpyRNG(seed=4242))
syn = sim.StaticSynapse(weight=w, delay=0.5)
#specify parameters as a function of the distance- um
syn = sim.StaticSynapse(weight=w, delay="0.2 + 0.01*d")
#=====Short-term synaptic plasticity=====
depressing_synapse = sim.TsodyksMarkramSynapse(weight=w,
delay=0.2,
U=0.5,
tau_rec=800.0,
tau_facil=0.0)
tau_rec = RandomDistribution('normal', [100.0, 10.0])
facilitating_synapse = sim.TsodyksMarkramSynapse(weight=w,
delay=0.5,
U=0.04,
tau_rec=tau_rec)
#=====Spike-timing-dependent plasticity=====
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,
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,
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')
