def dendrite_model__parameter_sweep(data_file_list, L_di_vec, tau_di_vec,
dt_vec, tf_vec, drive_info, amp_vec,
mu1_vec, mu2_vec, mu3_vec, mu4_vec,
master_error_plot_name):
master_error_plot_name = 'mstr_err__' + master_error_plot_name
best_params = dict()
best_params['amp_mu12'] = []
best_params['amp_mu34'] = []
best_params['mu1'] = []
best_params['mu2'] = []
best_params['mu3'] = []
best_params['mu4'] = []
data_array = dict()
data_array['amp_vec'] = amp_vec
data_array['mu1_vec'] = mu1_vec
data_array['mu2_vec'] = mu2_vec
data_array['mu3_vec'] = mu3_vec
data_array['mu4_vec'] = mu4_vec
num_sims = len(data_file_list)
num_amps = len(amp_vec)
num_mu1 = len(mu1_vec)
num_mu2 = len(mu2_vec)
num_mu3 = len(mu3_vec)
num_mu4 = len(mu4_vec)
mu3_initial = 0 #1
mu4_initial = 0 #0.5
print(
'\n\nrunning dendrite_model__parameter_sweep\n\nnum_files = {:d}\nnum_amps = {:d}\nnum_mu1 = {:d}\nnum_mu2 = {:d}\nnum_mu3 = {:d}\nnum_mu4 = {:d}'
.format(num_sims, num_amps, num_mu1, num_mu2, num_mu3, num_mu4))
error_mat_master__mu1_mu2 = np.zeros([num_amps, num_mu1, num_mu2])
error_mat_master__mu3_mu4 = np.zeros([num_amps, num_mu3, num_mu4])
if drive_info['drive_type'] == 'piecewise_linear':
pwl_drive = drive_info['pwl_drive']
directory_string = 'constant_drive'
wr_drive_string = '@I0[c]'
wr_target_string = 'L9#branch'
if drive_info['drive_type'] == 'linear_ramp':
pwl_drive = drive_info['pwl_drive']
directory_string = 'linear_ramp'
wr_drive_string = '@I0[c]'
wr_target_string = 'L9#branch'
if drive_info['drive_type'] == 'sq_pls_trn':
sq_pls_trn_params = drive_info['sq_pls_trn_params']
directory_string = 'square_pulse_sequence'
wr_drive_string = '@I0[c]'
wr_target_string = 'L9#branch'
if drive_info['drive_type'] == 'exp_pls_trn':
exp_pls_trn_params = drive_info['exp_pls_trn_params']
directory_string = 'exponential_pulse_sequence'
wr_drive_string = 'L5#branch'
wr_target_string = 'L10#branch'
for ii in range(num_sims):
print('\ndata_file {} of {}\n'.format(ii + 1, num_sims))
plt.close('all')
dt = dt_vec[ii]
tf = tf_vec[ii]
# WR data
print('reading wr data ...\n')
file_name = data_file_list[ii] + '.dat'
data_dict = read_wr_data('wrspice_data/' + directory_string + '/' +
file_name)
target_data = np.vstack(
(data_dict['time'], data_dict[wr_target_string]))
#----------------------
# compare drive signals
#----------------------
target_data__drive = np.vstack(
(data_dict['time'], data_dict[wr_drive_string]))
# initialize input signal
if drive_info['drive_type'] == 'piecewise_linear' or drive_info[
'drive_type'] == 'linear_ramp':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
piecewise_linear=pwl_drive)
dendritic_drive = dendritic_drive__piecewise_linear(
input_1.time_vec, pwl_drive)
if drive_info['drive_type'] == 'sq_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
square_pulse_train=sq_pls_trn_params)
dendritic_drive = dendritic_drive__square_pulse_train(
input_1.time_vec, sq_pls_trn_params)
if drive_info['drive_type'] == 'exp_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
exponential_pulse_train=exp_pls_trn_params)
dendritic_drive = dendritic_drive__exp_pls_train__LR(
input_1.time_vec, exp_pls_trn_params)
actual_data__drive = np.vstack(
(input_1.time_vec[:], dendritic_drive[:, 0]))
print('comparing drive signals ...\n')
error__drive = chi_squared_error(target_data__drive,
actual_data__drive)
#------------------------
# find best amp, mu1, mu2
#------------------------
mu3 = [mu3_initial] #np.linspace([0.5,2.5,10])
mu4 = [mu4_initial] #np.linspace([0.25,1.5,10])
error_mat_1 = np.zeros([num_amps, num_mu1, num_mu2])
print('seeking amp, mu1, mu2 ...')
for aa in range(num_amps):
for bb in range(num_mu1):
for cc in range(num_mu2):
print('aa = {} of {}, bb = {} of {}, cc = {} of {}'.format(
aa + 1, num_amps, bb + 1, num_mu1, cc + 1, num_mu2))
# create sim_params dictionary
sim_params = dict()
sim_params['amp'] = amp_vec[aa]
sim_params['mu1'] = mu1_vec[bb]
sim_params['mu2'] = mu2_vec[cc]
sim_params['mu3'] = mu3
sim_params['mu4'] = mu4
sim_params['dt'] = dt
sim_params['tf'] = tf
# initialize dendrite
dendrite_1 = dendrite(
'dendrite_under_test',
inhibitory_or_excitatory='excitatory',
circuit_inductances=[
10e-12, 26e-12, 200e-12, 77.5e-12
],
input_synaptic_connections=[],
input_synaptic_inductances=[[]],
input_dendritic_connections=[],
input_dendritic_inductances=[[]],
input_direct_connections=['input_dendritic_drive'],
input_direct_inductances=[[10e-12, 1]],
thresholding_junction_critical_current=40e-6,
bias_currents=[72e-6, 29e-6, 35e-6],
integration_loop_self_inductance=L_di_vec[ii],
integration_loop_output_inductance=0e-12,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_di_vec[ii],
integration_loop_saturation_current=11.75e-6,
dendrite_model_params=sim_params)
dendrite_1.run_sim()
actual_data = np.vstack(
(input_1.time_vec[:], dendrite_1.I_di[:, 0]))
error_mat_1[aa, bb, cc] = chi_squared_error(
target_data, actual_data)
error_mat_master__mu1_mu2 += error_mat_1
ind_best = np.where(
error_mat_1 == np.amin(error_mat_1)) #error_mat.argmin()
amp_best_mu12 = amp_vec[ind_best[0]][0]
mu1_best = mu1_vec[ind_best[1]][0]
mu2_best = mu2_vec[ind_best[2]][0]
print('\n\namp_best_mu12 = {}'.format(amp_best_mu12))
print('mu1_best = {}'.format(mu1_best))
print('mu2_best = {}\n\n'.format(mu2_best))
best_params['amp_mu12'].append(amp_best_mu12)
best_params['mu1'].append(mu1_best)
best_params['mu2'].append(mu2_best)
data_array['error_mat__amp_mu1_mu2'] = error_mat_1
#plot errors
title_string = '{}\namp_best_mu12 = {:2.2f}, mu1_best = {:1.2f}, mu2_best = {:1.2f}'.format(
data_file_list[ii], amp_best_mu12, mu1_best, mu2_best)
save_str = '{}__error__mu1_mu2'.format(data_file_list[ii])
for aa in range(num_amps):
plot_error_mat(error_mat_1[aa, :, :], mu1_vec, mu2_vec, 'mu1',
'mu2', 'amp = {}'.format(amp_vec[aa]), title_string,
save_str)
#repeat best one and plot
if drive_info['drive_type'] == 'piecewise_linear' or drive_info[
'drive_type'] == 'linear_ramp':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
piecewise_linear=pwl_drive)
dendritic_drive = dendritic_drive__piecewise_linear(
input_1.time_vec, pwl_drive)
if drive_info['drive_type'] == 'sq_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
square_pulse_train=sq_pls_trn_params)
dendritic_drive = dendritic_drive__square_pulse_train(
input_1.time_vec, sq_pls_trn_params)
if drive_info['drive_type'] == 'exp_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
exponential_pulse_train=exp_pls_trn_params)
dendritic_drive = dendritic_drive__exp_pls_train__LR(
input_1.time_vec, exp_pls_trn_params)
sim_params = dict()
sim_params['amp'] = amp_best_mu12
sim_params['mu1'] = mu1_best
sim_params['mu2'] = mu2_best
sim_params['mu3'] = mu3
sim_params['mu4'] = mu4
sim_params['dt'] = dt
sim_params['tf'] = tf
dendrite_1 = dendrite(
'dendrite_under_test',
inhibitory_or_excitatory='excitatory',
circuit_inductances=[10e-12, 26e-12, 200e-12, 77.5e-12],
input_synaptic_connections=[],
input_synaptic_inductances=[[]],
input_dendritic_connections=[],
input_dendritic_inductances=[[]],
input_direct_connections=['input_dendritic_drive'],
input_direct_inductances=[[10e-12, 1]],
thresholding_junction_critical_current=40e-6,
bias_currents=[72e-6, 29e-6, 35e-6],
integration_loop_self_inductance=L_di_vec[ii],
integration_loop_output_inductance=0e-12,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_di_vec[ii],
integration_loop_saturation_current=11.75e-6,
dendrite_model_params=sim_params)
dendrite_1.run_sim()
# plot_dendritic_integration_loop_current(dendrite_1)
actual_data = np.vstack((input_1.time_vec[:], dendrite_1.I_di[:, 0]))
main_title = '{}\namp_best_{:2.2f}_mu1_best_{:1.4f}_mu2_best_{:1.4f}'.format(
data_file_list[ii], amp_best_mu12, mu1_best, mu2_best)
error__signal = np.amin(error_mat_1)
plot_wr_comparison__drive_and_response(main_title, target_data__drive,
actual_data__drive, target_data,
actual_data, data_file_list[ii],
error__drive, error__signal)
#-----------------------------
# find best amp_mu34, mu3, mu4
#-----------------------------
error_mat_2 = np.zeros([num_amps, num_mu3, num_mu4])
print('seeking amp, mu3, mu4 ...')
for aa in range(num_amps):
for bb in range(num_mu1):
for cc in range(num_mu2):
print('aa = {} of {}, bb = {} of {}, cc = {} of {}'.format(
aa + 1, num_amps, bb + 1, num_mu3, cc + 1, num_mu4))
# initialize input signal
if drive_info[
'drive_type'] == 'piecewise_linear' or drive_info[
'drive_type'] == 'linear_ramp':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
piecewise_linear=pwl_drive)
dendritic_drive = dendritic_drive__piecewise_linear(
input_1.time_vec, pwl_drive)
if drive_info['drive_type'] == 'sq_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
square_pulse_train=sq_pls_trn_params)
dendritic_drive = dendritic_drive__square_pulse_train(
input_1.time_vec, sq_pls_trn_params)
if drive_info['drive_type'] == 'exp_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
exponential_pulse_train=exp_pls_trn_params)
dendritic_drive = dendritic_drive__exp_pls_train__LR(
input_1.time_vec, exp_pls_trn_params)
# create sim_params dictionary
sim_params = dict()
sim_params['amp'] = amp_vec[aa]
sim_params['mu1'] = mu1_best
sim_params['mu2'] = mu2_best
sim_params['mu3'] = mu3_vec[bb]
sim_params['mu4'] = mu4_vec[cc]
sim_params['dt'] = dt
sim_params['tf'] = tf
# initialize dendrite
dendrite_1 = dendrite(
'dendrite_under_test',
inhibitory_or_excitatory='excitatory',
circuit_inductances=[
10e-12, 26e-12, 200e-12, 77.5e-12
],
input_synaptic_connections=[],
input_synaptic_inductances=[[]],
input_dendritic_connections=[],
input_dendritic_inductances=[[]],
input_direct_connections=['input_dendritic_drive'],
input_direct_inductances=[[10e-12, 1]],
thresholding_junction_critical_current=40e-6,
bias_currents=[72e-6, 29e-6, 35e-6],
integration_loop_self_inductance=L_di_vec[ii],
integration_loop_output_inductance=0e-12,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_di_vec[ii],
integration_loop_saturation_current=11.75e-6,
dendrite_model_params=sim_params)
dendrite_1.run_sim()
actual_data = np.vstack(
(input_1.time_vec[:], dendrite_1.I_di[:, 0]))
error_mat_2[aa, bb, cc] = chi_squared_error(
target_data, actual_data)
error_mat_master__mu3_mu4 += error_mat_2
ind_best = np.where(
error_mat_2 == np.amin(error_mat_2)) #error_mat.argmin()
amp_best_mu34 = amp_vec[ind_best[0]][0]
mu3_best = mu3_vec[ind_best[1]][0]
mu4_best = mu4_vec[ind_best[2]][0]
print('\n\namp_best_mu34 = {}'.format(amp_best_mu34))
print('mu3_best = {}'.format(mu3_best))
print('mu4_best = {}'.format(mu4_best))
best_params['amp_mu34'].append(amp_best_mu34)
best_params['mu3'].append(mu3_best)
best_params['mu4'].append(mu4_best)
data_array['error_mat__mu3_mu4'] = error_mat_2
#plot errors
title_string = '{}\namp_best_mu12 = {:2.2f}, amp_best_mu34 = {:2.2f}, mu1_best = {:1.2f}, mu2_best = {:1.2f}, mu3_best = {:1.2f}, mu4_best = {:1.2f}'.format(
data_file_list[ii], amp_best_mu12, amp_best_mu34, mu1_best,
mu2_best, mu3_best, mu4_best)
save_str = '{}__error__mu3_mu4'.format(data_file_list[ii])
for aa in range(num_amps):
plot_error_mat(error_mat_2[aa, :, :], mu3_vec, mu4_vec, 'mu3',
'mu4', 'amp = {}'.format(amp_vec[aa]), title_string,
save_str)
#repeat best one and plot
if drive_info['drive_type'] == 'piecewise_linear' or drive_info[
'drive_type'] == 'linear_ramp':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
piecewise_linear=pwl_drive)
dendritic_drive = dendritic_drive__piecewise_linear(
input_1.time_vec, pwl_drive)
if drive_info['drive_type'] == 'sq_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
square_pulse_train=sq_pls_trn_params)
dendritic_drive = dendritic_drive__square_pulse_train(
input_1.time_vec, sq_pls_trn_params)
if drive_info['drive_type'] == 'exp_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
exponential_pulse_train=exp_pls_trn_params)
dendritic_drive = dendritic_drive__exp_pls_train__LR(
input_1.time_vec, exp_pls_trn_params)
sim_params = dict()
sim_params['amp'] = amp_best_mu34
sim_params['mu1'] = mu1_best
sim_params['mu2'] = mu2_best
sim_params['mu3'] = mu3_best
sim_params['mu4'] = mu4_best
sim_params['dt'] = dt
sim_params['tf'] = tf
dendrite_1 = dendrite(
'dendrite_under_test',
inhibitory_or_excitatory='excitatory',
circuit_inductances=[10e-12, 26e-12, 200e-12, 77.5e-12],
input_synaptic_connections=[],
input_synaptic_inductances=[[]],
input_dendritic_connections=[],
input_dendritic_inductances=[[]],
input_direct_connections=['input_dendritic_drive'],
input_direct_inductances=[[10e-12, 1]],
thresholding_junction_critical_current=40e-6,
bias_currents=[72e-6, 29e-6, 35e-6],
integration_loop_self_inductance=L_di_vec[ii],
integration_loop_output_inductance=0e-12,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_di_vec[ii],
integration_loop_saturation_current=11.75e-6,
dendrite_model_params=sim_params)
dendrite_1.run_sim()
main_title = '{}\namp_best_mu12_{:2.2f}_amp_best_mu34_{:2.2f}_mu1_best_{:1.2f}_mu2_best_{:1.2f}_mu3_best_{:1.2f}_mu4_best_{:1.2f}'.format(
data_file_list[ii], amp_best_mu12, amp_best_mu34, mu1_best,
mu2_best, mu3_best, mu4_best)
actual_data = np.vstack((input_1.time_vec[:], dendrite_1.I_di[:, 0]))
error__signal = np.amin(error_mat_2)
plot_wr_comparison__drive_and_response(main_title, target_data__drive,
actual_data__drive, target_data,
actual_data, data_file_list[ii],
error__drive, error__signal)
# save data
save_string = 'wr_fits__finding_amp_mu1_mu2+mu3_mu4'
data_array['wr_spice_data_file_list'] = data_file_list
data_array['best_params'] = best_params
data_array['error_mat_master__mu1_mu2'] = error_mat_master__mu1_mu2
data_array['error_mat_master__mu3_mu4'] = error_mat_master__mu3_mu4
print('\n\nsaving session data ...')
save_session_data(data_array, save_string)
#plot errors
title_string = '{}\namp_best_mu12 = {:2.2f}, amp_best_mu34 = {:2.2f}, mu1_best = {:1.2f}, mu2_best = {:1.2f}, mu3_best = {:1.2f}, mu4_best = {:1.2f}'.format(
master_error_plot_name, amp_best_mu12, amp_best_mu34, mu1_best,
mu2_best, mu3_best, mu4_best)
for aa in range(num_amps):
save_str_1 = '{}__master_error__mu1_mu2__amp_{:2.2f}'.format(
master_error_plot_name, amp_vec[aa])
save_str_2 = '{}__master_error__mu3_mu4__amp_{:2.2f}'.format(
master_error_plot_name, amp_vec[aa])
plot_error_mat(error_mat_master__mu1_mu2[aa, :, :], mu1_vec, mu2_vec,
'mu1', 'mu2', 'amp = {}'.format(amp_vec[aa]),
title_string, save_str_1)
plot_error_mat(error_mat_master__mu3_mu4[aa, :, :], mu3_vec, mu4_vec,
'mu3', 'mu4', 'amp = {}'.format(amp_vec[aa]),
title_string, save_str_2)
return best_params, error_mat_master__mu1_mu2, error_mat_master__mu3_mu4
def dendrite_model__parameter_sweep(data_file_list, L_di_vec, tau_di_vec,
dt_vec, tf_vec, drive_info, gamma1_vec,
gamma2_vec, master_error_plot_name):
master_error_plot_name = 'mstr_err__' + master_error_plot_name
best_params = dict()
best_params['gamma1'] = []
best_params['gamma2'] = []
data_array = dict()
data_array['gamma1_vec'] = gamma1_vec
data_array['gamma2_vec'] = gamma2_vec
num_sims = len(data_file_list)
num_gamma1 = len(gamma1_vec)
num_gamma2 = len(gamma2_vec)
print(
'\n\nrunning dendrite_model__parameter_sweep\n\nnum_files = {:d}\nnum_gamma1 = {:d}\nnum_gamma2 = {:d}'
.format(num_sims, num_gamma1, num_gamma2))
error_mat_master__gamma1_gamma2 = np.zeros([num_gamma1, num_gamma2])
if drive_info['drive_type'] == 'piecewise_linear':
pwl_drive = drive_info['pwl_drive']
directory_string = 'constant_drive'
wr_drive_string = '@I0[c]'
wr_target_string = 'L9#branch'
if drive_info['drive_type'] == 'linear_ramp':
pwl_drive = drive_info['pwl_drive']
directory_string = 'linear_ramp'
wr_drive_string = '@I0[c]'
wr_target_string = 'L9#branch'
if drive_info['drive_type'] == 'sq_pls_trn':
sq_pls_trn_params = drive_info['sq_pls_trn_params']
directory_string = 'square_pulse_sequence'
wr_drive_string = '@I0[c]'
wr_target_string = 'L9#branch'
if drive_info['drive_type'] == 'exp_pls_trn':
exp_pls_trn_params = drive_info['exp_pls_trn_params']
directory_string = 'exponential_pulse_sequence'
wr_drive_string = 'L5#branch'
wr_target_string = 'L10#branch'
for ii in range(num_sims):
print('\ndata_file {} of {}\n'.format(ii + 1, num_sims))
plt.close('all')
dt = dt_vec[ii]
tf = tf_vec[ii]
# WR data
print('reading wr data ...\n')
file_name = data_file_list[ii] + '.dat'
data_dict = read_wr_data('wrspice_data/' + directory_string + '/' +
file_name)
target_data = np.vstack(
(data_dict['time'], data_dict[wr_target_string]))
#----------------------
# compare drive signals
#----------------------
target_data__drive = np.vstack(
(data_dict['time'], data_dict[wr_drive_string]))
# initialize input signal
if drive_info['drive_type'] == 'piecewise_linear' or drive_info[
'drive_type'] == 'linear_ramp':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
piecewise_linear=pwl_drive)
dendritic_drive = dendritic_drive__piecewise_linear(
input_1.time_vec, pwl_drive)
if drive_info['drive_type'] == 'sq_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
square_pulse_train=sq_pls_trn_params)
dendritic_drive = dendritic_drive__square_pulse_train(
input_1.time_vec, sq_pls_trn_params)
if drive_info['drive_type'] == 'exp_pls_trn':
input_1 = input_signal(
'input_dendritic_drive',
input_temporal_form='analog_dendritic_drive',
output_inductance=200e-12,
time_vec=np.arange(0, tf + dt, dt),
exponential_pulse_train=exp_pls_trn_params)
dendritic_drive = dendritic_drive__exp_pls_train__LR(
input_1.time_vec, exp_pls_trn_params)
actual_data__drive = np.vstack(
(input_1.time_vec[:], dendritic_drive[:, 0]))
print('comparing drive signals ...\n')
error__drive = chi_squared_error(target_data__drive,
actual_data__drive)
#------------------------
# find best amp, gamma1, gamma2
#------------------------
error_mat_1 = np.zeros([num_gamma1, num_gamma2])
print('seeking gamma1, gamma2 ...')
for aa in range(num_gamma1):
for bb in range(num_gamma2):
print('aa = {} of {}, bb = {} of {}'.format(
aa + 1, num_gamma1, bb + 1, num_gamma2))
# create sim_params dictionary
sim_params = dict()
sim_params['gamma1'] = gamma1_vec[aa]
sim_params['gamma2'] = gamma2_vec[bb]
sim_params['dt'] = dt
sim_params['tf'] = tf
# initialize dendrite
dendrite_1 = dendrite(
'dendrite_under_test',
inhibitory_or_excitatory='excitatory',
circuit_inductances=[10e-12, 26e-12, 200e-12, 77.5e-12],
input_synaptic_connections=[],
input_synaptic_inductances=[[]],
input_dendritic_connections=[],
input_dendritic_inductances=[[]],
input_direct_connections=['input_dendritic_drive'],
input_direct_inductances=[[10e-12, 1]],
thresholding_junction_critical_current=40e-6,
bias_currents=[72e-6, 29e-6, 35e-6],
integration_loop_self_inductance=L_di_vec[ii],
integration_loop_output_inductance=0e-12,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_di_vec[ii],
integration_loop_saturation_current=11.75e-6,
dendrite_model_params=sim_params)
dendrite_1.run_sim()
actual_data = np.vstack(
(input_1.time_vec[:], dendrite_1.I_di[:, 0]))
error_mat_1[aa,
bb] = chi_squared_error(target_data, actual_data)
error_mat_master__gamma1_gamma2 += error_mat_1
ind_best = np.where(
error_mat_1 == np.amin(error_mat_1)) #error_mat.argmin()
gamma1_best = gamma1_vec[ind_best[0]][0]
gamma2_best = gamma2_vec[ind_best[1]][0]
print('gamma1_best = {}'.format(gamma1_best))
print('gamma2_best = {}\n\n'.format(gamma2_best))
best_params['gamma1'].append(gamma1_best)
best_params['gamma2'].append(gamma2_best)
data_array['error_mat__amp_gamma1_gamma2'] = error_mat_1
#plot errors
title_string = '{}\ngamma1_best = {:1.2f}, gamma2_best = {:1.2f}'.format(
data_file_list[ii], gamma1_best, gamma2_best)
save_str = '{}__error__gamma1_gamma2'.format(data_file_list[ii])
# plot_error_mat(error_mat_1[:,:],gamma1_vec,gamma2_vec,'gamma1','gamma2',title_string,save_str)
# #repeat best one and plot
# if drive_info['drive_type'] == 'piecewise_linear' or drive_info['drive_type'] == 'linear_ramp':
# input_1 = input_signal('input_dendritic_drive', input_temporal_form = 'analog_dendritic_drive', output_inductance = 200e-12,
# time_vec = np.arange(0,tf+dt,dt), piecewise_linear = pwl_drive)
# dendritic_drive = dendritic_drive__piecewise_linear(input_1.time_vec,pwl_drive)
# if drive_info['drive_type'] == 'sq_pls_trn':
# input_1 = input_signal('input_dendritic_drive', input_temporal_form = 'analog_dendritic_drive', output_inductance = 200e-12,
# time_vec = np.arange(0,tf+dt,dt), square_pulse_train = sq_pls_trn_params)
# dendritic_drive = dendritic_drive__square_pulse_train(input_1.time_vec,sq_pls_trn_params)
# if drive_info['drive_type'] == 'exp_pls_trn':
# input_1 = input_signal('input_dendritic_drive', input_temporal_form = 'analog_dendritic_drive', output_inductance = 200e-12,
# time_vec = np.arange(0,tf+dt,dt), exponential_pulse_train = exp_pls_trn_params)
# dendritic_drive = dendritic_drive__exp_pls_train__LR(input_1.time_vec,exp_pls_trn_params)
# sim_params = dict()
# sim_params['gamma1'] = gamma1_best
# sim_params['gamma2'] = gamma2_best
# sim_params['dt'] = dt
# sim_params['tf'] = tf
# dendrite_1 = dendrite('dendrite_under_test', inhibitory_or_excitatory = 'excitatory', circuit_inductances = [10e-12,26e-12,200e-12,77.5e-12],
# input_synaptic_connections = [], input_synaptic_inductances = [[]],
# input_dendritic_connections = [], input_dendritic_inductances = [[]],
# input_direct_connections = ['input_dendritic_drive'], input_direct_inductances = [[10e-12,1]],
# thresholding_junction_critical_current = 40e-6, bias_currents = [72e-6,29e-6,35e-6],
# integration_loop_self_inductance = L_di_vec[ii], integration_loop_output_inductance = 0e-12,
# integration_loop_temporal_form = 'exponential', integration_loop_time_constant = tau_di_vec[ii],
# integration_loop_saturation_current = 11.75e-6, dendrite_model_params = sim_params)
# dendrite_1.run_sim()
# # plot_dendritic_integration_loop_current(dendrite_1)
# actual_data = np.vstack((input_1.time_vec[:],dendrite_1.I_di[:,0]))
main_title = '{}\ngamma1_best_{:1.4f}_gamma2_best_{:1.4f}'.format(
data_file_list[ii], gamma1_best, gamma2_best)
error__signal = np.amin(error_mat_1)
plot_wr_comparison__dend_drive_and_response(
main_title, target_data__drive, actual_data__drive, target_data,
actual_data, data_file_list[ii], error__drive, error__signal)
# # save data
# save_string = 'wr_fits__finding_gamma1_gamma2'
# data_array['wr_spice_data_file_list'] = data_file_list
# data_array['best_params'] = best_params
# data_array['error_mat_master__gamma1_gamma2'] = error_mat_master__gamma1_gamma2
# print('\n\nsaving session data ...')
# save_session_data(data_array,save_string)
# #plot errors
# title_string = '{}; gamma1_best = {:1.2f}, gamma2_best = {:1.2f}'.format(master_error_plot_name,gamma1_best,gamma2_best)
# save_str_1 = '{}__master_error__gamma1_gamma2'.format(master_error_plot_name)
# plot_error_mat(error_mat_master__gamma1_gamma2[:,:],gamma1_vec,gamma2_vec,'gamma1','gamma2',title_string,save_str_1)
return best_params, error_mat_master__gamma1_gamma2
Id = 20
drv_params = dict()
drv_params['t_r1_start'] = 5
drv_params['t_r1_rise'] = 0.1
drv_params['t_r1_pulse'] = 0.2
drv_params['t_r1_fall'] = 1
drv_params['t_r1_period'] = isi
drv_params['value_r1_off'] = 0
drv_params['value_r1_on'] = 5e6
drv_params['L1'] = 100e3
drv_params['L2'] = 100e3
drv_params['r2'] = 200e3 / 50
drv_params['Ib'] = Id
I_d = dendritic_drive__exp_pls_train__LR(time_vec, drv_params)
#%% ode loop
Lt = L3 + L4
state_previous = 'off'
state_next = 'off'
I_1_vec = np.zeros([_nt])
I_3_vec = np.zeros([_nt])
ii_vec = np.arange(1, _nt - 1, 1)
for ii in ii_vec:
I_gate = I_1_vec[ii]
I_channel = Ib - I_3_vec[ii]
if state_previous == 'off':
if I_gate >= I_gate_on and I_channel >= I_channel_on:
def run_sim(self):
# set up time vec
dt = self.dendrite_model_params['dt']
tf = self.dendrite_model_params['tf']
time_vec = np.arange(0, tf + dt, dt)
# attach synapses, dendrites, and direct connections to dendrite
self.make_connections()
# print('simulating dendrite with {:d} synapses, {:d} dendrites, and {:d} direct connections\n\n'.format(len(self.synapses),len(self.dendrites),len(self.direct_connections)))
# calculate receiving loop inductance
# self.receiving_loop_total_inductance = self.circuit_inductances[0]+self.circuit_inductances[1]
# for ii in range(len(self.synapses)):
# self.receiving_loop_total_inductance += self.input_synaptic_inductances[ii][0]
# for ii in range(len(self.dendrites)):
# self.receiving_loop_total_inductance += self.input_dendritic_inductances[ii][0]
# for ii in range(len(self.direct_connections)):
# self.receiving_loop_total_inductance += self.input_direct_inductances[ii][0]
self.time_vec = time_vec
if hasattr(self.direct_connections[0], 'piecewise_linear'):
dendritic_drive = dendritic_drive__piecewise_linear(
time_vec, self.direct_connections[0].piecewise_linear)
if hasattr(self.direct_connections[0], 'square_pulse_train'):
dendritic_drive = dendritic_drive__square_pulse_train(
time_vec, self.direct_connections[0].square_pulse_train)
if hasattr(self.direct_connections[0], 'exponential_pulse_train'):
dendritic_drive = dendritic_drive__exp_pls_train__LR(
time_vec, self.direct_connections[0].exponential_pulse_train)
# if hasattr(self.direct_connections[0],'slope'):
# dendritic_drive = dendritic_drive__linear_ramp(time_vec, time_on = self.direct_connections[0].time_on, slope = self.direct_connections[0].slope)
# dendritic_drive = dendritic_drive__step_function(time_vec, amplitude = self.direct_connections[0].amplitude, time_on = self.direct_connections[0].time_on)
#
# plot_dendritic_drive(time_vec, dendritic_drive)
self.dendritic_drive = dendritic_drive
# I_b = self.bias_currents
# Ic = self.thresholding_junction_critical_current
# I_di_sat = self.integration_loop_saturation_current
tau_di = self.integration_loop_time_constant
# mu_1 = self.dendrite_model_params['mu1']
# mu_2 = self.dendrite_model_params['mu2']
# mu_3 = self.dendrite_model_params['mu3']
# mu_4 = self.dendrite_model_params['mu4']
# print('mu1 = {}'.format(mu_1))
# print('mu2 = {}'.format(mu_2))
# print('mu3 = {}'.format(mu_3))
# print('mu4 = {}'.format(mu_4))
# M_direct = self.input_direct_inductances[0][1]*np.sqrt(self.input_direct_inductances[0][0]*self.direct_connections[0].output_inductance)
# Lm2 = self.input_direct_inductances[0][0]
# Ldr1 = self.circuit_inductances[0]
# Ldr2 = self.circuit_inductances[1]
# L1 = self.circuit_inductances[2]
# L2 = self.circuit_inductances[3]
L3 = self.integration_loop_self_inductance + self.integration_loop_output_inductance
# L_reference = 10e-6
# A_prefactor = self.dendrite_model_params['amp']*L_reference/L3 #9.27586207*L_reference/L3#self.sim_params['A']*L_reference/L3 #
# print(A_prefactor)
# tau_di = self.integration_loop_time_constant
#I_di_vec = dendritic_time_stepper_old2(time_vec,A_prefactor,dendritic_drive,I_b,I_th,M_direct,Lm2,Ldr1,Ldr2,L1,L2,L3,tau_di,mu_1,mu_2,mu_3,mu_4)
# R = 4.125
# I_di_vec = dendritic_time_stepper(time_vec,R,dendritic_drive,I_b,Ic,M_direct,Lm2,Ldr1,Ldr2,L1,L2,L3,tau_di,mu_1,mu_2)
# dendrite_time_stepper(time_vec,I_drive,L3,tau_di)
I_di_vec = dendrite_time_stepper(time_vec, dendritic_drive, L3, tau_di)
self.I_di = I_di_vec
return self