def test_simulation_theory(self):
reset_brian2()
t = 3000 * ms
dt = 0.01 * ms
n = 100
alpha = 0.5
poisson = MFPoissonPopulation(n, n * 10 * Hz)
pop = MFLinearPopulation(
n, {
PP.GM: 10 * nsiemens,
PP.VL: 0 * mV,
PP.CM: 5 * nfarad,
PP.VTHR: 0 * mV,
PP.VRES: 0 * mV,
PP.TAU_RP: 15 * ms
})
syn = MFLinear3TSInput(
poisson, pop, {
IP.GM: 10 * nsiemens,
IP.VREV: 0 * mvolt,
IP.TAU: 0 * ms,
IP.TAU_RISE: 2 * ms,
IP.TAU_D1: 20 * ms,
IP.TAU_D2: 30 * ms,
IP.ALPHA: alpha
})
system = MFSystem(pop, poisson)
solver = MFSolver.rates_voltages(system, solver='mse')
solver.run()
theory = syn.g_dyn() / syn.origin.n
print(syn.brian2)
m1 = StateMonitor(syn.brian2,
syn.post_variable_name[0],
record=range(100))
m2 = StateMonitor(syn.brian2,
syn.post_variable_name[1],
record=range(100))
m3 = StateMonitor(syn.brian2,
syn.post_variable_name[2],
record=range(100))
m4 = StateMonitor(syn.brian2,
syn.post_variable_name[3],
record=range(100))
defaultclock.dt = dt
net = system.collect_brian2_network(m1, m2, m3, m4)
net.run(t)
stable_t = int(t / dt * 0.1)
simulation_1 = m1.__getattr__(syn.post_variable_name[0])[:, stable_t:]
simulation_mean_1 = np.mean(simulation_1)
simulation_2 = m2.__getattr__(syn.post_variable_name[1])[:, stable_t:]
simulation_mean_2 = np.mean(simulation_2)
simulation_3 = m3.__getattr__(syn.post_variable_name[2])[:, stable_t:]
simulation_mean_3 = np.mean(simulation_3)
simulation_4 = m4.__getattr__(syn.post_variable_name[3])[:, stable_t:]
simulation_mean_4 = np.mean(simulation_4)
simulation_mean = alpha * simulation_mean_1 + (
1 - alpha) * simulation_mean_2 + -alpha * simulation_mean_3 - (
1 - alpha) * simulation_mean_4
assert np.isclose(theory, simulation_mean, rtol=0.5, atol=0.5)
def test_ExportDevice_basic():
"""
Test the components and structure of the dictionary exported
by ExportDevice
"""
start_scope()
set_device('exporter')
grp = NeuronGroup(10,
'dv/dt = (1-v)/tau :1',
method='exact',
threshold='v > 0.5',
reset='v = 0',
refractory=2 * ms)
tau = 10 * ms
rate = '1/tau'
grp.v['i > 2 and i < 5'] = -0.2
pgrp = PoissonGroup(10, rates=rate)
smon = SpikeMonitor(pgrp)
smon.active = False
netobj = Network(grp, pgrp, smon)
netobj.run(100 * ms)
dev_dict = device.runs
# check the structure and components in dev_dict
assert dev_dict[0]['duration'] == 100 * ms
assert dev_dict[0]['inactive'][0] == smon.name
components = dev_dict[0]['components']
assert components['spikemonitor'][0]
assert components['poissongroup'][0]
assert components['neurongroup'][0]
initializers = dev_dict[0]['initializers_connectors']
assert initializers[0]['source'] == grp.name
assert initializers[0]['variable'] == 'v'
assert initializers[0]['index'] == 'i > 2 and i < 5'
# TODO: why not a Quantity type?
assert initializers[0]['value'] == '-0.2'
with pytest.raises(KeyError):
initializers[0]['identifiers']
device.reinit()
start_scope()
set_device('exporter', build_on_run=False)
tau = 10 * ms
v0 = -70 * mV
vth = 800 * mV
grp = NeuronGroup(10,
'dv/dt = (v0-v)/tau :volt',
method='exact',
threshold='v > vth',
reset='v = v0',
refractory=2 * ms)
v0 = -80 * mV
grp.v[:] = 'v0 + 2 * mV'
smon = StateMonitor(grp, 'v', record=True)
smon.active = False
net = Network(grp, smon)
net.run(10 * ms) # first run
v0 = -75 * mV
grp.v[3:8] = list(range(3, 8)) * mV
smon.active = True
net.run(20 * ms) # second run
v_new = -5 * mV
grp.v['i >= 5'] = 'v0 + v_new'
v_new = -10 * mV
grp.v['i < 5'] = 'v0 - v_new'
spikemon = SpikeMonitor(grp)
net.add(spikemon)
net.run(5 * ms) # third run
dev_dict = device.runs
# check run1
assert dev_dict[0]['duration'] == 10 * ms
assert dev_dict[0]['inactive'][0] == smon.name
components = dev_dict[0]['components']
assert components['statemonitor'][0]
assert components['neurongroup'][0]
initializers = dev_dict[0]['initializers_connectors']
assert initializers[0]['source'] == grp.name
assert initializers[0]['variable'] == 'v'
assert initializers[0]['index']
assert initializers[0]['value'] == 'v0 + 2 * mV'
assert initializers[0]['identifiers']['v0'] == -80 * mV
with pytest.raises(KeyError):
initializers[0]['identifiers']['mV']
# check run2
assert dev_dict[1]['duration'] == 20 * ms
initializers = dev_dict[1]['initializers_connectors']
assert initializers[0]['source'] == grp.name
assert initializers[0]['variable'] == 'v'
assert (initializers[0]['index'] == grp.indices[slice(3, 8, None)]).all()
assert (initializers[0]['value'] == list(range(3, 8)) * mV).all()
with pytest.raises(KeyError):
dev_dict[1]['inactive']
initializers[1]['identifiers']
# check run3
assert dev_dict[2]['duration'] == 5 * ms
with pytest.raises(KeyError):
dev_dict[2]['inactive']
assert dev_dict[2]['components']['spikemonitor']
initializers = dev_dict[2]['initializers_connectors']
assert initializers[0]['source'] == grp.name
assert initializers[0]['variable'] == 'v'
assert initializers[0]['index'] == 'i >= 5'
assert initializers[0]['value'] == 'v0 + v_new'
assert initializers[0]['identifiers']['v0'] == -75 * mV
assert initializers[0]['identifiers']['v_new'] == -5 * mV
assert initializers[1]['index'] == 'i < 5'
assert initializers[1]['value'] == 'v0 - v_new'
assert initializers[1]['identifiers']['v_new'] == -10 * mV
with pytest.raises(IndexError):
initializers[2]
dev_dict[3]
device.reinit()
#I_Gate = 1 # Current input / Zap frequency-sweep parameters I_Bias = 0 * pA I_Zap_Max = 0 * pA sweepdur = 1 * second #sweepdur_ms = 960*ms #f_max = 100*Hz f_max = 2000 * Hz f_min = 1 * Hz m1000 = (f_max - f_min) / (2 * (sweepdur - defaultclock.dt)) t_settle = 50 * ms t_bias = 450 * ms #zap1000_0p96 = I_Zap_Max * sin(2*pi*(m1000*(t - t_settle) + f_min) * (t - t_settle)); #M = StateMonitor(lsonGrp, 'v', record=True) M = StateMonitor(lsonGrp, ['v', 'I'], record=True) run(t_settle, report='text') # Go to rest I_Bias = 9. * pA run(t_bias, report='text') # Equilibrate to I_Bias IBiasStr = 'IBias' + str(int(I_Bias / pA)) + 'pA' I_Zap_Max = 1. * pA run(sweepdur, report='text') # Apply Zap current IZapMaxStr = 'IZapMax' + str(int(I_Zap_Max / pA)) + 'pA' I_Zap_Max = 0. * pA run(100 * ms, report='text') fftStart = round((t_settle + t_bias) / defaultclock.dt) fftStop = round((t_settle + t_bias + sweepdur) / defaultclock.dt)
lsonSynI = Synapses(gbCoSpkGenGrp, lsonGrp,
model='''dg_i/dt = -g_i/tausI : siemens (clock-driven)
gs_i_post = g_i : siemens (summed)''',
on_pre='g_i += w_ilson*siemens',
method = 'exact')
lsonSynI.connect(i=np.arange(nGbcsCoPerLson), j=0)
#lsonSynE = Synapses(sbIpSpkGenGrp, lsonGrp,
# model='''dg_e/dt = -g_e/tausE : siemens (clock-driven)
# gs_e_post = g_e : siemens (summed)''',
# on_pre='g_e += w_elson*siemens',
# method = 'exact')
#lsonSynE.connect(i=np.arange(nSbcsIpPerLson), j=0)
lsonSpks = SpikeMonitor(lsonGrp)
lsonState = StateMonitor(lsonGrp, ['gs_e','Is_e','gs_i','Is_i','v'], record=True)
run(50*ms, report='text')
plt.plot(lsonState.t / ms, lsonState[0].gs_e / nS)
plt.xlabel('t (ms)')
plt.ylabel('gs_e (nS)')
plt.show()
plt.plot(lsonState.t / ms, lsonState[0].Is_e / pA)
plt.xlabel('t (ms)')
plt.ylabel('Is_e (pA)')
plt.show()
plt.plot(lsonState.t / ms, lsonState[0].gs_i / nS)
plt.xlabel('t (ms)')
def run_net(tr):
# prefs.codegen.target = 'numpy'
# prefs.codegen.target = 'cython'
set_device('cpp_standalone',
directory='./builds/%.4d' % (tr.v_idx),
build_on_run=False)
print("Started process with id ", str(tr.v_idx))
T = tr.T1 + tr.T2 + tr.T3
namespace = tr.netw.f_to_dict(short_names=True, fast_access=True)
namespace['idx'] = tr.v_idx
defaultclock.dt = tr.netw.sim.dt
GExc = NeuronGroup(
N=tr.N_e,
model=tr.condlif_sig,
threshold=tr.nrnEE_thrshld,
reset=tr.nrnEE_reset, #method=tr.neuron_method,
namespace=namespace)
GInh = NeuronGroup(
N=tr.N_i,
model=tr.condlif_sig,
threshold='V > Vt',
reset='V=Vr_i', #method=tr.neuron_method,
namespace=namespace)
# set initial thresholds fixed, init. potentials uniformly distrib.
GExc.sigma, GInh.sigma = tr.sigma_e, tr.sigma_i
GExc.Vt, GInh.Vt = tr.Vt_e, tr.Vt_i
GExc.V , GInh.V = np.random.uniform(tr.Vr_e/mV, tr.Vt_e/mV,
size=tr.N_e)*mV, \
np.random.uniform(tr.Vr_i/mV, tr.Vt_i/mV,
size=tr.N_i)*mV
print("need to fix?")
synEE_pre_mod = mod.synEE_pre
synEE_post_mod = mod.synEE_post
if tr.PInp_mode == 'pool':
PInp = PoissonGroup(tr.NPInp, rates=tr.PInp_rate, namespace=namespace)
sPN = Synapses(target=GExc,
source=PInp,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace)
sPN_src, sPN_tar = generate_N_connections(N_tar=tr.N_e,
N_src=tr.NPInp,
N=tr.NPInp_1n)
elif tr.PInp_mode == 'indep':
PInp = PoissonGroup(tr.N_e, rates=tr.PInp_rate, namespace=namespace)
sPN = Synapses(target=GExc,
source=PInp,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace)
sPN_src, sPN_tar = range(tr.N_e), range(tr.N_e)
sPN.connect(i=sPN_src, j=sPN_tar)
if tr.PInp_mode == 'pool':
PInp_inh = PoissonGroup(tr.NPInp_inh,
rates=tr.PInp_inh_rate,
namespace=namespace)
sPNInh = Synapses(target=GInh,
source=PInp_inh,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace)
sPNInh_src, sPNInh_tar = generate_N_connections(N_tar=tr.N_i,
N_src=tr.NPInp_inh,
N=tr.NPInp_inh_1n)
elif tr.PInp_mode == 'indep':
PInp_inh = PoissonGroup(tr.N_i,
rates=tr.PInp_inh_rate,
namespace=namespace)
sPNInh = Synapses(target=GInh,
source=PInp_inh,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace)
sPNInh_src, sPNInh_tar = range(tr.N_i), range(tr.N_i)
sPNInh.connect(i=sPNInh_src, j=sPNInh_tar)
if tr.stdp_active:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.synEE_pre_STDP)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.synEE_post_STDP)
if tr.synEE_rec:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.synEE_pre_rec)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.synEE_post_rec)
# E<-E advanced synapse model, rest simple
SynEE = Synapses(
target=GExc,
source=GExc,
model=tr.synEE_mod,
on_pre=synEE_pre_mod,
on_post=synEE_post_mod,
#method=tr.synEE_method,
namespace=namespace)
SynIE = Synapses(target=GInh,
source=GExc,
on_pre='ge_post += a_ie',
namespace=namespace)
SynEI = Synapses(target=GExc,
source=GInh,
on_pre='gi_post += a_ei',
namespace=namespace)
SynII = Synapses(target=GInh,
source=GInh,
on_pre='gi_post += a_ii',
namespace=namespace)
if tr.strct_active:
sEE_src, sEE_tar = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=sEE_src, j=sEE_tar)
SynEE.syn_active = 0
else:
srcs_full, tars_full = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=srcs_full, j=tars_full)
SynEE.syn_active = 0
sIE_src, sIE_tar = generate_connections(tr.N_i, tr.N_e, tr.p_ie)
sEI_src, sEI_tar = generate_connections(tr.N_e, tr.N_i, tr.p_ei)
sII_src, sII_tar = generate_connections(tr.N_i, tr.N_i, tr.p_ii, same=True)
SynIE.connect(i=sIE_src, j=sIE_tar)
SynEI.connect(i=sEI_src, j=sEI_tar)
SynII.connect(i=sII_src, j=sII_tar)
tr.f_add_result('sIE_src', sIE_src)
tr.f_add_result('sIE_tar', sIE_tar)
tr.f_add_result('sEI_src', sEI_src)
tr.f_add_result('sEI_tar', sEI_tar)
tr.f_add_result('sII_src', sII_src)
tr.f_add_result('sII_tar', sII_tar)
SynEE.a = tr.a_ee
SynEE.insert_P = tr.insert_P
SynEE.p_inactivate = tr.p_inactivate
# make synapse active at beginning
SynEE.run_regularly(tr.synEE_p_activate, dt=T, when='start', order=-100)
# synaptic scaling
if tr.netw.config.scl_active:
SynEE.summed_updaters['Asum_post']._clock = Clock(
dt=tr.dt_synEE_scaling)
SynEE.run_regularly(tr.synEE_scaling,
dt=tr.dt_synEE_scaling,
when='end')
# intrinsic plasticity
if tr.netw.config.it_active:
GExc.h_ip = tr.h_ip
GExc.run_regularly(tr.intrinsic_mod, dt=tr.it_dt, when='end')
# structural plasticity
if tr.netw.config.strct_active:
if tr.strct_mode == 'zero':
if tr.turnover_rec:
strct_mod = '''%s
%s''' % (tr.strct_mod, tr.turnover_rec_mod)
else:
strct_mod = tr.strct_mod
SynEE.run_regularly(strct_mod, dt=tr.strct_dt, when='end')
elif tr.strct_mode == 'thrs':
if tr.turnover_rec:
strct_mod_thrs = '''%s
%s''' % (tr.strct_mod_thrs,
tr.turnover_rec_mod)
else:
strct_mod_thrs = tr.strct_mod_thrs
SynEE.run_regularly(strct_mod_thrs, dt=tr.strct_dt, when='end')
# -------------- recording ------------------
#run(tr.sim.preT)
GExc_recvars = []
if tr.memtraces_rec:
GExc_recvars.append('V')
if tr.vttraces_rec:
GExc_recvars.append('Vt')
if tr.getraces_rec:
GExc_recvars.append('ge')
if tr.gitraces_rec:
GExc_recvars.append('gi')
if tr.gfwdtraces_rec:
GExc_recvars.append('gfwd')
GInh_recvars = GExc_recvars
GExc_stat = StateMonitor(GExc,
GExc_recvars,
record=[0, 1, 2],
dt=tr.GExc_stat_dt)
GInh_stat = StateMonitor(GInh,
GInh_recvars,
record=[0, 1, 2],
dt=tr.GInh_stat_dt)
SynEE_recvars = []
if tr.synee_atraces_rec:
SynEE_recvars.append('a')
if tr.synee_Apretraces_rec:
SynEE_recvars.append('Apre')
if tr.synee_Aposttraces_rec:
SynEE_recvars.append('Apost')
SynEE_stat = StateMonitor(SynEE,
SynEE_recvars,
record=range(tr.n_synee_traces_rec),
when='end',
dt=tr.synEE_stat_dt)
GExc_spks = SpikeMonitor(GExc)
GInh_spks = SpikeMonitor(GInh)
PInp_spks = SpikeMonitor(PInp)
GExc_rate = PopulationRateMonitor(GExc)
GInh_rate = PopulationRateMonitor(GInh)
PInp_rate = PopulationRateMonitor(PInp)
if tr.synee_a_nrecpoints == 0:
SynEE_a_dt = 10 * tr.sim.T2
else:
SynEE_a_dt = tr.sim.T2 / tr.synee_a_nrecpoints
SynEE_a = StateMonitor(SynEE, ['a', 'syn_active'],
record=range(tr.N_e * (tr.N_e - 1)),
dt=SynEE_a_dt,
when='end',
order=100)
net = Network(GExc, GInh, PInp, sPN, sPNInh, SynEE, SynEI, SynIE, SynII,
GExc_stat, GInh_stat, SynEE_stat, SynEE_a, GExc_spks,
GInh_spks, PInp_spks, GExc_rate, GInh_rate, PInp_rate,
PInp_inh)
spks_recorders = [GExc_spks, GInh_spks, PInp_spks]
stat_recorders = [SynEE_stat, GExc_stat, GInh_stat]
rate_recorders = [GExc_rate, GInh_rate, PInp_rate]
for rcc in spks_recorders:
rcc.active = False
for rcc in stat_recorders:
rcc.active = False
for rcc in rate_recorders:
rcc.active = False
for rcc in stat_recorders:
rcc.active = True
if tr.rates_rec:
for rcc in rate_recorders:
rcc.active = True
if tr.spks_rec:
GExc_spks.active = True
GInh_spks.active = True
PInp_spks.active = True
net.run(tr.sim.T1, report='text')
for rcc in spks_recorders:
rcc.active = False
for rcc in stat_recorders:
rcc.active = False
for rcc in rate_recorders:
rcc.active = False
# print('''Hack solution: Simulate single timestep
# to avoid missing simulation chunks''')
# net.run(tr.dt)
for time_step in range(int(tr.sim.T2 / (100 * second))):
net.run(100 * second, report='text')
for rcc in stat_recorders:
rcc.active = True
if tr.rates_rec:
for rcc in rate_recorders:
rcc.active = True
if tr.spks_rec:
GExc_spks.active = True
GInh_spks.active = True
PInp_spks.active = True
net.run(tr.sim.T3, report='text')
SynEE_a.record_single_timestep()
device.build(directory='builds/%.4d' % (tr.v_idx), clean=True)
# save monitors as raws in build directory
raw_dir = 'builds/%.4d/raw/' % (tr.v_idx)
if not os.path.exists(raw_dir):
os.makedirs(raw_dir)
with open(raw_dir + 'namespace.p', 'wb') as pfile:
pickle.dump(namespace, pfile)
with open(raw_dir + 'gexc_stat.p', 'wb') as pfile:
pickle.dump(GExc_stat.get_states(), pfile)
with open(raw_dir + 'ginh_stat.p', 'wb') as pfile:
pickle.dump(GInh_stat.get_states(), pfile)
with open(raw_dir + 'synee_stat.p', 'wb') as pfile:
pickle.dump(SynEE_stat.get_states(), pfile)
with open(raw_dir + 'synee_a.p', 'wb') as pfile:
pickle.dump(SynEE_a.get_states(), pfile)
with open(raw_dir + 'gexc_spks.p', 'wb') as pfile:
pickle.dump(GExc_spks.get_states(), pfile)
with open(raw_dir + 'ginh_spks.p', 'wb') as pfile:
pickle.dump(GInh_spks.get_states(), pfile)
with open(raw_dir + 'pinp_spks.p', 'wb') as pfile:
pickle.dump(PInp_spks.get_states(), pfile)
with open(raw_dir + 'gexc_rate.p', 'wb') as pfile:
pickle.dump(GExc_rate.get_states(), pfile)
if tr.rates_rec:
pickle.dump(GExc_rate.smooth_rate(width=25 * ms), pfile)
with open(raw_dir + 'ginh_rate.p', 'wb') as pfile:
pickle.dump(GInh_rate.get_states(), pfile)
if tr.rates_rec:
pickle.dump(GInh_rate.smooth_rate(width=25 * ms), pfile)
with open(raw_dir + 'pinp_rate.p', 'wb') as pfile:
pickle.dump(PInp_rate.get_states(), pfile)
if tr.rates_rec:
pickle.dump(PInp_rate.smooth_rate(width=25 * ms), pfile)
# ----------------- add raw data ------------------------
fpath = 'builds/%.4d/' % (tr.v_idx)
from pathlib import Path
Path(fpath + 'turnover').touch()
turnover_data = np.genfromtxt(fpath + 'turnover', delimiter=',')
os.remove(fpath + 'turnover')
with open(raw_dir + 'turnover.p', 'wb') as pfile:
pickle.dump(turnover_data, pfile)
Path(fpath + 'spk_register').touch()
spk_register_data = np.genfromtxt(fpath + 'spk_register', delimiter=',')
os.remove(fpath + 'spk_register')
with open(raw_dir + 'spk_register.p', 'wb') as pfile:
pickle.dump(spk_register_data, pfile)
# ---------------- create the powerlaw fit ---------------
# if len(turnover_data) > 10:
# _lt, _dt = extract_lifetimes(turnover_data, tr.N_e,
# with_starters=True)
# life_t, death_t = _lt*second, _dt*second
# if len(life_t)>25:
# fit_wstart = powerlaw.Fit(life_t/ms, discrete=True)
# _lt, _dt = extract_lifetimes(turnover_data, tr.N_e,
# with_starters=False)
# life_t, death_t = _lt*second, _dt*second
# if len(life_t)>25:
# fit_nostart = powerlaw.Fit(life_t/ms, discrete=True)
# with open(raw_dir+'powerlaw_fit.p', 'wb') as pfile:
# pickle.dump({'fit_wstart': fit_wstart,
# 'fit_nostart': fit_nostart}, pfile)
# ----------------- clean up ---------------------------
shutil.rmtree('builds/%.4d/results/' % (tr.v_idx))
# ---------------- plot results --------------------------
#os.chdir('./analysis/file_based/')
from analysis.overview_fb import overview_figure
overview_figure('builds/%.4d' % (tr.v_idx), namespace)
from analysis.synw_fb import synw_figure
synw_figure('builds/%.4d' % (tr.v_idx), namespace)
from analysis.synw_log_fb import synw_log_figure
synw_log_figure('builds/%.4d' % (tr.v_idx), namespace)
from analysis.turnover_fb import turnover_figure
turnover_figure('builds/%.4d' % (tr.v_idx), namespace, fit=False)
from analysis.turnover_fb import turnover_figure
turnover_figure('builds/%.4d' % (tr.v_idx), namespace, fit=True)
and thus
w ~ (vmax - v) / (n - 1)
'''
start_scope()
A = 5
nNeuron = 20
period = 100*ms
tau = 5*ms
eqs = '''
dv/dt = (I-v)/tau : 1
I = A * floor(0.5 + sin(2 * pi * t / period)) : 1
'''
group1 = NeuronGroup(nNeuron, eqs, threshold='v>1', reset='v=0', method='euler')
monitor1 = StateMonitor(group1, variables=True, record=True)
syn1 = Synapses(group1, group1, on_pre='v_post += 1 / (nNeuron - 1)')
syn1.connect(condition='i != j')
run(500*ms)
plt.figure()
plt.plot(monitor1.t/ms, np.mean(monitor1.v, axis=0), label='v')
plt.plot(monitor1.t/ms, monitor1.I[0], label='I')
plt.xlabel('Time (ms)')
plt.ylabel('v')
plt.legend(loc='best')
plt.show()
from brian2 import NeuronGroup, StateMonitor
from brian2 import second, ms
N = NeuronGroup(2,
"""
tau : second
sigma : 1
dy/dt = -y/tau + sqrt(2*sigma**2/tau)*xi : 1
""",
method="euler")
N.tau = np.array([1, 0.1]) * second
N.sigma = np.array([0.1, 0.31622])
N.y = 1
M = StateMonitor(N, "y", record=True)
run(10 * second)
plt.plot(M.t / second,
M.y[1],
color="red",
label=r"$\tau$=0.1 s, $\sigma$=0.31622")
plt.plot(M.t / second, M.y[0], color="k", label=r"$\tau$=1 s, $\sigma$=0.1")
plt.xlim(0, 10)
plt.ylim(-1.1, 1.1)
plt.xlabel("time (sec)")
plt.ylabel("Ornstein-Uhlenbeck process")
def test_from_papers_example():
"""
Test Izhikevich_2007 example
`brian2.readthedocs.io/en/stable/examples/frompapers.Izhikevich_2007.html`
"""
set_device('markdown', build_on_run=False)
# Parameters
simulation_duration = 6 * second
# Neurons
taum = 10*ms
Ee = 0*mV
vt = -54*mV
vr = -60*mV
El = -74*mV
taue = 5*ms
# STDP
taupre = 20*ms
taupost = taupre
gmax = .01
dApre = .01
dApost = -dApre * taupre / taupost * 1.05
dApost *= gmax
dApre *= gmax
# Dopamine signaling
tauc = 1000*ms
taud = 200*ms
taus = 1*ms
epsilon_dopa = 5e-3
# Setting the stage
# Stimuli section
input_indices = array([0, 1, 0, 1, 1, 0,
0, 1, 0, 1, 1, 0])
input_times = array([500, 550, 1000, 1010, 1500, 1510,
3500, 3550, 4000, 4010, 4500, 4510])*ms
input = SpikeGeneratorGroup(2, input_indices, input_times)
neurons = NeuronGroup(2, '''dv/dt = (ge * (Ee-vr) + El - v) / taum : volt
dge/dt = -ge / taue : 1''',
threshold='v>vt', reset='v = vr',
method='exact')
neurons.v = vr
neurons_monitor = SpikeMonitor(neurons)
synapse = Synapses(input, neurons,
model='''s: volt''',
on_pre='v += s')
synapse.connect(i=[0, 1], j=[0, 1])
synapse.s = 100. * mV
# STDP section
synapse_stdp = Synapses(neurons, neurons,
model='''mode: 1
dc/dt = -c / tauc : 1 (clock-driven)
dd/dt = -d / taud : 1 (clock-driven)
ds/dt = mode * c * d / taus : 1 (clock-driven)
dApre/dt = -Apre / taupre : 1 (event-driven)
dApost/dt = -Apost / taupost : 1 (event-driven)''',
on_pre='''ge += s
Apre += dApre
c = clip(c + mode * Apost, -gmax, gmax)
s = clip(s + (1-mode) * Apost, -gmax, gmax)
''',
on_post='''Apost += dApost
c = clip(c + mode * Apre, -gmax, gmax)
s = clip(s + (1-mode) * Apre, -gmax, gmax)
''',
method='euler'
)
synapse_stdp.connect(i=0, j=1)
synapse_stdp.mode = 0
synapse_stdp.s = 1e-10
synapse_stdp.c = 1e-10
synapse_stdp.d = 0
synapse_stdp_monitor = StateMonitor(synapse_stdp, ['s', 'c', 'd'],
record=[0])
# Dopamine signaling section
dopamine_indices = array([0, 0, 0])
dopamine_times = array([3520, 4020, 4520])*ms
dopamine = SpikeGeneratorGroup(1, dopamine_indices, dopamine_times)
dopamine_monitor = SpikeMonitor(dopamine)
reward = Synapses(dopamine, synapse_stdp, model='''''',
on_pre='''d_post += epsilon_dopa''',
method='exact')
reward.connect()
# Simulation
# Classical STDP
synapse_stdp.mode = 0
run(simulation_duration/2)
# Dopamine modulated STDP
synapse_stdp.mode = 1
run(simulation_duration/2)
device.build()
md_str = device.md_text
assert _markdown_lint(md_str)
device.reinit()
def test_common_example():
"""
Test COBAHH (brian2.readthedocs.io/en/stable/examples/COBAHH.html)
"""
set_device('markdown')
# Parameters
area = 20000*umetre**2
Cm = (1*ufarad*cm**-2) * area
gl = (5e-5*siemens*cm**-2) * area
El = -60*mV
EK = -90*mV
ENa = 50*mV
g_na = (100*msiemens*cm**-2) * area
g_kd = (30*msiemens*cm**-2) * area
VT = -63*mV
# Time constants
taue = 5*ms
taui = 10*ms
# Reversal potentials
Ee = 0*mV
Ei = -80*mV
we = 6*nS # excitatory synaptic weight
wi = 67*nS # inhibitory synaptic weight
# The model
eqs = Equations('''
dv/dt = (gl*(El-v)+ge*(Ee-v)+gi*(Ei-v)-
g_na*(m*m*m)*h*(v-ENa)-
g_kd*(n*n*n*n)*(v-EK))/Cm : volt
dm/dt = alpha_m*(1-m)-beta_m*m : 1
dn/dt = alpha_n*(1-n)-beta_n*n : 1
dh/dt = alpha_h*(1-h)-beta_h*h : 1
dge/dt = -ge*(1./taue) : siemens
dgi/dt = -gi*(1./taui) : siemens
alpha_m = 0.32*(mV**-1)*4*mV/exprel((13.0*mV-v+VT)/(4*mV))/ms : Hz
beta_m = 0.28*(mV**-1)*5*mV/exprel((v-VT-40*mV)/(5*mV))/ms : Hz
alpha_h = 0.128*exp((17*mV-v+VT)/(18.0*mV))/ms : Hz
beta_h = 4./(1+exp((40*mV-v+VT)/(5*mV)))/ms : Hz
alpha_n = 0.032*(mV**-1)*5*mV/exprel((15.*mV-v+VT)/(5.*mV))/ms : Hz
beta_n = .5*exp((10*mV-v+VT)/(40.*mV))/ms : Hz
''')
P = NeuronGroup(4000, model=eqs, threshold='v>-20*mV', refractory=3*ms,
method='exponential_euler')
Pe = P[:3200]
Pi = P[3200:]
Ce = Synapses(Pe, P, on_pre='ge+=we')
Ci = Synapses(Pi, P, on_pre='gi+=wi')
Ce.connect(p=0.02)
Ci.connect(p=0.02)
# Initialization
P.v = 'El + (randn() * 5 - 5)*mV'
P.ge = '(randn() * 1.5 + 4) * 10.*nS'
P.gi = '(randn() * 12 + 20) * 10.*nS'
# Record a few traces
trace = StateMonitor(P, 'v', record=[1, 10, 100])
run(1 * second)
md_str = device.md_text
assert _markdown_lint(md_str)
device.reinit()
fill_value=10,
dtype=np.int)*ms
# DrivingGroup.tau = [10, 5, 100]*ms
OutputGroup = NeuronGroup(1, eqs, threshold='v>2', reset='v = 0', method='exact')
OutputGroup.I = [0]
OutputGroup.tau = [100]*ms
# Comment these two lines out to see what happens without Synapses
S = Synapses(DrivingGroup, OutputGroup, on_pre='v_post += 0.2')
S.connect(i=np.arange(9), j=0)
# S.connect(i=0, j=2)
# S.connect(i=1, j=2)
DrivingMonitor = StateMonitor(DrivingGroup, 'v', record=True)
OutputMonitor = StateMonitor(OutputGroup, 'v', record=True)
def visualise_connectivity(S):
Ns = len(S.source)
Nt = len(S.target)
plt.figure(figsize=(3, 6))
# plt.subplot(121)
plt.plot(np.zeros(Ns), np.arange(Ns), 'ok', ms=10)
plt.plot(np.ones(Nt), np.arange(Nt), 'ok', ms=10)
for i, j in zip(S.i, S.j):
plt.plot([0, 1], [i, j], '-k')
# plt.xticks([0, 1], ['Source', 'Target'])
# plt.ylabel('Neuron no.')
plt.xlim(-0.1, 1.1)
plt.ylim(-1, max(Ns, Nt))
c = np.sqrt((diff[0]**2) + (diff[1]**2))
distance = np.sqrt((c**2) + (diff[2]**2))
return -distance
if __name__ == '__main__':
TIMESTEP = 10
# Define NN
nn = BrianLIFAgent(input_size=100,
hidden_size=10,
output_size=4,
namespace={'tau': 10 * ms})
nn.build()
state_in = StateMonitor(nn.inp, variables='v', record=True)
nn.add(state_in)
state_out = StateMonitor(nn.output, variables='v', record=True)
nn.add(state_out)
fig_in = None
fig_out = None
handler = SpikeEventHandler(output=[])
nn.add_spike_handler(nn.output, handler=handler)
nn.init_network(duration=TIMESTEP * ms)
# Define Robot
MAX_SPEED = 6.28
robo = DistanceRewardRobotSim(camera="camera")
# =============================================================================
# EXTERNAL STIMULUS/SYNAPSES
S1 = Synapses(EXT1, P_E, model='w : 1', on_pre='s_ext1 += w', method='euler')
S1.connect(j='i') # one-to-one
S1.w[:] = 1
S2 = Synapses(EXT2, P_E, model='w : 1', on_pre='s_ext2 += w', method='euler')
S2.connect(j='i') # one-to-one
S2.w[:] = 0
# =============================================================================
# =============================================================================
M = StateMonitor(P_E, ('v_soma', 'v_dend1', 'v_dend2'), record=True)
# SIMULATION RUNNING
net = Network(collect())
net.add(M)
net.run(simtime, report='stdout')
# =============================================================================
# A N A L Y S I S o f t h e S I M U L A T I O N
# =============================================================================
plt.figure(1)
plt.plot(M.t/ms, M[0].v_soma, label='soma')
plt.plot(M.t/ms, M[0].v_dend1, label='dend1')
plt.plot(M.t/ms, M[0].v_dend2, label='dend2')
plt.xlabel("Time [ms]")
def run_net(tr):
# prefs.codegen.target = 'numpy'
# prefs.codegen.target = 'cython'
if tr.n_threads > 1:
prefs.devices.cpp_standalone.openmp_threads = tr.n_threads
set_device('cpp_standalone',
directory='./builds/%.4d' % (tr.v_idx),
build_on_run=False)
# set brian 2 and numpy random seeds
seed(tr.random_seed)
np.random.seed(tr.random_seed + 11)
print("Started process with id ", str(tr.v_idx))
T = tr.T1 + tr.T2 + tr.T3 + tr.T4 + tr.T5
namespace = tr.netw.f_to_dict(short_names=True, fast_access=True)
namespace['idx'] = tr.v_idx
defaultclock.dt = tr.netw.sim.dt
# collect all network components dependent on configuration
# (e.g. poisson vs. memnoise) and add them to the Brian 2
# network object later
netw_objects = []
if tr.external_mode == 'memnoise':
neuron_model = tr.condlif_memnoise
elif tr.external_mode == 'poisson':
raise NotImplementedError
#neuron_model = tr.condlif_poisson
if tr.syn_cond_mode == 'exp':
neuron_model += tr.syn_cond_EE_exp
print("Using EE exp mode")
elif tr.syn_cond_mode == 'alpha':
neuron_model += tr.syn_cond_EE_alpha
print("Using EE alpha mode")
elif tr.syn_cond_mode == 'biexp':
neuron_model += tr.syn_cond_EE_biexp
namespace['invpeakEE'] = (tr.tau_e / tr.tau_e_rise) ** \
(tr.tau_e_rise / (tr.tau_e - tr.tau_e_rise))
print("Using EE biexp mode")
if tr.syn_cond_mode_EI == 'exp':
neuron_model += tr.syn_cond_EI_exp
print("Using EI exp mode")
elif tr.syn_cond_mode_EI == 'alpha':
neuron_model += tr.syn_cond_EI_alpha
print("Using EI alpha mode")
elif tr.syn_cond_mode_EI == 'biexp':
neuron_model += tr.syn_cond_EI_biexp
namespace['invpeakEI'] = (tr.tau_i / tr.tau_i_rise) ** \
(tr.tau_i_rise / (tr.tau_i - tr.tau_i_rise))
print("Using EI biexp mode")
GExc = NeuronGroup(
N=tr.N_e,
model=neuron_model,
threshold=tr.nrnEE_thrshld,
reset=tr.nrnEE_reset, #method=tr.neuron_method,
name='GExc',
namespace=namespace)
GInh = NeuronGroup(
N=tr.N_i,
model=neuron_model,
threshold='V > Vt',
reset='V=Vr_i', #method=tr.neuron_method,
name='GInh',
namespace=namespace)
if tr.external_mode == 'memnoise':
# GExc.mu, GInh.mu = [0.*mV] + (tr.N_e-1)*[tr.mu_e], tr.mu_i
# GExc.sigma, GInh.sigma = [0.*mV] + (tr.N_e-1)*[tr.sigma_e], tr.sigma_i
GExc.mu, GInh.mu = tr.mu_e, tr.mu_i
GExc.sigma, GInh.sigma = tr.sigma_e, tr.sigma_i
GExc.Vt, GInh.Vt = tr.Vt_e, tr.Vt_i
GExc.V , GInh.V = np.random.uniform(tr.Vr_e/mV, tr.Vt_e/mV,
size=tr.N_e)*mV, \
np.random.uniform(tr.Vr_i/mV, tr.Vt_i/mV,
size=tr.N_i)*mV
netw_objects.extend([GExc, GInh])
if tr.external_mode == 'poisson':
if tr.PInp_mode == 'pool':
PInp = PoissonGroup(tr.NPInp,
rates=tr.PInp_rate,
namespace=namespace,
name='poissongroup_exc')
sPN = Synapses(target=GExc,
source=PInp,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace,
name='synPInpExc')
sPN_src, sPN_tar = generate_N_connections(N_tar=tr.N_e,
N_src=tr.NPInp,
N=tr.NPInp_1n)
elif tr.PInp_mode == 'indep':
PInp = PoissonGroup(tr.N_e,
rates=tr.PInp_rate,
namespace=namespace)
sPN = Synapses(target=GExc,
source=PInp,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace,
name='synPInp_inhInh')
sPN_src, sPN_tar = range(tr.N_e), range(tr.N_e)
sPN.connect(i=sPN_src, j=sPN_tar)
if tr.PInp_mode == 'pool':
PInp_inh = PoissonGroup(tr.NPInp_inh,
rates=tr.PInp_inh_rate,
namespace=namespace,
name='poissongroup_inh')
sPNInh = Synapses(target=GInh,
source=PInp_inh,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace)
sPNInh_src, sPNInh_tar = generate_N_connections(N_tar=tr.N_i,
N_src=tr.NPInp_inh,
N=tr.NPInp_inh_1n)
elif tr.PInp_mode == 'indep':
PInp_inh = PoissonGroup(tr.N_i,
rates=tr.PInp_inh_rate,
namespace=namespace)
sPNInh = Synapses(target=GInh,
source=PInp_inh,
model=tr.poisson_mod,
on_pre='gfwd_post += a_EPoi',
namespace=namespace)
sPNInh_src, sPNInh_tar = range(tr.N_i), range(tr.N_i)
sPNInh.connect(i=sPNInh_src, j=sPNInh_tar)
netw_objects.extend([PInp, sPN, PInp_inh, sPNInh])
if tr.syn_noise:
if tr.syn_noise_type == 'additive':
synEE_mod = '''%s
%s''' % (tr.synEE_noise_add, tr.synEE_mod)
synEI_mod = '''%s
%s''' % (tr.synEE_noise_add, tr.synEE_mod)
elif tr.syn_noise_type == 'multiplicative':
synEE_mod = '''%s
%s''' % (tr.synEE_noise_mult, tr.synEE_mod)
synEI_mod = '''%s
%s''' % (tr.synEE_noise_mult, tr.synEE_mod)
else:
synEE_mod = '''%s
%s''' % (tr.synEE_static, tr.synEE_mod)
synEI_mod = '''%s
%s''' % (tr.synEE_static, tr.synEE_mod)
if tr.scl_active:
synEE_mod = '''%s
%s''' % (synEE_mod, tr.synEE_scl_mod)
synEI_mod = '''%s
%s''' % (synEI_mod, tr.synEI_scl_mod)
if tr.syn_cond_mode == 'exp':
synEE_pre_mod = mod.synEE_pre_exp
elif tr.syn_cond_mode == 'alpha':
synEE_pre_mod = mod.synEE_pre_alpha
elif tr.syn_cond_mode == 'biexp':
synEE_pre_mod = mod.synEE_pre_biexp
synEE_post_mod = mod.syn_post
if tr.stdp_active:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.syn_pre_STDP)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.syn_post_STDP)
if tr.synEE_rec:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.synEE_pre_rec)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.synEE_post_rec)
# E<-E advanced synapse model
SynEE = Synapses(target=GExc,
source=GExc,
model=synEE_mod,
on_pre=synEE_pre_mod,
on_post=synEE_post_mod,
namespace=namespace,
dt=tr.synEE_mod_dt)
if tr.istdp_active and tr.istdp_type == 'dbexp':
if tr.syn_cond_mode_EI == 'exp':
EI_pre_mod = mod.synEI_pre_exp
elif tr.syn_cond_mode_EI == 'alpha':
EI_pre_mod = mod.synEI_pre_alpha
elif tr.syn_cond_mode_EI == 'biexp':
EI_pre_mod = mod.synEI_pre_biexp
synEI_pre_mod = '''%s
%s''' % (EI_pre_mod, mod.syn_pre_STDP)
synEI_post_mod = '''%s
%s''' % (mod.syn_post, mod.syn_post_STDP)
elif tr.istdp_active and tr.istdp_type == 'sym':
if tr.syn_cond_mode_EI == 'exp':
EI_pre_mod = mod.synEI_pre_sym_exp
elif tr.syn_cond_mode_EI == 'alpha':
EI_pre_mod = mod.synEI_pre_sym_alpha
elif tr.syn_cond_mode_EI == 'biexp':
EI_pre_mod = mod.synEI_pre_sym_biexp
synEI_pre_mod = '''%s
%s''' % (EI_pre_mod, mod.syn_pre_STDP)
synEI_post_mod = '''%s
%s''' % (mod.synEI_post_sym, mod.syn_post_STDP)
if tr.istdp_active and tr.synEI_rec:
synEI_pre_mod = '''%s
%s''' % (synEI_pre_mod, mod.synEI_pre_rec)
synEI_post_mod = '''%s
%s''' % (synEI_post_mod, mod.synEI_post_rec)
if tr.istdp_active:
SynEI = Synapses(target=GExc,
source=GInh,
model=synEI_mod,
on_pre=synEI_pre_mod,
on_post=synEI_post_mod,
namespace=namespace,
dt=tr.synEE_mod_dt)
else:
model = '''a : 1
syn_active : 1'''
SynEI = Synapses(target=GExc,
source=GInh,
model=model,
on_pre='gi_post += a',
namespace=namespace)
#other simple
SynIE = Synapses(target=GInh,
source=GExc,
on_pre='ge_post += a_ie',
namespace=namespace)
SynII = Synapses(target=GInh,
source=GInh,
on_pre='gi_post += a_ii',
namespace=namespace)
sEE_src, sEE_tar = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=sEE_src, j=sEE_tar)
SynEE.syn_active = 0
SynEE.taupre, SynEE.taupost = tr.taupre, tr.taupost
if tr.istdp_active and tr.istrct_active:
print('istrct active')
sEI_src, sEI_tar = generate_full_connectivity(Nsrc=tr.N_i,
Ntar=tr.N_e,
same=False)
SynEI.connect(i=sEI_src, j=sEI_tar)
SynEI.syn_active = 0
else:
print('istrct not active')
if tr.weight_mode == 'init':
sEI_src, sEI_tar = generate_connections(tr.N_e, tr.N_i, tr.p_ei)
# print('Index Zero will not get inhibition')
# sEI_src, sEI_tar = np.array(sEI_src), np.array(sEI_tar)
# sEI_src, sEI_tar = sEI_src[sEI_tar > 0],sEI_tar[sEI_tar > 0]
elif tr.weight_mode == 'load':
fpath = os.path.join(tr.basepath, tr.weight_path)
with open(fpath + 'synei_a.p', 'rb') as pfile:
synei_a_init = pickle.load(pfile)
sEI_src, sEI_tar = synei_a_init['i'], synei_a_init['j']
SynEI.connect(i=sEI_src, j=sEI_tar)
if tr.istdp_active:
SynEI.taupre, SynEI.taupost = tr.taupre_EI, tr.taupost_EI
sIE_src, sIE_tar = generate_connections(tr.N_i, tr.N_e, tr.p_ie)
sII_src, sII_tar = generate_connections(tr.N_i, tr.N_i, tr.p_ii, same=True)
SynIE.connect(i=sIE_src, j=sIE_tar)
SynII.connect(i=sII_src, j=sII_tar)
tr.f_add_result('sEE_src', sEE_src)
tr.f_add_result('sEE_tar', sEE_tar)
tr.f_add_result('sIE_src', sIE_src)
tr.f_add_result('sIE_tar', sIE_tar)
tr.f_add_result('sEI_src', sEI_src)
tr.f_add_result('sEI_tar', sEI_tar)
tr.f_add_result('sII_src', sII_src)
tr.f_add_result('sII_tar', sII_tar)
if tr.syn_noise:
SynEE.syn_sigma = tr.syn_sigma
SynEE.run_regularly('a = clip(a,0,amax)',
when='after_groups',
name='SynEE_noise_clipper')
if tr.syn_noise and tr.istdp_active:
SynEI.syn_sigma = tr.syn_sigma
SynEI.run_regularly('a = clip(a,0,amax)',
when='after_groups',
name='SynEI_noise_clipper')
SynEE.insert_P = tr.insert_P
SynEE.p_inactivate = tr.p_inactivate
SynEE.stdp_active = 1
print('Setting maximum EE weight threshold to ', tr.amax)
SynEE.amax = tr.amax
if tr.istdp_active:
SynEI.insert_P = tr.insert_P_ei
SynEI.p_inactivate = tr.p_inactivate_ei
SynEI.stdp_active = 1
SynEI.amax = tr.amax
SynEE.syn_active, SynEE.a = init_synapses('EE', tr)
SynEI.syn_active, SynEI.a = init_synapses('EI', tr)
# recording of stdp in T4
SynEE.stdp_rec_start = tr.T1 + tr.T2 + tr.T3
SynEE.stdp_rec_max = tr.T1 + tr.T2 + tr.T3 + tr.stdp_rec_T
if tr.istdp_active:
SynEI.stdp_rec_start = tr.T1 + tr.T2 + tr.T3
SynEI.stdp_rec_max = tr.T1 + tr.T2 + tr.T3 + tr.stdp_rec_T
# synaptic scaling
if tr.netw.config.scl_active:
if tr.syn_scl_rec:
SynEE.scl_rec_start = tr.T1 + tr.T2 + tr.T3
SynEE.scl_rec_max = tr.T1 + tr.T2 + tr.T3 + tr.scl_rec_T
else:
SynEE.scl_rec_start = T + 10 * second
SynEE.scl_rec_max = T
if tr.sig_ATotalMax == 0.:
GExc.ANormTar = tr.ATotalMax
else:
GExc.ANormTar = np.random.normal(loc=tr.ATotalMax,
scale=tr.sig_ATotalMax,
size=tr.N_e)
SynEE.summed_updaters['AsumEE_post']._clock = Clock(
dt=tr.dt_synEE_scaling)
synee_scaling = SynEE.run_regularly(tr.synEE_scaling,
dt=tr.dt_synEE_scaling,
when='end',
name='synEE_scaling')
if tr.istdp_active and tr.netw.config.iscl_active:
if tr.syn_iscl_rec:
SynEI.scl_rec_start = tr.T1 + tr.T2 + tr.T3
SynEI.scl_rec_max = tr.T1 + tr.T2 + tr.T3 + tr.scl_rec_T
else:
SynEI.scl_rec_start = T + 10 * second
SynEI.scl_rec_max = T
if tr.sig_iATotalMax == 0.:
GExc.iANormTar = tr.iATotalMax
else:
GExc.iANormTar = np.random.normal(loc=tr.iATotalMax,
scale=tr.sig_iATotalMax,
size=tr.N_e)
SynEI.summed_updaters['AsumEI_post']._clock = Clock(
dt=tr.dt_synEE_scaling)
synei_scaling = SynEI.run_regularly(tr.synEI_scaling,
dt=tr.dt_synEE_scaling,
when='end',
name='synEI_scaling')
# # intrinsic plasticity
# if tr.netw.config.it_active:
# GExc.h_ip = tr.h_ip
# GExc.run_regularly(tr.intrinsic_mod, dt = tr.it_dt, when='end')
# structural plasticity
if tr.netw.config.strct_active:
if tr.strct_mode == 'zero':
if tr.turnover_rec:
strct_mod = '''%s
%s''' % (tr.strct_mod, tr.turnover_rec_mod)
else:
strct_mod = tr.strct_mod
strctplst = SynEE.run_regularly(strct_mod,
dt=tr.strct_dt,
when='end',
name='strct_plst_zero')
elif tr.strct_mode == 'thrs':
if tr.turnover_rec:
strct_mod_thrs = '''%s
%s''' % (tr.strct_mod_thrs,
tr.turnover_rec_mod)
else:
strct_mod_thrs = tr.strct_mod_thrs
strctplst = SynEE.run_regularly(strct_mod_thrs,
dt=tr.strct_dt,
when='end',
name='strct_plst_thrs')
if tr.istdp_active and tr.netw.config.istrct_active:
if tr.strct_mode == 'zero':
if tr.turnover_rec:
strct_mod_EI = '''%s
%s''' % (tr.strct_mod,
tr.turnoverEI_rec_mod)
else:
strct_mod_EI = tr.strct_mod
strctplst_EI = SynEI.run_regularly(strct_mod_EI,
dt=tr.strct_dt,
when='end',
name='strct_plst_EI')
elif tr.strct_mode == 'thrs':
raise NotImplementedError
netw_objects.extend([SynEE, SynEI, SynIE, SynII])
# keep track of the number of active synapses
sum_target = NeuronGroup(1, 'c : 1 (shared)', dt=tr.csample_dt)
sum_model = '''NSyn : 1 (constant)
c_post = (1.0*syn_active_pre)/NSyn : 1 (summed)'''
sum_connection = Synapses(target=sum_target,
source=SynEE,
model=sum_model,
dt=tr.csample_dt,
name='get_active_synapse_count')
sum_connection.connect()
sum_connection.NSyn = tr.N_e * (tr.N_e - 1)
if tr.adjust_insertP:
# homeostatically adjust growth rate
growth_updater = Synapses(sum_target, SynEE)
growth_updater.run_regularly('insert_P_post *= 0.1/c_pre',
when='after_groups',
dt=tr.csample_dt,
name='update_insP')
growth_updater.connect(j='0')
netw_objects.extend([sum_target, sum_connection, growth_updater])
if tr.istdp_active and tr.istrct_active:
# keep track of the number of active synapses
sum_target_EI = NeuronGroup(1, 'c : 1 (shared)', dt=tr.csample_dt)
sum_model_EI = '''NSyn : 1 (constant)
c_post = (1.0*syn_active_pre)/NSyn : 1 (summed)'''
sum_connection_EI = Synapses(target=sum_target_EI,
source=SynEI,
model=sum_model_EI,
dt=tr.csample_dt,
name='get_active_synapse_count_EI')
sum_connection_EI.connect()
sum_connection_EI.NSyn = tr.N_e * tr.N_i
if tr.adjust_EI_insertP:
# homeostatically adjust growth rate
growth_updater_EI = Synapses(sum_target_EI, SynEI)
growth_updater_EI.run_regularly('insert_P_post *= 0.1/c_pre',
when='after_groups',
dt=tr.csample_dt,
name='update_insP_EI')
growth_updater_EI.connect(j='0')
netw_objects.extend(
[sum_target_EI, sum_connection_EI, growth_updater_EI])
# -------------- recording ------------------
GExc_recvars = []
if tr.memtraces_rec:
GExc_recvars.append('V')
if tr.vttraces_rec:
GExc_recvars.append('Vt')
if tr.getraces_rec:
GExc_recvars.append('ge')
if tr.gitraces_rec:
GExc_recvars.append('gi')
if tr.gfwdtraces_rec and tr.external_mode == 'poisson':
GExc_recvars.append('gfwd')
GInh_recvars = GExc_recvars
GExc_stat = StateMonitor(GExc,
GExc_recvars,
record=list(range(tr.nrec_GExc_stat)),
dt=tr.GExc_stat_dt)
GInh_stat = StateMonitor(GInh,
GInh_recvars,
record=list(range(tr.nrec_GInh_stat)),
dt=tr.GInh_stat_dt)
# SynEE stat
SynEE_recvars = []
if tr.synee_atraces_rec:
SynEE_recvars.append('a')
if tr.synee_activetraces_rec:
SynEE_recvars.append('syn_active')
if tr.synee_Apretraces_rec:
SynEE_recvars.append('Apre')
if tr.synee_Aposttraces_rec:
SynEE_recvars.append('Apost')
SynEE_stat = StateMonitor(SynEE,
SynEE_recvars,
record=range(tr.n_synee_traces_rec),
when='end',
dt=tr.synEE_stat_dt)
if tr.istdp_active:
# SynEI stat
SynEI_recvars = []
if tr.synei_atraces_rec:
SynEI_recvars.append('a')
if tr.synei_activetraces_rec:
SynEI_recvars.append('syn_active')
if tr.synei_Apretraces_rec:
SynEI_recvars.append('Apre')
if tr.synei_Aposttraces_rec:
SynEI_recvars.append('Apost')
SynEI_stat = StateMonitor(SynEI,
SynEI_recvars,
record=range(tr.n_synei_traces_rec),
when='end',
dt=tr.synEI_stat_dt)
netw_objects.append(SynEI_stat)
if tr.adjust_insertP:
C_stat = StateMonitor(sum_target,
'c',
dt=tr.csample_dt,
record=[0],
when='end')
insP_stat = StateMonitor(SynEE,
'insert_P',
dt=tr.csample_dt,
record=[0],
when='end')
netw_objects.extend([C_stat, insP_stat])
if tr.istdp_active and tr.adjust_EI_insertP:
C_EI_stat = StateMonitor(sum_target_EI,
'c',
dt=tr.csample_dt,
record=[0],
when='end')
insP_EI_stat = StateMonitor(SynEI,
'insert_P',
dt=tr.csample_dt,
record=[0],
when='end')
netw_objects.extend([C_EI_stat, insP_EI_stat])
GExc_spks = SpikeMonitor(GExc)
GInh_spks = SpikeMonitor(GInh)
GExc_rate = PopulationRateMonitor(GExc)
GInh_rate = PopulationRateMonitor(GInh)
if tr.external_mode == 'poisson':
PInp_spks = SpikeMonitor(PInp)
PInp_rate = PopulationRateMonitor(PInp)
netw_objects.extend([PInp_spks, PInp_rate])
if tr.synee_a_nrecpoints == 0 or tr.sim.T2 == 0 * second:
SynEE_a_dt = 2 * (tr.T1 + tr.T2 + tr.T3 + tr.T4 + tr.T5)
else:
SynEE_a_dt = tr.sim.T2 / tr.synee_a_nrecpoints
# make sure that choice of SynEE_a_dt does lead
# to execessively many recordings - this can
# happen if t1 >> t2.
estm_nrecs = int(T / SynEE_a_dt)
if estm_nrecs > 3 * tr.synee_a_nrecpoints:
print('''Estimated number of EE weight recordings (%d)
exceeds desired number (%d), increasing
SynEE_a_dt''' % (estm_nrecs, tr.synee_a_nrecpoints))
SynEE_a_dt = T / tr.synee_a_nrecpoints
SynEE_a = StateMonitor(SynEE, ['a', 'syn_active'],
record=range(tr.N_e * (tr.N_e - 1)),
dt=SynEE_a_dt,
when='end',
order=100)
if tr.istrct_active:
record_range = range(tr.N_e * tr.N_i)
else:
record_range = range(len(sEI_src))
if tr.synei_a_nrecpoints > 0 and tr.sim.T2 > 0 * second:
SynEI_a_dt = tr.sim.T2 / tr.synei_a_nrecpoints
estm_nrecs = int(T / SynEI_a_dt)
if estm_nrecs > 3 * tr.synei_a_nrecpoints:
print('''Estimated number of EI weight recordings
(%d) exceeds desired number (%d), increasing
SynEI_a_dt''' % (estm_nrecs, tr.synei_a_nrecpoints))
SynEI_a_dt = T / tr.synei_a_nrecpoints
SynEI_a = StateMonitor(SynEI, ['a', 'syn_active'],
record=record_range,
dt=SynEI_a_dt,
when='end',
order=100)
netw_objects.append(SynEI_a)
netw_objects.extend([
GExc_stat, GInh_stat, SynEE_stat, SynEE_a, GExc_spks, GInh_spks,
GExc_rate, GInh_rate
])
if (tr.synEEdynrec
and (2 * tr.syndynrec_npts * tr.syndynrec_dt < tr.sim.T2)):
SynEE_dynrec = StateMonitor(SynEE, ['a'],
record=range(tr.N_e * (tr.N_e - 1)),
dt=tr.syndynrec_dt,
name='SynEE_dynrec',
when='end',
order=100)
SynEE_dynrec.active = False
netw_objects.extend([SynEE_dynrec])
if (tr.synEIdynrec
and (2 * tr.syndynrec_npts * tr.syndynrec_dt < tr.sim.T2)):
SynEI_dynrec = StateMonitor(SynEI, ['a'],
record=record_range,
dt=tr.syndynrec_dt,
name='SynEI_dynrec',
when='end',
order=100)
SynEI_dynrec.active = False
netw_objects.extend([SynEI_dynrec])
net = Network(*netw_objects)
def set_active(*argv):
for net_object in argv:
net_object.active = True
def set_inactive(*argv):
for net_object in argv:
net_object.active = False
### Simulation periods
# --------- T1 ---------
# initial recording period,
# all recorders active
T1T3_recorders = [
GExc_spks, GInh_spks, SynEE_stat, GExc_stat, GInh_stat, GExc_rate,
GInh_rate
]
if tr.istdp_active:
T1T3_recorders.append(SynEI_stat)
set_active(*T1T3_recorders)
if tr.external_mode == 'poisson':
set_active(PInp_spks, PInp_rate)
net.run(tr.sim.T1, report='text', report_period=300 * second, profile=True)
# --------- T2 ---------
# main simulation period
# only active recordings are:
# 1) turnover 2) C_stat 3) SynEE_a
set_inactive(*T1T3_recorders)
if tr.T2_spks_rec:
set_active(GExc_spks, GInh_spks)
if tr.external_mode == 'poisson':
set_inactive(PInp_spks, PInp_rate)
run_T2_syndynrec(net, tr, netw_objects)
# --------- T3 ---------
# second recording period,
# all recorders active
set_active(*T1T3_recorders)
if tr.external_mode == 'poisson':
set_active(PInp_spks, PInp_rate)
run_T3_split(net, tr)
# --------- T4 ---------
# record STDP and scaling weight changes to file
# through the cpp models
set_inactive(*T1T3_recorders)
if tr.external_mode == 'poisson':
set_inactive(PInp_spks, PInp_rate)
run_T4(net, tr)
# --------- T5 ---------
# freeze network and record Exc spikes
# for cross correlations
if tr.scl_active:
synee_scaling.active = False
if tr.istdp_active and tr.netw.config.iscl_active:
synei_scaling.active = False
if tr.strct_active:
strctplst.active = False
if tr.istdp_active and tr.istrct_active:
strctplst_EI.active = False
SynEE.stdp_active = 0
if tr.istdp_active:
SynEI.stdp_active = 0
set_active(GExc_rate, GInh_rate)
set_active(GExc_spks, GInh_spks)
run_T5(net, tr)
SynEE_a.record_single_timestep()
if tr.synei_a_nrecpoints > 0 and tr.sim.T2 > 0. * second:
SynEI_a.record_single_timestep()
device.build(directory='builds/%.4d' % (tr.v_idx),
clean=True,
compile=True,
run=True,
debug=False)
# -----------------------------------------
# save monitors as raws in build directory
raw_dir = 'builds/%.4d/raw/' % (tr.v_idx)
if not os.path.exists(raw_dir):
os.makedirs(raw_dir)
with open(raw_dir + 'namespace.p', 'wb') as pfile:
pickle.dump(namespace, pfile)
with open(raw_dir + 'gexc_stat.p', 'wb') as pfile:
pickle.dump(GExc_stat.get_states(), pfile)
with open(raw_dir + 'ginh_stat.p', 'wb') as pfile:
pickle.dump(GInh_stat.get_states(), pfile)
with open(raw_dir + 'synee_stat.p', 'wb') as pfile:
pickle.dump(SynEE_stat.get_states(), pfile)
if tr.istdp_active:
with open(raw_dir + 'synei_stat.p', 'wb') as pfile:
pickle.dump(SynEI_stat.get_states(), pfile)
if ((tr.synEEdynrec or tr.synEIdynrec)
and (2 * tr.syndynrec_npts * tr.syndynrec_dt < tr.sim.T2)):
if tr.synEEdynrec:
with open(raw_dir + 'syneedynrec.p', 'wb') as pfile:
pickle.dump(SynEE_dynrec.get_states(), pfile)
if tr.synEIdynrec:
with open(raw_dir + 'syneidynrec.p', 'wb') as pfile:
pickle.dump(SynEI_dynrec.get_states(), pfile)
with open(raw_dir + 'synee_a.p', 'wb') as pfile:
SynEE_a_states = SynEE_a.get_states()
if tr.crs_crrs_rec:
SynEE_a_states['i'] = list(SynEE.i)
SynEE_a_states['j'] = list(SynEE.j)
pickle.dump(SynEE_a_states, pfile)
if tr.synei_a_nrecpoints > 0 and tr.sim.T2 > 0. * second:
with open(raw_dir + 'synei_a.p', 'wb') as pfile:
SynEI_a_states = SynEI_a.get_states()
if tr.crs_crrs_rec:
SynEI_a_states['i'] = list(SynEI.i)
SynEI_a_states['j'] = list(SynEI.j)
pickle.dump(SynEI_a_states, pfile)
if tr.adjust_insertP:
with open(raw_dir + 'c_stat.p', 'wb') as pfile:
pickle.dump(C_stat.get_states(), pfile)
with open(raw_dir + 'insP_stat.p', 'wb') as pfile:
pickle.dump(insP_stat.get_states(), pfile)
if tr.istdp_active and tr.adjust_EI_insertP:
with open(raw_dir + 'c_EI_stat.p', 'wb') as pfile:
pickle.dump(C_EI_stat.get_states(), pfile)
with open(raw_dir + 'insP_EI_stat.p', 'wb') as pfile:
pickle.dump(insP_EI_stat.get_states(), pfile)
with open(raw_dir + 'gexc_spks.p', 'wb') as pfile:
pickle.dump(GExc_spks.get_states(), pfile)
with open(raw_dir + 'ginh_spks.p', 'wb') as pfile:
pickle.dump(GInh_spks.get_states(), pfile)
if tr.external_mode == 'poisson':
with open(raw_dir + 'pinp_spks.p', 'wb') as pfile:
pickle.dump(PInp_spks.get_states(), pfile)
with open(raw_dir + 'gexc_rate.p', 'wb') as pfile:
pickle.dump(GExc_rate.get_states(), pfile)
if tr.rates_rec:
pickle.dump(GExc_rate.smooth_rate(width=25 * ms), pfile)
with open(raw_dir + 'ginh_rate.p', 'wb') as pfile:
pickle.dump(GInh_rate.get_states(), pfile)
if tr.rates_rec:
pickle.dump(GInh_rate.smooth_rate(width=25 * ms), pfile)
if tr.external_mode == 'poisson':
with open(raw_dir + 'pinp_rate.p', 'wb') as pfile:
pickle.dump(PInp_rate.get_states(), pfile)
if tr.rates_rec:
pickle.dump(PInp_rate.smooth_rate(width=25 * ms), pfile)
# ----------------- add raw data ------------------------
fpath = 'builds/%.4d/' % (tr.v_idx)
from pathlib import Path
Path(fpath + 'turnover').touch()
turnover_data = np.genfromtxt(fpath + 'turnover', delimiter=',')
os.remove(fpath + 'turnover')
with open(raw_dir + 'turnover.p', 'wb') as pfile:
pickle.dump(turnover_data, pfile)
Path(fpath + 'turnover_EI').touch()
turnover_EI_data = np.genfromtxt(fpath + 'turnover_EI', delimiter=',')
os.remove(fpath + 'turnover_EI')
with open(raw_dir + 'turnover_EI.p', 'wb') as pfile:
pickle.dump(turnover_EI_data, pfile)
Path(fpath + 'spk_register').touch()
spk_register_data = np.genfromtxt(fpath + 'spk_register', delimiter=',')
os.remove(fpath + 'spk_register')
with open(raw_dir + 'spk_register.p', 'wb') as pfile:
pickle.dump(spk_register_data, pfile)
Path(fpath + 'spk_register_EI').touch()
spk_register_EI_data = np.genfromtxt(fpath + 'spk_register_EI',
delimiter=',')
os.remove(fpath + 'spk_register_EI')
with open(raw_dir + 'spk_register_EI.p', 'wb') as pfile:
pickle.dump(spk_register_EI_data, pfile)
Path(fpath + 'scaling_deltas').touch()
scaling_deltas_data = np.genfromtxt(fpath + 'scaling_deltas',
delimiter=',')
os.remove(fpath + 'scaling_deltas')
with open(raw_dir + 'scaling_deltas.p', 'wb') as pfile:
pickle.dump(scaling_deltas_data, pfile)
Path(fpath + 'scaling_deltas_EI').touch()
scaling_deltas_data = np.genfromtxt(fpath + 'scaling_deltas_EI',
delimiter=',')
os.remove(fpath + 'scaling_deltas_EI')
with open(raw_dir + 'scaling_deltas_EI.p', 'wb') as pfile:
pickle.dump(scaling_deltas_data, pfile)
with open(raw_dir + 'profiling_summary.txt', 'w+') as tfile:
tfile.write(str(profiling_summary(net)))
# --------------- cross-correlations ---------------------
if tr.crs_crrs_rec:
GExc_spks = GExc_spks.get_states()
synee_a = SynEE_a_states
wsize = 100 * pq.ms
for binsize in [1 * pq.ms, 2 * pq.ms, 5 * pq.ms]:
wlen = int(wsize / binsize)
ts, idxs = GExc_spks['t'], GExc_spks['i']
idxs = idxs[ts > tr.T1 + tr.T2 + tr.T3 + tr.T4]
ts = ts[ts > tr.T1 + tr.T2 + tr.T3 + tr.T4]
ts = ts - (tr.T1 + tr.T2 + tr.T3 + tr.T4)
sts = [
neo.SpikeTrain(ts[idxs == i] / second * pq.s,
t_stop=tr.T5 / second * pq.s)
for i in range(tr.N_e)
]
crs_crrs, syn_a = [], []
for f, (i, j) in enumerate(zip(synee_a['i'], synee_a['j'])):
if synee_a['syn_active'][-1][f] == 1:
crs_crr, cbin = cch(BinnedSpikeTrain(sts[i],
binsize=binsize),
BinnedSpikeTrain(sts[j],
binsize=binsize),
cross_corr_coef=True,
border_correction=True,
window=(-1 * wlen, wlen))
crs_crrs.append(list(np.array(crs_crr).T[0]))
syn_a.append(synee_a['a'][-1][f])
fname = 'crs_crrs_wsize%dms_binsize%fms_full' % (wsize / pq.ms,
binsize / pq.ms)
df = {
'cbin': cbin,
'crs_crrs': np.array(crs_crrs),
'syn_a': np.array(syn_a),
'binsize': binsize,
'wsize': wsize,
'wlen': wlen
}
with open('builds/%.4d/raw/' % (tr.v_idx) + fname + '.p',
'wb') as pfile:
pickle.dump(df, pfile)
GInh_spks = GInh_spks.get_states()
synei_a = SynEI_a_states
wsize = 100 * pq.ms
for binsize in [1 * pq.ms, 2 * pq.ms, 5 * pq.ms]:
wlen = int(wsize / binsize)
ts_E, idxs_E = GExc_spks['t'], GExc_spks['i']
idxs_E = idxs_E[ts_E > tr.T1 + tr.T2 + tr.T3 + tr.T4]
ts_E = ts_E[ts_E > tr.T1 + tr.T2 + tr.T3 + tr.T4]
ts_E = ts_E - (tr.T1 + tr.T2 + tr.T3 + tr.T4)
ts_I, idxs_I = GInh_spks['t'], GInh_spks['i']
idxs_I = idxs_I[ts_I > tr.T1 + tr.T2 + tr.T3 + tr.T4]
ts_I = ts_I[ts_I > tr.T1 + tr.T2 + tr.T3 + tr.T4]
ts_I = ts_I - (tr.T1 + tr.T2 + tr.T3 + tr.T4)
sts_E = [
neo.SpikeTrain(ts_E[idxs_E == i] / second * pq.s,
t_stop=tr.T5 / second * pq.s)
for i in range(tr.N_e)
]
sts_I = [
neo.SpikeTrain(ts_I[idxs_I == i] / second * pq.s,
t_stop=tr.T5 / second * pq.s)
for i in range(tr.N_i)
]
crs_crrs, syn_a = [], []
for f, (i, j) in enumerate(zip(synei_a['i'], synei_a['j'])):
if synei_a['syn_active'][-1][f] == 1:
crs_crr, cbin = cch(BinnedSpikeTrain(sts_I[i],
binsize=binsize),
BinnedSpikeTrain(sts_E[j],
binsize=binsize),
cross_corr_coef=True,
border_correction=True,
window=(-1 * wlen, wlen))
crs_crrs.append(list(np.array(crs_crr).T[0]))
syn_a.append(synei_a['a'][-1][f])
fname = 'EI_crrs_wsize%dms_binsize%fms_full' % (wsize / pq.ms,
binsize / pq.ms)
df = {
'cbin': cbin,
'crs_crrs': np.array(crs_crrs),
'syn_a': np.array(syn_a),
'binsize': binsize,
'wsize': wsize,
'wlen': wlen
}
with open('builds/%.4d/raw/' % (tr.v_idx) + fname + '.p',
'wb') as pfile:
pickle.dump(df, pfile)
# ----------------- clean up ---------------------------
shutil.rmtree('builds/%.4d/results/' % (tr.v_idx))
shutil.rmtree('builds/%.4d/static_arrays/' % (tr.v_idx))
shutil.rmtree('builds/%.4d/brianlib/' % (tr.v_idx))
shutil.rmtree('builds/%.4d/code_objects/' % (tr.v_idx))
# ---------------- plot results --------------------------
#os.chdir('./analysis/file_based/')
if tr.istdp_active:
from src.analysis.overview_winh import overview_figure
overview_figure('builds/%.4d' % (tr.v_idx), namespace)
else:
from src.analysis.overview import overview_figure
overview_figure('builds/%.4d' % (tr.v_idx), namespace)
from src.analysis.synw_fb import synw_figure
synw_figure('builds/%.4d' % (tr.v_idx), namespace)
if tr.istdp_active:
synw_figure('builds/%.4d' % (tr.v_idx), namespace, connections='EI')
from src.analysis.synw_log_fb import synw_log_figure
synw_log_figure('builds/%.4d' % (tr.v_idx), namespace)
if tr.istdp_active:
synw_log_figure('builds/%.4d' % (tr.v_idx),
namespace,
connections='EI')
spikemon_retina = SpikeMonitor(retina, name='spikemon_retina')
# Monitor the spiking activity of the populations of simple neurons
neurons_spikes = []
for k in range(num_orientations):
neurons_spikes.append(
SpikeMonitor(populations[k], name='spikemon_pop_' + str(k)))
# Monitor current activity of a single neuron per population
# Useful to debug the model or some parameters
ind = num_neurons_sub_pop / 2
neurons_states = []
for k in range(num_orientations):
neurons_states.append(
StateMonitor(populations[k],
variables=["Iin", "Imem"],
record=ind,
name='statemon_pop_' + str(k)))
# Monitor current activity of a single synapse per population
# Useful to debug the model or some parameters
ind = (num_neurons_sub_pop * kernel_size**2) / 2
synapse_states = []
for k in range(num_orientations):
synapse_states.append(
StateMonitor(synapses[k],
variables=["Ie_syn", "Ii_syn"],
record=ind,
name='statemon_syn_' + str(k)))
Net.add(retina, populations, synapses, spikemon_retina, neurons_spikes,
neurons_states, synapse_states)
def lson(lsoInputSpkFileTuple, temp_degC=37):
defaultclock.dt = 0.02 * ms # for better precision
neuron_type = 'type2' # medium speed membrane f0 88-130Hz CF 6kHz
#temp_degC=37.
Vrest = -63.6 * mV # resting potential for type2 from RM2003
nLsons = 1 # number of LSO neurons
nGbcsCo = 4
# nGbcsIp = 4
# nSbcsCo = 4
nSbcsIp = 4
# nSbcs = 4
# nAnfsPerSbc = 3
# nGbcs = 4
# nAnfsPerGbc=30
nAnfsPerInputFile = 40
nGbcsCoPerLson = 8 # Gjoni et al. 2018
nSbcsIpPerLson = 40 # Gjoni et al. 2018
# sbCoSpkFile = inputSpkFileTuple[0]
# sbIpSpkFile = lsoInputSpkFileTuple[1]
# gbCoSpkFile = lsoInputSpkFileTuple[2]
# gbIpSpkFile = inputSpkFileTuple[3]
anCoSpkFile = lsoInputSpkFileTuple[0]
anIpSpkFile = lsoInputSpkFileTuple[1]
# sbCoIdxSpktimeArray = np.loadtxt(sbCoSpkFile)
# sbCoCellIndices = sbCoIdxSpktimeArray[:, 0].astype(int)
# sbCoSpkTimes = sbCoIdxSpktimeArray[:, 1] * ms
# sbCoSpkGenGrp = SpikeGeneratorGroup(nSbcsCo, sbCoCellIndices, sbCoSpkTimes)
gbCoIdxSpktimeArray = np.loadtxt(anCoSpkFile)
gbCoCellIndices = gbCoIdxSpktimeArray[:, 0].astype(int)
# For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms
gbCoSpkTimes = gbCoIdxSpktimeArray[:, 1] * 1000. * ms
gbCoSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, gbCoCellIndices,
gbCoSpkTimes)
sbIpIdxSpktimeArray = np.loadtxt(anIpSpkFile)
sbIpCellIndices = sbIpIdxSpktimeArray[:, 0].astype(int)
# For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms
sbIpSpkTimes = sbIpIdxSpktimeArray[:, 1] * 1000. * ms
sbIpSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, sbIpCellIndices,
sbIpSpkTimes)
# gbIpIdxSpktimeArray = np.loadtxt(gbIpSpkFile)
# gbIpCellIndices = gbIpIdxSpktimeArray[:, 0].astype(int)
# gbIpSpkTimes = gbIpIdxSpktimeArray[:, 1] * ms
# gbIpSpkGenGrp = SpikeGeneratorGroup(nGbcsIp, gbIpCellIndices, gbIpSpkTimes)
# anfIdxSpktimeArray = np.loadtxt(anfSpkFile)
# anfIndices = anfIdxSpktimeArray[:, 0].astype(int)
# nANF = 132
# #anfSpkTimes = [i * second for i in anfIdxSpktimeArray[:, 1]]
# anfSpkTimes = anfIdxSpktimeArray[:, 1] * 1000*ms
# anfSpkGeneratorGrp = SpikeGeneratorGroup(nANF, anfIndices, anfSpkTimes)
# Membrane and Ion-Channel parameters
C = 12 * pF
EH = -43 * mV
EK = -70 * mV # -77*mV in mod file
EL = -65 * mV
ENa = 55 * mV # 55*mV in RM2003; 50*mv by Brette
nf = 0.85 # proportion of n vs p kinetics
zss = 0.5 # steady state inactivation of glt
# default temp_degC = 37., human body temperature in degree celcius
# q10 for ion-channel time-constants (RM2003, p.3106):
q10 = 3.**((temp_degC - 22.) / 10.)
# q10 for ion-channel gbar parameters (RM2003, p.3106):
q10gbar = 2.**((temp_degC - 22.) / 10.)
# hcno current (octopus cell)
frac = 0.0
qt = 4.5**((temp_degC - 33.) / 10.)
# Synaptic parameters:
Es_e = 0. * mV
tausE = 0.5 * ms
Es_i = -90 * mV
tausI = 1.0 * ms
'''Synaptic weights are unitless according to Brian2.
The effective unit is siemens, so they can work in amp, volt, siemens eqns.
We multiply synaptic weight w_e by unit siemens when adding it to g_e.
We use a local variable w_e for synaptic weight rather than the standard w:'''
w_elson = 5e-9
w_ilson = 50e-9 # 6e-9 @ 200Hz; 12e-9 @ 600 Hz
'''Here's why:
The synapses sbc3SynE.w synaptic weight references the Same State Variable as
as the neuron group sbc3Grp.w (klt activation w).
Update sbc3Grp.w, and you set sbc3SynE.w to same value, and vice versa.
This way klt activation and synaptic weight are identical and quite ridiculous.
So use a local variable other than w for the synaptic weight!'''
# Maximal conductances of different cell types in nS
maximal_conductances = dict(
type1c=(1000, 150, 0, 0, 0.5, 0, 2),
type1t=(1000, 80, 0, 65, 0.5, 0, 2),
type12=(1000, 150, 20, 0, 2, 0, 2),
type21=(1000, 150, 35, 0, 3.5, 0, 2),
type2=(1000, 150, 200, 0, 20, 0, 2),
type2gLTH2x=(1000, 150, 400, 0, 40, 0, 2),
type2gLTH0p5x=(1000, 150, 100, 0, 10, 0, 2),
type2o=(1000, 150, 600, 0, 0, 40, 2) # octopus cell
)
gnabar, gkhtbar, gkltbar, gkabar, ghbar, gbarno, gl = [
x * nS for x in maximal_conductances[neuron_type]
]
# Classical Na channel
eqs_na = """
ina = gnabar*m**3*h*(ENa-v) : amp
dm/dt=q10*(minf-m)/mtau : 1
dh/dt=q10*(hinf-h)/htau : 1
minf = 1./(1+exp(-(vu + 38.) / 7.)) : 1
hinf = 1./(1+exp((vu + 65.) / 6.)) : 1
mtau = ((10. / (5*exp((vu+60.) / 18.) + 36.*exp(-(vu+60.) / 25.))) + 0.04)*ms : second
htau = ((100. / (7*exp((vu+60.) / 11.) + 10.*exp(-(vu+60.) / 25.))) + 0.6)*ms : second
"""
# KHT channel (delayed-rectifier K+)
eqs_kht = """
ikht = gkhtbar*(nf*n**2 + (1-nf)*p)*(EK-v) : amp
dn/dt=q10*(ninf-n)/ntau : 1
dp/dt=q10*(pinf-p)/ptau : 1
ninf = (1 + exp(-(vu + 15) / 5.))**-0.5 : 1
pinf = 1. / (1 + exp(-(vu + 23) / 6.)) : 1
ntau = ((100. / (11*exp((vu+60) / 24.) + 21*exp(-(vu+60) / 23.))) + 0.7)*ms : second
ptau = ((100. / (4*exp((vu+60) / 32.) + 5*exp(-(vu+60) / 22.))) + 5)*ms : second
"""
# Ih channel (subthreshold adaptive, non-inactivating)
eqs_ih = """
ih = ghbar*r*(EH-v) : amp
dr/dt=q10*(rinf-r)/rtau : 1
rinf = 1. / (1+exp((vu + 76.) / 7.)) : 1
rtau = ((100000. / (237.*exp((vu+60.) / 12.) + 17.*exp(-(vu+60.) / 14.))) + 25.)*ms : second
"""
# KLT channel (low threshold K+)
eqs_klt = """
iklt = gkltbar*w**4*z*(EK-v) : amp
dw/dt=q10*(winf-w)/wtau : 1
dz/dt=q10*(zinf-z)/ztau : 1
winf = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25 : 1
zinf = zss + ((1.-zss) / (1 + exp((vu + 71.) / 10.))) : 1
wtau = ((100. / (6.*exp((vu+60.) / 6.) + 16.*exp(-(vu+60.) / 45.))) + 1.5)*ms : second
ztau = ((1000. / (exp((vu+60.) / 20.) + exp(-(vu+60.) / 8.))) + 50)*ms : second
"""
# Ka channel (transient K+)
eqs_ka = """
ika = gkabar*a**4*b*c*(EK-v): amp
da/dt=q10*(ainf-a)/atau : 1
db/dt=q10*(binf-b)/btau : 1
dc/dt=q10*(cinf-c)/ctau : 1
ainf = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25 : 1
binf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1
cinf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1
atau = ((100. / (7*exp((vu+60) / 14.) + 29*exp(-(vu+60) / 24.))) + 0.1)*ms : second
btau = ((1000. / (14*exp((vu+60) / 27.) + 29*exp(-(vu+60) / 24.))) + 1)*ms : second
ctau = ((90. / (1 + exp((-66-vu) / 17.))) + 10)*ms : second
"""
# Leak
eqs_leak = """
ileak = gl*(EL-v) : amp
"""
# h current for octopus cells
eqs_hcno = """
ihcno = gbarno*(h1*frac + h2*(1-frac))*(EH-v) : amp
dh1/dt=(hinfno-h1)/tau1 : 1
dh2/dt=(hinfno-h2)/tau2 : 1
hinfno = 1./(1+exp((vu+66.)/7.)) : 1
tau1 = bet1/(qt*0.008*(1+alp1))*ms : second
tau2 = bet2/(qt*0.0029*(1+alp2))*ms : second
alp1 = exp(1e-3*3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1
bet1 = exp(1e-3*3*0.3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1
alp2 = exp(1e-3*3*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1
bet2 = exp(1e-3*3*0.6*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1
"""
eqs = """
dv/dt = (ileak + ina + ikht + iklt + ika + ih + ihcno + I + Is_e + Is_i)/C : volt
Is_e = gs_e * (Es_e - v) : amp
gs_e : siemens
Is_i = gs_i * (Es_i - v) : amp
gs_i : siemens
vu = v/mV : 1 # unitless v
I : amp
"""
#Added Is_i to RM2003
eqs += eqs_leak + eqs_ka + eqs_na + eqs_ih + eqs_klt + eqs_kht + eqs_hcno
lsonGrp = NeuronGroup(nLsons,
eqs,
method='exponential_euler',
threshold='v > -30*mV',
refractory='v > -45*mV')
#gbcGrp.I = 2500.0*pA
lsonGrp.I = 0.0 * pA
# Initialize model near v_rest with no inputs
lsonGrp.v = Vrest
#vu = EL/mV # unitless v
vu = lsonGrp.v / mV # unitless v
lsonGrp.m = 1. / (1 + exp(-(vu + 38.) / 7.))
lsonGrp.h = 1. / (1 + exp((vu + 65.) / 6.))
lsonGrp.n = (1 + exp(-(vu + 15) / 5.))**-0.5
lsonGrp.p = 1. / (1 + exp(-(vu + 23) / 6.))
lsonGrp.r = 1. / (1 + exp((vu + 76.) / 7.))
lsonGrp.w = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25
lsonGrp.z = zss + ((1. - zss) / (1 + exp((vu + 71.) / 10.)))
lsonGrp.a = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25
lsonGrp.b = 1. / (1 + exp((vu + 66) / 7.))**0.5
lsonGrp.c = 1. / (1 + exp((vu + 66) / 7.))**0.5
lsonGrp.h1 = 1. / (1 + exp((vu + 66.) / 7.))
lsonGrp.h2 = 1. / (1 + exp((vu + 66.) / 7.))
#lsonGrp.gs_e = 0.0*siemens
#netGbcEq = Network(gbcGrp, report='text')
#netGbcEq.run(50*ms, report='text')
lsonSynI = Synapses(gbCoSpkGenGrp,
lsonGrp,
model='''dg_i/dt = -g_i/tausI : siemens (clock-driven)
gs_i_post = g_i : siemens (summed)''',
on_pre='g_i += w_ilson*siemens',
method='exact')
lsonSynI.connect(i=np.arange(nGbcsCoPerLson), j=0)
lsonSynE = Synapses(sbIpSpkGenGrp,
lsonGrp,
model='''dg_e/dt = -g_e/tausE : siemens (clock-driven)
gs_e_post = g_e : siemens (summed)''',
on_pre='g_e += w_elson*siemens',
method='exact')
lsonSynE.connect(i=np.arange(nSbcsIpPerLson), j=0)
lsonSpks = SpikeMonitor(lsonGrp)
lsonState = StateMonitor(lsonGrp, ['v', 'gs_e'], record=True)
run(300 * ms, report='text')
# Console Output Won't Clear from Script
# Memory issue with so many repeated simulations:
# Comment out the plt commands
#plt.plot(lsonState.t / ms, lsonState[0].v / mV)
#plt.xlabel('t (ms)')
#plt.ylabel('v (mV)')
#plt.show()
# Output file - EIPD in output filename. Spiketimes in file
EPhsStrCo = anCoSpkFile[35:39]
EPhsStrIp = anIpSpkFile[35:39]
if (EPhsStrCo[0] == 'N'):
EPhsIntCo = -1 * int(EPhsStrCo[1:4])
else:
EPhsIntCo = int(EPhsStrCo[0:3])
if (EPhsStrIp[0] == 'N'):
EPhsIntIp = -1 * int(EPhsStrIp[1:4])
else:
EPhsIntIp = int(EPhsStrIp[0:3])
# EIPD = (EPhsIntCo - EPhsIntIp) % 360
EIPDint = (EPhsIntCo - EPhsIntIp) # unwrapped Envelope IPD
#EIPDstr = str(EIPDint)
if (EIPDint == 15):
EIPDstr = 'EIPDP015'
elif (EIPDint == 30):
EIPDstr = 'EIPDP030'
elif (EIPDint == 45):
EIPDstr = 'EIPDP045'
elif (EIPDint == 60):
EIPDstr = 'EIPDP060'
elif (EIPDint == 75):
EIPDstr = 'EIPDP075'
elif (EIPDint == 90):
EIPDstr = 'EIPDP090'
elif (EIPDint == -15):
EIPDstr = 'EIPDN015'
elif (EIPDint == -30):
EIPDstr = 'EIPDN030'
elif (EIPDint == -45):
EIPDstr = 'EIPDN045'
elif (EIPDint == -60):
EIPDstr = 'EIPDN060'
elif (EIPDint == -75):
EIPDstr = 'EIPDN075'
elif (EIPDint == -90):
EIPDstr = 'EIPDN090'
elif (EIPDint > 0):
EIPDstr = 'EIPDP' + str(EIPDint)
elif (EIPDint < 0):
EIPDstr = 'EIPDN' + str(-EIPDint)
elif (EIPDint == 0):
EIPDstr = 'EIPDP000'
# if (EIPDint < 0):
# EIPDstr = EIPDstr.replace('-','N')
# Synaptic parameters in output filename
if (abs(round(tausE / ms) - (tausE / ms)) < 0.1):
Te = str(round(tausE / ms))
else:
Te = str(tausE / ms)
Te = Te.replace('.', 'p')
if (abs(round(w_elson / 1e-9) - (w_elson / 1e-9)) < 0.1):
We = str(round(w_elson / 1e-9))
else:
We = str(w_elson / 1e-9)
We = We.replace('.', 'p')
if (abs(round(tausI / ms) - (tausI / ms)) < 0.1):
Ti = str(round(tausI / ms))
else:
Ti = str(tausI / ms)
Ti = Ti.replace('.', 'p')
if (abs(round(w_ilson / 1e-9) - (w_ilson / 1e-9)) < 0.1):
Wi = str(round(w_ilson / 1e-9))
else:
Wi = str(w_ilson / 1e-9)
Wi = Wi.replace('.', 'p')
lsonSpkFile = 'Lso2SpT' + anCoSpkFile[6:13] + anCoSpkFile[16:21] + anCoSpkFile[
24:
31] + 'Te' + Te + 'We' + We + 'Ti' + Ti + 'Wi' + Wi + EIPDstr + 'C' + anCoSpkFile[
46:48] + anCoSpkFile[31:33] + anCoSpkFile[35:39] + anCoSpkFile[53:]
file0 = open(lsonSpkFile, 'w')
for index in range(len(lsonSpks.t)):
file0.write(
str(lsonSpks.i[index]) + " " + str(lsonSpks.t[index] / ms) + '\n')
file0.close()
return (lsonGrp, lsonSpks, lsonState)
# end of mkgbcs
def main(): # pragma: no cover
from brian2 import start_scope, mvolt, ms, NeuronGroup, StateMonitor, run
import matplotlib.pyplot as plt
import neo
import quantities as pq
start_scope()
# Izhikevich neuron parameters.
a = 0.02 / ms
b = 0.2 / ms
c = -65 * mvolt
d = 6 * mvolt / ms
I = 4 * mvolt / ms
# Standard Izhikevich neuron equations.
eqs = """
dv/dt = 0.04*v**2/(ms*mvolt) + (5/ms)*v + 140*mvolt/ms - u + I : volt
du/dt = a*((b*v) - u) : volt/second
"""
reset = """
v = c
u += d
"""
# Setup and run simulation.
G = NeuronGroup(1, eqs, threshold='v>30*mvolt', reset='v = -70*mvolt')
G.v = -65 * mvolt
G.u = b * G.v
M = StateMonitor(G, 'v', record=True)
run(300 * ms)
# Store results in neo format.
vm = neo.core.AnalogSignal(M.v[0], units=pq.V, sampling_period=0.1 * pq.ms)
# Plot results.
plt.figure()
plt.plot(vm.times * 1000, vm * 1000) # Plot mV and ms instead of V and s.
plt.xlabel('Time (ms)')
plt.ylabel('mv')
# Save results.
iom = neo.io.PyNNNumpyIO('spike_extraction_test_data')
block = neo.core.Block()
segment = neo.core.Segment()
segment.analogsignals.append(vm)
block.segments.append(segment)
iom.write(block)
# Load results.
iom2 = neo.io.PyNNNumpyIO('spike_extraction_test_data.npz')
data = iom2.read()
vm = data[0].segments[0].analogsignals[0]
# Plot results.
# The two figures should match.
plt.figure()
plt.plot(vm.times * 1000, vm * 1000) # Plot mV and ms instead of V and s.
plt.xlabel('Time (ms)')
plt.ylabel('mv')
synPropsI = getattr(synapsePropsList, DLInt1SynapsePropsI)
dlint1.addSynapse(synName="InhJO",
sourceNG=JO.JOSGG,
**exp2Syn,
synParsInits=synPropsI,
synStateInits=exp2SynStateInits,
sourceInd=0,
destInd=0)
net = Network()
net.add(JO.JOSGG)
dlint1.addToNetwork(net)
if DLInt1SynapsePropsE:
gEMonitor = StateMonitor(dlint1.incomingSynapses["ExiJO"],
"g_ExiJO",
record=True)
net.add(gEMonitor)
if DLInt1SynapsePropsI:
gIMonitor = StateMonitor(dlint1.incomingSynapses["InhJO"],
"g_InhJO",
record=True)
net.add(gIMonitor)
defaultclock.dt = simStepSize
totalSimDur = simDuration + simSettleTime
net.run(totalSimDur, report='text')
simT, memV = dlint1.getMemVTrace()
spikeTimes = dlint1.getSpikes()
"ylim": [0, 20],
"xlim": [0, 500],
"xtickstep": 50,
},
},
}
fig, axes = plt.subplots(3)
for ax, (panel, p) in zip(axes, parameters.items()):
neuron = get_neuron(**p["neuron"])
stimulus = get_stimulus(**p["stimulus"])
synapses = get_synapses(stimulus, neuron, **p["synapse"])
state_monitor_neuron = StateMonitor(neuron, ["v"], record=True)
run(p["simulation"]["duration"])
ax.plot(
state_monitor_neuron.t / ms,
state_monitor_neuron[0].v / mV,
label=p["plot"]["title"],
)
ax.set_xlim(*p["plot"]["xlim"])
ax.set_ylim(*p["plot"]["ylim"])
ax.set_ylabel("mV")
ax.set_xlabel("Time (ms)")
ax.set_xticks(
def lson(lsoInputSpkFileTuple, temp_degC=37):
defaultclock.dt = 0.02 * ms # for better precision
neuron_type = 'type2gLTH0p5x' # medium speed membrane, nominal f0 88Hz
Vrest = -63.6 * mV # resting potential for type2 from RM2003
nLsons = 1 # number of LSO neurons
# As in Wang & Colburn (2012), the LSO model has simplified inputs.
# Spike times from model auditory nerve fibers represent inputs
# driven by the cochlear nucleus: contralateral inhibitory inputs
# driven by globular bushy cells via the MNTB, and ipsilateral
# excitatory inputs from spherical bushy cells.
nAnfsPerInputFile = 40
nGbcsCoPerLson = 8 # Gjoni et al. 2018
nSbcsIpPerLson = 40 # Gjoni et al. 2018
#sbIpSpkFile = lsoInputSpkFileTuple[1]
#gbCoSpkFile = lsoInputSpkFileTuple[2]
anCoSpkFile = lsoInputSpkFileTuple[0]
anIpSpkFile = lsoInputSpkFileTuple[1]
gbCoIdxSpktimeArray = np.loadtxt(anCoSpkFile)
gbCoCellIndices = gbCoIdxSpktimeArray[:, 0].astype(int)
# For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms
gbCoSpkTimes = gbCoIdxSpktimeArray[:, 1] * 1000. * ms
gbCoSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, gbCoCellIndices,
gbCoSpkTimes)
sbIpIdxSpktimeArray = np.loadtxt(anIpSpkFile)
sbIpCellIndices = sbIpIdxSpktimeArray[:, 0].astype(int)
# For now, spiketimes from Zilany AN in SECONDS, so * 1000*ms
sbIpSpkTimes = sbIpIdxSpktimeArray[:, 1] * 1000. * ms
sbIpSpkGenGrp = SpikeGeneratorGroup(nAnfsPerInputFile, sbIpCellIndices,
sbIpSpkTimes)
# Membrane and Ion-Channel parameters
C = 12 * pF
EH = -43 * mV
EK = -70 * mV # -77*mV in mod file
EL = -65 * mV
ENa = 55 * mV # 55*mV in RM2003; 50*mv by Brette
nf = 0.85 # proportion of n vs p kinetics
zss = 0.5 # steady state inactivation of glt
# default temp_degC = 37., human body temperature in degree celcius
# q10 for ion-channel time-constants (RM2003, p.3106):
q10 = 3.**((temp_degC - 22.) / 10.)
# q10 for ion-channel gbar parameters (RM2003, p.3106):
q10gbar = 2.**((temp_degC - 22.) / 10.)
# hcno current (octopus cell)
frac = 0.0
qt = 4.5**((temp_degC - 33.) / 10.)
# Synaptic parameters:
Es_e = 0. * mV
tausE = 1.0 * ms
Es_i = -90 * mV
tausI = 2.0 * ms
'''Synaptic weights are unitless according to Brian2.
The effective unit is siemens, so they can work in amp, volt, siemens eqns.
We multiply synaptic weight w_e by unit siemens when adding it to g_e.
We use a local variable w_e for synaptic weight rather than the standard w:'''
w_elson = 3e-9
w_ilson = 30e-9 # 6e-9 @ 200Hz; 12e-9 @ 600 Hz
'''Here's why:
The synapses sbc3SynE.w synaptic weight references the Same State Variable as
as the neuron group sbc3Grp.w (klt activation w).
Update sbc3Grp.w, and you set sbc3SynE.w to same value, and vice versa.
This way klt activation and synaptic weight are identical and quite ridiculous.
So use a local variable other than w for the synaptic weight!'''
# Maximal conductances of different cell types in nS
maximal_conductances = dict(
type1c=(1000, 150, 0, 0, 0.5, 0, 2),
type1t=(1000, 80, 0, 65, 0.5, 0, 2),
type12=(1000, 150, 20, 0, 2, 0, 2),
type21=(1000, 150, 35, 0, 3.5, 0, 2),
type2=(1000, 150, 200, 0, 20, 0, 2),
type2g2x=(2000, 300, 400, 0, 40, 0, 2),
type2g1p5x=(1000, 150, 300, 0, 30, 0, 2),
type2g1p2x=(1200, 180, 240, 0, 24, 0, 2),
type2gLTH0p5x=(1000, 150, 100, 0, 10, 0, 2),
type2o=(1000, 150, 600, 0, 0, 40, 2) # octopus cell
)
gnabar, gkhtbar, gkltbar, gkabar, ghbar, gbarno, gl = [
x * nS for x in maximal_conductances[neuron_type]
]
# Classical Na channel
eqs_na = """
ina = gnabar*m**3*h*(ENa-v) : amp
dm/dt=q10*(minf-m)/mtau : 1
dh/dt=q10*(hinf-h)/htau : 1
minf = 1./(1+exp(-(vu + 38.) / 7.)) : 1
hinf = 1./(1+exp((vu + 65.) / 6.)) : 1
mtau = ((10. / (5*exp((vu+60.) / 18.) + 36.*exp(-(vu+60.) / 25.))) + 0.04)*ms : second
htau = ((100. / (7*exp((vu+60.) / 11.) + 10.*exp(-(vu+60.) / 25.))) + 0.6)*ms : second
"""
# KHT channel (delayed-rectifier K+)
eqs_kht = """
ikht = gkhtbar*(nf*n**2 + (1-nf)*p)*(EK-v) : amp
dn/dt=q10*(ninf-n)/ntau : 1
dp/dt=q10*(pinf-p)/ptau : 1
ninf = (1 + exp(-(vu + 15) / 5.))**-0.5 : 1
pinf = 1. / (1 + exp(-(vu + 23) / 6.)) : 1
ntau = ((100. / (11*exp((vu+60) / 24.) + 21*exp(-(vu+60) / 23.))) + 0.7)*ms : second
ptau = ((100. / (4*exp((vu+60) / 32.) + 5*exp(-(vu+60) / 22.))) + 5)*ms : second
"""
# Ih channel (subthreshold adaptive, non-inactivating)
eqs_ih = """
ih = ghbar*r*(EH-v) : amp
dr/dt=q10*(rinf-r)/rtau : 1
rinf = 1. / (1+exp((vu + 76.) / 7.)) : 1
rtau = ((100000. / (237.*exp((vu+60.) / 12.) + 17.*exp(-(vu+60.) / 14.))) + 25.)*ms : second
"""
# KLT channel (low threshold K+)
eqs_klt = """
iklt = gkltbar*w**4*z*(EK-v) : amp
dw/dt=q10*(winf-w)/wtau : 1
dz/dt=q10*(zinf-z)/ztau : 1
winf = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25 : 1
zinf = zss + ((1.-zss) / (1 + exp((vu + 71.) / 10.))) : 1
wtau = ((100. / (6.*exp((vu+60.) / 6.) + 16.*exp(-(vu+60.) / 45.))) + 1.5)*ms : second
ztau = ((1000. / (exp((vu+60.) / 20.) + exp(-(vu+60.) / 8.))) + 50)*ms : second
"""
# Ka channel (transient K+)
eqs_ka = """
ika = gkabar*a**4*b*c*(EK-v): amp
da/dt=q10*(ainf-a)/atau : 1
db/dt=q10*(binf-b)/btau : 1
dc/dt=q10*(cinf-c)/ctau : 1
ainf = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25 : 1
binf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1
cinf = 1. / (1 + exp((vu + 66) / 7.))**0.5 : 1
atau = ((100. / (7*exp((vu+60) / 14.) + 29*exp(-(vu+60) / 24.))) + 0.1)*ms : second
btau = ((1000. / (14*exp((vu+60) / 27.) + 29*exp(-(vu+60) / 24.))) + 1)*ms : second
ctau = ((90. / (1 + exp((-66-vu) / 17.))) + 10)*ms : second
"""
# Leak
eqs_leak = """
ileak = gl*(EL-v) : amp
"""
# h current for octopus cells
eqs_hcno = """
ihcno = gbarno*(h1*frac + h2*(1-frac))*(EH-v) : amp
dh1/dt=(hinfno-h1)/tau1 : 1
dh2/dt=(hinfno-h2)/tau2 : 1
hinfno = 1./(1+exp((vu+66.)/7.)) : 1
tau1 = bet1/(qt*0.008*(1+alp1))*ms : second
tau2 = bet2/(qt*0.0029*(1+alp2))*ms : second
alp1 = exp(1e-3*3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1
bet1 = exp(1e-3*3*0.3*(vu+50)*9.648e4/(8.315*(273.16+temp_degC))) : 1
alp2 = exp(1e-3*3*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1
bet2 = exp(1e-3*3*0.6*(vu+84)*9.648e4/(8.315*(273.16+temp_degC))) : 1
"""
eqs = """
dv/dt = (ileak + ina + ikht + iklt + ika + ih + ihcno + I + Is_e + Is_i)/C : volt
Is_e = gs_e * (Es_e - v) : amp
gs_e : siemens
Is_i = gs_i * (Es_i - v) : amp
gs_i : siemens
vu = v/mV : 1 # unitless v
I : amp
"""
#Added Is_i to RM2003
eqs += eqs_leak + eqs_ka + eqs_na + eqs_ih + eqs_klt + eqs_kht + eqs_hcno
lsonGrp = NeuronGroup(nLsons,
eqs,
method='exponential_euler',
threshold='v > -30*mV',
refractory='v > -45*mV')
lsonGrp.I = 0.0 * pA
# Initialize model near v_rest with no inputs
lsonGrp.v = Vrest
vu = lsonGrp.v / mV # unitless v
lsonGrp.m = 1. / (1 + exp(-(vu + 38.) / 7.))
lsonGrp.h = 1. / (1 + exp((vu + 65.) / 6.))
lsonGrp.n = (1 + exp(-(vu + 15) / 5.))**-0.5
lsonGrp.p = 1. / (1 + exp(-(vu + 23) / 6.))
lsonGrp.r = 1. / (1 + exp((vu + 76.) / 7.))
lsonGrp.w = (1. / (1 + exp(-(vu + 48.) / 6.)))**0.25
lsonGrp.z = zss + ((1. - zss) / (1 + exp((vu + 71.) / 10.)))
lsonGrp.a = (1. / (1 + exp(-(vu + 31) / 6.)))**0.25
lsonGrp.b = 1. / (1 + exp((vu + 66) / 7.))**0.5
lsonGrp.c = 1. / (1 + exp((vu + 66) / 7.))**0.5
lsonGrp.h1 = 1. / (1 + exp((vu + 66.) / 7.))
lsonGrp.h2 = 1. / (1 + exp((vu + 66.) / 7.))
#lsonGrp.gs_e = 0.0*siemens
lsonSynI = Synapses(gbCoSpkGenGrp,
lsonGrp,
model='''dg_i/dt = -g_i/tausI : siemens (clock-driven)
gs_i_post = g_i : siemens (summed)''',
on_pre='g_i += w_ilson*siemens',
method='exact')
lsonSynI.connect(i=np.arange(nGbcsCoPerLson), j=0)
lsonSynE = Synapses(sbIpSpkGenGrp,
lsonGrp,
model='''dg_e/dt = -g_e/tausE : siemens (clock-driven)
gs_e_post = g_e : siemens (summed)''',
on_pre='g_e += w_elson*siemens',
method='exact')
lsonSynE.connect(i=np.arange(nSbcsIpPerLson), j=0)
lsonSpks = SpikeMonitor(lsonGrp)
lsonState = StateMonitor(lsonGrp, ['v', 'gs_e'], record=True)
run(8150 * ms, report='text')
plt.plot(lsonState.t / ms, lsonState[0].v / mV)
#plt.plot(gbcState.t / ms, gbcState[0].gs_e)
#plt.plot(gSynEState.t / ms, gSynEState[0].gs_e_post)
#plt.plot(gSynEState.t / ms, gSynEState[0].g_e)
plt.xlabel('t (ms)')
plt.ylabel('v (mV)')
plt.show()
dBSPLStrCo = anCoSpkFile[28:30]
dBSPLStrIp = anIpSpkFile[28:30]
dBSPLCo = int(dBSPLStrCo)
dBSPLIp = int(dBSPLStrIp)
IIDdB = dBSPLCo - dBSPLIp
if (IIDdB >= 0):
IIDdBStr = 'IIDP' + str(IIDdB).zfill(2) + 'dBSPL'
elif (IIDdB < 0):
IIDdBStr = 'IIDN' + str(-IIDdB).zfill(2) + 'dBSPL'
# Synaptic parameters in output filename
if (abs(round(tausE / ms) - (tausE / ms)) < 0.1):
Te = str(round(tausE / ms))
else:
#Te = str(tausE/ms)
Te = str(round(10 * tausE / ms) / 10.)
Te = Te.replace('.', 'p')
if (abs(round(w_elson / 1e-9) - (w_elson / 1e-9)) < 0.1):
We = str(round(w_elson / 1e-9))
else:
#We = str(w_elson/1e-9)
We = str(round(10 * w_elson / 1e-9) / 10)
We = We.replace('.', 'p')
if (abs(round(tausI / ms) - (tausI / ms)) < 0.1):
Ti = str(round(tausI / ms))
else:
Ti = str(tausI / ms)
Ti = Ti.replace('.', 'p')
if (abs(round(w_ilson / 1e-9) - (w_ilson / 1e-9)) < 0.1):
Wi = str(round(w_ilson / 1e-9))
else:
Wi = str(w_ilson / 1e-9)
Wi = Wi.replace('.', 'p')
# CaCF, Te We Ti Wi, IID, SPLdBiNNcDD, .txt
lsonSpkFile = 'Lso2zSpTms' + anCoSpkFile[
10:
17] + 'Te' + Te + 'We' + We + 'Ti' + Ti + 'Wi' + Wi + IIDdBStr + 'co' + dBSPLStrCo + 'ip' + dBSPLStrIp + anCoSpkFile[
35:]
file0 = open(lsonSpkFile, 'w')
for index in range(len(lsonSpks.t)):
file0.write(
str(lsonSpks.i[index]) + " " + str(lsonSpks.t[index] / ms) + '\n')
file0.close()
return (lsonGrp, lsonSpks, lsonState)
# end of mkgbcs
def run_net(tr):
# prefs.codegen.target = 'numpy'
# prefs.codegen.target = 'cython'
set_device('cpp_standalone', directory='./builds/%.4d'%(tr.v_idx),
build_on_run=False)
print("Started process with id ", str(tr.v_idx))
namespace = tr.netw.f_to_dict(short_names=True, fast_access=True)
namespace['idx'] = tr.v_idx
defaultclock.dt = tr.netw.sim.dt
GExc = NeuronGroup(N=tr.N_e, model=tr.condlif_sig,
threshold=tr.nrnEE_thrshld,
reset=tr.nrnEE_reset, #method=tr.neuron_method,
namespace=namespace)
GInh = NeuronGroup(N=tr.N_i, model=tr.condlif_sig,
threshold ='V > Vt',
reset='V=Vr_i', #method=tr.neuron_method,
namespace=namespace)
# set initial thresholds fixed, init. potentials uniformly distrib.
GExc.sigma, GInh.sigma = tr.sigma_e, tr.sigma_i
GExc.Vt, GInh.Vt = tr.Vt_e, tr.Vt_i
GExc.V , GInh.V = np.random.uniform(tr.Vr_e/mV, tr.Vt_e/mV,
size=tr.N_e)*mV, \
np.random.uniform(tr.Vr_i/mV, tr.Vt_i/mV,
size=tr.N_i)*mV
synEE_pre_mod = mod.synEE_pre
synEE_post_mod = mod.synEE_post
if tr.stdp_active:
synEE_pre_mod = '''%s
%s''' %(synEE_pre_mod, mod.synEE_pre_STDP)
synEE_post_mod = '''%s
%s''' %(synEE_post_mod, mod.synEE_post_STDP)
if tr.synEE_rec:
synEE_pre_mod = '''%s
%s''' %(synEE_pre_mod, mod.synEE_pre_rec)
synEE_post_mod = '''%s
%s''' %(synEE_post_mod, mod.synEE_post_rec)
# E<-E advanced synapse model, rest simple
SynEE = Synapses(target=GExc, source=GExc, model=tr.synEE_mod,
on_pre=synEE_pre_mod, on_post=synEE_post_mod,
#method=tr.synEE_method,
namespace=namespace)
SynIE = Synapses(target=GInh, source=GExc, on_pre='ge_post += a_ie',
namespace=namespace)
SynEI = Synapses(target=GExc, source=GInh, on_pre='gi_post += a_ei',
namespace=namespace)
SynII = Synapses(target=GInh, source=GInh, on_pre='gi_post += a_ii',
namespace=namespace)
if tr.strct_active:
sEE_src, sEE_tar = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=sEE_src, j=sEE_tar)
SynEE.syn_active = 0
else:
srcs_full, tars_full = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=srcs_full, j=tars_full)
SynEE.syn_active = 0
sIE_src, sIE_tar = generate_connections(tr.N_i, tr.N_e, tr.p_ie)
sEI_src, sEI_tar = generate_connections(tr.N_e, tr.N_i, tr.p_ei)
sII_src, sII_tar = generate_connections(tr.N_i, tr.N_i, tr.p_ii,
same=True)
SynIE.connect(i=sIE_src, j=sIE_tar)
SynEI.connect(i=sEI_src, j=sEI_tar)
SynII.connect(i=sII_src, j=sII_tar)
tr.f_add_result('sIE_src', sIE_src)
tr.f_add_result('sIE_tar', sIE_tar)
tr.f_add_result('sEI_src', sEI_src)
tr.f_add_result('sEI_tar', sEI_tar)
tr.f_add_result('sII_src', sII_src)
tr.f_add_result('sII_tar', sII_tar)
if tr.strct_active:
SynEE.a = 0
else:
SynEE.a = tr.a_ee
SynEE.insert_P = tr.insert_P
# make synapse active at beginning
if not tr.strct_active:
SynEE.run_regularly(tr.synEE_p_activate, dt=tr.T, when='start',
order=-100)
# synaptic scaling
if tr.netw.config.scl_active:
SynEE.summed_updaters['Asum_post']._clock = Clock(
dt=tr.dt_synEE_scaling)
SynEE.run_regularly(tr.synEE_scaling, dt = tr.dt_synEE_scaling,
when='end')
# intrinsic plasticity
if tr.netw.config.it_active:
GExc.h_ip = tr.h_ip
GExc.run_regularly(tr.intrinsic_mod, dt = tr.it_dt, when='end')
# structural plasticity
if tr.netw.config.strct_active:
SynEE.run_regularly(tr.strct_mod, dt = tr.strct_dt, when='end')
# -------------- recording ------------------
#run(tr.sim.preT)
GExc_recvars = []
if tr.memtraces_rec:
GExc_recvars.append('V')
if tr.vttraces_rec:
GExc_recvars.append('Vt')
if tr.getraces_rec:
GExc_recvars.append('ge')
if tr.gitraces_rec:
GExc_recvars.append('gi')
GInh_recvars = GExc_recvars
GExc_stat = StateMonitor(GExc, GExc_recvars, record=[0,1,2],
dt=tr.GExc_stat_dt)
GInh_stat = StateMonitor(GInh, GInh_recvars, record=[0,1,2],
dt=tr.GInh_stat_dt)
SynEE_recvars = []
if tr.synee_atraces_rec:
SynEE_recvars.append('a')
if tr.synee_Apretraces_rec:
SynEE_recvars.append('Apre')
if tr.synee_Aposttraces_rec:
SynEE_recvars.append('Apost')
SynEE_stat = StateMonitor(SynEE, SynEE_recvars,
record=range(tr.n_synee_traces_rec),
when='end', dt=tr.synEE_stat_dt)
GExc_spks = SpikeMonitor(GExc)
GInh_spks = SpikeMonitor(GInh)
SynEE_a = StateMonitor(SynEE, ['a','syn_active'],
record=range(tr.N_e*(tr.N_e-1)),
dt=tr.sim.T/10., when='end', order=100)
run(tr.sim.T, report='text')
SynEE_a.record_single_timestep()
device.build(directory='../builds/%.4d'%(tr.v_idx))
tr.v_standard_result = Brian2MonitorResult
tr.f_add_result('GExc_stat', GExc_stat)
tr.f_add_result('SynEE_stat', SynEE_stat)
print("Saving exc spikes... ", GExc_spks.get_states()['N'])
tr.f_add_result('GExc_spks', GExc_spks)
tr.f_add_result('GInh_stat', GInh_stat)
print("Saving inh spikes... ", GInh_spks.get_states()['N'])
tr.f_add_result('GInh_spks', GInh_spks)
tr.f_add_result('SynEE_a', SynEE_a)
# ----------------- add raw data ------------------------
fpath = '../builds/%.4d/'%(tr.v_idx)
from pathlib import Path
Path(fpath+'turnover').touch()
turnover_data = np.genfromtxt(fpath+'turnover',delimiter=',')
tr.f_add_result('turnover', turnover_data)
os.remove(fpath+'turnover')
Path(fpath+'spk_register').touch()
spk_register_data = np.genfromtxt(fpath+'spk_register',delimiter=',')
tr.f_add_result('spk_register', spk_register_data)
os.remove(fpath+'spk_register')
