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