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=====
def do_run(Neurons, sim_time, record, seed=None):
"""
:param Neurons: Number of Neurons
:type Neurons: int
:param sim_time: times for run
:type sim_time: int
:param record: If True will aks for spikes to be recorded
:type record: bool
"""
g = 5.0
eta = 2.0
delay = 2.0
epsilon = 0.1
tau_m = 20.0 # ms (20ms will give a FR of 20hz)
tau_ref = 2.0
v_reset = 10.0
v_th = 20.0
v_rest = 0.0
tau_syn = 1.0
n_e = int(round(Neurons * 0.8))
n_i = int(round(Neurons * 0.2))
c_e = n_e * 0.1
# Excitatory and inhibitory weights
j_e = 0.1
j_i = -g * j_e
# The firing rate of a neuron in the external pop
# is the product of eta time the threshold rate
# the steady state firing rate which is
# needed to bring a neuron to threshold.
nu_ex = eta * v_th / (j_e * c_e * tau_m)
# population rate of the whole external population.
# With CE neurons the pop rate is simply the product
# nu_ex*c_e the factor 1000.0 changes the units from
# spikes per ms to spikes per second.
p_rate = 1000.0 * nu_ex * c_e
print("Rate is: %f HZ" % (p_rate / 1000))
# Neural Parameters
pynn.setup(timestep=1.0, min_delay=1.0, max_delay=16.0)
# Makes it easy to scale up the number of cores
pynn.set_number_of_neurons_per_core(pynn.IF_curr_exp, 100)
pynn.set_number_of_neurons_per_core(pynn.SpikeSourcePoisson, 100)
exc_cell_params = {
'cm': 1.0, # pf
'tau_m': tau_m,
'tau_refrac': tau_ref,
'v_rest': v_rest,
'v_reset': v_reset,
'v_thresh': v_th,
'tau_syn_E': tau_syn,
'tau_syn_I': tau_syn,
'i_offset': 0.9
}
inh_cell_params = {
'cm': 1.0, # pf
'tau_m': tau_m,
'tau_refrac': tau_ref,
'v_rest': v_rest,
'v_reset': v_reset,
'v_thresh': v_th,
'tau_syn_E': tau_syn,
'tau_syn_I': tau_syn,
'i_offset': 0.9
}
# Set-up pynn Populations
e_pop = pynn.Population(n_e, pynn.IF_curr_exp(**exc_cell_params),
label="e_pop")
i_pop = pynn.Population(n_i, pynn.IF_curr_exp, inh_cell_params,
label="i_pop")
if seed is None:
poisson_ext_e = pynn.Population(
n_e, pynn.SpikeSourcePoisson(rate=10.0),
label="Poisson_pop_E")
poisson_ext_i = pynn.Population(
n_i, pynn.SpikeSourcePoisson(rate=10.0),
label="Poisson_pop_I")
else:
poisson_ext_e = pynn.Population(
n_e, pynn.SpikeSourcePoisson(rate=10.0),
label="Poisson_pop_E", additional_parameters={"seed": seed})
poisson_ext_i = pynn.Population(
n_i, pynn.SpikeSourcePoisson(rate=10.0),
label="Poisson_pop_I", additional_parameters={"seed": seed+1})
# Connectors
e_conn = pynn.FixedProbabilityConnector(epsilon)
i_conn = pynn.FixedProbabilityConnector(epsilon)
# Use random delays for the external noise and
# set the initial membrane voltage below the resting potential
# to avoid the overshoot of activity in the beginning of the simulation
rng = NumpyRNG(seed=seed)
delay_distr = RandomDistribution('uniform', [1.0, 16.0], rng=rng)
ext_conn = pynn.OneToOneConnector()
uniform_distr = RandomDistribution('uniform', [-10, 0], rng=rng)
e_pop.initialize(v=uniform_distr)
i_pop.initialize(v=uniform_distr)
# Projections
pynn.Projection(
presynaptic_population=e_pop, postsynaptic_population=e_pop,
connector=e_conn, receptor_type="excitatory",
synapse_type=pynn.StaticSynapse(weight=j_e, delay=delay_distr))
pynn.Projection(
presynaptic_population=i_pop, postsynaptic_population=e_pop,
connector=i_conn, receptor_type="inhibitory",
synapse_type=pynn.StaticSynapse(weight=j_i, delay=delay))
pynn.Projection(
presynaptic_population=e_pop, postsynaptic_population=i_pop,
connector=e_conn, receptor_type="excitatory",
synapse_type=pynn.StaticSynapse(weight=j_e, delay=delay_distr))
pynn.Projection(
presynaptic_population=i_pop, postsynaptic_population=i_pop,
connector=i_conn, receptor_type="inhibitory",
synapse_type=pynn.StaticSynapse(weight=j_i, delay=delay))
pynn.Projection(
presynaptic_population=poisson_ext_e, postsynaptic_population=e_pop,
connector=ext_conn, receptor_type="excitatory",
synapse_type=pynn.StaticSynapse(weight=j_e * 10, delay=delay_distr))
pynn.Projection(
presynaptic_population=poisson_ext_i, postsynaptic_population=i_pop,
connector=ext_conn, receptor_type="excitatory",
synapse_type=pynn.StaticSynapse(weight=j_e * 10, delay=delay_distr))
# Record stuff
if record:
e_pop.record('spikes')
poisson_ext_e.record('spikes')
pynn.run(sim_time)
esp = None
s = None
if record:
esp = e_pop.get_data('spikes')
s = poisson_ext_e.get_data('spikes')
pynn.end()
return esp, s, n_e
simulator_name = get_script_args(1)[0]
sim = import_module("pyNN.%s" % simulator_name)
from pyNN.random import NumpyRNG, RandomDistribution
init_logging(None, debug=True)
seed = 764756387
rng = NumpyRNG(seed=seed, parallel_safe=True)
tstop = 1000.0 # ms
input_rate = 100.0 # Hz
cell_params = {'tau_refrac': 2.0, # ms
'v_thresh': -50.0, # mV
'tau_syn_E': 2.0, # ms
'tau_syn_I': 2.0, # ms
'tau_m': RandomDistribution('uniform', [18.0, 22.0], rng=rng)
}
n_record = 3
node = sim.setup(timestep=0.025, min_delay=1.0, max_delay=1.0, debug=True, quit_on_end=False)
print "Process with rank %d running on %s" % (node, socket.gethostname())
print "[%d] Creating populations" % node
n_spikes = int(2*tstop*input_rate/1000.0)
spike_times = numpy.add.accumulate(rng.next(n_spikes, 'exponential',
[1000.0/input_rate], mask_local=False))
input_population = sim.Population(10, sim.SpikeSourceArray(spike_times=spike_times), label="input")
output_population = sim.Population(20, sim.IF_curr_exp(**cell_params), label="output")
print "[%d] input_population cells: %s" % (node, input_population.local_cells)
print "[%d] output_population cells: %s" % (node, output_population.local_cells)
def train(untrained_weights=None):
organisedStim = {}
labelSpikes = []
Data = generate_data()
spikeTimes=Data[0]
labelSpikes=Data[1]
'''
for i in range(output_size):
labelSpikes.append([])
labelSpikes[i] = [i*input_len*v_co*5+(input_len-1)*v_co+1,
i*input_len*v_co*5+(input_len-1)*v_co*2+1,
i*input_len*v_co*5+(input_len-1)*v_co*3+1]
'''
#for j in range(5):
# labelSpikes
#labelSpikes[label] = [(input_len-1)*v_co+1,(input_len-1)*v_co*2+1,(input_len-1)*v_co*3+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 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),
#weight_dependence=sim.AdditiveWeightDependence(w_min=0, w_max=0.4),
dendritic_delay_fraction=1.0)
#def projections
#stdp_proj = sim.Projection(layer1, layer2, sim.FromListConnector(connections), synapse_type=stdp)
stdp_proj = sim.Projection(layer1, layer2, sim.AllToAllConnector(), 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)
sim.run(400)
trained=stdp_proj.get('weight', format='list', with_address=False)
stdp_proj = sim.Projection(layer1, layer2, sim.AllToAllConnector(), sim.StaticSynapse(weight=trained, delay=__delay__))
sim.run(800)
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"])
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),xlabel='(a) Membrane Potential of Output Layer'),
pplt.Panel(spikesinput,xticks=True, yticks=True, markersize=2, xlim=(0,runTime),xlabel='(b) Spikes of Input Layer'),
pplt.Panel(spikestim, xticks=True, yticks=True, markersize=2, xlim=(0,runTime),xlabel='(c) Spikes of Supervised Layer'),
pplt.Panel(spikes, xticks=True, xlabel="(d) Spikes of Output Layer\nTime (ms)", yticks=True, markersize=2, xlim=(0,runTime)),
title="Multiple_car Training without noise",
annotations="Multiple_car Training without noise"
).save('plot1/'+str(trylabel)+'_training.png')
#plt.hist(weight_list[1], bins=100)
plt.close('all')
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()
return weight_list[1]
def do_run(nNeurons):
p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0)
p.set_number_of_neurons_per_core(p.IF_curr_exp, 100)
cm = list()
i_off = list()
tau_m = list()
tau_re = list()
tau_syn_e = list()
tau_syn_i = list()
v_reset = list()
v_rest = list()
v_thresh = list()
for atom in range(0, nNeurons):
cm.append(0.25)
i_off.append(0.0)
tau_m.append(10.0)
tau_re.append(2.0)
tau_syn_e.append(0.5)
tau_syn_i.append(0.5)
v_reset.append(-65.0)
v_rest.append(-65.0)
v_thresh.append(-64.4)
gbar_na_distr = RandomDistribution('normal', (20.0, 2.0),
rng=NumpyRNG(seed=85524))
cell_params_lif = {
'cm': cm,
'i_offset': i_off,
'tau_m': tau_m,
'tau_refrac': tau_re,
'tau_syn_E': tau_syn_e,
'tau_syn_I': tau_syn_i,
'v_reset': v_reset,
'v_rest': v_rest,
'v_thresh': v_thresh
}
populations = list()
projections = list()
weight_to_spike = 2
delay = 1
connections = list()
for i in range(0, nNeurons):
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay)
connections.append(singleConnection)
injectionConnection = [(0, 0, weight_to_spike, delay)]
spikeArray = {'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, spikeArray, label='inputSpikes_1'))
populations[0].set(cm=0.25)
populations[0].set(cm=cm)
populations[0].set(tau_m=tau_m, v_thresh=v_thresh)
populations[0].set(i_offset=gbar_na_distr)
populations[0].set(i_offset=i_off)
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(connections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injectionConnection)))
populations[0].record("v")
populations[0].record("gsyn_exc")
populations[0].record("spikes")
p.run(100)
neo = populations[0].get_data(["v", "spikes", "gsyn_exc"])
p.end()
return neo
#================================================================================================
# Populations
#================================================================================================
input_pops=[]
# input_spikes = [10.]
input_pop = sim.Population(number_of_inputs,sim.SpikeSourceArray(spike_times=input_spikes),label="an_pop_input")
# cd_pop = sim.Population(n_b,sim.extra_models.Izhikevich_cond,bushy_params_cond,label="fixed_weight_scale_cond_1")
# cd_pop_2 = sim.Population(n_b,sim.extra_models.Izhikevich_cond,bushy_params_cond,label="fixed_weight_scale_cond_2")
cd_pop = sim.Population(n_b,sim.IF_cond_exp,bushy_params_cond,label="fixed_weight_scale_cond_1")
cd_pop.record("all")
#================================================================================================
# Projections
#================================================================================================
n_an_b_connections = RandomDistribution('uniform',[2.,5.])
w2s_b = 5.#
av_an_b = w2s_b/5.
an_b_weight = RandomDistribution('normal_clipped',[av_an_b,0.1*av_an_b,0,av_an_b*2.])
an_b_list, max_dist = normal_dist_connection_builder(number_of_inputs, n_b, RandomDistribution,
conn_num=n_an_b_connections, dist=1.,
sigma=1., conn_weight=an_b_weight, delay=timestep,
normalised_space=pop_size, get_max_dist=True)
# sim.Projection(input_pop,cd_pop,sim.FromListConnector([(0,0)]),synapse_type=sim.StaticSynapse(weight=w2s_b))
sim.Projection(input_pop, cd_pop, sim.FromListConnector(an_b_list),
synapse_type=sim.StaticSynapse())
# sim.Projection(input_pop, cd_pop_2, sim.FromListConnector(an_b_list),
# synapse_type=sim.StaticSynapse())
n_exc, celltype(**cell_params), label="Excitatory_Cells")
inh_cells = p.Population(
n_inh, celltype(**cell_params), label="Inhibitory_Cells")
exc_conn = None
ext_stim = None
if benchmark == "COBA":
ext_stim = p.Population(
20, p.SpikeSourcePoisson(rate=rate, duration=stim_dur),
label="expoisson")
rconn = 0.01
ext_conn = p.FixedProbabilityConnector(rconn)
ext_stim.record("spikes")
print("%s Initialising membrane potential to random values..." % node_id)
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
uniformDistr = RandomDistribution('uniform', [v_reset, v_thresh], rng=rng)
exc_cells.set(v=uniformDistr)
inh_cells.set(v=uniformDistr)
print("%s Connecting populations..." % node_id)
exc_conn = p.FixedProbabilityConnector(pconn, rng=rng)
inh_conn = p.FixedProbabilityConnector(pconn, rng=rng)
connections = {
'e2e': p.Projection(
exc_cells, exc_cells, exc_conn, receptor_type='excitatory',
synapse_type=p.StaticSynapse(weight=w_exc, delay=delay)),
'e2i': p.Projection(
exc_cells, inh_cells, exc_conn, receptor_type='excitatory',
synapse_type=p.StaticSynapse(weight=w_exc, delay=delay)),
'i2e': p.Projection(
# With CE neurons the pop rate is simply the product
# nu_ex*C_E the factor 1000.0 changes the units from
# spikes per ms to spikes per second.
p_rate = 1000.0 * nu_ex * C_E
print "Rate is: %f HZ" % (p_rate/1000)
# Neural Parameters
pynn.setup(timestep=1.0,min_delay=1.0,max_delay=16.0)
if simulator_Name == "spiNNaker":
pynn.set_number_of_neurons_per_core("IF_curr_exp", 100)
pynn.set_number_of_neurons_per_core("SpikeSourcePoisson", 100)
rng = NumpyRNG(seed=1)
v_distr_exc = RandomDistribution('uniform', [-10.0, 0.0], rng)
v_distr_inh = RandomDistribution('uniform', [-10.0, 0.0], rng)
exc_cell_params ={
'cm': 1.0, # pf
'tau_m': tau_m,
'tau_refrac': tau_ref,
'v_rest': v_rest,
'v_reset': v_reset,
'v_thresh': V_th,
'tau_syn_E' : tauSyn,
'tau_syn_I' : tauSyn,
#'v_init': [ v_distr_exc.next() for i in range(N_E)],
'i_offset': 0.9
}
def do_run(seed=None):
simulator_name = 'spiNNaker'
timer = Timer()
# === Define parameters =========================================
parallel_safe = True
n = 1500 # number of cells
# number of excitatory cells:number of inhibitory cells
r_ei = 4.0
pconn = 0.02 # connection probability
dt = 1 # (ms) simulation timestep
tstop = 200 # (ms) simulaton duration
delay = 1
# Cell parameters
area = 20000. # (µm²)
tau_m = 20. # (ms)
cm = 1. # (µF/cm²)
g_leak = 5e-5 # (S/cm²)
e_leak = -49. # (mV)
v_thresh = -50. # (mV)
v_reset = -60. # (mV)
t_refrac = 5. # (ms) (clamped at v_reset)
# (mV) 'mean' membrane potential, for calculating CUBA weights
v_mean = -60.
tau_exc = 5. # (ms)
tau_inh = 10. # (ms)
# (nS) #Those weights should be similar to the COBA weights
g_exc = 0.27
# (nS) # but the delpolarising drift should be taken into account
g_inh = 4.5
e_rev_exc = 0. # (mV)
e_rev_inh = -80. # (mV)
# === Calculate derived parameters ===============================
area *= 1e-8 # convert to cm²
cm *= area * 1000 # convert to nF
r_m = 1e-6 / (g_leak * area) # membrane resistance in MΩ
assert tau_m == cm * r_m # just to check
# number of excitatory cells
n_exc = int(round((n * r_ei / (1 + r_ei))))
n_inh = n - n_exc # number of inhibitory cells
celltype = p.IF_curr_exp
# (nA) weight of excitatory synapses
w_exc = 1e-3 * g_exc * (e_rev_exc - v_mean)
w_inh = 1e-3 * g_inh * (e_rev_inh - v_mean) # (nA)
assert w_exc > 0
assert w_inh < 0
# === Build the network ==========================================
p.setup(timestep=dt, min_delay=delay, max_delay=delay)
if simulator_name == 'spiNNaker':
# this will set 100 neurons per core
p.set_number_of_neurons_per_core(p.IF_curr_exp, 100)
# this will set 50 neurons per core
p.set_number_of_neurons_per_core(p.IF_cond_exp, 50)
# node_id = 1
# np = 1
# host_name = socket.gethostname()
cell_params = {
'tau_m': tau_m,
'tau_syn_E': tau_exc,
'tau_syn_I': tau_inh,
'v_rest': e_leak,
'v_reset': v_reset,
'v_thresh': v_thresh,
'cm': cm,
'tau_refrac': t_refrac,
'i_offset': 0
}
timer.start()
exc_cells = p.Population(n_exc,
celltype,
cell_params,
label="Excitatory_Cells")
inh_cells = p.Population(n_inh,
celltype,
cell_params,
label="Inhibitory_Cells")
rng = NumpyRNG(seed=seed, parallel_safe=parallel_safe)
uniform_distr = RandomDistribution('uniform', [v_reset, v_thresh], rng=rng)
exc_cells.initialize(v=uniform_distr)
inh_cells.initialize(v=uniform_distr)
exc_conn = p.FixedProbabilityConnector(pconn, rng=rng)
synapse_exc = p.StaticSynapse(weight=w_exc, delay=delay)
inh_conn = p.FixedProbabilityConnector(pconn, rng=rng)
synapse_inh = p.StaticSynapse(weight=w_inh, delay=delay)
connections = dict()
connections['e2e'] = p.Projection(exc_cells,
exc_cells,
exc_conn,
synapse_type=synapse_exc,
receptor_type='excitatory')
connections['e2i'] = p.Projection(exc_cells,
inh_cells,
exc_conn,
synapse_type=synapse_exc,
receptor_type='excitatory')
connections['i2e'] = p.Projection(inh_cells,
exc_cells,
inh_conn,
synapse_type=synapse_inh,
receptor_type='inhibitory')
connections['i2i'] = p.Projection(inh_cells,
inh_cells,
inh_conn,
synapse_type=synapse_inh,
receptor_type='inhibitory')
# === Setup recording ==============================
exc_cells.record("spikes")
# === Run simulation ================================
p.run(tstop)
exc_spikes = exc_cells.get_data("spikes")
exc_cells.write_data(neo_path, "spikes")
p.end()
return exc_spikes
# t_pops[td] = sim.Population(n_sub_t, sim.IF_cond_exp, t_stellate_lif_params,
# label="t_stellate_fixed_weight_scale_cond")
t_pops[td].record("all")
# cd_pop = sim.Population(target_pop_size,sim.extra_models.Izhikevich_cond,t_stellate_izk_class_2_params,label="fixed_weight_scale_cond")
# cd_pop.record("all")
#================================================================================================
# Projections
#================================================================================================
# connection_dicts_file = np.load(input_directory+'/cn_{}an_fibres_{}ears_connectivity.npz'.format
# (n_fibres,n_ears))
# connection_dicts = connection_dicts_file['connection_dicts']
w2s_t = 12. #50.#15.#0.4#1.6#0.4#0.1# 0.8#0.5#0.25#0.1#0.3#0.1#0.7
n_an_t_connections = RandomDistribution('uniform', [4., 6.])
av_an_t = w2s_t / 5.
# an_t_weight = RandomDistribution('uniform',[0,av_an_t*2])
# an_t_weight = RandomDistribution('uniform',[av_an_t/5.,av_an_t*2])
an_t_weight = RandomDistribution('normal_clipped',
[av_an_t, 0.1 * av_an_t, 0, av_an_t * 2.])
an_t_master, max_dist = normal_dist_connection_builder(
n_fibres,
n_t,
RandomDistribution,
conn_num=n_an_t_connections,
dist=1.,
sigma=1.,
conn_weight=an_t_weight,
normalised_space=pop_size,
get_max_dist=True,
# sim.set_number_of_neurons_per_core(sim.SpikeSourceArray,128)
#================================================================================================
# Populations
#================================================================================================
# input_pop = sim.Population(number_of_inputs,sim.SpikeSourceArray(spike_times=input_spikes),label="an_pop_input")
# t_pop = sim.Population(n_t,sim.IF_cond_exp,t_stellate_params_cond,label="t_fixed_weight_scale_cond")
# t_pop.record(["spikes"])
# d_pop = sim.Population(n_d,sim.IF_cond_exp,d_stellate_params_cond,label="d_fixed_weight_scale_cond")
# d_pop.record(["spikes"])
#================================================================================================
# AN --> CN Projections
#================================================================================================
w2s_t = 0.7
n_an_t_connections = RandomDistribution('uniform', [4., 6.])
av_an_t = w2s_t / 5.
# an_t_weight = RandomDistribution('uniform',[0,av_an_t])
an_t_weight = RandomDistribution('normal_clipped',
[av_an_t, 0.1 * av_an_t, 0, av_an_t * 2.])
an_t_list = normal_dist_connection_builder(number_of_inputs,
n_t,
RandomDistribution,
conn_num=n_an_t_connections,
dist=1.,
sigma=1.,
conn_weight=an_t_weight)
# an_t_projection = sim.Projection(input_pop,t_pop,sim.FromListConnector(an_t_list),synapse_type=sim.StaticSynapse())
input_pops, t_pops, an_t_projs, m_pre = sub_pop_builder_inter(
sim, n_t, sim.IF_cond_exp, t_stellate_params_cond, "SSA", input_spikes,
"an_input", "t_stellate", an_t_list)
def scenario4(sim):
"""
Network with spatial structure
"""
init_logging(logfile=None, debug=True)
sim.setup()
rng = NumpyRNG(seed=76454, parallel_safe=False)
input_layout = RandomStructure(boundary=Cuboid(width=500.0,
height=500.0,
depth=100.0),
origin=(0, 0, 0),
rng=rng)
inputs = sim.Population(
100,
sim.SpikeSourcePoisson(
rate=RandomDistribution('uniform', [3.0, 7.0], rng=rng)),
structure=input_layout,
label="inputs")
output_layout = Grid3D(aspect_ratioXY=1.0,
aspect_ratioXZ=5.0,
dx=10.0,
dy=10.0,
dz=10.0,
x0=0.0,
y0=0.0,
z0=200.0)
outputs = sim.Population(
200,
sim.EIF_cond_exp_isfa_ista(),
initial_values={
'v': RandomDistribution('normal', [-65.0, 5.0], rng=rng),
'w': RandomDistribution('normal', [0.0, 1.0], rng=rng)
},
structure=output_layout, # 10x10x2 grid
label="outputs")
logger.debug("Output population positions:\n %s", outputs.positions)
DDPC = sim.DistanceDependentProbabilityConnector
input_connectivity = DDPC("0.5*exp(-d/100.0)", rng=rng)
recurrent_connectivity = DDPC("sin(pi*d/250.0)**2", rng=rng)
depressing = sim.TsodyksMarkramSynapse(weight=RandomDistribution(
'normal', (0.1, 0.02), rng=rng),
delay="0.5 + d/100.0",
U=0.5,
tau_rec=800.0,
tau_facil=0.0)
facilitating = sim.TsodyksMarkramSynapse(weight=0.05,
delay="0.2 + d/100.0",
U=0.04,
tau_rec=100.0,
tau_facil=1000.0)
input_connections = sim.Projection(inputs,
outputs,
input_connectivity,
receptor_type='excitatory',
synapse_type=depressing,
space=Space(axes='xy'),
label="input connections")
recurrent_connections = sim.Projection(
outputs,
outputs,
recurrent_connectivity,
receptor_type='inhibitory',
synapse_type=facilitating,
space=Space(periodic_boundaries=(
(-100.0, 100.0), (-100.0, 100.0), None
)), # should add "calculate_boundaries" method to Structure classes
label="recurrent connections")
outputs.record('spikes')
outputs.sample(10, rng=rng).record('v')
sim.run(1000.0)
data = outputs.get_data()
sim.end()
return data
def scenario1(sim):
"""
Balanced network of integrate-and-fire neurons.
"""
cell_params = {
'tau_m': 20.0,
'tau_syn_E': 5.0,
'tau_syn_I': 10.0,
'v_rest': -60.0,
'v_reset': -60.0,
'v_thresh': -50.0,
'cm': 1.0,
'tau_refrac': 5.0,
'e_rev_E': 0.0,
'e_rev_I': -80.0
}
stimulation_params = {'rate': 100.0, 'duration': 50.0}
n_exc = 80
n_inh = 20
n_input = 20
rngseed = 98765
parallel_safe = True
n_threads = 1
pconn_recurr = 0.02
pconn_input = 0.01
tstop = 1000.0
delay = 0.2
dt = 0.1
weights = {
'excitatory': 4.0e-3,
'inhibitory': 51.0e-3,
'input': 0.1,
}
sim.setup(timestep=dt, min_delay=dt, threads=n_threads)
all_cells = sim.Population(n_exc + n_inh,
sim.IF_cond_exp(**cell_params),
label="All cells")
cells = {
'excitatory':
all_cells[:n_exc],
'inhibitory':
all_cells[n_exc:],
'input':
sim.Population(n_input,
sim.SpikeSourcePoisson(**stimulation_params),
label="Input")
}
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
uniform_distr = RandomDistribution(
'uniform', [cell_params['v_reset'], cell_params['v_thresh']], rng=rng)
all_cells.initialize(v=uniform_distr)
connections = {}
for name, pconn, receptor_type in (
('excitatory', pconn_recurr, 'excitatory'),
('inhibitory', pconn_recurr, 'inhibitory'),
('input', pconn_input, 'excitatory'),
):
connector = sim.FixedProbabilityConnector(pconn, rng=rng)
syn = sim.StaticSynapse(weight=weights[name], delay=delay)
connections[name] = sim.Projection(cells[name],
all_cells,
connector,
syn,
receptor_type=receptor_type,
label=name)
all_cells.record('spikes')
cells['excitatory'][0:2].record('v')
assert_equal(cells['excitatory'][0:2].grandparent, all_cells)
sim.run(tstop)
E_count = cells['excitatory'].mean_spike_count()
I_count = cells['inhibitory'].mean_spike_count()
print "Excitatory rate : %g Hz" % (E_count * 1000.0 / tstop, )
print "Inhibitory rate : %g Hz" % (I_count * 1000.0 / tstop, )
sim.end()
print "%d Initialising the simulator with single thread..." % (rank)
# Small function to display information only on node 1
def nprint(s):
if (rank == 0):
print s
timer.start() # start timer on construction
print "%d Setting up random number generator" % rank
rng = NumpyRNG(kernelseed, parallel_safe=True)
# Initialising membrane potential to random values
vrest_sd = 5
vrest_distr = RandomDistribution('uniform', [
Vrest_Pyr - numpy.sqrt(3) * vrest_sd,
Vrest_Pyr + numpy.sqrt(3) * vrest_sd
], rng)
Pyr_net = []
for sp in range(NP):
print "%d Creating pyramidal cell population %d with %d neurons." % (
rank, sp, N_Pyr)
Pyr_subnet = Population((N_Pyr, ), IF_cond_exp, cell_params_Pyr)
for cell in Pyr_subnet:
vrest_rval = vrest_distr.next(1)
cell.set_parameters(v_rest=vrest_rval)
Pyr_net.append(Pyr_subnet)
print "%d Creating basket cell population with %d neurons." % (rank, N_Bas)
Bas_net = Population((N_Bas, ), IF_cond_exp, cell_params_Bas)
def callback(data_input):
#====================================================================
# Unpacking the Joint Angle Message
#====================================================================
global message
message = data_input.degree
rospy.loginfo('=====> received joint angle in degree %r', message)
print message
if type(message) != int:
input_rates = list(message)
n_input_neurons = len(input_rates)
else:
input_rates = message
n_input_neurons = 1
#msg_list= [int(msg.encode('hex'),16) for msg in message]
timer = Timer()
dt = 0.1
p.setup(timestep=dt) # 0.1ms
#====================================================================
# Defining the LSM
#====================================================================
n_res=2000
w_exc_b=0.2
w_inh_b=-0.8
rout_w_exc=20
rout_w_inh=-80
n_readout_neurons = 2
n_reservoir_neurons = n_res
n_res = n_reservoir_neurons
exc_rate = 0.8 # percentage of excitatory neurons in reservoir
n_exc = int(round(n_reservoir_neurons*exc_rate))
n_inh = n_reservoir_neurons-n_exc
izh_celltype = p.native_cell_type('izhikevich')
if_celltype = p.IF_curr_exp
celltype = if_celltype
spike_source = p.native_cell_type('poisson_generator')
inp_pop=p.Population(n_input_neurons*10,spike_source,{'rate':input_rates})
exc_cells = p.Population(n_exc, celltype, label="Excitatory_Cells")
inh_cells = p.Population(n_inh, celltype, label="Inhibitory_Cells")
# initialize with a uniform random distributin
# use seeding for reproducability
rngseed = 98766987
parallel_safe = True
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
unifDistr = RandomDistribution('uniform', (-70,-65), rng=rng)
inh_cells.initialize('V_m',unifDistr)
exc_cells.initialize('V_m',unifDistr)
readout_neurons = p.Population(2, celltype, label="readout_neuron")
inp_weight=3.
inp_delay =1
inp_weight_distr = RandomDistribution('normal', [inp_weight, 1e-3], rng=rng)
# connect each input neuron to 30% of the reservoir neurons
inp_conn = p.FixedProbabilityConnector(p_connect=0.3,weights =inp_weight_distr, delays=inp_delay)
connections = {}
connections['inp2e'] = p.Projection(inp_pop, exc_cells, inp_conn)
connections['inp2i'] = p.Projection(inp_pop, inh_cells, inp_conn)
pconn = 0.01 # sparse connection probability
# scale the weights w.r.t. the network to keep it stable
w_exc = w_exc_b/np.sqrt(n_res) # nA
w_inh = w_inh_b/np.sqrt(n_res) # nA
delay_exc = 1 # defines how long (ms) the synapse takes for transmission
delay_inh = 1
weight_distr_exc = RandomDistribution('normal', [w_exc, 1/n_res], rng=rng)
weight_distr_inh = RandomDistribution('normal', [w_inh, 1/n_res], rng=rng)
exc_conn = p.FixedProbabilityConnector(pconn, weights=weight_distr_exc, delays=delay_exc)
inh_conn = p.FixedProbabilityConnector(pconn, weights=weight_distr_inh, delays=delay_inh)
connections['e2e'] = p.Projection(exc_cells, exc_cells, exc_conn, target='excitatory')
connections['e2i'] = p.Projection(exc_cells, inh_cells, exc_conn, target='excitatory')
connections['i2e'] = p.Projection(inh_cells, exc_cells, inh_conn, target='inhibitory')
connections['i2i'] = p.Projection(inh_cells, inh_cells, inh_conn, target='inhibitory')
rout_conn_exc = p.AllToAllConnector(weights=rout_w_exc, delays=delay_exc)
rout_conn_inh = p.AllToAllConnector(weights=rout_w_inh, delays=delay_exc)
connections['e2rout'] = p.Projection(exc_cells, readout_neurons, rout_conn_exc, target='excitatory')
connections['i2rout'] = p.Projection(inh_cells, readout_neurons, rout_conn_inh, target='inhibitory')
readout_neurons.record()
exc_cells.record()
inh_cells.record()
inp_pop.record()
p.run(20)
r_spikes = readout_neurons.getSpikes()
exc_spikes = exc_cells.getSpikes()
inh_spikes = inh_cells.getSpikes()
inp_spikes = inp_pop.getSpikes()
rospy.loginfo('=====> shape of r_spikes %r', np.shape(r_spikes))
#====================================================================
# Compute Readout Spike Rates
#====================================================================
alpha_rates = alpha_decoding(r_spikes,dt)
mean_rates = mean_decoding(r_spikes,dt)
#====================================================================
# Publish Readout Rates
#====================================================================
# TODO: error handling if r_spikes is empty
pub = rospy.Publisher('/alpha_readout_rates', Pop_List, queue_size=10)
alpha_readout_rates = Pop_List
alpha_readout_rates = alpha_rates
pub.publish(alpha_readout_rates)
pub = rospy.Publisher('/mean_readout_rates', Pop_List, queue_size=10)
mean_readout_rates = Pop_List
mean_readout_rates = mean_rates
pub.publish(mean_readout_rates)
def simulate(sim, rng, setup_kwargs):
sim.setup(timestep=dt, **setup_kwargs)
# Brian was performing synaptic input with ge*(Ee-vr)
# Ee = 0 so infact Vr is being treated as an input resistance and therefore C = tau_m / v_rest = 10*10^-3 / 60*10^6 = 0.17*10^-9
# Weight dependences to test
weight_dependences = [
sim.AdditiveWeightDependence(w_min=0.0, w_max=g_max),
sim.MultiplicativeWeightDependence(w_min=0.0, w_max=g_max)
]
# Create a neural population to stimulate using each weight dependence
neural_pops = [
sim.Population(
num_neurons,
sim.IF_curr_exp(v_rest=-74.0,
v_reset=-60.0,
v_thresh=-54.0,
tau_syn_E=5.0,
tau_syn_I=5.0,
tau_m=10.0,
cm=0.17)) for _ in weight_dependences
]
# Create poisson source to stimulate both populations
ex_poisson = sim.Population(num_ex_synapses,
sim.SpikeSourcePoisson(rate=15.0))
# Record spikes from each population
for n in neural_pops:
n.record("spikes")
a_plus = 0.01
a_minus = 1.05 * a_plus
# Create weight distribution
weight_dist = RandomDistribution("uniform", low=0, high=g_max, rng=rng)
# Create STDP projections with correct weight dependence between poisson source and each neural population
projections = [
sim.Projection(ex_poisson,
n,
sim.AllToAllConnector(),
sim.STDPMechanism(timing_dependence=sim.SpikePairRule(
tau_plus=20.0,
tau_minus=20.00,
A_plus=a_plus,
A_minus=a_minus),
weight_dependence=w,
weight=weight_dist,
delay=dt,
dendritic_delay_fraction=1.0),
receptor_type="excitatory")
for n, w in zip(neural_pops, weight_dependences)
]
# Simulate
sim.run(duration)
# Download weights
weights = [
np.asarray(p.get("weight", format="list", with_address=False))
for p in projections
]
# Download spikes
data = [n.get_data() for n in neural_pops]
# End simulation
sim.end()
# Return learned weights and data
return weights, data
print(IF_cond_exp.default_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 = 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 = Population(500,
cortical_type,
structure=Grid2D(dx=10.0, dy=10.0),
initial_values={'v': v_init},
label="Cortical neurons")
'''
view
'''
id = ctx_cells[47] # the 48th neuron in a Population
view = ctx_cells[:80] # the first eighty neurons
view = ctx_cells[::2] # every second neuron
view = ctx_cells[45, 91, 7] # a specific set of neurons
view = ctx_cells.sample(50,
rng=NumpyRNG(seed=6538)) # select 50 neurons at random
print(view.parent.label)
def setup(self, sim, conf):
# extract parameters
pyseed = conf['params_dict']['nest']['pyseed']
parallel_safe = conf['params_dict']['nest']['parallel_safe']
input_type = conf['params_dict']['nest']['input_type']
layers = conf['layers']
pops = conf['pops']
bg_rate = conf['bg_rate']
w_mean = conf['w_mean']
K_scaling = conf['params_dict']['nest']['K_scaling']
N_scaling = conf['params_dict']['nest']['N_scaling']
n_record = conf['params_dict']['nest']['n_record']
neuron_model = conf['neuron_model']
tau_max = conf['tau_max']
record_corr = conf['params_dict']['nest']['record_corr']
n_layers = conf['n_layers']
n_pops_per_layer = conf['n_pops_per_layer']
V0_mean = conf['V0_mean']
n_record_v = conf['params_dict']['nest']['n_record_v']
record_v = conf['params_dict']['nest']['record_v']
record_fraction = conf['params_dict']['nest']['record_fraction']
thalamic_input = conf['thalamic_input']
w_rel = conf['w_rel']
w_rel_234 = conf['w_rel_234']
simulator = conf['simulator']
N_full = conf['N_full']
K_ext = conf['K_ext']
tau_syn_E = conf['neuron_params']['tau_syn_E']
v_thresh = conf['neuron_params']['v_thresh']
v_rest = conf['neuron_params']['v_rest']
neuron_params = conf['neuron_params']
thal_params = conf['thal_params']
structure = conf['structure']
d_mean = conf['d_mean']
d_sd = conf['d_sd']
frac_record_v = conf['params_dict']['nest']['frac_record_v']
n_rec = helper_functions.get_n_rec(conf)
# if parallel_safe=False, PyNN offsets the seeds by 1 for each rank
script_rng = NumpyRNG(seed=pyseed, parallel_safe=parallel_safe)
# Compute DC input before scaling
if input_type == 'DC':
self.DC_amp = {}
for target_layer in layers:
self.DC_amp[target_layer] = {}
for target_pop in pops:
self.DC_amp[target_layer][target_pop] = bg_rate * \
K_ext[target_layer][target_pop] * \
w_mean * tau_syn_E / 1000.
else:
self.DC_amp = {
'L23': {
'E': 0.,
'I': 0.
},
'L4': {
'E': 0.,
'I': 0.
},
'L5': {
'E': 0.,
'I': 0.
},
'L6': {
'E': 0.,
'I': 0.
}
}
# In-degrees of the full-scale and scaled models
K_full = scaling.get_indegrees(conf)
self.K = K_scaling * K_full
self.K_ext = {}
for layer in layers:
self.K_ext[layer] = {}
for pop in pops:
self.K_ext[layer][pop] = K_scaling * K_ext[layer][pop]
self.w = helper_functions.create_weight_matrix(conf)
# Network scaling
if K_scaling != 1:
self.w, self.w_ext, self.DC_amp = scaling.adjust_w_and_ext_to_K(
K_full, K_scaling, self.w, self.DC_amp, conf)
else:
self.w_ext = w_mean
Vthresh = {}
for layer in layers:
Vthresh[layer] = {}
for pop in pops:
Vthresh[layer][pop] = v_thresh
# Initial membrane potential distributions
# The original study used V0_mean = -58 mV, V0_sd = 5 mV.
# This is adjusted here to any changes in v_rest and scaling of V.
V0_mean = {}
V0_sd = {}
for layer in layers:
V0_mean[layer] = {}
V0_sd[layer] = {}
for pop in pops:
V0_mean[layer][pop] = (v_rest + Vthresh[layer][pop]) / 2.
V0_sd[layer][pop] = (Vthresh[layer][pop] - v_rest) / 3.
V_dist = {}
for layer in layers:
V_dist[layer] = {}
for pop in pops:
V_dist[layer][pop] = RandomDistribution(
'normal', [V0_mean[layer][pop], V0_sd[layer][pop]],
rng=script_rng)
model = getattr(sim, neuron_model)
if record_corr and simulator == 'nest':
# Create correlation recording device
sim.nest.SetDefaults('correlomatrix_detector', {'delta_tau': 0.5})
self.corr_detector = sim.nest.Create('correlomatrix_detector')
sim.nest.SetStatus(
self.corr_detector, {
'N_channels': n_layers * n_pops_per_layer,
'tau_max': tau_max,
'Tstart': tau_max,
})
if sim.rank() == 0:
print 'neuron_params:', conf['neuron_params']
print 'K: ', self.K
print 'K_ext: ', self.K_ext
print 'w: ', self.w
print 'w_ext: ', self.w_ext
print 'DC_amp: ', self.DC_amp
print 'V0_mean: '
for layer in layers:
for pop in pops:
print layer, pop, V0_mean[layer][pop]
print 'n_rec:'
for layer in layers:
for pop in pops:
print layer, pop, n_rec[layer][pop]
if not record_fraction and n_record > \
int(round(N_full[layer][pop] * N_scaling)):
print 'Note that requested number of neurons to record',
print 'exceeds ', layer, pop, ' population size'
# Create cortical populations
self.pops = {}
global_neuron_id = 1
self.base_neuron_ids = {}
# list containing the GIDs of recording devices, needed for output
# bundle
device_list = []
for layer in layers:
self.pops[layer] = {}
for pop in pops:
cellparams = neuron_params
self.pops[layer][pop] = sim.Population(int(
round(N_full[layer][pop] * N_scaling)),
model,
cellparams=cellparams,
label=layer + pop)
this_pop = self.pops[layer][pop]
# Provide DC input in the current-based case
# DC input is assumed to be absent in the conductance-based
# case
this_pop.set('i_offset', self.DC_amp[layer][pop])
self.base_neuron_ids[this_pop] = global_neuron_id
global_neuron_id += len(this_pop) + 2
this_pop.initialize('v', V_dist[layer][pop])
# Spike recording
sd = sim.nest.Create('spike_detector',
params={
'label':
'spikes_{0}{1}'.format(layer, pop),
'withtime':
True,
'withgid':
True,
'to_file':
True
})
device_list.append(sd)
sim.nest.Connect(list(this_pop[0:n_rec[layer][pop]].all_cells),
sd)
# Membrane potential recording
if record_v:
if record_fraction:
n_rec_v = round(this_pop.size * frac_record_v)
else:
n_rec_v = n_record_v
vm = sim.nest.Create('voltmeter',
params={
'label':
'voltages_{0}{1}'.format(
layer, pop),
'withtime':
True,
'withgid':
True,
'to_file':
True
})
device_list.append(vm)
sim.nest.Connect(vm, list(this_pop[0:n_rec_v]))
# Correlation recording
if record_corr and simulator == 'nest':
index = structure[layer][pop]
sim.nest.SetDefaults('static_synapse',
{'receptor_type': index})
sim.nest.Connect(list(this_pop.all_cells),
self.corr_detector)
sim.nest.SetDefaults('static_synapse',
{'receptor_type': 0})
if thalamic_input:
self.thalamic_population = sim.nest.Create('parrot_neuron',
thal_params['n_thal'])
# create and connect a poisson generator for stimulating the
# thalamic population
thal_pg = sim.nest.Create('poisson_generator',
params={'rate': thal_params['rate'],
'start': thal_params['start'],
'stop': thal_params['start'] \
+ thal_params['duration']})
sim.nest.Connect(thal_pg, self.thalamic_population)
possible_targets_curr = ['inhibitory', 'excitatory']
# Connect
for target_layer in layers:
for target_pop in pops:
target_index = structure[target_layer][target_pop]
this_target_pop = self.pops[target_layer][target_pop]
w_ext = self.w_ext
# External inputs
if input_type == 'poisson':
rate = bg_rate * self.K_ext[target_layer][target_pop]
if simulator == 'nest':
# create only a single Poisson generator for each
# population, since the native NEST implementation sends
# independent spike trains to all targets
if sim.rank() == 0:
print 'connecting Poisson generator to',
print target_layer, target_pop
pg = sim.nest.Create('poisson_generator',
params={'rate': rate})
conn_dict = {'rule': 'all_to_all'}
syn_dict = {
'model': 'static_synapse',
'weight': 1000. * w_ext,
'delay': d_mean['E']
}
sim.nest.Connect(pg, list(this_target_pop.all_cells),
conn_dict, syn_dict)
if thalamic_input:
if sim.rank() == 0:
print 'creating thalamic connections to ', target_layer,
print target_pop
C_thal = thal_params['C'][target_layer][target_pop]
n_target = N_full[target_layer][target_pop]
K_thal = round(np.log(1 - C_thal) / \
np.log(
(n_target * thal_params['n_thal'] - 1.) /
(n_target * thal_params['n_thal']))) / \
n_target * K_scaling
target_neurons = list(this_target_pop.all_cells)
n_syn = int(round(K_thal * len(target_neurons)))
conn_dict = {'rule': 'fixed_total_number', 'N': n_syn}
syn_dict = {'model': 'static_synapse',
'weight': {'distribution': 'normal_clipped',
'mu': 1000. * w_ext,
'sigma': 1000. * w_rel * w_ext},
'delay': {'distribution': 'normal_clipped',
'low': conf['simulator_params'] \
[simulator]['min_delay'],
'mu': d_mean['E'],
'sigma': d_sd['E']}}
sim.nest.Connect(self.thalamic_population, target_neurons,
conn_dict, syn_dict)
# Recurrent inputs
for source_layer in layers:
for source_pop in pops:
source_index = structure[source_layer][source_pop]
this_source_pop = self.pops[source_layer][source_pop]
weight = self.w[target_index][source_index]
possible_targets_curr[int((np.sign(weight) + 1) / 2)]
if sim.rank() == 0:
print 'creating connections from ', source_layer + \
source_pop + ' to ' + target_layer + target_pop
if source_pop == 'E' and source_layer == 'L4' and \
target_layer == 'L23' and target_pop == 'E':
w_sd = weight * w_rel_234
else:
w_sd = abs(weight * w_rel)
connectivity.FixedTotalNumberConnect(
sim, this_source_pop, this_target_pop,
self.K[target_index][source_index], weight, w_sd,
d_mean[source_pop], d_sd[source_pop], conf)
return device_list
EI_connections = Projection(popI, popE,
FixedProbabilityConnector(p_connect=plocal),
StaticSynapse(weight=wEI_alpha, delay=d))
II_connections = Projection(popI, popI,
FixedProbabilityConnector(p_connect=plocal),
StaticSynapse(weight=wII_alpha, delay=d))
# Stimulus
amplitudeV = 10.1 #[mV]
pulse = DCSource(amplitude=amplitudeV / R, start=300.0, stop=320.0)
pulse.inject_into(popE)
# initial conditions
kernelseed = 5456532
rng = NumpyRNG(kernelseed, parallel_safe=True)
uniformDistr = RandomDistribution('uniform', low=Vrest, high=Vt, rng=rng)
initialize(popE, v=uniformDistr)
initialize(popI, v=uniformDistr)
# Record
popE.record('spikes')
popI.record('spikes')
popE.record(['v']) # record other variables from first two neurons
popI.record(['v']) # record other variables from first two neurons
# Run
run(duration)
# Store spikes
spikesE_in = popE.get_data()
spikesI_in = popI.get_data()
def scenario3(sim):
"""
Simple feed-forward network network with additive STDP. The second half of
the presynaptic neurons fires faster than the second half, so their
connections should be potentiated more.
"""
init_logging(logfile=None, debug=True)
second = 1000.0
duration = 10
tau_m = 20 # ms
cm = 1.0 # nF
v_reset = -60
cell_parameters = dict(
tau_m=tau_m,
cm=cm,
v_rest=-70,
e_rev_E=0,
e_rev_I=-70,
v_thresh=-54,
v_reset=v_reset,
tau_syn_E=5,
tau_syn_I=5,
)
g_leak = cm / tau_m # µS
w_min = 0.0 * g_leak
w_max = 0.05 * g_leak
r1 = 5.0
r2 = 40.0
sim.setup()
pre = sim.Population(100, sim.SpikeSourcePoisson())
post = sim.Population(10, sim.IF_cond_exp())
pre.set(duration=duration * second)
pre.set(start=0.0)
pre[:50].set(rate=r1)
pre[50:].set(rate=r2)
assert_equal(pre[49].rate, r1)
assert_equal(pre[50].rate, r2)
post.set(**cell_parameters)
post.initialize(v=RandomDistribution('normal', mu=v_reset, sigma=5.0))
stdp = sim.STDPMechanism(
sim.SpikePairRule(tau_plus=20.0,
tau_minus=20.0,
A_plus=0.01,
A_minus=0.01),
sim.AdditiveWeightDependence(w_min=w_min, w_max=w_max),
#dendritic_delay_fraction=0.5))
dendritic_delay_fraction=1)
connections = sim.Projection(pre,
post,
sim.AllToAllConnector(),
synapse_type=stdp,
receptor_type='excitatory')
initial_weight_distr = RandomDistribution('uniform', low=w_min, high=w_max)
connections.randomizeWeights(initial_weight_distr)
initial_weights = connections.get('weight', format='array', gather=False)
# assert initial_weights.min() >= w_min
# assert initial_weights.max() < w_max
# assert initial_weights[0, 0] != initial_weights[1, 0]
pre.record('spikes')
post.record('spikes')
post[0:1].record('v')
sim.run(duration * second)
actual_rate = pre.mean_spike_count() / duration
expected_rate = (r1 + r2) / 2
errmsg = "actual rate: %g expected rate: %g" % (actual_rate,
expected_rate)
assert abs(actual_rate - expected_rate) < 1, errmsg
#assert abs(pre[:50].mean_spike_count()/duration - r1) < 1
#assert abs(pre[50:].mean_spike_count()/duration- r2) < 1
final_weights = connections.get('weight', format='array', gather=False)
assert initial_weights[0, 0] != final_weights[0, 0]
try:
import scipy.stats
except ImportError:
raise SkipTest
t, p = scipy.stats.ttest_ind(initial_weights[:50, :].flat,
initial_weights[50:, :].flat)
assert p > 0.05, p
t, p = scipy.stats.ttest_ind(final_weights[:50, :].flat,
final_weights[50:, :].flat)
assert p < 0.01, p
assert final_weights[:50, :].mean() < final_weights[50:, :].mean()
sim.end()
return initial_weights, final_weights, pre, post, connections
def __init__(self, name, sim, rng,
e_cell_model, i_cell_model,
e_cell_params, i_cell_params,
e_cell_flush_time, e_cell_mean_firing_rate,
stim_spike_times, wta, background_weight, stim_weight, simtime,
record_bias, record_spikes, record_membrane):
# Cache recording flags
self.record_bias = record_bias
self.record_spikes = record_spikes
self.record_membrane = record_membrane
self.wta = wta
logger.info("Creating HCU:%s" % name)
logger.debug("Membrane potentials uniformly distributed between %g mV and %g mV." % (-80, U0))
membrane_voltage_distribution = RandomDistribution("uniform", low=-80.0, high=U0, rng=rng)
logger.debug("Background noise rate %g Hz." % (p_rate))
logger.debug("Creating excitatory population with %d neurons." % (NE))
self.e_cells = sim.Population(NE, e_cell_model(**e_cell_params),
label="%s - e_cells" % name)
self.e_cells.initialize(v=membrane_voltage_distribution)
# Set e cell mean firing rate
self.e_cells.spinnaker_config.mean_firing_rate = e_cell_mean_firing_rate
# Set flush time
self.e_cells.spinnaker_config.flush_time = e_cell_flush_time
# **YUCK** record spikes actually entirely ignores
# sampling interval but throws exception if it is not set
if self.record_spikes:
self.e_cells.record("spikes", sampling_interval=100.0)
if self.record_bias:
self.e_cells.record("bias", sampling_interval=100.0)
if self.record_membrane:
self.e_cells.record("v", sampling_interval=100.0)
e_poisson = sim.Population(NE, sim.SpikeSourcePoisson(rate=p_rate, duration=simtime),
label="%s - e_poisson" % name)
logger.debug("Creating background->E AMPA connection weight %g nA." % (background_weight))
sim.Projection(e_poisson, self.e_cells,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=background_weight, delay=delay),
receptor_type="excitatory")
if self.wta:
logger.debug("Creating inhibitory population with %d neurons." % (NI))
self.i_cells = sim.Population(NI, i_cell_model, i_cell_params,
label="%s - i_cells" % name)
self.i_cells.initialize(v=membrane_voltage_distribution)
# Inhibitory cells generally fire at a low rate
self.i_cells.spinnaker_config.mean_firing_rate = 5.0
if self.record_spikes:
self.i_cells.record("spikes")
i_poisson = sim.Population(NI, sim.SpikeSourcePoisson(rate=p_rate, duration=simtime),
label="%s - i_poisson" % name)
logger.debug("Creating I->E GABA connection with connection probability %g, weight %g nA and delay %g ms." % (epsilon, JI, delay))
I_to_E = sim.Projection(self.i_cells, self.e_cells,
sim.FixedProbabilityConnector(p_connect=epsilon, rng=rng),
sim.StaticSynapse(weight=JI, delay=delay),
receptor_type="inhibitory")
logger.debug("Creating E->I AMPA connection with connection probability %g, weight %g nA and delay %g ms." % (epsilon, JE, delay))
sim.Projection(self.e_cells, self.i_cells,
sim.FixedProbabilityConnector(p_connect=epsilon, rng=rng),
sim.StaticSynapse(weight=JE, delay=delay),
receptor_type="excitatory")
logger.debug("Creating I->I GABA connection with connection probability %g, weight %g nA and delay %g ms." % (epsilon, JI, delay))
sim.Projection(self.i_cells, self.i_cells,
sim.FixedProbabilityConnector(p_connect=epsilon, rng=rng),
sim.StaticSynapse(weight=JI, delay=delay),
receptor_type="inhibitory")
logger.debug("Creating background->I AMPA connection weight %g nA." % (background_weight))
sim.Projection(i_poisson, self.i_cells,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=background_weight, delay=delay),
receptor_type="excitatory")
# Create a spike source capable of stimulating entirely excitatory population
stim_spike_source = sim.Population(NE, sim.SpikeSourceArray(spike_times=stim_spike_times))
# Connect one-to-one to excitatory neurons
sim.Projection(stim_spike_source, self.e_cells,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=stim_weight, delay=delay),
receptor_type="excitatory")
weight_exc = 0.1
weight_inh = -5.0 * weight_exc
weight_input = 0.001
pop_input = p.Population(100, p.SpikeSourcePoisson(rate=0), label="Input")
pop_exc = p.Population(n_exc, p.IF_curr_exp, label="Excitatory",
additional_parameters={"spikes_per_second": 100})
pop_inh = p.Population(n_inh, p.IF_curr_exp, label="Inhibitory",
additional_parameters={"spikes_per_second": 100})
stim_exc = p.Population(
n_exc, p.SpikeSourcePoisson(rate=1000.0), label="Stim_Exc")
stim_inh = p.Population(
n_inh, p.SpikeSourcePoisson(rate=1000.0), label="Stim_Inh")
delays_exc = RandomDistribution(
"normal_clipped", mu=1.5, sigma=0.75, low=1.0, high=14.4)
weights_exc = RandomDistribution(
"normal_clipped", mu=weight_exc, sigma=0.1, low=0, high=numpy.inf)
conn_exc = p.FixedProbabilityConnector(0.1)
synapse_exc = p.StaticSynapse(weight=weights_exc, delay=delays_exc)
delays_inh = RandomDistribution(
"normal_clipped", mu=0.75, sigma=0.375, low=1.0, high=14.4)
weights_inh = RandomDistribution(
"normal_clipped", mu=weight_inh, sigma=0.1, low=-numpy.inf, high=0)
conn_inh = p.FixedProbabilityConnector(0.1)
synapse_inh = p.StaticSynapse(weight=weights_inh, delay=delays_inh)
p.Projection(
pop_exc, pop_exc, conn_exc, synapse_exc, receptor_type="excitatory")
p.Projection(
pop_exc, pop_inh, conn_exc, synapse_exc, receptor_type="excitatory")
p.Projection(
#stdp_model = p.STDPMechanism( timing_dependence = p.RecurrentRule(accumulator_depression = -6, accumulator_potentiation = 6, mean_pre_window = 10.0, mean_post_window = 10.0), weight_dependence = p.SimpleMultiplicativeWeightDependence(potentiation_multiplier = 1.3, depression_multiplier = 1.3))
stdp_model = p.STDPMechanism(
timing_dependence=p.RecurrentRule(accumulator_depression=-6,
accumulator_potentiation=6,
mean_pre_window=10.0,
mean_post_window=10.0),
weight_dependence=p.MultiplicativeWeightDependence(w_min=0.0,
w_max=16.0,
A_plus=0.4,
A_minus=0.4))
rng = NumpyRNG(seed=1)
ext_delay_distr = RandomDistribution('normal',
parameters=[1.5, 0.75],
rng=rng,
boundaries=[0.1, 9.9],
constrain='redraw')
inh_delay_distr = RandomDistribution('normal',
parameters=[0.75, 0.375],
rng=rng,
boundaries=[0.1, 9.9],
constrain='redraw')
delay_distr_recurrent = RandomDistribution('uniform', [2.0, 8.0], rng=rng)
weight_distr_ffwd = RandomDistribution('uniform', [0.5, 1.25], rng=rng)
weight_distr_recurrent = RandomDistribution('uniform', [0.1, 0.2], rng=rng)
projections.append(
p.Projection(populations[stimulus],
populations[excit],
p.AllToAllConnector(weights=baseline_excit_weight,
def all(self):
return self.all_cells
@property
def size(self):
return self.all_cells.size
p1 = MockPopulation(100)
p2 = MockPopulation(100)
rng = NumpyRNG(8569552)
weight_sources = [
0.1,
RandomDistribution('uniform', (0, 1), rng),
numpy.arange(0.0, 1.0, 1e-4).reshape(100, 100), "exp(-(d*d)/1e4)"
]
for weight_source in weight_sources:
connector = FixedProbabilityConnector(p_connect=0.3,
allow_self_connections=True,
weights=weight_source,
delays=0.2)
prj = MockProjection(p1, p2, rng)
connector.connect(prj)
connector = AllToAllConnector(allow_self_connections=True,
weights=weight_source,
delays=0.2)
prj = MockProjection(p1, p2, rng)
connector.connect(prj)
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
# No_inp = {'exc': 32, 'inh': 32}
run_time = 500 # define the simulation time
# ==========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, :]))
timer.start() # start timer on construction
print "%d Setting up random number generator" % rank
rng = NumpyRNG(kernelseed, parallel_safe=True)
print "%d Creating excitatory population with %d neurons." % (rank, NE)
E_net = Population(NE, IF_curr_alpha, cell_params, label="E_net")
print "%d Creating inhibitory population with %d neurons." % (rank, NI)
I_net = Population(NI, IF_curr_alpha, cell_params, label="I_net")
print "%d Initialising membrane potential to random values between %g mV and %g mV." % (
rank, U0, theta)
uniformDistr = RandomDistribution('uniform', [U0, theta], rng)
E_net.initialize('v', uniformDistr)
I_net.initialize('v', uniformDistr)
print "%d Creating excitatory Poisson generator with rate %g spikes/s." % (
rank, p_rate)
expoisson = Population(NE, SpikeSourcePoisson, {'rate': p_rate}, "expoisson")
print "%d Creating inhibitory Poisson generator with the same rate." % rank
inpoisson = Population(NI, SpikeSourcePoisson, {'rate': p_rate}, "inpoisson")
# Record spikes
print "%d Setting up recording in excitatory population." % rank
E_net.record(Nrec)
E_net[[0, 1]].record_v()
# group the populations into an assembly
all_cells = exc_cells + inh_cells
if options.benchmark == "COBA":
ext_stim = sim.Population(20,
sim.SpikeSourcePoisson(rate=rate,
duration=stim_dur),
label="expoisson")
rconn = 0.01
ext_conn = sim.FixedProbabilityConnector(rconn)
ext_syn = sim.StaticSynapse(weight=0.1)
print("%s Initialising membrane potential to random values..." % node_id)
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
uniformDistr = RandomDistribution('uniform',
low=v_reset,
high=v_thresh,
rng=rng)
if options.use_views:
all_cells.initialize(v=uniformDistr)
else:
exc_cells.initialize(v=uniformDistr)
inh_cells.initialize(v=uniformDistr)
print("%s Connecting populations..." % node_id)
progress_bar = ProgressBar(width=20)
if options.use_csa:
connector = sim.CSAConnector(csa.cset(csa.random(pconn)))
else:
connector = sim.FixedProbabilityConnector(pconn,
rng=rng,
callback=progress_bar)
pattern2_stim = Population(numOfNeuronsPattern2_stim , cell_type, label='pattern2_stim')
patternIntersection = Population(numOfNeuronsPatternIntersection , cell_type, label='patternIntersection')
controlPopulation = Population(numOfNeuronsControl , cell_type, label='controlPop')
stimulus = Population(1000, SpikeSourcePoisson(rate=100.0))
print("-> DONE")
print("----------------------------------------------------------------------")
print("---------- Initialising membrane potential to random values ----------")
print("----------------------------------------------------------------------")
rand_distr = RandomDistribution('uniform', (v_reset, v_thresh), rng=NumpyRNG(seed=85524))
excPopulation.initialize(v=rand_distr)
inhibPopulation.initialize(v=rand_distr)
pattern1.initialize(v=rand_distr)
pattern1_stim.initialize(v=rand_distr)
pattern2.initialize(v=rand_distr)
pattern2_stim.initialize(v=rand_distr)
patternIntersection.initialize(v=rand_distr)
controlPopulation.initialize(v=rand_distr)
print("-> DONE")
# allow self-connections??
# what are the initial conditions??
stop=duration)
popE[i].inject(noise)
# Noise on inhibitory neurons
stdNoiseI = (sigmaV / R) * (tauI_m**0.5) / (dt**0.5)
for i in range(nAreas * NI):
noise = NoisyCurrentSource(mean=0,
stdev=stdNoiseI,
start=0.0,
stop=duration)
popI[i].inject(noise)
# paramters for initial conditions
kernelseed = 5456532
rng = NumpyRNG(kernelseed, parallel_safe=True)
uniformDistr = RandomDistribution('uniform', low=Vrest, high=Vt, rng=rng)
initialize(popE, v=uniformDistr)
initialize(popI, v=uniformDistr)
# Separate population in population views
popEList = []
popIList = []
# Store projections
EE = []
IE = []
EI = []
II = []
EElongRange = []
IElongRange = []
for i in range(nAreas):
start_time_1 = 0.00
stop_time_1 = 150.00
rate_1 = 100 # unit Hz
# second period signal
start_time_2 = stop_time_1
stop_time_2 = 350
rate_2 = 200
# third period signal
start_time_3 = stop_time_2
stop_time_3 = 500.00
rate_3 = 100 # unit Hz
spike_times_1 = RandomDistribution('uniform', (start_time_1, stop_time_1),
rng=NumpyRNG(seed=72386)).next(
int((stop_time_1 - start_time_1) *
rate_1 * 1e-3))
spike_times_2 = RandomDistribution('uniform', (start_time_2, stop_time_2),
rng=NumpyRNG(seed=72389)).next(
int((stop_time_2 - start_time_2) *
rate_2 * 1e-3))
spike_times_3 = RandomDistribution('uniform', (start_time_3, stop_time_3),
rng=NumpyRNG(seed=72389)).next(
int((stop_time_3 - start_time_3) *
rate_3 * 1e-3))
print type(spike_times_1)
spike_time = np.concatenate((spike_times_1, spike_times_2, spike_times_3),
axis=0)
