def get_k_grad(t0, t1, dt, S_e, S_i, v, kernel_params):
""" Get gradients (dv_soma/dw) for individual synaptic activations from
fitted approximations.
Parameters
----------
t0, t1 : float
initial and final times for computing gradients
dt : float
simulation time step
S_e, S_i : array_like
input spike patterns for E and I synapses
v : ndarray
compartment voltages from simulation
kernel_params : list
parameters for fitted kernels (see dendrites.kernels)
Returns
-------
F_e, F_i : list
approximated gradients with associated synapse indices and presynaptic
spike times F_e = [f_e, z_ind_e, z_e]
"""
Z_e = sequences.subsequence(S_e, t0, t1)
Z_i = sequences.subsequence(S_i, t0, t1)
Z_e, z_ind_e = sequences.rate2temp(Z_e)
Z_i, z_ind_i = sequences.rate2temp(Z_i)
f_e, f_i = training.kernel_grad_ss(int(t0 / dt), int(t1 / dt), S_e, S_i,
cell.seg_e, cell.seg_i, cell.b_type_e,
cell.b_type_i, v, kernel_params, dt)
F_e = [f_e, z_ind_e, Z_e - t1]
F_i = [f_i, z_ind_i, Z_i - t1]
return F_e, F_i
def get_grad(cell, t0_ind, t1_ind, dt, S_e, S_i, soln, stim, I_inj):
""" Get gradients (dv_soma/dw) for individual synaptic activations by
solving variational equations between times t0 and t1 with fast somatic
conductances set to zero.
Parameters
----------
cell : dendrites.comp_model.CModel object
compartmental model instance used for simulation
t0, t1 : float
initial and final times for computing gradients
dt : float
simulation time step
S_e, S_i : array_like
input spike patterns fro E and I synapses
soln : list
model states [v, m, h, n, p] (output from cell.simulate)
stim : list
synapse indices and states [ind_e, ind_i, A_r, A_d, N_r, N_d, G_r, G_d]
Returns
-------
F_e, F_i : list
computed gradients with associated synapse indices and presynaptic
spike times F_e = [f_e, z_ind_e, z_e]
"""
t0 = t0_ind * dt
t1 = t1_ind * dt
F_e = np.zeros(len(S_e))
F_i = np.zeros(len(S_i))
IC_sub = cell.set_IC(soln, stim, t0_ind)
g_na_temp, g_k_temp = cell.P['g_na'], cell.P['g_k']
cell.P['g_na'] = 0
cell.P['g_k'] = 0
t_s, soln_s, stim_s = cell.simulate(t0,
t1,
dt,
IC_sub,
S_e,
S_i,
I_inj=I_inj)
Z_e = sequences.subsequence(S_e, t0, t1)
Z_i = sequences.subsequence(S_i, t0, t1)
z_ind_e = stim_s[0]
z_ind_i = stim_s[1]
Z_e = pad_S(Z_e)[z_ind_e]
Z_i = pad_S(Z_i)[z_ind_i]
f_e, f_i = cell.grad_w(soln_s, stim_s, t_s, dt, Z_e, Z_i, z_ind_e, z_ind_i)
cell.P['g_na'] = g_na_temp
cell.P['g_k'] = g_k_temp
for k in range(len(z_ind_e)):
F_e[z_ind_e[k]] += f_e[k, -1]
for k in range(len(z_ind_i)):
F_i[z_ind_i[k]] += f_i[k, -1]
return F_e, F_i
def get_grad(cell, t0, t1, dt, S_e, S_i, soln, stim):
""" Get gradients (dv_soma/dw) for individual synaptic activations by
solving variational equations between times t0 and t1 with fast somatic
conductances set to zero.
Parameters
----------
cell : dendrites.comp_model.CModel object
compartmental model instance used for simulation
t0, t1 : float
initial and final times for computing gradients
dt : float
simulation time step
S_e, S_i : array_like
input spike patterns for E and I synapses
soln : list
model states [v, m, h, n, p] (output from cell.simulate)
stim : list
synapse indices and states [ind_e, ind_i, A_r, A_d, N_r, N_d, G_r, G_d]
Returns
-------
v_pre : list
voltage throughout the morphology preceding somatic spike
F_e, F_i : list
computed gradients with associated synapse indices and presynaptic
spike times F_e = [f_e, z_ind_e, z_e]
"""
IC_sub = cell.set_IC(soln, stim, int(t0 / dt))
g_na_temp, g_k_temp = P['g_na'], P['g_k']
cell.P['g_na'] = 0
cell.P['g_k'] = 0
t_s, soln_s, stim_s = cell.simulate(t0, t1, dt, IC_sub, S_e, S_i)
Z_e = sequences.subsequence(S_e, t0, t1)
Z_i = sequences.subsequence(S_i, t0, t1)
Z_e, z_ind_e = sequences.rate2temp(Z_e)
Z_i, z_ind_i = sequences.rate2temp(Z_i)
f_e, f_i = cell.grad_w(soln_s, stim_s, t_s, dt, Z_e, Z_i, z_ind_e, z_ind_i)
cell.P['g_na'] = g_na_temp
cell.P['g_k'] = g_k_temp
v_pre = soln[0][:, int(t1 / dt)]
f_e = f_e[:, -1]
f_i = f_i[:, -1]
z_e = Z_e - t1
z_i = Z_i - t1
return [v_pre], [f_e, z_ind_e, z_e], [f_i, z_ind_i, z_i]
def kernel_grad(t0_ind, t1_ind, S_e, S_i, seg_e, seg_i, b_type_e, b_type_i, v,
kernel, dt):
"""Look up fitted plasticity kernels to approximate gradients. Sums over all
inputs to a synapse.
Parameters
----------
t0, t1 : int
time indices to define range for computing gradients
S_e, S_i : list
presynaptic spike times for E and I synapses
seg_e, seg_i : ndarray
segment locations of E and I synapses
b_type_e, b_type_i : list
branch types for all synapses (soma=-1, basal=0, oblique=1, apical=2)
v : ndarray
vector of model compartment voltages
kernel : list
parameters of plasticity kernel
dt : float
timestep
Returns
-------
f_e, f_i : ndarray
gradients (dv_soma/dw) for E and I synapses
"""
t0 = t0_ind * dt
t1 = t1_ind * dt
Z_e = sequences.subsequence(S_e, t0, t1)
Z_i = sequences.subsequence(S_i, t0, t1)
Z_e, z_ind_e = sequences.rate2temp(Z_e)
Z_i, z_ind_i = sequences.rate2temp(Z_i)
s_e = t1 - Z_e
s_i = t1 - Z_i
f_e = np.zeros(len(S_e))
f_i = np.zeros(len(S_i))
if len(kernel) == 2: # somatic only
p_es, p_is = kernel
for k, s in enumerate(s_e):
f_e[z_ind_e[k]] += p_es(s)
for k, s in enumerate(s_i):
f_i[z_ind_i[k]] += p_is(s)
else: # basal and apical
p_eb, p_ea, p_ib, p_ia = kernel
if np.size(p_eb[0]) == 1:
for k, s in enumerate(s_e):
if b_type_e[z_ind_e[k]] == 2:
f_e[z_ind_e[k]] += p_ea(s)
else:
f_e[z_ind_e[k]] += p_eb(s)
for k, s in enumerate(s_i):
if b_type_i[z_ind_i[k]] == 2:
f_i[z_ind_i[k]] += p_ia(s)
else:
f_i[z_ind_i[k]] += p_ib(s)
else:
if v.ndim == 1:
v_dend_e = v[seg_e[z_ind_e]]
v_dend_i = v[seg_i[z_ind_i]]
else:
v_dend_e = v[seg_e[z_ind_e], t1_ind]
v_dend_i = v[seg_i[z_ind_i], t1_ind]
for k, (s, u) in enumerate(zip(s_e, v_dend_e)):
if b_type_e[z_ind_e[k]] == 2:
f_e[z_ind_e[k]] += kernels.eval_poly(s, u, p_ea)
else:
f_e[z_ind_e[k]] += kernels.eval_poly(s, u, p_eb)
for k, (s, u) in enumerate(zip(s_i, v_dend_i)):
if b_type_i[z_ind_i[k]] == 2:
f_i[z_ind_i[k]] += kernels.eval_poly(s, u, p_ia)
else:
f_i[z_ind_i[k]] += kernels.eval_poly(s, u, p_ib)
return f_e, f_i