import nest
import pylab
import numpy
MODULE_PATH= '/afs/nada.kth.se/home/w/u1yxbcfw/tools/NEST/dist/install-nest-2.2.2/lib/nest/ml_module'
nest.Install(MODULE_PATH) # Change ml_module to your module name
model= 'izhik_cond_exp'
n=nest.Create(model)
mm=nest.Create('multimeter')
sd=nest.Create('spike_detector')
nest.SetStatus(mm, {'interval': 0.1, 'record_from': ['V_m']})
rec={}
rec[model] = nest.GetDefaults('izhik_cond_exp')['receptor_types']
dic['nest']['MS']['a'] = 0.01 # (E.M. Izhikevich 2007)
dic['nest']['MS']['b_1'] = -20. # (E.M. Izhikevich 2007)
dic['nest']['MS']['b_2'] = -20. # (E.M. Izhikevich 2007)
dic['nest']['MS']['c'] = -55. # (Humphries, Lepora, et al. 2009)
dic['nest']['MS']['C_m'] = 15.2 # (Humphries, Lepora, et al. 2009) # C izh
dic['nest']['MS']['d'] = 66.9 # (Humphries, Lepora, et al. 2009)
dic['nest']['MS']['E_L'] = -81.85 # (Humphries, Lepora, et al. 2009) # v_r in izh
dic['nest']['MS']['k'] = 1. # (E.M. Izhikevich 2007)
dic['nest']['MS']['V_peak'] = 40. # (E.M. Izhikevich 2007)
dic['nest']['MS']['V_b'] = dic['nest']['MS']['E_L'] # (E.M. Izhikevich 2007)
dic['nest']['MS']['V_th'] = -29.7 # (Humphries, Lepora, et al. 2009)
dic['nest']['MS']['V_m'] = 80.
dic['nest']['MS']['AMPA_1_Tau_decay'] = 12. # (Ellender 2011)
dic['nest']['MS']['AMPA_1_E_rev'] = 0. # (Humphries, Wood, et al. 2009)
w1 = 0.0
return w1
# presynaptic and postsynaptic neurons
neuron_pre = nest.Create("parrot_neuron")
neuron_post = nest.Create("parrot_neuron")
#spike generators
sg_pre = nest.Create("spike_generator")
sg_post = nest.Create("spike_generator")
# spike times
spike_times_pre = [2.0]
spike_times_post = [1.0, 3.0]
nest.SetStatus(sg_pre, {"spike_times": spike_times_pre})
nest.SetStatus(sg_post, {"spike_times": spike_times_post})
# connect spike generators to neurons
syn_dict = {"weight": 1.0, "delay": 1.0}
nest.Connect(sg_pre, neuron_pre, "one_to_one", syn_dict)
nest.Connect(sg_post, neuron_post, "one_to_one", syn_dict)
# STDP connection parameters
tau_plus = 20.0
tau_minus = 20.0
lambd = 0.01
alpha = 1.0
mu_plus = 1.0
mu_minus = 1.0
Wmax = 10.0
neuron2 = nest.Create('iaf_psc_exp', 1, nrn_parameter_dict)
# Create inputs
t_spike_input = 55.
t_step = 50.
step_duration = 0.5
step_amplitude = 60790.
# step_amplitude = 0.
#sine = nest.Create('ac_generator',1,{'amplitude':100.0,'frequency':2.0})
spike_gen = nest.Create("spike_generator",
params={"spike_times": array([t_spike_input])})
step_gen = nest.Create('step_current_generator')
nest.SetStatus(
step_gen, {
'amplitude_times': array([t_step, t_step + step_duration]),
'amplitude_values': array([step_amplitude, 0.])
})
# step_amplitude is in [pA]
# needs a large value to produce a spike
# Create voltmeter and spike recorder
voltmeter = nest.Create('voltmeter', 1, {'withgid': True})
spike_rec = nest.Create('spike_detector')
###################################
# Connect nodes
###################################
# Connect spike generator to neuron
# Note: The connection weight is given in [pA]
def __init__(self, prefix, new_pars=[], pars_file=[]):
'''Creates and simulates a network in NEST'''
#Temporary way to run without the selected pars file
pars_file = []
start_build_net = time.time()
if pars_file == []: # import generic params_d file
import params_d_hysterisis
reload(params_d_hysterisis)
pars = params_d_hysterisis.Parameters(new_pars)
else: # import specific params_d file
fobj, pathname, description = imp.find_module(pars_file)
params_d_sp = imp.load_module(pars_file, fobj, pathname,
description)
pars = params_d_sp.Parameters(new_pars)
self.T_sim = pars.T_sim + pars.T_wup + pars.T_cdown
#self.record_spikes = pars.record_spikes
self.record_vm = pars.record_vm
self.recorders = {}
self.events = {'spikes': [], 'vm': []}
self.pars = pars
self.pars.prefix = prefix
# INITIALIZE NETWORK -----------------------------------------------------------------------
nest_path_tmp = tempfile.mktemp(prefix=pars.nest_path_tmp)
os.mkdir(nest_path_tmp)
nest.ResetKernel()
shutil.rmtree(nest.GetStatus([0], 'data_path')[0], ignore_errors=True)
nest.SetStatus(
[0], {
'resolution': pars.dt,
'print_time': pars.print_time,
'overwrite_files': pars.owr_files,
'rng_seeds': [int(pars.rnd_seeds)],
'data_path': nest_path_tmp
})
print '\nBuilding network...'
# CREATE SOURCES ----------------------------------------------------------------------------
self.pg_exc = nest.Create('poisson_generator', 1)
self.pg_inh = nest.Create('poisson_generator', 1)
nest.SetStatus(self.pg_exc, {
'rate': pars.pg_rate_exc,
'stop': pars.T_sim + pars.T_wup
})
nest.SetStatus(self.pg_inh, {
'rate': pars.pg_rate_inh,
'stop': pars.T_sim + pars.T_wup
})
self.dc1_exc = nest.Create('dc_generator', 1)
nest.SetStatus(self.dc1_exc, pars.dc1_pars)
self.dc2_exc = nest.Create('dc_generator', 1)
nest.SetStatus(self.dc2_exc, pars.dc2_pars)
# CREATE POPULATIONS -----------------------------------------------------------------------
print 'Creating populations...\n'
neurons = []
self.pops = range(len(pars.N))
for ii, nr in enumerate(pars.N):
self.pops[ii] = nest.Create(pars.model_type, abs(nr))
neurons.extend(self.pops[ii])
# set neuron parameters for every population independently
for ntypes in range(len(pars.N)):
nest.SetStatus(self.pops[ntypes], pars.neuron_params[ntypes])
if pars.rnd_dist:
nest.SetStatus(neurons, 'tau_m', pars.tau_m_rnd)
# Make connections -------------------------------------------------------------------------
self.exc_pop = self.pops[0]
#Create AC generator
self.shu_gen = nest.Create('poisson_generator',
params={
'rate': self.pars.shu_input,
'start': pars.st_val,
'stop': pars.st_val + 7 * pars.shu_width
})
J_exc = pars.J_exc
J_inh = pars.J_inh
total_neu = [item for sublist in self.pops for item in sublist]
nest.DivergentConnect(self.pg_exc,
self.exc_pop,
weight=pars.J_exc,
delay=pars.min_del)
for pop in self.pops[1:]:
nest.DivergentConnect(self.pg_inh,
pop,
weight=pars.J_exc,
delay=pars.min_del)
for pop2 in self.pops:
self.n_exc = int(pars.epsilon * len(pop2))
nest.RandomDivergentConnect(self.exc_pop,
pop2,
self.n_exc,
weight=J_exc,
delay=pars.delay)
for pop3 in self.pops:
self.n_inh = int(pars.epsilon * len(pop3))
nest.RandomDivergentConnect(self.pops[1],
pop3,
self.n_inh,
weight=J_inh,
delay=pars.delay)
if len(self.pops) > 2:
nest.RandomDivergentConnect(self.pops[2],
pop3,
self.n_inh,
weight=J_inh,
delay=pars.delay)
#CREATE RECORDERS----------------------------------------------------------------------------
self.record_spikes = list(
np.arange(self.pops[0][0], self.pops[-1][-1] + 1))
#if self.record_spikes!= []:
sd = nest.Create('spike_detector', 1)
nest.SetStatus(sd, {'to_file': True, 'to_memory': True})
nest.ConvergentConnect(self.record_spikes, sd)
self.recorders['sd'] = sd
if self.pars.record_vm != []:
vm = nest.Create('voltmeter', 1)
print 'Id of vm recorder: ', vm
nest.SetStatus(
vm, {
'withtime': True,
'withgid': True,
'to_file': True,
'to_memory': False
})
nest.DivergentConnect(vm, self.pars.record_vm)
nest.SetStatus(self.pars.record_vm,
{'V_th': 1000.}) # record free Vm
self.recorders['vm'] = vm
self.build_net_time = time.time() - start_build_net
def test_QuantalSTPSynapse(self):
"""Compare quantal_stp_synapse with its deterministic equivalent"""
nest.ResetKernel()
nest.rng_seed = 1
nest.set_verbosity(100)
n_syn = 12 # number of synapses in a connection
n_trials = 100 # number of measurement trials
# parameter set for facilitation
fac_params = {
"U": 0.03,
"u": 0.03,
"tau_fac": 500.,
"tau_rec": 200.,
"weight": 1.
}
# Here we assign the parameter set to the synapse models
t1_params = fac_params # for tsodyks2_synapse
t2_params = t1_params.copy() # for furhmann_synapse
t1_params["synapse_model"] = "tsodyks2_synapse"
t2_params["n"] = n_syn
t2_params["weight"] = 1. / n_syn
t2_params["synapse_model"] = "quantal_stp_synapse"
source = nest.Create("spike_generator")
source.spike_times = [
30., 60., 90., 120., 150., 180., 210., 240., 270., 300., 330.,
360., 390., 900.
]
parrot = nest.Create("parrot_neuron")
neuron = nest.Create("iaf_psc_exp",
2,
params={
"tau_syn_ex": 3.,
"tau_m": 70.
})
# We must send spikes via parrot because devices cannot
# connect through plastic synapses
# See #478.
nest.Connect(source, parrot)
nest.Connect(parrot, neuron[:1], syn_spec=t1_params)
nest.Connect(parrot, neuron[1:], syn_spec=t2_params)
voltmeter = nest.Create("voltmeter", 2)
t_tot = 1500.
# the following is a dry run trial so that the synapse dynamics is
# idential in all subsequent trials.
nest.Simulate(t_tot)
# Now we connect the voltmeters
nest.Connect(voltmeter[:1], neuron[:1])
nest.Connect(voltmeter[1:], neuron[1:])
for t in range(n_trials):
t_net = nest.biological_time
nest.SetStatus(source, {"origin": t_net})
nest.Simulate(t_tot)
nest.Simulate(.1) # flush the last voltmeter events from the queue
vm = numpy.array(voltmeter[1].events["V_m"])
vm_reference = numpy.array(voltmeter[0].events["V_m"])
assert (len(vm) % n_trials == 0)
n_steps = int(len(vm) / n_trials)
vm.shape = (n_trials, n_steps)
vm_reference.shape = (n_trials, n_steps)
vm_mean = numpy.mean(vm, axis=0)
vm_ref_mean = numpy.mean(vm_reference, axis=0)
error = numpy.sqrt((vm_ref_mean - vm_mean)**2)
self.assertLess(numpy.max(error), 4.0e-4)
def simulateMultiareaNetwork(simtime, dt, master_seed, num_threads,
V0_mean, V0_std, network_config):
"""Build a multi-area network and simulate it.
Parameters:
simtime simulation time in ms
dt simulation timestep in ms
master_seed master seed for random numbers
num_threads number of threads per MPI process
V0_mean mean initial membrane potential
V0_std standard deviation of initial membrane potential
network_config keyword arguments for buildBrunel
Returns:
spikes: dict of spike senders / spike times of all
neurons in all populations
"""
# configure kernel
nest.ResetKernel()
nest.SetKernelStatus({
'local_num_threads': num_threads, 'resolution': dt, 'print_time': False
})
# seed all random number generators
if nest.Rank() == 0:
print('Master seed: %i ' % master_seed)
N_tp = nest.GetKernelStatus(['total_num_virtual_procs'])[0]
if nest.Rank() == 0:
print('Total number of processes: %i' % N_tp)
pyrng_seeds = list(range(master_seed, master_seed+N_tp))
grng_seed = master_seed + N_tp
rng_seeds = list(range(master_seed+1+N_tp, master_seed+1+2*N_tp))
pyrngs = [np.random.RandomState(s) for s in pyrng_seeds]
nest.SetKernelStatus({'grng_seed': grng_seed, 'rng_seeds': rng_seeds})
# build the Brunel network
_, neurons, spike_detectors = buildMultiareaNetwork(**network_config)
# distribute initial voltages
for thread in np.arange(nest.GetKernelStatus('local_num_threads')):
# Using GetNodes is a work-around until NEST 3.0 is released. It
# will issue a deprecation warning.
local_nodes = nest.GetNodes([0], {'model': 'iaf_psc_exp',
'thread': thread},
local_only=True)[0]
vp = nest.GetStatus(local_nodes)[0]['vp']
# vp is the same for all local nodes on the same thread
nest.SetStatus(
local_nodes, 'V_m', pyrngs[vp].normal(
V0_mean, V0_std, len(local_nodes)
)
)
if nest.Rank() == 0:
print('Number of local nodes: %i' % len(local_nodes))
# simulate
nest.Simulate(simtime)
# read out spikes from spikedetectors
spikes = {}
for pop in spike_detectors:
data = nest.GetStatus(spike_detectors[pop], 'events')[0]
spikes[pop] = {
'ids': data['senders'], 'times': data['times'],
'min_id': neurons[pop][0], 'max_id': neurons[pop][-1]
}
return spikes
def column(setdegree, LGN):
""""
Visual Cortex (V1) Oriented Column -
This function creates a cortical column trained with a specific orientation (pre-trained 'soma_exc' IE values)
The column is composed by:
- Pyramidal (Pyr) layer 2/3
- Inhibitory interneurons(inh) layer 2/3
- Spiny Stellate Cells(SS) layer 4
- Inhibitory interneurons layer 4
- Pyramidal layer 5
- Inhibitory interneurons layer 5
- Pyramidal layer 6
- Inhibitory interneurons layer 6
"""
import matplotlib.pyplot as plt
import matplotlib
import pickle
import gzip
import numpy
import nest
import nest.raster_plot
import numpy as np
import scipy.io
import pickle
if not 'lifl_psc_exp_ie' in nest.Models():
nest.Install('LIFL_IEmodule')
SS4 = nest.Create(
'lifl_psc_exp_ie',
324,
{
'I_e': 0.0, # 122.1
'V_m': -70.0,
'E_L': -65.0,
'V_th': -50.0,
'V_reset': -65.0,
'C_m': 250.0,
'tau_m': 10.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 2.0,
'std_mod': False,
'lambda': 0.0005,
'tau': 12.5,
})
lgn2v1_delay = 1.0 # Delay from LGN to Cortex
nest.Connect(LGN, SS4, {'rule': 'one_to_one'}, {
"weight": 15000.0,
"delay": lgn2v1_delay
})
# Target neuron. Connections are set in order to produce a target spike only in pattern detection.
Pyr23 = nest.Create(
'aeif_psc_exp_peak', 324, {
'I_e': 0.0,
'V_m': -70.0,
'E_L': -70.0,
'V_th': -50.0,
'V_reset': -55.0,
'C_m': 250.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 2.0,
'g_L': 980.0
})
for idn in Pyr23:
nest.SetStatus([idn], {'V_m': (-65.0 + np.random.rand() * 10.0)})
Pyr5 = nest.Create(
'aeif_psc_exp_peak', 81, {
'I_e': 0.0,
'V_m': -70.0,
'E_L': -70.0,
'V_th': -50.0,
'V_reset': -55.0,
'C_m': 250.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 2.0,
'g_L': 980.0
})
for idn in Pyr5:
nest.SetStatus([idn], {'V_m': (-65.0 + np.random.rand() * 10.0)})
Pyr6 = nest.Create(
'aeif_psc_exp_peak', 243, {
'I_e': 0.0,
'V_m': -70.0,
'E_L': -70.0,
'V_th': -50.0,
'V_reset': -55.0,
'C_m': 250.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 2.0,
'g_L': 980.0
})
for idn in Pyr6:
nest.SetStatus([idn], {'V_m': (-65.0 + np.random.rand() * 10.0)})
# Poisson Noise Generators
poisson_activityL23 = nest.Create('poisson_generator', 1)
nest.SetStatus(poisson_activityL23, {'rate': 1721500.0})
poisson_activityL5 = nest.Create('poisson_generator', 1)
nest.SetStatus(poisson_activityL5, {'rate': 1740000.0})
poisson_activityL6 = nest.Create('poisson_generator', 1)
nest.SetStatus(poisson_activityL6, {'rate': 1700000.0})
poisson_activityInh = nest.Create('poisson_generator', 1)
nest.SetStatus(poisson_activityInh, {'rate': 1750000.0})
nest.Connect(poisson_activityL23, Pyr23, {'rule': 'all_to_all'},
{"weight": 5.0})
nest.Connect(poisson_activityL5, Pyr5, {'rule': 'all_to_all'},
{"weight": 5.0})
nest.Connect(poisson_activityL6, Pyr6, {'rule': 'all_to_all'},
{"weight": 5.0})
# FeedForward
nest.Connect(Pyr23, Pyr5, {
'rule': 'fixed_indegree',
'indegree': 15
}, {
"weight": 100.0,
"delay": 1.0
})
nest.Connect(Pyr5, Pyr6, {
'rule': 'fixed_indegree',
'indegree': 20
}, {
"weight": 100.0,
"delay": 1.0
})
## Connections between layers
nest.Connect(Pyr23, Pyr23, {
'rule': 'fixed_indegree',
'indegree': 36
}, {
"weight": 100.0,
"delay": 1.0
})
nest.Connect(Pyr5, Pyr5, {
'rule': 'fixed_indegree',
'indegree': 10
}, {
"weight": 100.0,
"delay": 1.0
})
nest.Connect(Pyr6, Pyr6, {
'rule': 'fixed_indegree',
'indegree': 20
}, {
"weight": 100.0,
"delay": 1.0
})
In4 = nest.Create(
'aeif_psc_exp_peak', 65, {
'I_e': 0.0,
'V_m': -70.0,
'E_L': -70.0,
'V_th': -50.0,
'V_reset': -55.0,
'C_m': 250.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 1.0,
'g_L': 980.0
})
nest.Connect(poisson_activityInh, In4, {'rule': 'all_to_all'},
{"weight": 4.9})
nest.Connect(SS4, In4, {
'rule': 'fixed_indegree',
'indegree': 32
}, {
"weight": 100.0,
"delay": 1.0
})
nest.Connect(In4, SS4, {
'rule': 'fixed_indegree',
'indegree': 6
}, {
"weight": -100.0,
"delay": 1.0
})
nest.Connect(In4, In4, {
'rule': 'fixed_indegree',
'indegree': 6
}, {
"weight": -100.0,
"delay": 1.0
})
poisson_activity_inh = nest.Create('poisson_generator', 1)
nest.SetStatus(poisson_activity_inh, {'rate': 340000.0})
In23 = nest.Create(
'aeif_psc_exp_peak', 65, {
'I_e': 0.0,
'V_m': -70.0,
'E_L': -70.0,
'V_th': -50.0,
'V_reset': -55.0,
'C_m': 250.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 1.0,
'g_L': 980.0
})
nest.Connect(poisson_activityInh, In23, {'rule': 'all_to_all'},
{"weight": 5.0})
nest.Connect(Pyr23, In23, {
'rule': 'fixed_indegree',
'indegree': 35
}, {
"weight": 100.0,
"delay": 1.0
})
nest.Connect(In23, Pyr23, {
'rule': 'fixed_indegree',
'indegree': 8
}, {
"weight": -100.0,
"delay": 1.0
})
nest.Connect(In23, In23, {
'rule': 'fixed_indegree',
'indegree': 8
}, {
"weight": -100.0,
"delay": 1.0
})
In5 = nest.Create(
'aeif_psc_exp_peak', 16, {
'I_e': 0.0,
'V_m': -70.0,
'E_L': -70.0,
'V_th': -50.0,
'V_reset': -55.0,
'C_m': 250.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 1.0,
'g_L': 980.0
})
nest.Connect(poisson_activityInh, In5, {'rule': 'all_to_all'},
{"weight": 5.0})
nest.Connect(Pyr5, In5, {
'rule': 'fixed_indegree',
'indegree': 30
}, {
"weight": 100.0,
"delay": 1.0
})
nest.Connect(In5, Pyr5, {
'rule': 'fixed_indegree',
'indegree': 8
}, {
"weight": -100.0,
"delay": 1.0
})
nest.Connect(In5, In5, {
'rule': 'fixed_indegree',
'indegree': 8
}, {
"weight": -100.0,
"delay": 1.0
})
In6 = nest.Create(
'aeif_psc_exp_peak', 49, {
'I_e': 0.0,
'V_m': -70.0,
'E_L': -70.0,
'V_th': -50.0,
'V_reset': -55.0,
'C_m': 250.0,
'tau_syn_ex': 2.0,
'tau_syn_in': 2.0,
't_ref': 1.0,
'g_L': 980.0
})
nest.Connect(poisson_activityInh, In6, {'rule': 'all_to_all'},
{"weight": 5.0})
nest.Connect(Pyr6, In6, {
'rule': 'fixed_indegree',
'indegree': 32
}, {
"weight": 100.0,
"delay": 1.0
})
nest.Connect(In6, Pyr6, {
'rule': 'fixed_indegree',
'indegree': 6
}, {
"weight": -100.0,
"delay": 1.0
})
nest.Connect(In6, In6, {
'rule': 'fixed_indegree',
'indegree': 6
}, {
"weight": -100.0,
"delay": 1.0
})
# Here we load the Soma_exc (IE value) trained before for each preferred angle.
exec('file = "./files/soma_exc_15_' + str(setdegree) + '.pckl"', None,
globals())
with open(file, 'rb') as f:
u = pickle._Unpickler(f)
u.encoding = 'latin1'
SS4_soma_exc_raw = u.load()
SS4_soma_exc = SS4_soma_exc_raw[:]
del SS4_soma_exc_raw, setdegree
for i in range(0, 324):
nest.SetStatus([SS4[i]], {'soma_exc': SS4_soma_exc[i]})
k = 0
for j in range(0, 324, 36):
for i in range(0, 18, 2):
# Set stimulator (i.e. Neuromodulator) of each SS cell
nest.SetStatus([SS4[i + j]],
{'stimulator': [SS4[i + j + 1], SS4[i + j + 18]]})
nest.SetStatus([SS4[i + j + 1]],
{'stimulator': [SS4[i + j], SS4[i + j + 19]]})
nest.SetStatus([SS4[i + j + 18]],
{'stimulator': [SS4[i + j], SS4[i + j + 19]]})
nest.SetStatus([SS4[i + j + 19]],
{'stimulator': [SS4[i + j + 18], SS4[i + j + 1]]})
# Connect betwen neuromodulators of SS cell (groups of 4 SS)
nest.Connect([SS4[i + j]], [SS4[i + j + 1]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
nest.Connect([SS4[i + j]], [SS4[i + j + 18]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
nest.Connect([SS4[i + j + 1]], [SS4[i + j]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
nest.Connect([SS4[i + j + 1]], [SS4[i + j + 19]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
nest.Connect([SS4[i + j + 18]], [SS4[i + j]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
nest.Connect([SS4[i + j + 18]], [SS4[i + j + 19]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
nest.Connect([SS4[i + j + 19]], [SS4[i + j + 1]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
nest.Connect([SS4[i + j + 19]], [SS4[i + j + 18]],
{"rule": "one_to_one"}, {
"model": "stdp_synapse",
'delay': 0.1
})
# Connect each group of 4 SS to 4 layer 2/3 Pyramidal Cells so that each pyramidal only fire on polychrony arrival of SS fires
nest.Connect(
[SS4[i + j], SS4[i + j + 1], SS4[i + j + 18], SS4[i + j + 19]],
[
Pyr23[i + j], Pyr23[i + j + 1], Pyr23[i + j + 2],
Pyr23[i + j + 3]
], {"rule": "all_to_all"}, {
"weight": 100.0,
"delay": 1.0
})
k += 1
# We create a Detector so that we can get spike times and raster plot
Detector = nest.Create('spike_detector')
nest.Connect(Pyr5, Detector)
nest.Connect(Pyr6, Detector)
nest.Connect(SS4, Detector)
nest.Connect(Pyr23, Detector)
nest.Connect(In23, Detector)
nest.Connect(In4, Detector)
nest.Connect(In5, Detector)
nest.Connect(In6, Detector)
Spikes = nest.Create('spike_detector')
nest.Connect(Pyr23, Spikes)
nest.Connect(Pyr5, Spikes)
nest.Connect(Pyr6, Spikes)
Multimeter = nest.Create('multimeter',
params={
'withtime': True,
'record_from': ['V_m', 'I_syn_ex'],
'interval': 0.1
})
nest.Connect(Multimeter, Pyr23)
nest.Connect(Multimeter, Pyr5)
nest.Connect(Multimeter, SS4)
nest.Connect(Multimeter, Pyr6)
SomaMultimeter = nest.Create('multimeter',
params={
'withtime': True,
'record_from': ['soma_exc'],
'interval': 0.1
})
nest.Connect(SomaMultimeter, SS4)
return Detector, Spikes, Multimeter, SomaMultimeter, Pyr23, SS4, Pyr5, Pyr6, In23, In4, In5, In6
neuronparams = {
'tau_m': 20.,
'V_th': 20.,
'E_L': 10.,
't_ref': 2.,
'V_reset': 0.,
'C_m': 200.,
'V_m': 0.
}
neurons = nest.Create('iaf_psc_alpha', N)
sd = nest.Create('spike_detector')
noise = nest.Create('noise_generator')
drive = nest.Create('ac_generator')
nest.SetStatus(drive, driveparams)
nest.SetStatus(noise, noiseparams)
nest.SetStatus(neurons, neuronparams)
nest.SetStatus(neurons, [{
'I_e': (n * (bias_end - bias_begin) / N + bias_begin)
} for n in neurons])
nest.SetStatus(sd, {"withgid": True, "withtime": True})
nest.DivergentConnect(drive, neurons)
nest.DivergentConnect(noise, neurons)
nest.ConvergentConnect(neurons, sd)
nest.Simulate(T)
nest.raster_plot.from_device(sd, hist=True)
def _convergent_connect(self, presynaptic_indices, postsynaptic_index,
**connection_parameters):
"""
Connect a neuron to one or more other neurons with a static connection.
`presynaptic_indices` - 1D array of presynaptic indices
`postsynaptic_index` - integer - the index of the postsynaptic neuron
`connection_parameters` - dict whose keys are native NEST parameter names. Values may be scalars or arrays.
"""
# Clean the connection parameters by removing parameters that are
# used by PyNN but should not be passed to NEST
connection_parameters.pop(
'tau_minus',
None) # TODO: set tau_minus on the post-synaptic cells
connection_parameters.pop('dendritic_delay_fraction', None)
connection_parameters.pop('w_min_always_zero_in_NEST', None)
syn_dict = {
'synapse_model': self.nest_synapse_model,
'synapse_label': self.nest_synapse_label,
}
# Weights require some special handling
if self.receptor_type == 'inhibitory' and self.post.conductance_based:
connection_parameters[
'weight'] *= -1 # NEST wants negative values for inhibitory weights, even if these are conductances
if "stdp" in self.nest_synapse_model:
syn_dict[
"Wmax"] = -1.2345e6 # just some very large negative value to avoid
# NEST complaining about weight and Wmax having different signs
# (see https://github.com/NeuralEnsemble/PyNN/issues/636)
# Will be overwritten below.
connection_parameters["Wmax"] *= -1
if hasattr(self.post, "celltype") and hasattr(
self.post.celltype,
"receptor_scale"): # this is a bit of a hack
connection_parameters[
'weight'] *= self.post.celltype.receptor_scale # needed for the Izhikevich model
# Prepare connections. NodeCollections can't have repeated values, so for some
# connector types we need to split the presynaptic cells into groups that
# don't have such repeats.
# note that NEST needs sorted indices
sort_indices = presynaptic_indices.argsort()
presynaptic_indices = presynaptic_indices[sort_indices]
for name, value in connection_parameters.items():
if isinstance(value, np.ndarray):
connection_parameters[name] = value[sort_indices]
try:
presynaptic_cell_groups = [
self.pre.node_collection[presynaptic_indices]
]
connection_parameter_groups = [connection_parameters]
except ValueError as err:
if "All node IDs in a NodeCollection have to be unique" in str(
err):
presynaptic_index_groups, connection_parameter_groups = \
split_array_to_avoid_repeats(presynaptic_indices, **connection_parameters)
presynaptic_cell_groups = [
self.pre.node_collection[i]
for i in presynaptic_index_groups
]
else:
raise
postsynaptic_cell = self.post[postsynaptic_index]
# Create connections and set parameters
for presynaptic_cells, connection_parameter_group in zip(
presynaptic_cell_groups, connection_parameter_groups):
self._sources.update(presynaptic_cells.tolist())
try:
weights = connection_parameter_group.pop('weight')
delays = connection_parameter_group.pop('delay')
# nest.Connect expects a 2D array
if not np.isscalar(weights):
weights = np.array([weights])
if not np.isscalar(delays):
delays = np.array([delays])
syn_dict.update({'weight': weights, 'delay': delays})
if postsynaptic_cell.celltype.standard_receptor_type:
# For Tsodyks-Markram synapses models we set the "tau_psc" parameter to match
# the relevant "tau_syn" parameter from the post-synaptic neuron.
if 'tsodyks' in self.nest_synapse_model:
if self.receptor_type == 'inhibitory':
param_name = postsynaptic_cell.celltype.translations[
'tau_syn_I']['translated_name']
elif self.receptor_type == 'excitatory':
param_name = postsynaptic_cell.celltype.translations[
'tau_syn_E']['translated_name']
else:
raise NotImplementedError()
syn_dict["tau_psc"] = nest.GetStatus(
postsynaptic_cell.node_collection, param_name)[0]
else:
syn_dict.update({
"receptor_type":
postsynaptic_cell.celltype.get_receptor_type(
self.receptor_type)
})
# For parameters other than weight and delay, we need to know if they are "common"
# parameters (the same for all synapses) or "local" (different synapses can have
# different values), as this affects how they are set.
#
# To introspect which parameters are common, we need an existing connection, so
# the first time we create connections we pass just the weight and delay, and set
# the other parameters later. We then get the list of common parameters and cache
# it so that in subsequent Connect() calls we can pass all of the local
# (non-common) parameters.
if self._common_synapse_property_names is None:
nest.Connect(presynaptic_cells,
postsynaptic_cell.node_collection,
'all_to_all', syn_dict)
self._identify_common_synapse_properties()
# Retrieve connections so that we can set additional
# parameters using nest.SetStatus
connections = nest.GetConnections(
source=presynaptic_cells,
target=postsynaptic_cell.node_collection,
synapse_model=self.nest_synapse_model,
synapse_label=self.nest_synapse_label)
for name, value in connection_parameter_group.items():
if name not in self._common_synapse_property_names:
value = make_sli_compatible(value)
if isinstance(value, np.ndarray):
nest.SetStatus(connections, name,
value.tolist())
else:
nest.SetStatus(connections, name, value)
else:
self._set_common_synapse_property(name, value)
else:
# Since we know which parameters are common, we can set the non-common
# parameters directly in the nest.Connect call
syn_dict = self._update_syn_params(
syn_dict, connection_parameter_group)
nest.Connect(presynaptic_cells,
postsynaptic_cell.node_collection,
'all_to_all', syn_dict)
# and then set the common parameters
for name, value in connection_parameter_group.items():
if name in self._common_synapse_property_names:
self._set_common_synapse_property(name, value)
except nest.kernel.NESTError as e:
errmsg = "%s. presynaptic_cells=%s, postsynaptic_cell=%s, weights=%s, delays=%s, synapse model='%s'" % (
e, presynaptic_cells, postsynaptic_cell, weights, delays,
self.nest_synapse_model)
raise errors.ConnectionError(errmsg)
# Reset the caching of the connection list, since this will have to be recalculated
self._connections = None
self._simulator.state.stale_connection_cache = True
import pyNN.nest as sim
import numpy
import nest
__population_views = {}
pop1 = sim.Population(10, sim.IF_cond_alpha())
__population_views['pop1'] = pop1
source = sim.Population(1, sim.SpikeSourcePoisson(rate=1000000.0))
nest_source = nest.Create('poisson_generator')
nest.SetStatus(nest_source, {'rate': 100000.0})
nest.Connect(nest_source, map(int, pop1.all_cells), 'all_to_all')
print "Network loaded"
'''
nest.CopyModel("static_synapse", "spike_det", {
"weight": var.JE,
"delay": var.delay
})
'''
Creates a spike detector layer. Each population is read out simultaneously and added to the
file - ::file:: - whilst reading out note the neural order.
'''
pop_A1, pop_A2, excRec, inhRec, noise = tools.layerNet()
nest.SetStatus(excRec, [{
'label': "Excitatory-" + var.date + "_" + var.time,
"withtime": True,
"withgid": True,
"to_file": True
}])
nest.SetStatus(inhRec, [{
'label': "Inhibitory-" + var.date + "_" + var.time,
"withtime": True,
"withgid": True,
"to_file": True
}])
print("Finished Preparing Defaults")
'''
The nodes from each topology layer are read out using nest.GetNodes, the resulting list
is used to establish a connection between neurons given the adjacency dictionary created
in truConnect
'''
#! layer, since they will differ from layer to layer. We will add them
#! below by updating the ``'elements'`` dictionary entry for each
#! population.
#! Retina
#! ------
layerProps.update({'elements': 'RetinaNode'})
retina = topo.CreateLayer(layerProps)
#! Now set phases of retinal oscillators; we use a list comprehension instead
#! of a loop.
[
nest.SetStatus(
[n], {
"phi":
phiInit(
topo.GetPosition([n])[0], Params["lambda_dg"],
Params["phi_dg"])
}) for n in nest.GetLeaves(retina)[0]
]
#! Thalamus
#! --------
#! We first introduce specific neuron models for the thalamic relay
#! cells and interneurons. These have identical properties, but by
#! treating them as different models, we can address them specifically
#! when building connections.
#!
#! We use a list comprehension to do the model copies.
[
import nest
from sklearn.svm import LinearSVC
from scipy.special import erf
print("heloooooo")
neuron = nest.Create("iaf_psc_alpha")
#neuron2=nest.Create("iaf_psc_alpha") checking how the id numbers goes for nodes in order of creation
#voltmeter=nest.Create("voltmeter")
#neuron3=nest.Create("iaf_psc_alpha")
cu = nest.GetStatus(neuron, "I_e")
vth = nest.GetStatus(neuron, ["V_m", "V_th"])
multimeter = nest.Create("multimeter")
nest.SetStatus(multimeter, {"withtime": True, "record_from": ["V_m"]})
nest.Connect(multimeter, neuron)
nest.Simulate(1000)
with open(file, 'rb') as f:
#with open('/Users/alex/Documents/IJASEIT Implementation of MNSD in NEST/Vision Pattern Decodificator/spikes_gabor_18_Final_rnd/spikes_gabor_18_randn02_19.pckl', 'rb') as f:
u = pickle._Unpickler(f)
u.encoding = 'latin1'
resultados = u.load()
senders = resultados['senders']
times = resultados[
'times'] # We give some randomness to spike times. (Avoiding spikes to be equal)
GCells = len(senders)
spikingGanglion = range(min(senders),
max(senders) + 1, 1)
inputs = nest.Create("spike_generator", GCells)
for i in range(0, GCells):
spike_time = times[senders == spikingGanglion[i]]
nest.SetStatus([inputs[i]], {'spike_times': spike_time.tolist()})
print(i, times[senders == spikingGanglion[i]])
Ganglions = nest.Create('parrot_neuron', GCells)
nest.Connect(inputs, Ganglions, 'one_to_one')
Decoders = nest.Create('lif_psc_alpha_sl_ip', GCells, {
'tau_syn': 0.5,
'lambda': 0.0006,
'tau_decay': 0.02,
'tau': 50.0
})
nest.Connect(
Ganglions, Decoders, {'rule': 'one_to_one'}, {"weight": 3700.0}
) # 3100.0 tuple(np.random.permutation(Decoders)) //// We can permutate the connections to biologically randomice pixel-detector.
def create_populations(self):
""" Creates the neuronal populations.
The neuronal populations are created and the parameters are assigned
to them. The initial membrane potential of the neurons is drawn from a
normal distribution. Scaling of the number of neurons and of the
synapses is performed. If scaling is performed extra DC input is added
to the neuronal populations.
"""
self.N_full = self.net_dict['N_full']
self.N_scaling = self.net_dict['N_scaling']
self.K_scaling = self.net_dict['K_scaling']
self.synapses = get_total_number_of_synapses(self.net_dict)
self.synapses_scaled = self.synapses * self.K_scaling
self.nr_neurons = self.N_full * self.N_scaling
self.K_ext = self.net_dict['K_ext'] * self.K_scaling
self.background_pool_size = self.net_dict[
'background_pool_size'] * self.K_scaling
self.w_from_PSP = get_weight(self.net_dict['PSP_e'], self.net_dict)
self.weight_mat = get_weight(self.net_dict['PSP_mean_matrix'],
self.net_dict)
self.weight_mat_std = self.net_dict['PSP_std_matrix']
self.w_ext = self.w_from_PSP
# self.w_input = get_weight(self.net_dict['input_conn_params']['JE'], self.net_dict)
# self.w_input = self.net_dict['input_conn_params']['JE']
self.w_input = self.net_dict['input_conn_params'][
'JE'] * self.net_dict['neuron_params'][
'tau_syn_ex'] / self.net_dict['neuron_params']['C_m'] * 1e6
print('w_input', self.w_input)
# if self.net_dict['poisson_input']:
# self.DC_amp_e = np.zeros(len(self.net_dict['populations']))
# else:
# if nest.Rank() == 0:
# print(
# '''
# no poisson input provided
# calculating dc input to compensate
# '''
# )
self.DC_amp_e = compute_DC(self.net_dict,
self.w_ext) # always use external input
if self.net_dict['poisson_input'] or self.net_dict[
'poisson_pool_input'] or self.net_dict['network_input']:
KE_ext = self.K_ext * self.net_dict['input_conn_params']['gamma']
KI_ext = self.K_ext * (1. -
self.net_dict['input_conn_params']['gamma'])
# if self.net_dict['network_input']:
offset = KE_ext * self.w_input * self.net_dict['network_rate'] * self.net_dict['neuron_params']['tau_syn_ex'] + \
-1. * KI_ext * self.net_dict['input_conn_params']['g'] * self.w_input * self.net_dict['network_rate'] * self.net_dict['neuron_params']['tau_syn_in']
# else:
# offset = KE_ext * JE_ext * self.net_dict['bg_rate'] * self.net_dict['neuron_params']['tau_syn_ex'] + \
# -1. * KI_ext * JI_ext * self.net_dict['bg_rate'] * self.net_dict['neuron_params']['tau_syn_in']
# print(self.DC_amp_e, offset * 1e-3)
# exit()
self.DC_amp_e -= (offset * 1e-3)
if nest.Rank() == 0:
print('The number of neurons is scaled by a factor of: %.2f' %
self.N_scaling)
print('The number of synapses is scaled by a factor of: %.2f' %
self.K_scaling)
# Scaling of the synapses.
if self.K_scaling != 1:
synapses_indegree = self.synapses / (
self.N_full.reshape(len(self.N_full), 1) * self.N_scaling)
self.weight_mat, self.w_ext, self.DC_amp_e = adj_w_ext_to_K(
synapses_indegree, self.K_scaling, self.weight_mat,
self.w_from_PSP, self.DC_amp_e, self.net_dict, self.stim_dict)
# Create cortical populations.
self.pops = []
pop_file = open(os.path.join(self.data_path, 'population_GIDs.dat'),
'w+')
for i, pop in enumerate(self.net_dict['populations']):
population = nest.Create(self.net_dict['neuron_model'],
int(self.nr_neurons[i]))
nest.SetStatus(
population, {
'tau_syn_ex': self.net_dict['neuron_params']['tau_syn_ex'],
'tau_syn_in': self.net_dict['neuron_params']['tau_syn_in'],
'E_L': self.net_dict['neuron_params']['E_L'],
'V_th': self.net_dict['neuron_params']['V_th'],
'V_reset': self.net_dict['neuron_params']['V_reset'],
't_ref': self.net_dict['neuron_params']['t_ref'],
'I_e': self.DC_amp_e[i]
})
self.pops.append(population)
pop_file.write('%d %d \n' % (population[0], population[-1]))
pop_file.close()
for thread in np.arange(nest.GetKernelStatus('local_num_threads')):
# Using GetNodes is a work-around until NEST 3.0 is released. It
# will issue a deprecation warning.
local_nodes = nest.GetNodes([0], {
'model': self.net_dict['neuron_model'],
'thread': thread
},
local_only=True)[0]
vp = nest.GetStatus(local_nodes)[0]['vp']
# vp is the same for all local nodes on the same thread
nest.SetStatus(
local_nodes, 'V_m', self.pyrngs[vp].normal(
self.net_dict['neuron_params']['V0_mean'],
self.net_dict['neuron_params']['V0_sd'], len(local_nodes)))
def _set_initial_value_array(self, variable, value):
local_value = value.evaluate(simplify=True)
nest.SetStatus(self.nest_connections, variable, local_value)
"""Init File. Imports nest and sets up a poisson generator, neuron, and voltmeter"""
import nest
import nest.voltage_trace
nest.set_verbosity("M_WARNING")
nest.ResetKernel()
neuron = nest.Create("iaf_psc_alpha")
noise = nest.Create("poisson_generator", 2)
voltmeter = nest.Create("voltmeter")
nest.SetStatus(noise, {"rate": 80000.0, "rate": 15000.0})
nest.Connect(noise, neuron, syn_spec={'weight': [[1.2, -1.0]], 'delay': 1.0})
nest.Connect(voltmeter, neuron)
def runNetwork(wf=0.5, ws=0.5, wpfc=0.5, seed_mice=0, w_inc_pfc_i=0.5, weight_gain_i=30, w_io_bf_i=500., w_io_bs_i=500., w_cs_stim=0.5, w_inc_pfc_i_nsp=0.00001, weight_k_increment_i_s=0.00001, weight_k_increment_i_f=0.00001, Ie_pfc_random = 370., Ie_m1_random = 370., w_n_nd_f_to_n_m1 = 100., w_n_nd_s_to_n_pfc=100.):
#==============================================================================
# ISI - interstimulus interval - the time distance in ms between GC spikes and IO spikes
# wf - weight fast line
# ws- weight slow line
# wpfc- weight pfc to m1
# seed_mice - seed
# w_inc_pfc_i - weigth incrementi pfc to m1
# w_inc_pfc_i_nsp= weigth incrementi pfc to m1 no spike
# weight_k_increment_i_s weigth increment gc -> pj slow
# weight_k_increment_i_f weigth increment gc -> pj fast
# weight_gain_i- correction kernel
# w_io_bf_i weight io on purkinje fast line
# w_io_bs_i weight io on purkinje slow line
# w_cs_stim weight Mossy fiber(stim) to Dentate Nucleus
#==============================================================================
#==============================================================================
# Setup Parameters
#==============================================================================
print ("EXP ---- W_FAST ----- >>>>> " + str(wf))
print ("EXP ---- W_SLOW ----- >>>>> " + str(ws))
print ("EXP ---- W_PFC ----- >>>>> " + str(wpfc))
nt.ResetKernel() # reset nest
nt.SetKernelStatus({'grng_seed': seed_mice})
nt.SetKernelStatus({"local_num_threads": 4})
#number of neuron test
nNeuronGR_Fast = 512
nNeuronGR_Slow = 512
nNeuronPJ_Fast = 16
nNeuronPJ_Slow = 16
nNeuronND_Fast = 8
nNeuronND_Slow = 8
nNeuronIO_Fast = 16
nNeuronIO_Slow = 16
nNeuronM1 = 8
nNeuronPFC =8
# neuron type
neuron_Type= 'iaf_psc_alpha'
ISI = 250
wnd=0.40 # kernel window
version = 10
start_network = datetime.datetime.today() #start elaboration time
#loop parameter
dcfrom = 0 #start
dcstep = 10 #rate
dcto = 2500 #end
weight_k_increment_pfc_to_m1 = w_inc_pfc_i #costant increment weight pfc to m1
weight_k_increment_pfc_to_m1_no_spike = w_inc_pfc_i_nsp
weight_k_increment_s = weight_k_increment_i_s #costant increment weight Granular cells to PJ
weight_k_increment_f = weight_k_increment_i_f #costant increment weight Granular cells to PJ
weight_gain= weight_gain_i #normalization parallel fiber
sum_w_fast=sum_w_slow=sum_w_pfc= 0
# Initialization w
wi_af_bf = wf
wi_as_bs = ws
wi_pfc_m1 = wpfc
w_io_bf = w_io_bf_i
w_io_bs = w_io_bs_i
#variables
w_fast=[]
w_slow=[]
t_chart_fast= []
w_chart_fast= []
t_chart_slow= []
w_chart_slow= []
t_chart_pfc= []
w_chart_pfc= []
w_pfc_to_m1=[]
w_pfc_to_m1_no_spike=[]
buffer_kernel_k_fast=[]
buffer_kernel_t_fast=[]
buffer_kernel_k_slow=[]
buffer_kernel_t_slow=[]
spike_pfc_count=[]
spike_io_count_f = 0
spike_io_count_s = 0
spike_pj_count_f=0
spike_pj_count_s=0
spike_pfc_count=0
spike_m1_count=0
def generateSpikeTrainIO(step=10, start=1050+ISI, dStim=20, isiStim=530, sTrain=2500):
# Train of impulse on IO
s_io= []
for i in range(sTrain/isiStim) :
s_io += SpikeGenerator(map(float,(range(start, start+dStim, step))))
start += isiStim+dStim
return s_io
def generateSpikeTrainGR(step=10, start=1000, dStim=50, isiStim=500, sTrain=2500):
# Train of impulse on Granular Cells CS
s_gr= []
for i in range(sTrain/isiStim) :
s_gr += SpikeGenerator(map(float,(range(start, start+dStim, step))))
start += isiStim+dStim
return s_gr
s_io = generateSpikeTrainIO()
s_gc = generateSpikeTrainGR()
#single shot CS
s_gc_base = generateSpikeTrainGR(10, 100, 50, 500, 600)
noise_in = nt.Create("poisson_generator")
nt.SetStatus(noise_in, {"rate": 2500.0, "start": 1., "stop": 2500.})
# Spike detectors
spike_det_gc_f = nt.Create("spike_detector")
spike_det_gc_s = nt.Create("spike_detector")
spike_det_nb_f = nt.Create("spike_detector")
spike_det_nb_s = nt.Create("spike_detector")
spike_det_nio_f = nt.Create("spike_detector")
spike_det_nio_s = nt.Create("spike_detector")
spike_det_m1 = nt.Create("spike_detector")
spike_det_pfc = nt.Create("spike_detector")
# Voltmeters granular cells
vm_gc_f = nt.Create('voltmeter', params={'to_file': False, 'withgid': True, 'withtime': True, 'interval': 0.1})
nt.SetStatus(vm_gc_f, {'n_events': 0})
vm_gc_s = nt.Create('voltmeter', params={'to_file': False, 'withgid': True, 'withtime': True, 'interval': 0.1})
nt.SetStatus(vm_gc_s, {'n_events': 0})
# Voltmeters purkinje cells
vm_pjf = nt.Create('voltmeter', params={'to_file': False, 'withgid': True, 'withtime': True, 'interval': 0.1})
nt.SetStatus(vm_pjf, {'n_events': 0})
vm_pjL = nt.Create('voltmeter', params={'to_file': False, 'withgid': True, 'withtime': True, 'interval': 0.1})
nt.SetStatus(vm_pjL, {'n_events': 0})
#==============================================================================
# Create nodes
#==============================================================================
# Granular Cells
n_a_f = nt.Create(neuron_Type, nNeuronGR_Fast)
n_a_s = nt.Create(neuron_Type, nNeuronGR_Slow)
nt.SetStatus(n_a_f, {'I_e': 370.0, "tau_m": 10., "V_th": -55.0})
nt.SetStatus(n_a_s, {'I_e': 370.0, "tau_m": 10., "V_th": -55.0})
#Purkinje
n_b_f = nt.Create(neuron_Type, nNeuronPJ_Fast)
n_b_s = nt.Create(neuron_Type, nNeuronPJ_Slow)
nt.SetStatus(n_b_f, {'I_e': 380.0, "tau_m": 10.0, "V_th": -55.0})
nt.SetStatus(n_b_s, {'I_e': 380.0, "tau_m": 10.0, "V_th": -55.0})
# Inferior Olive
n_io_f = nt.Create(neuron_Type, nNeuronIO_Fast)
n_io_s = nt.Create(neuron_Type, nNeuronIO_Slow)
nt.SetStatus(n_io_f, {'I_e': 370.0, "tau_m": 10.0, "V_th": -55.0})
nt.SetStatus(n_io_s, {'I_e': 370.0, "tau_m": 10.0, "V_th": -55.0})
# Dentate Nucleus
n_nd_f = nt.Create(neuron_Type, nNeuronND_Fast)
n_nd_s = nt.Create(neuron_Type, nNeuronND_Slow)
nt.SetStatus(n_nd_f, {'I_e': 370.0, "tau_m": 10.0, "V_th": -55.0})
nt.SetStatus(n_nd_s, {'I_e': 370.0, "tau_m": 10.0, "V_th": -55.0})
# Motor primary cortex
n_m1 = nt.Create(neuron_Type, nNeuronM1)
nt.SetStatus(n_m1, {'I_e': Ie_m1_random, "tau_m": 10. , "V_th": -55.0})
# prefrontal cortex
n_pfc = nt.Create(neuron_Type, nNeuronPFC)
nt.SetStatus(n_pfc, {'I_e': Ie_pfc_random , "tau_m": 10., "V_th": -55.0})
#==============================================================================
# Connections
#==============================================================================
nt.Connect(s_gc, n_a_f, syn_spec={'model': 'static_synapse', 'weight': 500.}) #CS to GCf
nt.Connect(s_gc, n_a_s, syn_spec={'model': 'static_synapse', 'weight': 500.}) #CS to GCs
nt.Connect(s_gc, n_nd_f, syn_spec={'model': 'static_synapse', 'weight': w_cs_stim}) #CS to ND
nt.Connect(s_gc, n_nd_s, syn_spec={'model': 'static_synapse', 'weight': w_cs_stim}) #CS to ND
nt.Connect(s_gc_base, n_a_f, syn_spec={'model': 'static_synapse', 'weight': 500.}) #CS to GCf
nt.Connect(s_gc_base, n_a_s, syn_spec={'model': 'static_synapse', 'weight': 500.}) #CS to GCs
nt.Connect(s_gc_base, n_nd_f, syn_spec={'model': 'static_synapse', 'weight': w_cs_stim}) #CS to ND
nt.Connect(s_gc_base, n_nd_s, syn_spec={'model': 'static_synapse', 'weight': w_cs_stim}) #CS to ND
nt.Connect(s_io, n_io_f, syn_spec={'model': 'static_synapse', 'weight': 100.}) #US to IO
nt.Connect(s_io, n_io_s, syn_spec={'model': 'static_synapse', 'weight': 100.}) #US to IO
nt.Connect(n_io_f, n_b_f, 'one_to_one', syn_spec={'model': 'static_synapse', 'weight': w_io_bf}) #IO to PJ
nt.Connect(n_io_s, n_b_s, 'one_to_one', syn_spec={'model': 'static_synapse', 'weight': w_io_bs}) #IO to PJ
nt.Connect(n_io_f, n_nd_f, syn_spec={'model': 'static_synapse', 'weight': 60.}) #Io to ND
nt.Connect(n_io_s, n_nd_s, syn_spec={'model': 'static_synapse', 'weight': 60.}) #Io to ND
# Connect PJ to ND divide by 2
nt.Connect(n_b_f, n_nd_f, syn_spec={'model': 'static_synapse', 'weight': -7})
nt.Connect(n_b_s, n_nd_s, syn_spec={'model': 'static_synapse', 'weight': -7})
nt.Connect(n_nd_f, n_m1, syn_spec={'model': 'static_synapse', 'weight': w_n_nd_f_to_n_m1 }) #w dentate nucleus to m1 and pfc
nt.Connect(n_nd_s, n_pfc, syn_spec={'model': 'static_synapse', 'weight': w_n_nd_s_to_n_pfc }) #w dentate nucleus to m1 and pfc
nt.Connect(noise_in, n_nd_f, syn_spec={'model': 'static_synapse', 'weight': round(random.uniform(0.1, 0.5), 2)}) #w dentate nucleus to m1 and pfc
nt.Connect(noise_in, n_nd_s, syn_spec={'model': 'static_synapse', 'weight': round(random.uniform(0.1, 0.5), 2)}) #w dentate nucleus to m1 and pfc
# Connect voltimeters to neurons
nt.Connect(vm_gc_f, n_a_f, 'all_to_all')
nt.Connect(vm_gc_s, n_a_s, 'all_to_all')
nt.Connect(vm_pjf, n_b_f, 'all_to_all') #purkinie line fast
nt.Connect(vm_pjL, n_b_s, 'all_to_all') #purkinie line slow
# Connect spike detector to neurons
nt.Connect(n_a_f, spike_det_gc_f)
nt.Connect(n_a_s, spike_det_gc_s)
nt.Connect(n_b_f, spike_det_nb_f)
nt.Connect(n_b_s, spike_det_nb_s)
nt.Connect(n_io_f, spike_det_nio_f)
nt.Connect(n_io_s, spike_det_nio_s)
nt.Connect(n_m1, spike_det_m1)
nt.Connect(n_pfc, spike_det_pfc)
#==============================================================================
# Loop
#==============================================================================
for i, sim in enumerate(range(dcfrom, dcto, dcstep)):
# Membrane potential and time Granular Cells Fast
t_gc_f = nt.GetStatus(vm_gc_f, 'events')[0]['times']
v_gc_f = nt.GetStatus(vm_gc_s, 'events')[0]['V_m']
# Membrane potential and time Granular Cells Slow
t_gc_s = nt.GetStatus(vm_gc_f, 'events')[0]['times']
v_gc_s = nt.GetStatus(vm_gc_s, 'events')[0]['V_m']
# Membrane potential and time putkinje line fast
t_pjf = nt.GetStatus(vm_pjf, 'events')[0]['times']
v_pjf = nt.GetStatus(vm_pjf, 'events')[0]['V_m']
# Membrane potential and time putkinje line fast
t_pjL = nt.GetStatus(vm_pjL, 'events')[0]['times']
v_pjL = nt.GetStatus(vm_pjL, 'events')[0]['V_m']
dSD_gc_f = nt.GetStatus(spike_det_gc_f, keys="events")[0]
evs_gc_f = dSD_gc_f["senders"]
ts_gc_f = dSD_gc_f["times"]
dSD_gc_s = nt.GetStatus(spike_det_gc_s, keys="events")[0]
evs_gc_s = dSD_gc_s["senders"]
ts_gc_s = dSD_gc_s["times"]
# Spike Purkinje Cells
dSD_b_f = nt.GetStatus(spike_det_nb_f, keys="events")[0]
evs_b_f = dSD_b_f["senders"]
ts_b_f = dSD_b_f["times"]
dSD_b_s = nt.GetStatus(spike_det_nb_s, keys="events")[0]
evs_b_s = dSD_b_s["senders"]
ts_b_s = dSD_b_s["times"]
# Spike Inferior Olive
dSD_io_f = nt.GetStatus(spike_det_nio_f, keys="events")[0]
evs_io_f = dSD_io_f["senders"]
ts_io_f = dSD_io_f["times"]
# Spike Inferior Olive
dSD_io_s = nt.GetStatus(spike_det_nio_s, keys="events")[0]
evs_io_s = dSD_io_s["senders"]
ts_io_s = dSD_io_s["times"]
# Spike M1
dSD_m1 = nt.GetStatus(spike_det_m1, keys="events")[0]
evs_m1 = dSD_m1["senders"]
ts_m1 = dSD_m1["times"]
# Spike pfC
dSD_pfc = nt.GetStatus(spike_det_pfc, keys="events")[0]
evs_pfc = dSD_pfc["senders"]
ts_pfc = dSD_pfc["times"]
####################################################
#################### LINE FAST ####################
####################################################
if len(evs_gc_f) >=1 :
#print ("LF1")
# Record all time Spike of Granular Cells
tm_f = np.unique(ts_gc_f*0.001)
# Time Spike Inferior Olive e Purkinje
TIO_f = (float(nt.GetStatus(n_io_f, 't_spike')[0])*0.001)
TPJ_f = (float(nt.GetStatus(n_b_f, 't_spike')[0])*0.001)
# If inferior olive send a Spike
if np.count_nonzero(evs_io_f) > spike_io_count_f:
# Current number spike of inferior olive
spike_io_count_f = np.count_nonzero(evs_io_f)
# For each Granular spike in the interval between TIO and TIO-tm_i
for tm_i in tm_f:
if (TIO_f - tm_i) <= wnd :
# Calculate the time in the range -800 / 0
window_tm_f = window(TIO_f, tm_i)
# Create an array of weights calculated with the kernel fast
w_fast.append(kernel_fast(window_tm_f))
# Parameters for the chart fast
buffer_kernel_k_fast.append(kernel_fast(window_tm_f))
buffer_kernel_t_fast.append(window_tm_f)
for tm_i in tm_f:
# If pj f send a Spike
if np.count_nonzero(evs_b_f) > spike_pj_count_f:
# Current number spike of pj f
spike_pj_count_f = np.count_nonzero(evs_b_f)
if (m.fabs(TPJ_f-tm_i) > wnd and (sum_w_fast <= wi_af_bf)) : w_fast.append(-weight_k_increment_f)
####################################################
#################### LINE SLOW ####################
####################################################
if len(evs_gc_s) >=1 :
# Record all time Spike of Granular Cells
tm_s = np.unique(ts_gc_s*0.001)
# Time Spike Inferior Olive e Purkinje
TIO_s = (float(nt.GetStatus(n_io_s, 't_spike')[0])*0.001)
TPJ_s = (float(nt.GetStatus(n_b_s, 't_spike')[0])*0.001)
# If inferior olive send a Spike
if np.count_nonzero(evs_io_s) > spike_io_count_s:
# Current number spike of inferior olive
spike_io_count_s = np.count_nonzero(evs_io_s)
# For each Granular spike in the interval between TIO and TIO-tm_i
for tm_i in tm_s:
if (TIO_s - tm_i) <= wnd :
# Calculate the time in the range
window_tm_s = window(TIO_s, tm_i)
# Create an array of weights calculated with the kernel slow
w_slow.append(kernel_slow(window_tm_s))
# Parameters for the chart slow
buffer_kernel_k_slow.append(kernel_slow(window_tm_s))
buffer_kernel_t_slow.append(window_tm_s)
for tm_i in tm_s:
# If pj s send a Spike
if np.count_nonzero(evs_b_s) > spike_pj_count_s:
# Current number spike of pj s
spike_pj_count_s = np.count_nonzero(evs_b_s)
if (m.fabs(TPJ_s-tm_i) > wnd and (sum_w_slow <= wi_as_bs)) : w_slow.append(-weight_k_increment_s)
#if sum_w_fast <= wi_af_bf : w_fast.append(-weight_k_increment) # Costant inccreaase weight if sum_w_fast <= wi_af_bf
sum_w_fast = wi_af_bf - (sum(w_fast) * weight_gain)
#if sum_w_slow <= wi_as_bs : w_slow.append(-weight_k_increment) #costant increaase weight
sum_w_slow = wi_as_bs - (sum(w_slow) * weight_gain)
#weight chart
t_chart_fast.append(i)
w_chart_fast.append(sum_w_fast)
t_chart_slow.append(i)
w_chart_slow.append(sum_w_slow)
# If pfc send a Spike
TM1 = np.array(nt.GetStatus(spike_det_m1, keys="events")[0]["times"])[-1:]*0.001
TPFC = np.array(nt.GetStatus(spike_det_pfc, keys="events")[0]["times"])[-1:]*0.001
if (np.count_nonzero(evs_pfc) > spike_pfc_count) and (np.count_nonzero(evs_m1) > spike_m1_count) and m.fabs(TM1-TPFC) < 0.40:
spike_pfc_count = np.count_nonzero(evs_pfc)
spike_m1_count = np.count_nonzero(evs_m1)
w_pfc_to_m1.append(weight_k_increment_pfc_to_m1) #incrementare weight on array pfc
else:
if np.count_nonzero(evs_m1) > spike_m1_count:
w_pfc_to_m1_no_spike.append(weight_k_increment_pfc_to_m1_no_spike)
spike_m1_count = np.count_nonzero(evs_m1)
sum_w_pfc=wi_pfc_m1 + sum(w_pfc_to_m1) - sum(w_pfc_to_m1_no_spike) # Sum array weigth
t_chart_pfc.append(i)
w_chart_pfc.append(sum_w_pfc)
syn_dict_fast= {"model": "static_synapse", "weight": sum_w_fast}
syn_dict_slow = {"model": "static_synapse", "weight": sum_w_slow}
syn_dict_pfc_to_m1 = {"model": "static_synapse", "weight": sum_w_pfc} #peso tra pfc e m1
# Connect GRf to PJs
nt.Connect(n_a_f, n_b_f, syn_spec=syn_dict_fast)
# Connect GRs to PJs
nt.Connect(n_a_s, n_b_s, syn_spec=syn_dict_slow)
# Connect pfc to m1
nt.Connect(n_pfc, n_m1, syn_spec=syn_dict_pfc_to_m1)
nt.Simulate(dcstep) #12/01 inserito la variabile step invece del valore fisso 1
obj_returned={"timesSpikeGC_f":ts_gc_f,"sendersGC_f":evs_gc_f,
"timesSpikeGC_s":ts_gc_s,"sendersGC_s":evs_gc_s,
"potentialGC_f":np.array(v_gc_f, dtype=float),
"tPotentialGC_f":np.array(t_gc_f, dtype=float),
"potentialGC_s":np.array(v_gc_s, dtype=float),
"tPotentialGC_s":np.array(t_gc_s, dtype=float),
"timesSpikePjF":ts_b_f,"sendersPjF":evs_b_f,
"timesSpikePjS": ts_b_s, "sendersPjS":evs_b_s,
"timesSpikeIO_f": ts_io_f, "sendersIO_f":evs_io_f,
"timesSpikeIO_s": ts_io_s, "sendersIO_s":evs_io_s,
"timesSpikeM1": ts_m1, "timesSpikePFC": ts_pfc,
"timesSpikeStartNetwork": start_network,
"tw_chart_fast": t_chart_fast, "w_chart_fast": w_chart_fast,
"tw_chart_slow": t_chart_slow, "w_chart_slow": w_chart_slow,
"t_chart_pfc": t_chart_pfc, "w_chart_pfc": w_chart_pfc,
"senderM1": evs_m1, "senderPFC": evs_pfc,
"potentialPjA":np.array(v_pjf, dtype=float),
"tPotentialPjA":np.array(t_pjf, dtype=float),
"potentialPjL":np.array(v_pjL, dtype=float),
"tPotentialPjL":np.array(t_pjL, dtype=float)}
return obj_returned
nodes_E = nodes[:N_E]
nodes_I = nodes[N_E:]
noise = nest.Create('poisson_generator', 1, {'rate': p_rate})
spikes = nest.Create('spike_detector', 2,
[{'label': 'brunel_py_ex', 'to_file': data2file},
{'label': 'brunel_py_in', 'to_file': data2file}])
spikes_E = spikes[:1]
spikes_I = spikes[1:]
# randomize membrane potential
node_info = nest.GetStatus(nodes, ['global_id', 'vp', 'local'])
local_nodes = [(gid, vp) for gid, vp, islocal in node_info if islocal]
for gid, vp in local_nodes:
nest.SetStatus([gid], {'V_m': pyrngs[vp].uniform(-V_th, V_th)})
# Connect nodes ------------------------------------------------
# We create a plastic excitatory synapse model for the
# excitatory-excitatory weights and a static excitatory model for
# the excitatory-inhibitory weights
nest.CopyModel('stdp_synapse_hom',
'excitatory_plastic',
{'alpha': STDP_alpha,
'Wmax': STDP_Wmax})
nest.CopyModel('static_synapse', 'excitatory_static')
# weights are drawn at random while connecting
nest.Connect(nodes_E, nodes_E,
def simulate():
'''instantiate and execute network simulation'''
#separate model execution from parameters for safe import from other files
nest.ResetKernel()
'''
Configuration of the simulation kernel by the previously defined time
resolution used in the simulation. Setting "print_time" to True prints
the already processed simulation time as well as its percentage of the
total simulation time.
'''
nest.SetKernelStatus({
"resolution": dt,
"print_time": True,
"overwrite_files": True
})
print("Building network")
'''
Configuration of the model `iaf_psc_alpha` and `poisson_generator`
using SetDefaults(). This function expects the model to be the
inserted as a string and the parameter to be specified in a
dictionary. All instances of theses models created after this point
will have the properties specified in the dictionary by default.
'''
nest.SetDefaults("iaf_psc_alpha", neuron_params)
nest.SetDefaults("poisson_generator", {"rate": p_rate})
'''
Creation of the nodes using `Create`. We store the returned handles in
variables for later reference. Here the excitatory and inhibitory, as
well as the poisson generator and two spike detectors. The spike
detectors will later be used to record excitatory and inhibitory
spikes.
'''
nodes_ex = nest.Create("iaf_psc_alpha", NE)
nodes_in = nest.Create("iaf_psc_alpha", NI)
noise = nest.Create("poisson_generator")
espikes = nest.Create("spike_detector")
ispikes = nest.Create("spike_detector")
print("first exc node: {}".format(nodes_ex[0]))
print("first inh node: {}".format(nodes_in[0]))
'''
distribute membrane potentials
'''
nest.SetStatus(nodes_ex, "V_m",
random.rand(len(nodes_ex)) * neuron_params["V_th"])
nest.SetStatus(nodes_in, "V_m",
random.rand(len(nodes_in)) * neuron_params["V_th"])
'''
Configuration of the spike detectors recording excitatory and
inhibitory spikes using `SetStatus`, which expects a list of node
handles and a list of parameter dictionaries. Setting the variable
"to_file" to True ensures that the spikes will be recorded in a .gdf
file starting with the string assigned to label. Setting "withtime"
and "withgid" to True ensures that each spike is saved to file by
stating the gid of the spiking neuron and the spike time in one line.
'''
nest.SetStatus(espikes,
[{
"label": os.path.join(spike_output_path, label + "-EX"),
"withtime": True,
"withgid": True,
"to_file": True,
}])
nest.SetStatus(ispikes,
[{
"label": os.path.join(spike_output_path, label + "-IN"),
"withtime": True,
"withgid": True,
"to_file": True,
}])
print("Connecting devices")
'''
Definition of a synapse using `CopyModel`, which expects the model
name of a pre-defined synapse, the name of the customary synapse and
an optional parameter dictionary. The parameters defined in the
dictionary will be the default parameter for the customary
synapse. Here we define one synapse for the excitatory and one for the
inhibitory connections giving the previously defined weights and equal
delays.
'''
nest.CopyModel("static_synapse", "excitatory", {
"weight": J_ex,
"delay": delay
})
nest.CopyModel("static_synapse", "inhibitory", {
"weight": J_in,
"delay": delay
})
'''
Connecting the previously defined poisson generator to the excitatory
and inhibitory neurons using the excitatory synapse. Since the poisson
generator is connected to all neurons in the population the default
rule ('all_to_all') of Connect() is used. The synaptic properties are
inserted via syn_spec which expects a dictionary when defining
multiple variables or a string when simply using a pre-defined
synapse.
'''
if Poisson:
nest.Connect(noise, nodes_ex, 'all_to_all', "excitatory")
nest.Connect(noise, nodes_in, 'all_to_all', "excitatory")
'''
Connecting the first N_neurons nodes of the excitatory and inhibitory
population to the associated spike detectors using excitatory
synapses. Here the same shortcut for the specification of the synapse
as defined above is used.
'''
nest.Connect(nodes_ex, espikes, 'all_to_all', "excitatory")
nest.Connect(nodes_in, ispikes, 'all_to_all', "excitatory")
print("Connecting network")
print("Excitatory connections")
'''
Connecting the excitatory population to all neurons using the
pre-defined excitatory synapse. Beforehand, the connection parameter
are defined in a dictionary. Here we use the connection rule
'fixed_indegree', which requires the definition of the indegree. Since
the synapse specification is reduced to assigning the pre-defined
excitatory synapse it suffices to insert a string.
'''
conn_params_ex = {'rule': 'fixed_indegree', 'indegree': CE}
nest.Connect(nodes_ex, nodes_ex + nodes_in, conn_params_ex, "excitatory")
print("Inhibitory connections")
'''
Connecting the inhibitory population to all neurons using the
pre-defined inhibitory synapse. The connection parameter as well as
the synapse paramtere are defined analogously to the connection from
the excitatory population defined above.
'''
conn_params_in = {'rule': 'fixed_indegree', 'indegree': CI}
nest.Connect(nodes_in, nodes_ex + nodes_in, conn_params_in, "inhibitory")
'''
Storage of the time point after the buildup of the network in a
variable.
'''
endbuild = time.time()
'''
Simulation of the network.
'''
print("Simulating")
nest.Simulate(simtime)
'''
Storage of the time point after the simulation of the network in a
variable.
'''
endsimulate = time.time()
'''
Reading out the total number of spikes received from the spike
detector connected to the excitatory population and the inhibitory
population.
'''
events_ex = nest.GetStatus(espikes, "n_events")[0]
events_in = nest.GetStatus(ispikes, "n_events")[0]
'''
Calculation of the average firing rate of the excitatory and the
inhibitory neurons by dividing the total number of recorded spikes by
the number of neurons recorded from and the simulation time. The
multiplication by 1000.0 converts the unit 1/ms to 1/s=Hz.
'''
rate_ex = events_ex / simtime * 1000.0 / N_neurons
rate_in = events_in / simtime * 1000.0 / N_neurons
'''
Reading out the number of connections established using the excitatory
and inhibitory synapse model. The numbers are summed up resulting in
the total number of synapses.
'''
num_synapses = nest.GetDefaults("excitatory")["num_connections"]+\
nest.GetDefaults("inhibitory")["num_connections"]
'''
Establishing the time it took to build and simulate the network by
taking the difference of the pre-defined time variables.
'''
build_time = endbuild - startbuild
sim_time = endsimulate - endbuild
'''
Printing the network properties, firing rates and building times.
'''
print("Brunel network simulation (Python)")
print("Number of neurons : {0}".format(N_neurons))
print("Number of synapses: {0}".format(num_synapses))
print(" Exitatory : {0}".format(int(CE * N_neurons) + N_neurons))
print(" Inhibitory : {0}".format(int(CI * N_neurons)))
print("Excitatory rate : %.2f Hz" % rate_ex)
print("Inhibitory rate : %.2f Hz" % rate_in)
print("Building time : %.2f s" % build_time)
print("Simulation time : %.2f s" % sim_time)
'''
Plot a raster of the excitatory neurons and a histogram.
'''
if False:
nest.raster_plot.from_device(espikes, hist=True)
nest.raster_plot.from_device(ispikes, hist=True)
nest.raster_plot.show()
def test(referenceModel, testant, gsl_error_tol, tolerance=0.000001):
spike_times = [100.0, 200.0]
spike_weights = [1., -1.]
nest.ResetKernel()
neuron1 = nest.Create(referenceModel)
neuron2 = nest.Create(testant)
if not (gsl_error_tol is None):
nest.SetStatus(neuron2, {"gsl_error_tol": gsl_error_tol})
spikegenerator = nest.Create('spike_generator',
params={
'spike_times': spike_times,
'spike_weights': spike_weights
})
nest.Connect(spikegenerator, neuron1)
nest.Connect(spikegenerator, neuron2)
multimeter1 = nest.Create('multimeter')
multimeter2 = nest.Create('multimeter')
V_m_specifier = 'V_m' # 'delta_V_m'
nest.SetStatus(multimeter1, {
"withtime": True,
"record_from": [V_m_specifier]
})
nest.SetStatus(multimeter2, {
"withtime": True,
"record_from": [V_m_specifier]
})
nest.Connect(multimeter1, neuron1)
nest.Connect(multimeter2, neuron2)
nest.Simulate(400.0)
dmm1 = nest.GetStatus(multimeter1)[0]
Vms1 = dmm1["events"][V_m_specifier]
ts1 = dmm1["events"]["times"]
dmm2 = nest.GetStatus(multimeter2)[0]
Vms2 = dmm2["events"][V_m_specifier]
ts2 = dmm2["events"]["times"]
if TEST_PLOTS:
fig, ax = plt.subplots(2, 1)
ax[0].plot(ts1, Vms1, label="Reference " + referenceModel)
ax[1].plot(ts2, Vms2, label="Testant " + testant)
for _ax in ax:
_ax.legend(loc='upper right')
_ax.grid()
plt.savefig("/tmp/nestml_nest_integration_test_[" + referenceModel +
"]_[" + testant + "].png")
for index in range(0, len(Vms1)):
if abs(Vms1[index] - Vms2[index]) > tolerance \
or np.isnan(Vms1[index]) \
or np.isnan(Vms2[index]):
print(
str(Vms1[index]) + " differs from " + str(Vms2[index]) +
" at iteration: " + str(index) + " of overall iterations: " +
str(len(Vms1)))
raise Exception(testant + ": TEST FAILED")
print(testant + " PASSED")
nest.Connect(pg,
neurons,
'all_to_all',
syn_spec={
'model': 'static_synapse',
'weight': j_exc,
'delay': delay
})
"""
Then the neurons are connected to the `spike_detector` and the initial
membrane potential of each neuron is set randomly between -40 and -80 mV.
"""
nest.Connect(neurons, sd)
for i in range(n_neuron):
nest.SetStatus([neurons[i]], {'V_m': (-40. - 40. * random.random())})
"""
Finally gap junctions are added to the network.
(60*500)/2 `gap_junction` connections are added randomly
resulting in an average of 60 gap-junction connections per neuron.
We must not use the `fixed_indegree` oder `fixed_outdegree` functionality of
`nest.Connect()` to create the connections, as `gap_junction` connections are
bidirectional connections and we need to make sure that the same neurons
are connected in both ways. This is achieved by creating the connections on
the Python level with the `random` module of the Python Standard Library
and connecting the neurons using the `make_symmetric` flag for
`one_to_one` connections.
"""
n_connection = int(n_neuron * gap_per_neuron / 2)
connections = numpy.transpose(
[random.sample(neurons, 2) for _ in range(n_connection)])
for ii in range(npop):
source = ii, p.nrow, p.ncol, p.nrow, p.ncol, p.ncon, p.kappa, p.theta
targets, delay = lcrn.lcrn_gamma_targets(*source)
if landscape is not None: # asymmetry
targets = (targets + p.shift * move[landscape[ii] % len(move)]) % npop
# no selfconnections
targets = targets[targets != ii]
nest.Connect([pop[ii]], (targets + offset).tolist(),
syn_spec={'weight': p.Ji})
# Connect noise input device to all neurons
nest.Connect(noise, pop)
# Connect spike detector to population of all neurons
nest.Connect(pop, sd)
"""
Warming up
"""
# Preparation for simulation
nest.SetStatus(noise, params={'std': 500.})
nest.Simulate(p.wuptime / 2)
nest.SetStatus(noise, params=p.noise)
nest.Simulate(p.wuptime / 2)
"""
Start simulation
"""
# Run simulation
nest.Simulate(p.simtime)
def _set_status(obj, parameters):
"""Wrapper around nest.SetStatus() to add a more informative error message."""
try:
nest.SetStatus(obj, parameters)
except nest.hl_api.NESTError as e:
raise nest.hl_api.NESTError("%s. Parameter dictionary was: %s" % (e, parameters))
noise = nest.Create("poisson_generator")
espikes = nest.Create("spike_detector")
ispikes = nest.Create("spike_detector")
###############################################################################
# Configuration of the spike detectors recording excitatory and inhibitory
# spikes using `SetStatus`, which expects a list of node handles and a list
# of parameter dictionaries. Setting the variable "to_file" to True ensures
# that the spikes will be recorded in a .gdf file starting with the string
# assigned to label. Setting "withtime" and "withgid" to True ensures that
# each spike is saved to file by stating the gid of the spiking neuron and
# the spike time in one line.
nest.SetStatus(espikes, [{
"label": "brunel-py-ex",
"withtime": True,
"withgid": True,
"to_file": True
}])
nest.SetStatus(ispikes, [{
"label": "brunel-py-in",
"withtime": True,
"withgid": True,
"to_file": True
}])
print("Connecting devices")
###############################################################################
# Definition of a synapse using `CopyModel`, which expects the model name of
# a pre-defined synapse, the name of the customary synapse and an optional
def _set_sampling_interval(self, value):
if value is not None:
nest.SetStatus(self._multimeter.device, {"interval": value})
def _convergent_connect(self, presynaptic_indices, postsynaptic_index,
**connection_parameters):
"""
Connect a neuron to one or more other neurons with a static connection.
`sources` -- a 1D array of pre-synaptic cell IDs
`target` -- the ID of the post-synaptic cell.
TO UPDATE
"""
#logger.debug("Connecting to index %s from %s with %s" % (postsynaptic_index, presynaptic_indices, connection_parameters))
presynaptic_cells = self.pre.all_cells[presynaptic_indices]
postsynaptic_cell = self.post[postsynaptic_index]
assert presynaptic_cells.size == presynaptic_indices.size
assert len(presynaptic_cells) > 0, presynaptic_cells
weights = connection_parameters.pop('weight')
if self.receptor_type == 'inhibitory' and self.post.conductance_based:
weights *= -1 # NEST wants negative values for inhibitory weights, even if these are conductances
if hasattr(self.post, "celltype") and hasattr(
self.post.celltype,
"receptor_scale"): # this is a bit of a hack
weights *= self.post.celltype.receptor_scale # needed for the Izhikevich model
delays = connection_parameters.pop('delay')
# Create connections, with weights and delays
# Setting other connection parameters is done afterwards
if postsynaptic_cell.celltype.standard_receptor_type:
try:
nest.ConvergentConnect(
presynaptic_cells.astype(int).tolist(),
[int(postsynaptic_cell)], listify(weights),
listify(delays), self.nest_synapse_model)
except nest.NESTError as e:
raise errors.ConnectionError(
"%s. presynaptic_cells=%s, postsynaptic_cell=%s, weights=%s, delays=%s, synapse model='%s'"
% (e, presynaptic_cells, postsynaptic_cell, weights,
delays, self.nest_synapse_model))
else:
receptor_type = postsynaptic_cell.celltype.get_receptor_type(
self.receptor_type)
if numpy.isscalar(weights):
weights = repeat(weights)
if numpy.isscalar(delays):
delays = repeat(delays)
for pre, w, d in zip(presynaptic_cells, weights, delays):
nest.Connect(
[pre], [postsynaptic_cell], 'one_to_one', {
'weight': w,
'delay': d,
'receptor_type': receptor_type,
'model': self.nest_synapse_model
})
# Book-keeping
self._connections = None # reset the caching of the connection list, since this will have to be recalculated
self._sources.extend(presynaptic_cells)
# Clean the connection parameters
connection_parameters.pop(
'tau_minus',
None) # TODO: set tau_minus on the post-synaptic cells
connection_parameters.pop('dendritic_delay_fraction', None)
connection_parameters.pop('w_min_always_zero_in_NEST', None)
# We need to distinguish between common synapse parameters and local ones
# We just get the parameters of the first connection (is there an easier way?)
if self._common_synapse_property_names is None:
self._identify_common_synapse_properties()
# Set connection parameters other than weight and delay
if connection_parameters:
#logger.debug(connection_parameters)
sort_indices = numpy.argsort(presynaptic_cells)
connections = nest.GetConnections(
source=numpy.unique(presynaptic_cells.astype(int)).tolist(),
target=[int(postsynaptic_cell)],
synapse_model=self.nest_synapse_model)
for name, value in connection_parameters.items():
value = make_sli_compatible(value)
if name not in self._common_synapse_property_names:
#logger.debug("Setting %s=%s for connections %s" % (name, value, connections))
if isinstance(value, numpy.ndarray):
# the str() is to work around a bug handling unicode names in SetStatus in NEST 2.4.1 when using Python 2
nest.SetStatus(connections, str(name),
value[sort_indices].tolist())
else:
nest.SetStatus(connections, str(name), value)
else:
self._set_common_synapse_property(name, value)
# Readout Spikedetector before phase: --------------------------------------------------------------------------
RGC_senders_before_phase = list(
nest.GetStatus(spikedetector)[0]['events']['senders'])
RGC_times_before_phase = list(
nest.GetStatus(spikedetector)[0]['events']['times'])
# Set voltage according to sensor response: --------------------------------------------------------------------
print('Defining sensor voltage')
rates = (scaling_factor / max(responses)) * np.array(responses)
amplitudes = []
for rate in rates:
amplitude = dict([['amplitude', rate]])
amplitudes.append(amplitude)
nest.SetStatus(sensors, amplitudes)
# Simulate Network: --------------------------------------------------------------------------------------------
simstart = time.time()
nest.Simulate(P.simtime)
simstop = time.time()
print('Simulation took: ' + str(simstop - simstart))
# Readout Spikedetector after phase: ---------------------------------------------------------------------------
RGC_senders_after_phase = list(
nest.GetStatus(spikedetector)[0]['events']['senders'])
RGC_times_after_phase = list(
nest.GetStatus(spikedetector)[0]['events']['times'])
nest.Connect(BS_HC1, PYR_MC3, conn_dict_PYR_TO_BS,syn_spec = {'model':'i2e_synapse'})
#PYR_TO_PYR(recurrent connections)
nest.Connect(PYR_MC3, PYR_MC3, conn_dict_PYR_TO_PYR,syn_spec = {'model':'AMPA_synapse_short_delay'})
#PYR3_TO_DBC0_DBC2
nest.Connect(PYR_MC3, DBC_MC0, conn_dict_PYR_TO_DBC,syn_spec = {'model':'AMPA_synapse2DBC_larger_delay'})
nest.Connect(PYR_MC3, DBC_MC2, conn_dict_PYR_TO_DBC,syn_spec = {'model':'AMPA_synapse2DBC_short_delay'})
#PYR_TO_PYR(DIFFERENT HYPERCOLUMNS)
nest.Connect(PYR_MC3, PYR_MC1, conn_dict_PYR_TO_PYR_DIFF_HC,syn_spec = {'model':'AMPA_synapse_larger_delay'})
# STIMULATIONS
# ZERO MEAN NOISE
zmn_nodes_L23e=nest.Create('poisson_generator', params={'rate' : ST['L23e_zmn_rate']})
zmn_nodes_L23i=nest.Create('poisson_generator', params={'rate' : ST['L23e_zmn_rate']})
nest.SetStatus(zmn_nodes_L23e, {"start": 0.0})
nest.SetStatus(zmn_nodes_L23e, {"stop": 5000.0})
nest.SetStatus(zmn_nodes_L23i, {"start": 0.0})
nest.SetStatus(zmn_nodes_L23i, {"stop":5000.0})
syn_dict_e = {'model': 'zmn_synapse', 'weight': +ST['zmn_weight'], 'delay': ST['zmn_delay']}
syn_dict_i = {'model': 'zmn_synapse', 'weight': -ST['zmn_weight'], 'delay': ST['zmn_delay']}
val=0.12
nest.DivergentConnect(zmn_nodes_L23e, PYR_MC0, model=syn_dict_e['model'],weight=syn_dict_e['weight'],delay=syn_dict_e['delay']) #adjusted for nest 2.2.2
nest.DivergentConnect(zmn_nodes_L23i, PYR_MC0, model=syn_dict_i['model'],weight=syn_dict_i['weight'],delay=syn_dict_i['delay']) #adjusted for nest 2.2.2
nest.DivergentConnect(zmn_nodes_L23e, DBC_MC0, model=syn_dict_e['model'],weight=val,delay=syn_dict_e['delay']) #adjusted for nest 2.2.2
nest.DivergentConnect(zmn_nodes_L23i, DBC_MC0, model=syn_dict_i['model'],weight=val,delay=syn_dict_i['delay']) #adjusted for nest 2.2.2
nest.DivergentConnect(zmn_nodes_L23e, PYR_MC1, model=syn_dict_e['model'],weight=syn_dict_e['weight'],delay=syn_dict_e['delay']) #adjusted for nest 2.2.2
import nest
import matplotlib.pyplot as plt
nest.Install("retinamodule")
nest.SetKernelStatus({"resolution": 1.0})
neurons = nest.Create("stbrst_gc_conv",2)
params = [
{
'totAHPinit':i,
'seed':s,
'gnoise':gnoise,
} for i,s,gnoise in zip(rnd.random(2),rnd.randint(32535,size=2),[2E-7,0.])
]
nest.SetStatus(neurons,params )
res=["Vm","synconv","spont","conCa","fAHP","sAHP", "ICa", "IAHP","ISyn"]
multimeter = nest.Create("multimeter")
nest.SetStatus(multimeter, {"withtime":True, "record_from":res})
nest.Connect(multimeter,neurons)
#sd = nest.Create("spike_detector")
#nest.Connect(neurons,sd)
nest.Connect((neurons[0],),(neurons[1],),syn_spec={"weight": 0.24, "delay":2., 'model':"Convolution"})
nest.Simulate(2000.0)
dmm = nest.GetStatus(multimeter)[0]
