print('\n\nii = {} of {} (I_de); jj = {} of {} (L_di); kk = {} of {} (tau_di); qq = {} of {} (dt)'.format(ii+1,len(I_de_vec),jj+1,len(L_di_vec),kk+1,len(tau_di_vec),qq+1,len(dt_vec)))
# setup soen sim for exp pulse seq
input_1 = input_signal(name = 'input_synaptic_drive',
input_temporal_form = 'single_spike', # 'single_spike' or 'constant_rate' or 'arbitrary_spike_train'
spike_times = [5e-9])
synapse_1 = synapse(name = 'synapse_under_test',
synaptic_circuit_inductors = [100e-9,100e-9,400e-12],
synaptic_circuit_resistors = [5e3,4.008],
synaptic_hotspot_duration = 200e-12,
synaptic_spd_current = 10e-6,
input_direct_connections = ['input_synaptic_drive'],
num_jjs = num_jjs,
inhibitory_or_excitatory = 'excitatory',
synaptic_dendrite_circuit_inductances = [0e-12,20e-12,200e-12,77.5e-12],
synaptic_dendrite_input_synaptic_inductance = [20e-12,1],
junction_critical_current = 40e-6,
bias_currents = [I_de, 36e-6, 35e-6],
integration_loop_self_inductance = L_di,
integration_loop_output_inductance = 0e-12,
integration_loop_time_constant = tau_di)
neuron_1 = neuron('dummy_neuron',
input_synaptic_connections = ['synapse_under_test'],
input_synaptic_inductances = [[20e-12,1]],
junction_critical_current = 40e-6,
circuit_inductances = [0e-12,0e-12,200e-12,77.5e-12],
refractory_loop_circuit_inductances = [0e-12,20e-12,200e-12,77.5e-12],
refractory_time_constant = 50e-9,
input_synapses = []
input_inductances = []
for pp in range(num_synapses):
# initialize input signals
name__i = 'input_signal__{:d}_{:d}'.format(num_id,pp)
time_last_spike = num_tau_sim*tau_si_vec[ii]+observation_duration+2*1/rate_vec[jj]
input_1 = input_signal(name__i, input_temporal_form = 'constant_rate', spike_times = [rate_vec[jj],time_last_spike],
stochasticity = 'gaussian', jitter_params = jitter_params)
# print(input_1.spike_times)
# initialize synapses
name__s = 'input_synapse__{:d}_{:d}'.format(num_id,pp)
synapse_1 = synapse(name__s, integration_loop_temporal_form = 'exponential', integration_loop_time_constant = tau_si_vec[ii],
integration_loop_self_inductance = 50e-9, integration_loop_output_inductance = 200e-12,
synaptic_bias_current = I_sy_vec[kk], integration_loop_bias_current = 31e-6,
input_signal_name = name__i)
input_synapses.append(name__s)
coupling_factor = -0.0375*num_synapses+0.5375
input_inductances.append([10e-12,coupling_factor])
#initialize neuron
input_inductances.append([10e-12,0.5])
name__n = 'rate_encoding_neuron__{:d}'.format(num_id)
neuron_1 = neuron(name__n, input_synaptic_connections = input_synapses, input_synaptic_inductances = input_inductances,
thresholding_junction_critical_current = 40e-6, thresholding_junction_bias_current = 35e-6,
refractory_temporal_form = 'exponential', refractory_time_constant = tau_ref_vec[qq],
refractory_loop_self_inductance = 10e-9, refractory_loop_output_inductance = 200e-12)
# propagate in time
# setup soen sim for exp pulse seq
input_1 = input_signal(
name='in',
input_temporal_form=
'single_spike', # 'single_spike' or 'constant_rate' or 'arbitrary_spike_train'
spike_times=spike_times)
sy = synapse(
name='sy',
synaptic_circuit_inductors=[100e3, 100e3, 400],
synaptic_circuit_resistors=[5e6, 4.008e3],
synaptic_hotspot_duration=0.2,
synaptic_spd_current=10,
input_direct_connections=['in'],
num_jjs=num_jjs,
inhibitory_or_excitatory='excitatory',
synaptic_dendrite_circuit_inductances=[0, 20, 200, 77.5],
synaptic_dendrite_input_synaptic_inductance=[20, 1],
junction_critical_current=40,
bias_currents=[I_de, 36, 35],
integration_loop_self_inductance=L_di,
integration_loop_output_inductance=0,
integration_loop_time_constant=tau_di)
ne = neuron('ne',
input_synaptic_connections=['sy'],
input_synaptic_inductances=[[20, 1]],
junction_critical_current=40,
circuit_inductances=[0, 0, 200, 77.5],
refractory_loop_circuit_inductances=[0, 20, 200, 77.5],
refractory_time_constant=50,
]
I_sy = 33e-6
L_si = 775e-9
tau_si = 500e-9
# initialize input signal
input_1 = input_signal('in',
input_temporal_form='arbitrary_spike_train',
spike_times=spike_times)
# initialize synapse
synapse_1 = synapse('sy',
num_jjs=3,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_si,
integration_loop_self_inductance=L_si,
integration_loop_output_inductance=400e-12,
synaptic_bias_currents=[I_spd, I_sy, 36e-6, 35e-6],
input_signal_name='in',
synapse_model_params=sim_params)
# synapse_1.run_sim()
# actual_drive = np.vstack((synapse_1.time_vec[:],synapse_1.I_spd[:]))
# actual_drive_array.append(actual_drive)
# actual_data = np.vstack((synapse_1.time_vec[:],synapse_1.I_si[:]))
# sf_data = np.vstack((synapse_1.time_vec[:],synapse_1.I_sf[:]))
# actual_data_array.append(actual_data)
#%% neuron
target_drive = np.vstack((data_dict['time'], data_dict['L0#branch']))
target_drive_array.append(target_drive)
target_data = np.vstack((data_dict['time'], data_dict['L2#branch']))
target_data_array.append(target_data)
# initialize input signal
input_1 = input_signal('in',
input_temporal_form='arbitrary_spike_train',
spike_times=spike_times)
# initialize synapse
synapse_1 = synapse('sy',
num_jjs=2,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_si_vec[ii],
integration_loop_self_inductance=L_si_vec[ii],
integration_loop_output_inductance=0e-12,
synaptic_bias_currents=[I_spd, I_sy_vec[ii], I_sc],
input_signal_name='in',
synapse_model_params=sim_params)
synapse_1.run_sim()
actual_drive = np.vstack((synapse_1.time_vec[:], synapse_1.I_spd[:]))
actual_drive_array.append(actual_drive)
actual_data = np.vstack((synapse_1.time_vec[:], synapse_1.I_si[:]))
sf_data = np.vstack((synapse_1.time_vec[:], synapse_1.I_sf[:]))
actual_data_array.append(actual_data)
if calculate_chi_squared == True:
error_drive = chi_squared_error(target_drive, actual_drive)
# calculate average currents, voltages, and times
V_sf_wr_avg = np.zeros([len(j_peaks)-1])
I_sf_wr_avg = np.zeros([len(j_peaks)-1])
time_avg = np.zeros([len(j_peaks)-1])
for jj in range(len(j_peaks)-1):
ind_vec = np.arange(j_peaks[jj],j_peaks[jj+1],1)
V_sf_wr_avg[jj] = np.sum(V_sf_wr[ind_vec])/len(ind_vec)
I_sf_wr_avg[jj] = np.sum(I_sf_wr[ind_vec])/len(ind_vec)
time_avg[jj] = np.sum(time_vec[ind_vec])/len(ind_vec)
# initialize input signal
input_1 = input_signal('in', input_temporal_form = 'arbitrary_spike_train', spike_times = spike_times)
# initialize synapse
synapse_1 = synapse('sy', num_jjs = 1, synaptic_bias_currents = [I_sy_vec[ii]], input_signal_name = 'in', synapse_model_params = sim_params)
synapse_1.run_sim()
I_sf = synapse_1.I_sf
V_sf = synapse_1.V_sf
r_spd1 = synapse_1.r_spd1
I_spd2 = I_sf - I_sy_vec[ii]
j_sf_state = synapse_1.j_sf_state
actual_drive = np.vstack((synapse_1.time_vec[:],I_spd2[:]))
actual_data = np.vstack((synapse_1.time_vec[:],I_sf[:]))
actual_data_array.append(actual_data)
# error_drive = chi_squared_error(target_drive,actual_drive)
# error_signal = chi_squared_error(target_data,actual_data)
def synapse_model__parameter_sweep(data_file_list, I_sy_vec, L_si_vec,
tau_si_vec, dt, tf, spike_times, gamma1_vec,
gamma2_vec, gamma3_vec,
master_error_plot_name):
gamma3_init = 1
master_error_plot_name = 'mstr_err__' + master_error_plot_name
best_params = dict()
best_params['gamma1'] = []
best_params['gamma2'] = []
best_params['gamma3'] = []
data_array = dict()
data_array['gamma1_vec'] = gamma1_vec
data_array['gamma2_vec'] = gamma2_vec
data_array['gamma3_vec'] = gamma3_vec
num_sims = len(data_file_list)
num_gamma1 = len(gamma1_vec)
num_gamma2 = len(gamma2_vec)
num_gamma3 = len(gamma3_vec)
print(
'\n\nrunning synapse_model__parameter_sweep\n\nnum_files = {:d}\nnum_gamma1 = {:d}\nnum_gamma2 = {:d}'
.format(num_sims, num_gamma1, num_gamma2))
#------------------------
# find best gamma1, gamma2
#------------------------
error_mat_master__gamma1_gamma2 = np.zeros([num_gamma1, num_gamma2])
for ii in range(num_sims):
print('\ndata_file {} of {}\n'.format(ii + 1, num_sims))
# plt.close('all')
# WR data
directory = 'wrspice_data/fitting_data'
file_name = data_file_list[ii]
data_dict = read_wr_data(directory + '/' + file_name)
target_data = np.vstack((data_dict['time'], data_dict['L3#branch']))
wr_drive = np.vstack((data_dict['time'], data_dict['L0#branch']))
# initialize input signal
name__i = 'in'
input_1 = input_signal(name__i,
input_temporal_form='arbitrary_spike_train',
spike_times=spike_times)
error_mat_1 = np.zeros([num_gamma1, num_gamma2])
print('\nseeking gamma1, gamma2 ...\n')
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['gamma3'] = gamma3_init
sim_params['dt'] = dt
sim_params['tf'] = tf
# initialize synapse
name_s = 'sy'
synapse_1 = synapse(
name_s,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_si_vec[ii],
integration_loop_self_inductance=L_si_vec[ii],
integration_loop_output_inductance=0e-12,
synaptic_bias_current=I_sy_vec[ii],
integration_loop_bias_current=35e-6,
input_signal_name='in',
synapse_model_params=sim_params)
synapse_1.run_sim()
actual_data = np.vstack(
(synapse_1.time_vec[:], synapse_1.I_si[:, 0]))
error_mat_1[aa,
bb] = chi_squared_error(target_data, actual_data)
plot_wr_comparison__synapse(
file_name + '; gamma1 = {:f}, gamma2 = {:f}'.format(
gamma1_vec[aa], gamma2_vec[bb]), spike_times, wr_drive,
target_data, actual_data, file_name, error_mat_1[aa, bb])
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__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
sim_params = dict()
sim_params['gamma1'] = gamma1_best
sim_params['gamma2'] = gamma2_best
sim_params['gamma3'] = gamma3_init
sim_params['dt'] = dt
sim_params['tf'] = tf
# initialize synapse
name_s = 'sy'
synapse_1 = synapse(name_s,
integration_loop_temporal_form='exponential',
integration_loop_time_constant=tau_si_vec[ii],
integration_loop_self_inductance=L_si_vec[ii],
integration_loop_output_inductance=0e-12,
synaptic_bias_current=I_sy_vec[ii],
integration_loop_bias_current=35e-6,
input_signal_name='in',
synapse_model_params=sim_params)
synapse_1.run_sim()
actual_data = np.vstack((synapse_1.time_vec[:], synapse_1.I_si[:, 0]))
error__si = chi_squared_error(target_data, actual_data)
main_title = '{}\ngamma1_best_{:6.4f}_gamma2_best_{:6.4f}'.format(
data_file_list[ii], gamma1_best, gamma2_best)
plot_wr_comparison__synapse(main_title, spike_times, wr_drive,
target_data, actual_data, file_name,
error__si)
# # 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 = {:6.4f}, gamma2_best = {:6.4f}'.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)
#-----------------
# find best gamma3
#-----------------
# error_mat_master__gamma3 = np.zeros([num_gamma3])
# for ii in range(num_sims):
# print('\ndata_file {} of {}\n'.format(ii+1,num_sims))
# # plt.close('all')
# # WR data
# directory = 'wrspice_data/fitting_data'
# file_name = data_file_list[ii]
# data_dict = read_wr_data(directory+'/'+file_name)
# target_data = np.vstack((data_dict['time'],data_dict['L3#branch']))
# wr_drive = np.vstack((data_dict['time'],data_dict['L0#branch']))
# # initialize input signal
# name__i = 'in'
# input_1 = input_signal(name__i, input_temporal_form = 'arbitrary_spike_train', spike_times = spike_times)
# error_mat_2 = np.zeros([num_gamma3])
# print('\nseeking gamma3 ...\n')
# for aa in range(num_gamma3):
# print('aa = {} of {}'.format(aa+1,num_gamma3))
# # create sim_params dictionary
# sim_params = dict()
# sim_params['gamma1'] = gamma1_best
# sim_params['gamma2'] = gamma2_best
# sim_params['gamma3'] = gamma3_vec[aa]
# sim_params['dt'] = dt
# sim_params['tf'] = tf
# # initialize synapse
# name_s = 'sy'
# synapse_1 = synapse(name_s, integration_loop_temporal_form = 'exponential', integration_loop_time_constant = tau_si_vec[ii],
# integration_loop_self_inductance = L_si_vec[ii], integration_loop_output_inductance = 0e-12,
# synaptic_bias_current = I_sy_vec[ii], integration_loop_bias_current = 35e-6,
# input_signal_name = 'in', synapse_model_params = sim_params)
# synapse_1.run_sim()
# actual_data = np.vstack((synapse_1.time_vec[:],synapse_1.I_si[:,0]))
# error_mat_2[aa] = chi_squared_error(target_data,actual_data)
# # plot_wr_comparison__synapse(file_name+'gamma1 = {:f}, gamma2 = {:f}'.format(gamma1_vec[aa],gamma2_vec[bb]),spike_times,wr_drive,target_data,actual_data,file_name,error_mat_1[aa,bb])
# error_mat_master__gamma3 += error_mat_2
# ind_best = np.where(error_mat_2 == np.amin(error_mat_2))#error_mat.argmin()
# gamma3_best = gamma3_vec[ind_best[0]][0]
# print('gamma3_best = {}'.format(gamma3_best))
# best_params['gamma3'].append(gamma3_best)
# data_array['error_mat__gamma3'] = error_mat_2
# #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
# sim_params = dict()
# sim_params['gamma1'] = gamma1_best
# sim_params['gamma2'] = gamma2_best
# sim_params['gamma3'] = gamma3_best
# sim_params['dt'] = dt
# sim_params['tf'] = tf
# # initialize synapse
# name_s = 'sy'
# synapse_1 = synapse(name_s, integration_loop_temporal_form = 'exponential', integration_loop_time_constant = tau_si_vec[ii],
# integration_loop_self_inductance = L_si_vec[ii], integration_loop_output_inductance = 0e-12,
# synaptic_bias_current = I_sy_vec[ii], integration_loop_bias_current = 35e-6,
# input_signal_name = 'in', synapse_model_params = sim_params)
# synapse_1.run_sim()
# actual_data = np.vstack((synapse_1.time_vec[:],synapse_1.I_si[:,0]))
# error__si = chi_squared_error(target_data,actual_data)
# main_title = '{}\ngamma1_best = {:6.4f}, gamma2_best = {:6.4f}\ngamma3_best_{:6.4f}'.format(data_file_list[ii],gamma1_best,gamma2_best,gamma3_best)
# plot_wr_comparison__synapse(main_title,spike_times,wr_drive,target_data,actual_data,file_name,error__si)
# # 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 = '{}; gamma3_best = {:6.4f}'.format(master_error_plot_name,gamma3_best)
# save_str_1 = '{}__master_error__gamma3'.format(master_error_plot_name)
# plot_error_vec(error_mat_master__gamma1_gamma2[:,:],gamma1_vec,gamma2_vec,'gamma1','gamma2',title_string,save_str_1)
return best_params, error_mat_master__gamma1_gamma2, error_mat_master__gamma3
#%%
import numpy as np
# import copy
# import time
from soen_sim import synapse, neuron
#%% set up synapses
synapse_0 = synapse()
synapse_1 = synapse('test_synapse__exp',
loop_temporal_form='exponential',
time_constant=200e-9,
integration_loop_self_inductance=50e-9,
integration_loop_output_inductance=200e-12,
synaptic_bias_current=36e-6,
loop_bias_current=31e-6)
synapse_2 = synapse('test_synapse__power_law',
loop_temporal_form='power_law',
power_law_exponent=-1.1,
integration_loop_self_inductance=100e-9,
integration_loop_output_inductance=200e-12,
synaptic_bias_current=37e-6,
loop_bias_current=33e-6)
# for obj in synapse.get_instances():
# print(obj.name)
#%% propagate in time
