def connect(self):
# connect populations
self.injection = pynn.Projection(self.sources,
self.columns,
pynn.FixedProbabilityConnector(
0.02, weights=0.0033 * 2),
target='excitatory',
rng=pynn.random.NumpyRNG(seed=5337))
self.recurrent_excitation = pynn.Projection(
self.columns,
self.columns,
pynn.OneToOneConnector(weights=0.01 * 2),
target='excitatory')
self.lateral_inhibition = pynn.Projection(
self.columns,
self.columns,
pynn.DistanceDependentProbabilityConnector('d < 10',
weights=0.004 * 2),
target='inhibitory',
rng=pynn.random.NumpyRNG(seed=5337))
self.global_inhibition = pynn.Projection(
self.inhibitory_pool,
self.columns,
pynn.FixedProbabilityConnector(0.8, weights=0.0012 * 2),
target='inhibitory',
rng=pynn.random.NumpyRNG(seed=5337))
self.forward_inhibition = pynn.Projection(
self.sources,
self.inhibitory_pool,
pynn.FixedProbabilityConnector(0.8, weights=0.0035),
target='excitatory',
rng=pynn.random.NumpyRNG(seed=5337))
def _connect(self):
'''Connect populations.'''
self._proj = sim.Projection(self._source_pop,
self._target_pop,
sim.FixedProbabilityConnector(self._p),
rng=self._rng)
def getConnectorType(conn_type, ff_prob=None, lat_prob=None):
"""
For getting the feed-forward and lateral connection types.
Arguments: conn_type, str, choices = ['all_to_all', 'fixed_prob', 'one_of_each']
ff_prob, float, probability of connection for feed-forward
lat_prob, float, probability of connection for lateral
Returns: ff_conn, lat_conn
"""
if conn_type == 'all_to_all':
ff_conn = pynn.AllToAllConnector()
lat_conn = pynn.AllToAllConnector(allow_self_connections=False)
elif conn_type == 'fixed_prob':
if (ff_prob == None) or (lat_prob == None):
print(dt.datetime.now().isoformat() + ' ERROR: ' +
'One of the connections probabilities is "None".')
sys.exit(2)
else:
ff_conn = pynn.FixedProbabilityConnector(
ff_prob, rng=pynn.random.NumpyRNG(seed=1798))
lat_conn = pynn.FixedProbabilityConnector(
lat_prob,
allow_self_connections=False,
rng=pynn.random.NumpyRNG(seed=1916))
elif conn_type == 'one_of_each':
if ff_prob == None:
print(dt.datetime.now().isoformat() + ' ERROR: ' +
'Feed forwards connections probabilities is "None".')
sys.exit(2)
else:
ff_conn = pynn.FixedProbabilityConnector(
ff_prob, rng=pynn.random.NumpyRNG(seed=1798))
lat_conn = pynn.AllToAllConnector(allow_self_connections=False)
else:
print(dt.datetime.now().isoformat() + ' ERROR: ' +
'Unrecognised connection type.')
sys.exit(2)
return ff_conn, lat_conn
def connect(self):
"""Setup connections between populations"""
params = self.parameters.projections
# generate weights with normal distributed jitter and set up stimulus
w = params.stimulus.weight + np.random.normal(
0, params.stimulus.jitter, len(self.columns))
stimulus_connector = pynn.OneToOneConnector(weights=w)
pynn.Projection(self.stimulus, self.columns, stimulus_connector)
# projection to accumulate/count the number of active columns
accumulation_connector = pynn.AllToAllConnector(
weights=params.accumulation.weight)
pynn.Projection(self.columns, self.kill_switch, accumulation_connector)
# projection to inhibit all columns
inhibition_connector = pynn.AllToAllConnector(
weights=params.inhibition.weight)
pynn.Projection(self.kill_switch,
self.columns,
inhibition_connector,
target='inhibitory')
# forward inhibition
forward_inhibition_connector = pynn.FixedProbabilityConnector(
params.forward_inhibition.probability,
weights=params.forward_inhibition.weight)
pynn.Projection(self.stimulus,
self.columns,
forward_inhibition_connector,
target='inhibitory')
# calculate connectivity matrix
n_columns = self.parameters.populations.columns.size
n_inputs = self.parameters.config.input_size
self.connections = (np.random.uniform(0, 1, n_columns * n_inputs) >
0.60).reshape(len(self.columns),
n_inputs).astype(np.int64)
self.permanences = np.random.normal(.3, .05,
n_columns * n_inputs).reshape(
len(self.columns), n_inputs)
def test():
if not HAVE_H5PY and HAVE_NEST:
raise SkipTest
sim.setup()
p1 = sim.Population(10,
sim.IF_cond_exp(v_rest=-65,
tau_m=lambda i: 10 + 0.1 * i,
cm=RD('normal', (0.5, 0.05))),
label="population_one")
p2 = sim.Population(20,
sim.IF_curr_alpha(v_rest=-64,
tau_m=lambda i: 11 + 0.1 * i),
label="population_two")
prj = sim.Projection(p1,
p2,
sim.FixedProbabilityConnector(p_connect=0.5),
synapse_type=sim.StaticSynapse(weight=RD(
'uniform', [0.0, 0.1]),
delay=0.5),
receptor_type='excitatory')
net = Network(p1, p2, prj)
export_to_sonata(net, "tmp_serialization_test", overwrite=True)
net2 = import_from_sonata("tmp_serialization_test/circuit_config.json",
sim)
for orig_population in net.populations:
imp_population = net2.get_component(orig_population.label)
assert orig_population.size == imp_population.size
for name in orig_population.celltype.default_parameters:
assert_array_almost_equal(orig_population.get(name),
imp_population.get(name), 12)
w1 = prj.get('weight', format='array')
prj2 = net2.get_component(asciify(prj.label).decode('utf-8') + "-0")
w2 = prj2.get('weight', format='array')
assert_array_almost_equal(w1, w2, 12)
def set_synapses(self, conn_type, sim_params, E_neurons, I_neurons, N_inh,
conn_types, verbose):
syn = {}
proj = {}
verbose = True
if verbose: print('Building %s synapses..' % conn_types[conn_type])
weight = sim_params['w_{}'.format(conn_types[conn_type])]
delay = sim_params['s_{}'.format(conn_types[conn_type])]
syn[conn_types[conn_type]] = sim.StaticSynapse(delay=delay)
if conn_types[
conn_type][:3] == 'exc': #string slicing, this co is TO exc
pre_neurons = E_neurons
receptor_type = 'excitatory'
else:
pre_neurons = I_neurons #TO inh
receptor_type = 'inhibitory'
if conn_types[conn_type][-3:] == 'exc': #FROM exc
post_neurons = E_neurons
else:
post_neurons = I_neurons #FROM inh
sparseness = sim_params['c_{}'.format(conn_types[conn_type])]
proj[conn_types[conn_type]] = sim.Projection(
pre_neurons,
post_neurons,
connector=sim.FixedProbabilityConnector(sparseness,
rng=sim.NumpyRNG(seed=42)),
synapse_type=syn[conn_types[conn_type]],
receptor_type=receptor_type)
bw = sim_params['b_{}'.format(conn_types[conn_type])]
angle_pre = 1. * np.arange(proj[conn_types[conn_type]].pre.size)
angle_post = 1. * np.arange(proj[conn_types[conn_type]].post.size)
w_ij = self.tuning_function(angle_pre[:, np.newaxis],
angle_post[np.newaxis, :], bw,
N_inh) * weight
proj[conn_types[conn_type]].set(weight=w_ij)
return proj
p.IF_curr_exp, {},
label="reservoir")
######################
###### Synapses #######
stat_syn_res = p.StaticSynapse(weight=5.0, delay=1)
stat_syn_input = p.StaticSynapse(weight=50.0, delay=1)
stat_syn_rout = p.StaticSynapse(weight=0.0, delay=1)
######################
###### Connections #######
res_conn = p.FixedProbabilityConnector(param.res_pconn, rng=param.rng)
inp_conn = p.AllToAllConnector()
rout_conn = p.AllToAllConnector()
connections = {}
connections['r2r'] = p.Projection(reservoir,
reservoir,
res_conn,
synapse_type=stat_syn_res,
receptor_type='excitatory')
connections['inp2r'] = p.Projection(input_neurons,
reservoir,
inp_conn,
synapse_type=stat_syn_input,
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)
cellclass=neuron_model,
cellparams=neuron_parameters_FS_cell)
#V value initialization
sim.initialize(Neurons_RS, v=-65.0, gsyn_exc=0,
gsyn_inh=0) # v:mV, gsyn_exc:nS, gsyn_inh:nS
sim.initialize(Neurons_FS, v=-65.0, gsyn_exc=0, gsyn_inh=0)
## RECURRENT CONNECTIONS
#The two populations of neurons are randomly connected
# (internally and mutually) with a connectivity probability of 5%
# exc_exc
exc_exc = sim.Projection(Neurons_RS,
Neurons_RS,
sim.FixedProbabilityConnector(
0.05, allow_self_connections=False),
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=0.001))
# exc_inh
exc_inh = sim.Projection(Neurons_RS,
Neurons_FS,
sim.FixedProbabilityConnector(
0.05, allow_self_connections=False),
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=0.001))
# inh_exc
inh_exc = sim.Projection(Neurons_FS,
Neurons_RS,
sim.FixedProbabilityConnector(
0.05, allow_self_connections=False),
receptor_type='inhibitory',
######################
###### Synapses #######
stat_syn_input = p.StaticSynapse(weight=dist_input, delay=1)
stat_syn_exc = p.StaticSynapse(weight=dist_exc, delay=1)
stat_syn_inh = p.StaticSynapse(weight=dist_inh, delay=1)
#stat_syn_input = p.StaticSynapse(weight =50.0, delay=1)
######################
###### Connections #######
exc_conn = p.FixedProbabilityConnector(param.res_pconn, rng=param.rng)
inh_conn = p.FixedProbabilityConnector(param.res_pconn, rng=param.rng)
inp_conn = p.FixedProbabilityConnector(0.5, rng=param.rng)
rout_conn = p.AllToAllConnector()
connections = {}
connections['e2e'] = p.Projection(reservoir_exc,
reservoir_exc,
exc_conn,
synapse_type=stat_syn_exc,
receptor_type='excitatory')
connections['e2i'] = p.Projection(reservoir_exc,
reservoir_inh,
exc_conn,
synapse_type=stat_syn_exc,
receptor_type='excitatory')
# setup simulation
timestep = 0.5
num_threads = 4
sim.setup(timestep=timestep, min_delay=1.0, max_delay=1001.0, threads=num_threads)
# ========================================================================= #
# ------------------------create pyNN network------------------------------ #
# ========================================================================= #
# ======================================================================================================
# create connectors
# ======================================================================================================
# connector_inp_hiddenP = sim.FixedProbabilityConnector(p_connect=Pconnect_intra)
connector_hiddenPexc_hiddenPinh = sim.FixedProbabilityConnector(p_connect=Pconnect_intra)
connector_hiddenPinh_hiddenPexc = sim.FixedProbabilityConnector(p_connect=Pconnect_intra)
#connector_hiddenP_hiddenP = sim.FixedProbabilityConnector(p_connect=Pconnect_intra)
# ======================================================================================================
# create populations
# ======================================================================================================
N_input = 2
input_populations = []
for idx in range(N_input):
input_populations.append(sim.Population(hiddenPexc_size, sim.IF_curr_exp, neuron_parameters))
hidden_populations = [ [] for x in range(N_res)]
for idx in range(N_res):
import pyNN.nest 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
sim.run(500.0)
spikes_in = p_in.get_data()
print("spikes_in : ", type(spikes_in))
print("spikes_in.segments[0].spiketrains[0]",
spikes_in.segments[0].spiketrains[0])
#print("spikes_in.segments[-1].spiketrains",spikes_in.segments[-1].spiketrains)
spike_result = p_in.getSpikes(compatible_output=True)
# define stdp rules, parameters could be messed around with here.
stdp = pynn.STDPMechanism(
weight=0.02, # this is the initial value of the weight
timing_dependence=pynn.SpikePairRule(tau_plus=20.0,
tau_minus=20.0,
A_plus=0.01,
A_minus=0.012),
weight_dependence=pynn.AdditiveWeightDependence(w_min=0, w_max=0.04))
synapse_to_use = stdp if args.stdp else pynn.StaticSynapse(weight=0.02)
# connect inhibitory and excitatory sources to target. Could connect inhib to excit?
if args.inhib_conn_type == 'ff':
inhib_conn = pynn.Projection(
inhib_source,
target_pop,
connector=pynn.FixedProbabilityConnector(0.75),
synapse_type=synapse_to_use,
receptor_type='inhibitory')
elif args.inhib_conn_type == 'lat':
inhib_conn = pynn.Projection(
target_pop,
target_pop,
connector=pynn.FixedProbabilityConnector(0.75),
synapse_type=synapse_to_use,
receptor_type='inhibitory')
else:
print(dt.datetime.now().isoformat() + ' ERROR: ' +
'Unrecognised inhibatory connection type!')
excit_conn = pynn.Projection(
excit_source,
target_pop,