def internal_inhibition(self, w_range=[-0.2, 0.0], d_range=[2.0, 2.0]):
"""Connect the domains populations of the same variable using inhibitory synapses.
the connectiviy establishes a lateral inhibition circuit over the domains of each variable, so that most of the
time only the neurons from a single domain population are active.
args:
w_range: range for the random distribution of synaptic weights in the form [w_min, w_max].
d_range: range for the random distribution of synaptic delays in the form [d_min, d_max].
"""
print msg, 'Creating lateral inhibition between domains of each variable'
delays = RandomDistribution('uniform', d_range)
weights = RandomDistribution('uniform', w_range)
connections = [(m, n, 0.0 if m // self.core_size == n //
self.core_size else weights.next(), delays.next())
for n in range(self.size) for m in range(self.size)]
for variable in range(self.variables_number):
if self.clues_inhibition:
synapses = p.Projection(self.var_pops[variable],
self.var_pops[variable],
p.FromListConnector(connections,
safe=True),
target="inhibitory")
self.internal_conns.append(synapses)
elif variable not in self.clues:
synapses = p.Projection(self.var_pops[variable],
self.var_pops[variable],
p.FromListConnector(connections,
safe=True),
target="inhibitory")
self.internal_conns.append(synapses)
def connect_cores(self, w_range=[0.6, 1.2], d_range=[1.0, 1.2]):
"""Create internal excitatory connections between the neurons of each domain subpopulation of each variable.
In the network representing the CSP, each neural population representing a variable contains a subpopulation
for each possible value on its domain. This method connects all-to-all the neurons of each domain population
of each variable using escitatory synapses.
args:
w_range: range for the random distribution of synaptic weights in the form [w_min, w_max].
d_range: range for the random distribution of synaptic delays in the form [d_min, d_max].
"""
print msg, 'internally connnecting the neurons of each domain of each variable'
delays = RandomDistribution('uniform', d_range)
weights = RandomDistribution('uniform', w_range)
connections = [
(m, n, weights.next() if m // self.core_size == n // self.core_size
and m != n else 0.0, delays.next())
for n in range(self.domain_size * self.core_size)
for m in range(self.domain_size * self.core_size)
]
for variable in range(self.variables_number):
synapses = p.Projection(self.var_pops[variable],
self.var_pops[variable],
p.FromListConnector(connections,
safe=True),
target="excitatory")
self.core_conns.append(synapses)
def generateRandomPattern(self, rng):
"""
"""
unordered_events = list()
rdNeurons = RandomDistribution('uniform', [0, self.totalNeurons-1], rng)
rdTimes = RandomDistribution('uniform', (0, self.cycleTime-1), rng)
randomNeurons = rdNeurons.next(self.firing)
randomTimes = rdTimes.next(self.firing)
for i in range(self.firing):
unordered_events.append((int(randomNeurons[i]), int(randomTimes[i]*10)/10.0))
#self.events = numpy.sort(unordered_events, 0)
self.events = unordered_events
def poisson_spike_train(rate: float,
start: float = 0,
stop: float = runtime,
seed: int = 4245) -> np.array:
"""
Generates a Poisson spike train.
:param rate: Rate of the train in Hz.
:param stop: Stop time of the spike train in ms.
:param start: Start time of the spike train in ms.
:param seed: Seed to use for the random number generator.
:return: Spike times of Poisson spike train as an array.
"""
assert start < stop, "Start time has to be shorter than stop time"
# Use period in us to support non-integer spike times in ms
period = 1 / rate * 1e6 # period in us
poisson_dist = RandomDistribution("poisson",
lambda_=period,
rng=NumpyRNG(seed=seed))
# Generate spike times till the stop time is exceeded
spikes = []
time = start
while True:
time += poisson_dist.next() / 1000 # convert from us to ms
if time > stop:
break
spikes.append(time)
return np.array(sorted(spikes))
def generate_stimulus(start, stop, interval):
rd = RandomDistribution('exponential', [interval], rng=rStim)
t = start
times = []
while t < stop:
t += rd.next()
if t < stop:
times.append(t)
return times
def stimulate_cores(self,
w_range=[1.4, 1.4],
d_range=[1.0, 1.0],
w_clues=[1.4, 1.6]): # w_clues=[0.0, 0.2]
"""Connect stimulating noise sources to variables populations.
args:
w_range: range for the random distribution of synaptic weights in the form [w_min, w_max].
d_range: range for the random distribution of synaptic delays in the form [d_min, d_max].
w_clues: clues specific range for the random distribution of synaptic weights in the form [w_min, w_max].
"""
p.set_number_of_neurons_per_core(p.IF_curr_exp, 150)
print msg, 'connecting Poisson noise sources to neural populations for stimulation'
delays = RandomDistribution('uniform', d_range)
weights = RandomDistribution('uniform', w_range)
weight_clues = RandomDistribution("uniform", w_clues)
for stimulus in range(self.n_populations):
for variable in range(self.variables_number):
counter = 0
if variable in self.clues[0]:
shift = self.clues[1][self.clues[0].index(
variable)] * self.core_size
connections = [(m, n + shift, weight_clues.next(),
delays.next())
for m in range(self.core_size)
for n in range(self.clue_size)]
synapses = p.Projection(self.clues_stim[counter],
self.var_pops[variable],
p.FromListConnector(connections,
safe=True),
target='excitatory')
counter += 1
self.stim_conns.append(synapses)
else:
synapses = p.Projection(
self.stim_pops[stimulus][variable],
self.var_pops[variable],
p.OneToOneConnector(weights=weights, delays=delays),
target='excitatory')
self.stim_conns.append(synapses)
self.stim_times += self.stims
def _generate_random_values(
self, values, n_connections, pre_vertex_slice, post_vertex_slice):
"""
:param ~pyNN.random.NumpyRNG values:
:param int n_connections:
:param ~pacman.model.graphs.common.Slice pre_vertex_slice:
:param ~pacman.model.graphs.common.Slice post_vertex_slice:
:rtype: ~numpy.ndarray
"""
key = (id(pre_vertex_slice), id(post_vertex_slice), id(values))
seed = self.__param_seeds.get(key, None)
if seed is None:
seed = int(values.rng.next() * 0x7FFFFFFF)
self.__param_seeds[key] = seed
new_rng = NumpyRNG(seed)
copy_rd = RandomDistribution(
values.name, parameters_pos=None, rng=new_rng,
**values.parameters)
if n_connections == 1:
return numpy.array([copy_rd.next(1)], dtype="float64")
return copy_rd.next(n_connections)
def buildStream(self, numSources=None, patterns=None, interPatternGap=10, rng=None, offset=0.0, order=None, noise=None, printTimes = False):
"""
"""
# Establish a list of times at which pattern start firing:
patternTimes = list()
recallStartTime = 0
# Create empty streams, one per source neuron:
for i in range(numSources):
self.streams.append(list())
# Go through order parameter, which is a list of the patterns to be appended.
# For each one, append it.
timePtr = 0
jitterDistribution = RandomDistribution('normal', (0.0, patterns[0].jitterSD), rng = rng)
for entry in order:
if entry < 0:
# Add blank entry:
patternEntry = [entry, timePtr]
patternTimes.append(patternEntry)
# Create a gap (20ms):
timePtr += 20
if entry == -1:
recallStartTime = timePtr
else:
if printTimes:
print "Pattern ", entry, " starts at time ", timePtr
if entry >= len(patterns):
print "ERROR: Pattern set requested pattern ", entry, \
" and pattern set has only ", len(patterns), " patterns"
return -1
patternEntry = [entry, timePtr]
patternTimes.append(patternEntry)
pattern = patterns[entry]
biggestTimestamp = 0
for element in pattern.events:
index, timestamp = element
timestamp += offset
if patterns[0].jitterSD > 0:
newNum = jitterDistribution.next(1)
#print "Base T: ", timestamp, " : ", newNum,
timestamp += newNum
if timestamp < 0:
timestamp = 0.0
#print ", new: ", timestamp
biggestTimestamp = max(biggestTimestamp, timestamp)
self.streams[index].append(timePtr + timestamp)
timePtr += pattern.cycleTime + interPatternGap
self.endTime = timePtr
return recallStartTime, patternTimes
def connect(self, projection):
# This implementation is not "parallel safe" for random numbers.
# todo: support the `parallel_safe` flag.
# Determine number of processes and current rank
rank = projection._simulator.state.mpi_rank
num_processes = projection._simulator.state.num_processes
# Assume that targets are equally distributed over processes
targets_per_process = int(len(projection.post) / num_processes)
# Calculate the number of synapses on each process
bino = RandomDistribution(
'binomial', [self.n, targets_per_process / len(projection.post)],
rng=self.rng)
num_conns_on_vp = numpy.zeros(num_processes, dtype=int)
sum_dist = 0
sum_partitions = 0
for k in range(num_processes):
p_local = targets_per_process / (len(projection.post) - sum_dist)
bino.parameters['p'] = p_local
bino.parameters['n'] = self.n - sum_partitions
num_conns_on_vp[k] = bino.next()
sum_dist += targets_per_process
sum_partitions += num_conns_on_vp[k]
# Draw random sources and targets
connections = [[] for i in range(projection.post.size)]
possible_targets = numpy.arange(
projection.post.size)[projection.post._mask_local]
for i in range(num_conns_on_vp[rank]):
source_index = self.rng.next(1,
'uniform_int', {
"low": 0,
"high": projection.pre.size
},
mask=None)[0]
target_index = self.rng.choice(possible_targets, size=1)[0]
connections[target_index].append(source_index)
def build_source_masks(mask=None):
if mask is None:
return [numpy.array(x) for x in connections]
else:
return [numpy.array(x) for x in numpy.array(connections)[mask]]
self._standard_connect(projection, build_source_masks)
def connect(self, projection):
# Determine number of processes and current rank
rank, num_processes = get_mpi_config()
# Assume that targets are equally distributed over processes
targets_per_process = int(len(projection.post) / num_processes)
# Calculate the number of synapses on each process
bino = RandomDistribution(
'binomial', [self.n, targets_per_process / len(projection.post)],
rng=self.rng)
num_conns_on_vp = numpy.zeros(num_processes)
sum_dist = 0
sum_partitions = 0
for k in xrange(num_processes):
p_local = targets_per_process / (len(projection.post) - sum_dist)
bino.parameters['p'] = p_local
bino.parameters['n'] = self.n - sum_partitions
num_conns_on_vp[k] = bino.next()
sum_dist += targets_per_process
sum_partitions += num_conns_on_vp[k]
# Draw random sources and targets
while num_conns_on_vp[rank] > 0:
s_index = self.rng.rng.randint(low=0,
high=len(projection.pre.all_cells))
t_index = self.rng.rng.randint(low=0,
high=len(
projection.post.local_cells))
t_index = numpy.where(projection.post.all_cells == int(
projection.post.local_cells[t_index]))[0][0]
# Evaluate the lazy arrays containing the synaptic parameters
parameter_space = self._parameters_from_synapse_type(projection)
connection_parameters = {}
for name, map in parameter_space.items():
if map.is_homogeneous:
connection_parameters[name] = map.evaluate(simplify=True)
else:
connection_parameters[name] = map[source_mask, col]
projection._convergent_connect(numpy.array([s_index]), t_index,
**connection_parameters)
num_conns_on_vp[rank] -= 1
def connect(self, projection):
# This implementation is not "parallel safe" for random numbers.
# todo: support the `parallel_safe` flag.
# Determine number of processes and current rank
rank = projection._simulator.state.mpi_rank
num_processes = projection._simulator.state.num_processes
# Assume that targets are equally distributed over processes
targets_per_process = int(len(projection.post) / num_processes)
# Calculate the number of synapses on each process
bino = RandomDistribution('binomial',
[self.n, targets_per_process / len(projection.post)],
rng=self.rng)
num_conns_on_vp = numpy.zeros(num_processes, dtype=int)
sum_dist = 0
sum_partitions = 0
for k in range(num_processes):
p_local = targets_per_process / (len(projection.post) - sum_dist)
bino.parameters['p'] = p_local
bino.parameters['n'] = self.n - sum_partitions
num_conns_on_vp[k] = bino.next()
sum_dist += targets_per_process
sum_partitions += num_conns_on_vp[k]
# Draw random sources and targets
connections = [[] for i in range(projection.post.size)]
possible_targets = numpy.arange(projection.post.size)[projection.post._mask_local]
for i in range(num_conns_on_vp[rank]):
source_index = self.rng.next(1, 'uniform_int',
{"low": 0, "high": projection.pre.size},
mask_local=False)[0]
target_index = self.rng.choice(possible_targets, size=1)[0]
connections[target_index].append(source_index)
def build_source_masks(mask=None):
if mask is None:
return [numpy.array(x) for x in connections]
else:
return [numpy.array(x) for x in numpy.array(connections)[mask]]
self._standard_connect(projection, build_source_masks)
def connect(self, projection):
# Determine number of processes and current rank
rank, num_processes = get_mpi_config()
# Assume that targets are equally distributed over processes
targets_per_process = int(len(projection.post)/num_processes)
# Calculate the number of synapses on each process
bino = RandomDistribution('binomial',[self.n,targets_per_process/len(projection.post)], rng=self.rng)
num_conns_on_vp = numpy.zeros(num_processes)
sum_dist = 0
sum_partitions = 0
for k in xrange(num_processes) :
p_local = targets_per_process / ( len(projection.post) - sum_dist)
bino.parameters['p'] = p_local
bino.parameters['n'] = self.n - sum_partitions
num_conns_on_vp[k] = bino.next()
sum_dist += targets_per_process
sum_partitions += num_conns_on_vp[k]
# Draw random sources and targets
while num_conns_on_vp[rank] > 0 :
s_index = self.rng.rng.randint(low=0, high=len(projection.pre.all_cells))
t_index = self.rng.rng.randint(low=0, high=len(projection.post.local_cells))
t_index = numpy.where(projection.post.all_cells == int(projection.post.local_cells[t_index]))[0][0]
# Evaluate the lazy arrays containing the synaptic parameters
parameter_space = self._parameters_from_synapse_type(projection)
connection_parameters = {}
for name, map in parameter_space.items():
if map.is_homogeneous:
connection_parameters[name] = map.evaluate(simplify=True)
else:
connection_parameters[name] = map[source_mask, col]
projection._convergent_connect(numpy.array([s_index]),t_index, **connection_parameters)
num_conns_on_vp[rank] -=1
def obtain_synapses(wiring_plan):
rng = NumpyRNG(seed=64754)
delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng)
flat_iter = [ (i,j,k,xaxis) for i,j in enumerate(filtered) for k,xaxis in enumerate(j) ]
index_exc = list(set( source for (source,j,target,xaxis) in flat_iter if xaxis==1 or xaxis == 2 ))
index_inh = list(set( source for (source,j,target,xaxis) in flat_iter if xaxis==-1 or xaxis == -2 ))
EElist = []
IIlist = []
EIlist = []
IElist = []
for (source,j,target,xaxis) in flat_iter:
delay = delay_distr.next()
weight = 1.0 # will be updated later.
if xaxis==1 or xaxis == 2:
if target in index_inh:
EIlist.append((source,target,delay,weight))
else:
EElist.append((source,target,delay,weight))
if xaxis==-1 or xaxis == -2:
if target in index_exc:
IElist.append((source,target,delay,weight))
else:
IIlist.append((source,target,delay,weight))
conn_ee = sim.FromListConnector(EElist)
conn_ie = sim.FromListConnector(IElist)
conn_ei = sim.FromListConnector(EIlist)
conn_ii = sim.FromListConnector(IIlist)
return (conn_ee, conn_ie, conn_ei, conn_ii,index_exc,index_inh)
delay_distr = RandomDistribution('normal', [45, 1e-1], rng=rng)
index_exc = [i for i, d in enumerate(dfm) if '+' in d[0]]
index_inh = [i for i, d in enumerate(dfm) if '-' in d[0]]
EElist = []
IIlist = []
EIlist = []
IElist = []
for i, j in enumerate(filtered):
for k, xaxis in enumerate(j):
if xaxis == 1 or xaxis == 2:
source = i
target = k
delay = delay_distr.next()
weight = 11.0
if target in index_inh:
EIlist.append((source, target, delay, weight))
else:
EElist.append((source, target, delay, weight))
if xaxis == -1 or xaxis == -2:
source = i
target = k
delay = delay_distr.next()
weight = 11.0
if target in index_exc:
IElist.append((source, target, delay, weight))
else:
IIlist.append((source, target, delay, weight))
# 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)
print "%d Creating slow inhibitory population with %d neurons." % (rank,
N_Sli)
Sli_net = Population((N_Sli, ), IF_cond_exp, cell_params_Sli)
# Creating external input - is this correct on multiple threads?
Pyr_input = []
for sp in range(NP):
print "%d Creating pyramidal cell external input %d with rate %g spikes/s." % (
def sim_runner(wg):
#import pyNN.neuron as sim
try:
import pyNN.spiNNaker as sim
except:
import pyNN.neuron as sim
nproc = sim.num_processes()
node = sim.rank()
print(nproc)
#import mpi4py
#threads = sim.rank()
threads = 1
rngseed = 98765
parallel_safe = False
#extra = {'threads' : threads}
# Get some hippocampus connectivity data, based on a conversation with
# academic researchers on GH:
# https://github.com/Hippocampome-Org/GraphTheory/issues?q=is%3Aissue+is%3Aclosed
# scrape hippocamome connectivity data, that I intend to use to program neuromorphic hardware.
# conditionally get files if they don't exist.
# This is literally the starting point of the connection map
path_xl = '_hybrid_connectivity_matrix_20171103_092033.xlsx'
if not os.path.exists(path_xl):
os.system(
'wget https://github.com/Hippocampome-Org/GraphTheory/files/1657258/_hybrid_connectivity_matrix_20171103_092033.xlsx'
)
xl = pd.ExcelFile(path_xl)
dfall = xl.parse()
dfall.loc[0].keys()
dfm = dfall.as_matrix()
rcls = dfm[:, :1] # real cell labels.
rcls = rcls[1:]
rcls = {k: v
for k, v in enumerate(rcls)
} # real cell labels, cast to dictionary
import pickle
with open('cell_names.p', 'wb') as f:
pickle.dump(rcls, f)
pd.DataFrame(rcls).to_csv('cell_names.csv', index=False)
filtered = dfm[:, 3:]
filtered = filtered[1:]
rng = NumpyRNG(seed=64754)
delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng)
sanity_e = []
sanity_i = []
EElist = []
IIlist = []
EIlist = []
IElist = []
with open('wire_map_online.p', 'wb') as f:
pickle.dump(filtered, f)
for i, j in enumerate(filtered):
for k, xaxis in enumerate(j):
if xaxis == 1 or xaxis == 2:
source = i
sanity_e.append(i)
target = k
if xaxis == -1 or xaxis == -2:
sanity_i.append(i)
source = i
target = k
index_exc = list(set(sanity_e))
index_inh = list(set(sanity_i))
import pickle
with open('cell_indexs.p', 'wb') as f:
returned_list = [index_exc, index_inh]
pickle.dump(returned_list, f)
'''
import numpy
a = numpy.asarray(index_exc)
numpy.savetxt('pickles/'+str(k)+'excitatory_nunber_labels.csv', a, delimiter=",")
a = numpy.asarray(index_inh)
numpy.savetxt('pickles/'+str(k)+'inhibitory_nunber_labels.csv', a, delimiter=",")
'''
for i, j in enumerate(filtered):
for k, xaxis in enumerate(j):
if xaxis == 1 or xaxis == 2:
source = i
sanity_e.append(i)
target = k
delay = delay_distr.next()
weight = 1.0
if target in index_inh:
EIlist.append((source, target, delay, weight))
else:
EElist.append((source, target, delay, weight))
if xaxis == -1 or xaxis == -2:
sanity_i.append(i)
source = i
target = k
delay = delay_distr.next()
weight = 1.0
if target in index_exc:
IElist.append((source, target, delay, weight))
else:
IIlist.append((source, target, delay, weight))
internal_conn_ee = sim.FromListConnector(EElist)
ee = internal_conn_ee.conn_list
ee_srcs = ee[:, 0]
ee_tgs = ee[:, 1]
internal_conn_ie = sim.FromListConnector(IElist)
ie = internal_conn_ie.conn_list
ie_srcs = set([int(e[0]) for e in ie])
ie_tgs = set([int(e[1]) for e in ie])
internal_conn_ei = sim.FromListConnector(EIlist)
ei = internal_conn_ei.conn_list
ei_srcs = set([int(e[0]) for e in ei])
ei_tgs = set([int(e[1]) for e in ei])
internal_conn_ii = sim.FromListConnector(IIlist)
ii = internal_conn_ii.conn_list
ii_srcs = set([int(e[0]) for e in ii])
ii_tgs = set([int(e[1]) for e in ii])
for e in internal_conn_ee.conn_list:
assert e[0] in ee_srcs
assert e[1] in ee_tgs
for i in internal_conn_ii.conn_list:
assert i[0] in ii_srcs
assert i[1] in ii_tgs
ml = len(filtered[1]) + 1
pre_exc = []
post_exc = []
pre_inh = []
post_inh = []
rng = NumpyRNG(seed=64754)
delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
plot_EE = np.zeros(shape=(ml, ml), dtype=bool)
plot_II = np.zeros(shape=(ml, ml), dtype=bool)
plot_EI = np.zeros(shape=(ml, ml), dtype=bool)
plot_IE = np.zeros(shape=(ml, ml), dtype=bool)
for i in EElist:
plot_EE[i[0], i[1]] = int(0)
if i[0] != i[1]: # exclude self connections
plot_EE[i[0], i[1]] = int(1)
pre_exc.append(i[0])
post_exc.append(i[1])
assert len(pre_exc) == len(post_exc)
for i in IIlist:
plot_II[i[0], i[1]] = int(0)
if i[0] != i[1]:
plot_II[i[0], i[1]] = int(1)
pre_inh.append(i[0])
post_inh.append(i[1])
for i in IElist:
plot_IE[i[0], i[1]] = int(0)
if i[0] != i[1]: # exclude self connections
plot_IE[i[0], i[1]] = int(1)
pre_inh.append(i[0])
post_inh.append(i[1])
for i in EIlist:
plot_EI[i[0], i[1]] = int(0)
if i[0] != i[1]:
plot_EI[i[0], i[1]] = int(1)
pre_exc.append(i[0])
post_exc.append(i[1])
plot_excit = plot_EI + plot_EE
plot_inhib = plot_IE + plot_II
assert len(pre_inh) == len(post_inh)
num_exc = [i for i, e in enumerate(plot_excit) if sum(e) > 0]
num_inh = [y for y, i in enumerate(plot_inhib) if sum(i) > 0]
# the network is dominated by inhibitory neurons, which is unusual for modellers.
assert num_inh > num_exc
assert np.sum(plot_inhib) > np.sum(plot_excit)
assert len(num_exc) < ml
assert len(num_inh) < ml
# # Plot all the Projection pairs as a connection matrix (Excitatory and Inhibitory Connections)
nproc = sim.num_processes()
nproc = 8
host_name = socket.gethostname()
node_id = sim.setup(timestep=0.01, min_delay=1.0) #, **extra)
print("Host #%d is on %s" % (node_id + 1, host_name))
rng = NumpyRNG(seed=64754)
all_cells = sim.Population(
len(index_exc) + len(index_inh),
sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0))
pop_exc = sim.PopulationView(all_cells, index_exc)
pop_inh = sim.PopulationView(all_cells, index_inh)
for pe in pop_exc:
pe = all_cells[pe]
r = random.uniform(0.0, 1.0)
pe.set_parameters(a=0.02,
b=0.2,
c=-65 + 15 * r,
d=8 - r**2,
i_offset=0)
for pi in index_inh:
pi = all_cells[pi]
r = random.uniform(0.0, 1.0)
pi.set_parameters(a=0.02 + 0.08 * r,
b=0.25 - 0.05 * r,
c=-65,
d=2,
i_offset=0)
NEXC = len(num_exc)
NINH = len(num_inh)
exc_syn = sim.StaticSynapse(weight=wg, delay=delay_distr)
assert np.any(internal_conn_ee.conn_list[:, 0]) < ee_srcs.size
prj_exc_exc = sim.Projection(all_cells,
all_cells,
internal_conn_ee,
exc_syn,
receptor_type='excitatory')
prj_exc_inh = sim.Projection(all_cells,
all_cells,
internal_conn_ei,
exc_syn,
receptor_type='excitatory')
inh_syn = sim.StaticSynapse(weight=wg, delay=delay_distr)
delay_distr = RandomDistribution('normal', [1, 100e-3], rng=rng)
prj_inh_inh = sim.Projection(all_cells,
all_cells,
internal_conn_ii,
inh_syn,
receptor_type='inhibitory')
prj_inh_exc = sim.Projection(all_cells,
all_cells,
internal_conn_ie,
inh_syn,
receptor_type='inhibitory')
inh_distr = RandomDistribution('normal', [1, 2.1e-3], rng=rng)
ext_Connector = OneToOneConnector(callback=progress_bar)
ext_syn = StaticSynapse(weight=JE, delay=dt)
'''
print("%d Connecting excitatory population with connection probability %g, weight %g nA and delay %g ms." % (rank, epsilon, JE, delay))
E_to_E = Projection(E_net, E_net, connector, E_syn, receptor_type="excitatory")
print("E --> E\t\t", len(E_to_E), "connections")
I_to_E = Projection(I_net, E_net, connector, I_syn, receptor_type="inhibitory")
print("I --> E\t\t", len(I_to_E), "connections")
input_to_E = Projection(expoisson, E_net, ext_Connector, ext_syn, receptor_type="excitatory")
print("input --> E\t", len(input_to_E), "connections")
print("%d Connecting inhibitory population with connection probability %g, weight %g nA and delay %g ms." % (rank, epsilon, JI, delay))
E_to_I = Projection(E_net, I_net, connector, E_syn, receptor_type="excitatory")
print("E --> I\t\t", len(E_to_I), "connections")
I_to_I = Projection(I_net, I_net, connector, I_syn, receptor_type="inhibitory")
print("I --> I\t\t", len(I_to_I), "connections")
input_to_I = Projection(inpoisson, I_net, ext_Connector, ext_syn, receptor_type="excitatory")
print("input --> I\t", len(input_to_I), "connections")
'''
def prj_change(prj, wg):
prj.setWeights(wg)
prj_change(prj_exc_exc, wg)
prj_change(prj_exc_inh, wg)
prj_change(prj_inh_exc, wg)
prj_change(prj_inh_inh, wg)
def prj_check(prj):
for w in prj.weightHistogram():
for i in w:
print(i)
prj_check(prj_exc_exc)
prj_check(prj_exc_inh)
prj_check(prj_inh_exc)
prj_check(prj_inh_inh)
#print(rheobase['value'])
#print(float(rheobase['value']),1.25/1000.0)
'''Old values that worked
noise = sim.NoisyCurrentSource(mean=0.85/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_exc.inject(noise)
#1000.0 pA
noise = sim.NoisyCurrentSource(mean=1.740/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_inh.inject(noise)
#1750.0 pA
'''
noise = sim.NoisyCurrentSource(mean=0.74 / 1000.0,
stdev=4.00 / 1000.0,
start=0.0,
stop=2000.0,
dt=1.0)
pop_exc.inject(noise)
#1000.0 pA
noise = sim.NoisyCurrentSource(mean=1.440 / 1000.0,
stdev=4.00 / 1000.0,
start=0.0,
stop=2000.0,
dt=1.0)
pop_inh.inject(noise)
##
# Setup and run a simulation. Note there is no current injection into the neuron.
# All cells in the network are in a quiescent state, so its not a surprise that xthere are no spikes
##
sim = pyNN.neuron
arange = np.arange
import re
all_cells.record(['v', 'spikes']) # , 'u'])
all_cells.initialize(v=-65.0, u=-14.0)
# === Run the simulation =====================================================
tstop = 2000.0
sim.run(tstop)
data = None
data = all_cells.get_data().segments[0]
if not os.path.exists("pickles"):
os.mkdir("pickles")
#print(len(data.analogsignals[0].times))
with open('pickles/qi' + str(wg) + '.p', 'wb') as f:
pickle.dump(data, f)
# make data none or else it will grow in a loop
all_cells = None
data = None
noise = None
def sim_runner(wgf):
wg = wgf
import pyNN.neuron as sim
nproc = sim.num_processes()
node = sim.rank()
print(nproc)
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams.update({'font.size':16})
#import mpi4py
#threads = sim.rank()
threads = 1
rngseed = 98765
parallel_safe = False
#extra = {'threads' : threads}
import os
import pandas as pd
import sys
import numpy as np
from pyNN.neuron import STDPMechanism
import copy
from pyNN.random import RandomDistribution, NumpyRNG
import pyNN.neuron as neuron
from pyNN.neuron import h
from pyNN.neuron import StandardCellType, ParameterSpace
from pyNN.random import RandomDistribution, NumpyRNG
from pyNN.neuron import STDPMechanism, SpikePairRule, AdditiveWeightDependence, FromListConnector, TsodyksMarkramSynapse
from pyNN.neuron import Projection, OneToOneConnector
from numpy import arange
import pyNN
from pyNN.utility import get_simulator, init_logging, normalized_filename
import random
import socket
#from neuronunit.optimization import get_neab
import networkx as nx
sim = pyNN.neuron
# Get some hippocampus connectivity data, based on a conversation with
# academic researchers on GH:
# https://github.com/Hippocampome-Org/GraphTheory/issues?q=is%3Aissue+is%3Aclosed
# scrape hippocamome connectivity data, that I intend to use to program neuromorphic hardware.
# conditionally get files if they don't exist.
path_xl = '_hybrid_connectivity_matrix_20171103_092033.xlsx'
if not os.path.exists(path_xl):
os.system('wget https://github.com/Hippocampome-Org/GraphTheory/files/1657258/_hybrid_connectivity_matrix_20171103_092033.xlsx')
xl = pd.ExcelFile(path_xl)
dfEE = xl.parse()
dfEE.loc[0].keys()
dfm = dfEE.as_matrix()
rcls = dfm[:,:1] # real cell labels.
rcls = rcls[1:]
rcls = { k:v for k,v in enumerate(rcls) } # real cell labels, cast to dictionary
import pickle
with open('cell_names.p','wb') as f:
pickle.dump(rcls,f)
import pandas as pd
pd.DataFrame(rcls).to_csv('cell_names.csv', index=False)
filtered = dfm[:,3:]
filtered = filtered[1:]
rng = NumpyRNG(seed=64754)
delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng)
sanity_e = []
sanity_i = []
EElist = []
IIlist = []
EIlist = []
IElist = []
for i,j in enumerate(filtered):
for k,xaxis in enumerate(j):
if xaxis == 1 or xaxis == 2:
source = i
sanity_e.append(i)
target = k
if xaxis ==-1 or xaxis == -2:
sanity_i.append(i)
source = i
target = k
index_exc = list(set(sanity_e))
index_inh = list(set(sanity_i))
import pickle
with open('cell_indexs.p','wb') as f:
returned_list = [index_exc, index_inh]
pickle.dump(returned_list,f)
import numpy
a = numpy.asarray(index_exc)
numpy.savetxt('pickles/'+str(k)+'excitatory_nunber_labels.csv', a, delimiter=",")
import numpy
a = numpy.asarray(index_inh)
numpy.savetxt('pickles/'+str(k)+'inhibitory_nunber_labels.csv', a, delimiter=",")
for i,j in enumerate(filtered):
for k,xaxis in enumerate(j):
if xaxis==1 or xaxis == 2:
source = i
sanity_e.append(i)
target = k
delay = delay_distr.next()
weight = 1.0
if target in index_inh:
EIlist.append((source,target,delay,weight))
else:
EElist.append((source,target,delay,weight))
if xaxis==-1 or xaxis == -2:
sanity_i.append(i)
source = i
target = k
delay = delay_distr.next()
weight = 1.0
if target in index_exc:
IElist.append((source,target,delay,weight))
else:
IIlist.append((source,target,delay,weight))
internal_conn_ee = sim.FromListConnector(EElist)
ee = internal_conn_ee.conn_list
ee_srcs = ee[:,0]
ee_tgs = ee[:,1]
internal_conn_ie = sim.FromListConnector(IElist)
ie = internal_conn_ie.conn_list
ie_srcs = set([ int(e[0]) for e in ie ])
ie_tgs = set([ int(e[1]) for e in ie ])
internal_conn_ei = sim.FromListConnector(EIlist)
ei = internal_conn_ei.conn_list
ei_srcs = set([ int(e[0]) for e in ei ])
ei_tgs = set([ int(e[1]) for e in ei ])
internal_conn_ii = sim.FromListConnector(IIlist)
ii = internal_conn_ii.conn_list
ii_srcs = set([ int(e[0]) for e in ii ])
ii_tgs = set([ int(e[1]) for e in ii ])
for e in internal_conn_ee.conn_list:
assert e[0] in ee_srcs
assert e[1] in ee_tgs
for i in internal_conn_ii.conn_list:
assert i[0] in ii_srcs
assert i[1] in ii_tgs
ml = len(filtered[1])+1
pre_exc = []
post_exc = []
pre_inh = []
post_inh = []
rng = NumpyRNG(seed=64754)
delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
plot_EE = np.zeros(shape=(ml,ml), dtype=bool)
plot_II = np.zeros(shape=(ml,ml), dtype=bool)
plot_EI = np.zeros(shape=(ml,ml), dtype=bool)
plot_IE = np.zeros(shape=(ml,ml), dtype=bool)
for i in EElist:
plot_EE[i[0],i[1]] = int(0)
#plot_ss[i[0],i[1]] = int(1)
if i[0]!=i[1]: # exclude self connections
plot_EE[i[0],i[1]] = int(1)
pre_exc.append(i[0])
post_exc.append(i[1])
assert len(pre_exc) == len(post_exc)
for i in IIlist:
plot_II[i[0],i[1]] = int(0)
if i[0]!=i[1]:
plot_II[i[0],i[1]] = int(1)
pre_inh.append(i[0])
post_inh.append(i[1])
for i in IElist:
plot_IE[i[0],i[1]] = int(0)
if i[0]!=i[1]: # exclude self connections
plot_IE[i[0],i[1]] = int(1)
pre_inh.append(i[0])
post_inh.append(i[1])
for i in EIlist:
plot_EI[i[0],i[1]] = int(0)
if i[0]!=i[1]:
plot_EI[i[0],i[1]] = int(1)
pre_exc.append(i[0])
post_exc.append(i[1])
plot_excit = plot_EI + plot_EE
plot_inhib = plot_IE + plot_II
assert len(pre_inh) == len(post_inh)
num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ]
num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ]
# the network is dominated by inhibitory neurons, which is unusual for modellers.
assert num_inh > num_exc
assert np.sum(plot_inhib) > np.sum(plot_excit)
assert len(num_exc) < ml
assert len(num_inh) < ml
# # Plot all the Projection pairs as a connection matrix (Excitatory and Inhibitory Connections)
import pickle
with open('graph_inhib.p','wb') as f:
pickle.dump(plot_inhib,f, protocol=2)
import pickle
with open('graph_excit.p','wb') as f:
pickle.dump(plot_excit,f, protocol=2)
#with open('cell_names.p','wb') as f:
# pickle.dump(rcls,f)
import pandas as pd
pd.DataFrame(plot_EE).to_csv('ee.csv', index=False)
import pandas as pd
pd.DataFrame(plot_IE).to_csv('ie.csv', index=False)
import pandas as pd
pd.DataFrame(plot_II).to_csv('ii.csv', index=False)
import pandas as pd
pd.DataFrame(plot_EI).to_csv('ei.csv', index=False)
from scipy.sparse import coo_matrix
m = np.matrix(filtered[1:])
bool_matrix = np.add(plot_excit,plot_inhib)
with open('bool_matrix.p','wb') as f:
pickle.dump(bool_matrix,f, protocol=2)
if not isinstance(m, coo_matrix):
m = coo_matrix(m)
Gexc_ud = nx.Graph(plot_excit)
avg_clustering = nx.average_clustering(Gexc_ud)#, nodes=None, weight=None, count_zeros=True)[source]
rc = nx.rich_club_coefficient(Gexc_ud,normalized=False)
print('This graph structure as rich as: ',rc[0])
gexc = nx.DiGraph(plot_excit)
gexcc = nx.betweenness_centrality(gexc)
top_exc = sorted(([ (v,k) for k, v in dict(gexcc).items() ]), reverse=True)
in_degree = gexc.in_degree()
top_in = sorted(([ (v,k) for k, v in in_degree.items() ]))
in_hub = top_in[-1][1]
out_degree = gexc.out_degree()
top_out = sorted(([ (v,k) for k, v in out_degree.items() ]))
out_hub = top_out[-1][1]
mean_out = np.mean(list(out_degree.values()))
mean_in = np.mean(list(in_degree.values()))
mean_conns = int(mean_in + mean_out/2)
k = 2 # number of neighbouig nodes to wire.
p = 0.25 # probability of instead wiring to a random long range destination.
ne = len(plot_excit)# size of small world network
small_world_ring_excit = nx.watts_strogatz_graph(ne,mean_conns,0.25)
k = 2 # number of neighbouring nodes to wire.
p = 0.25 # probability of instead wiring to a random long range destination.
ni = len(plot_inhib)# size of small world network
small_world_ring_inhib = nx.watts_strogatz_graph(ni,mean_conns,0.25)
nproc = sim.num_processes()
nproc = 8
host_name = socket.gethostname()
node_id = sim.setup(timestep=0.01, min_delay=1.0)#, **extra)
print("Host #%d is on %s" % (node_id + 1, host_name))
rng = NumpyRNG(seed=64754)
#pop_size = len(num_exc)+len(num_inh)
#num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ]
#num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ]
#pop_exc = sim.Population(len(num_exc), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0))
#pop_inh = sim.Population(len(num_inh), sim.Izhikevich(a=0.02, b=0.25, c=-65, d=2, i_offset=0))
#index_exc = list(set(sanity_e))
#index_inh = list(set(sanity_i))
all_cells = sim.Population(len(index_exc)+len(index_inh), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0))
#all_cells = None
#all_cells = pop_exc + pop_inh
pop_exc = sim.PopulationView(all_cells,index_exc)
pop_inh = sim.PopulationView(all_cells,index_inh)
#print(pop_exc)
#print(dir(pop_exc))
for pe in pop_exc:
print(pe)
#import pdb
pe = all_cells[pe]
#pdb.set_trace()
#pe = all_cells[i]
r = random.uniform(0.0, 1.0)
pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0)
#pop_exc.append(pe)
#pop_exc = sim.Population(pop_exc)
for pi in index_inh:
pi = all_cells[pi]
#print(pi)
#pi = all_cells[i]
r = random.uniform(0.0, 1.0)
pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0)
#pop_inh.append(pi)
#pop_inh = sim.Population(pop_inh)
'''
for pe in pop_exc:
r = random.uniform(0.0, 1.0)
pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0)
for pi in pop_inh:
r = random.uniform(0.0, 1.0)
pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0)
'''
NEXC = len(num_exc)
NINH = len(num_inh)
exc_syn = sim.StaticSynapse(weight = wg, delay=delay_distr)
assert np.any(internal_conn_ee.conn_list[:,0]) < ee_srcs.size
prj_exc_exc = sim.Projection(all_cells, all_cells, internal_conn_ee, exc_syn, receptor_type='excitatory')
prj_exc_inh = sim.Projection(all_cells, all_cells, internal_conn_ei, exc_syn, receptor_type='excitatory')
inh_syn = sim.StaticSynapse(weight = wg, delay=delay_distr)
delay_distr = RandomDistribution('normal', [1, 100e-3], rng=rng)
prj_inh_inh = sim.Projection(all_cells, all_cells, internal_conn_ii, inh_syn, receptor_type='inhibitory')
prj_inh_exc = sim.Projection(all_cells, all_cells, internal_conn_ie, inh_syn, receptor_type='inhibitory')
inh_distr = RandomDistribution('normal', [1, 2.1e-3], rng=rng)
def prj_change(prj,wg):
prj.setWeights(wg)
prj_change(prj_exc_exc,wg)
prj_change(prj_exc_inh,wg)
prj_change(prj_inh_exc,wg)
prj_change(prj_inh_inh,wg)
def prj_check(prj):
for w in prj.weightHistogram():
for i in w:
print(i)
prj_check(prj_exc_exc)
prj_check(prj_exc_inh)
prj_check(prj_inh_exc)
prj_check(prj_inh_inh)
#print(rheobase['value'])
#print(float(rheobase['value']),1.25/1000.0)
'''Old values that worked
noise = sim.NoisyCurrentSource(mean=0.85/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_exc.inject(noise)
#1000.0 pA
noise = sim.NoisyCurrentSource(mean=1.740/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_inh.inject(noise)
#1750.0 pA
'''
noise = sim.NoisyCurrentSource(mean=0.74/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_exc.inject(noise)
#1000.0 pA
noise = sim.NoisyCurrentSource(mean=1.440/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_inh.inject(noise)
##
# Setup and run a simulation. Note there is no current injection into the neuron.
# All cells in the network are in a quiescent state, so its not a surprise that xthere are no spikes
##
sim = pyNN.neuron
arange = np.arange
import re
all_cells.record(['v','spikes']) # , 'u'])
all_cells.initialize(v=-65.0, u=-14.0)
# === Run the simulation =====================================================
tstop = 2000.0
sim.run(tstop)
data = None
data = all_cells.get_data().segments[0]
#print(len(data.analogsignals[0].times))
with open('pickles/qi'+str(wg)+'.p', 'wb') as f:
pickle.dump(data,f)
# make data none or else it will grow in a loop
all_cells = None
data = None
noise = None
def apply_constraints(self,
kind="inhibitory",
w_range=[-0.2, -0.0],
d_range=[2.0, 2.0],
random_cons=False,
pAF=0.5):
"""Map constraints list to inhibitory or excitatory connections between neural populations.
The clues_inhibition class variable determines whether clues should receive inhibitory connections or not.
args:
kind: whether constraints are inhibitory or excitatory.
w_range: range for the random distribution of synaptic weights in the form [w_min, w_max].
d_range: range for the random distribution of synaptic delays in the form [d_min, d_max].
random_cons: whether constraints are randomly choosen to be inhibitory or excitatory with probability pAF.
pAF: probability of inhibitory connections, as a probability it should be between 0.0 and 1.0. It only works
when random_cons is True.
"""
delays = RandomDistribution('uniform', d_range)
weights = RandomDistribution('uniform', w_range) # 1.8 2.0 spin_system
if 'weight' in self.constraints[0]:
print msg, '''creating constraints between CSP variables with specified weights and randomly distributed
delays'''
else:
print msg, '''creating constraints between CSP variables with random and uniformelly distributed delays
and weights'''
for constraint in self.constraints:
source = constraint['source']
target = constraint['target']
if random_cons:
kind = np.random.choice(['inhibitory', 'excitatory'],
p=[pAF, 1 - pAF])
#TODO find a way of reducing the next two conditionals, they're equal except for conditioning on target...
#TODO ... being a clue.
if self.clues_inhibition:
connections = []
for n in range(self.size):
for m in range(self.size):
if 'weight' in constraint:
weight = constraint['weight']
else:
weight = weights.next()
connections.append(
(m, n, weight if m // self.core_size == n //
self.core_size else 0.0, delays.next()))
synapses = p.Projection(self.var_pops[source],
self.var_pops[target],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
if self.directed == False:
synapses = p.Projection(self.var_pops[target],
self.var_pops[source],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
elif target not in self.clues[0]:
connections = []
for n in range(self.size):
for m in range(self.size):
if 'weight' in constraint:
weight = constraint['weight']
else:
weight = weights.next()
connections.append(
(m, n, weight if m // self.core_size == n //
self.core_size else 0.0, delays.next()))
synapses = p.Projection(self.var_pops[source],
self.var_pops[target],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
if self.directed == False:
synapses = p.Projection(self.var_pops[target],
self.var_pops[source],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
"tau_syn_E": 5.0,
"tau_syn_I": 5.0,
"v_reset": -70.0,
"v_rest": -65.0,
"v_thresh": -50.0,
}
populations = list()
projections = list()
weight_to_spike = 2.0
delay = RandomDistribution("uniform", parameters=[1, max_delay])
loopConnections = list()
for i in range(0, nNeurons):
delay_value = delay.next()
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay_value)
loopConnections.append(singleConnection)
injectionConnection = [(0, 0, weight_to_spike, 1)]
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"))
projections.append(p.Projection(populations[0], populations[0], p.FromListConnector(loopConnections)))
projections.append(p.Projection(populations[1], populations[0], p.FromListConnector(injectionConnection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
'i_offset': 0.0,
'tau_m': 20.0,
'tau_refrac': 2.0,
'tau_syn_E': 5.0,
'tau_syn_I': 5.0,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -50.0
}
weight_to_spike = 2.0
delay = RandomDistribution("uniform", low=1, high=max_delay)
loopConnections = list()
for i in range(0, nNeurons):
delay_value = delay.next()
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay_value)
loopConnections.append(singleConnection)
injectionConnection = [(0, 0, weight_to_spike, 1)]
spikeArray = {'spike_times': [[0]]}
main_pop = p.Population(
nNeurons, p.IF_curr_exp(**cell_params_lif), label='pop_1')
input_pop = p.Population(
1, p.SpikeSourceArray(**spikeArray), label='inputSpikes_1')
p.Projection(main_pop, main_pop, p.FromListConnector(loopConnections))
p.Projection(input_pop, main_pop, p.FromListConnector(injectionConnection))
main_pop.record(['v', 'gsyn_exc', 'gsyn_inh', 'spikes'])
#import numpy
from pyNN.random import RandomDistribution, NumpyRNG, GSLRNG, NativeRNG
rng = NumpyRNG(seed=824756)
print(rng.next(5, 'normal', {'mu': 1.0, 'sigma': 0.2}))
'''
rng = GSLRNG(seed=824756, type='ranlxd2') # RANLUX algorithm of Luescher
rng.next(5, 'normal', {'mu': 1.0, 'sigma': 0.2})
#fail to import
#error: Cannot import pygsl
#need pygsl package, cannot be installed with pip
'''
gamma = RandomDistribution('gamma', (2.0, 0.3), rng=NumpyRNG(seed=72386))
print(gamma.next(5))
#by name
gamma = RandomDistribution('gamma', k=2.0, theta=0.3, rng=NumpyRNG(seed=72386))
#differece
print(gamma.next())
print(gamma.next(1))
norm = NativeRNG(seed=72386)
print(norm.next(5))
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)
print "%d Creating slow inhibitory population with %d neurons." % (rank, N_Sli)
Sli_net = Population((N_Sli,),IF_cond_exp,cell_params_Sli)
# Creating external input - is this correct on multiple threads?
Pyr_input = []
for sp in range(NP):
print "%d Creating pyramidal cell external input %d with rate %g spikes/s." % (rank, sp, p_rate_pyr)
pyr_poisson = Population((N_Pyr,), SpikeSourcePoisson, {'rate': p_rate_pyr})
import pylab as plt
from signal_prep import *
from pyNN.random import NumpyRNG, RandomDistribution
import numpy as np
sim_duration = 10000. #46349.#
w_max = 0.25 #10.
varying_weights = numpy.load("./weights_to_belt.npy")
ids = RandomDistribution('uniform', (0, 99))
chosen = ids.next(n=12)
chosen_int = [int(id) for id in chosen]
#chosen_int = [380]#single target id
vary_weight_plot(varying_weights,
chosen_int, [],
sim_duration,
plt,
np=numpy,
num_recs=int(np.ceil(sim_duration / 4000)),
ylim=w_max + (w_max / 10.))
weight_dist_plot(varying_weights, 1, plt)
#[spike_trains,duration,Fs]=numpy.load("/home/rjames/Dropbox (The University of Manchester)/EarProject/spike_trains_10sp_2num_5rep.npy")
#spikes_train_an_ms = [(neuron_id,int(1000*(1./22050.)*spike_time)) for (neuron_id,spike_time) in spike_trains]
#psth_plot(plt, numpy.arange(1000), spikes_train_an_ms, bin_width=0.001, duration=sim_duration / 1000.,
# scale_factor=0.001, title="PSTH_AN")
plt.show()
