def optimizetimescales(self, myExp): myExp.plotTrainingSet() myExp.plotTestSet() myGIF_rect = GIF(0.1) myGIF_rect.Tref = self.T_ref myGIF_rect.eta = Filter_Rect_LogSpaced() myGIF_rect.eta.setMetaParameters(length=500.0, binsize_lb=2.0, binsize_ub=100.0, slope=4.5) myGIF_rect.fitVoltageReset(myExp, myGIF_rect.Tref, do_plot=False) myGIF_rect.fitSubthresholdDynamics(myExp, DT_beforeSpike=self.DT_beforespike) myGIF_rect.eta.fitSumOfExponentials(3, [1.0, 0.5, 0.1], self.tau_gamma, ROI=None, dt=0.1) print "Optimal timescales: ", myGIF_rect.eta.tau0 self.tau_opt = [t for t in myGIF_rect.eta.tau0 if t < self.eta_tau_max] self.fitmodel(self, myExp)
def __init__(self, dt=0.1): self.dt = dt # dt used in simulations (eta and gamma are interpolated according to this value) # Define model parameters self.gl = 1.0 / 100.0 # nS, leak conductance self.C = 20.0 * self.gl # nF, capacitance self.El = -65.0 # mV, reversal potential self.Vr = -50.0 # mV, voltage reset self.Tref = 4.0 # ms, absolute refractory period self.Vt_star = -48.0 # mV, steady state voltage threshold VT* self.DV = 0.5 # mV, threshold sharpness self.lambda0 = 1.0 # by default this parameter is always set to 1.0 Hz self.eta = Filter_Rect_LogSpaced( ) # nA, spike-triggered current (must be instance of class Filter) self.gamma = Filter_Rect_LogSpaced( ) # mV, spike-triggered movement of the firing threshold (must be instance of class Filter) # Initialize the spike-triggered current eta with an exponential function def expfunction_eta(x): return 0.2 * np.exp(-x / 100.0) self.eta.setFilter_Function(expfunction_eta) # Initialize the spike-triggered current gamma with an exponential function def expfunction_gamma(x): return 10.0 * np.exp(-x / 100.0) self.gamma.setFilter_Function(expfunction_gamma) # Variables related to fitting procedure self.avg_spike_shape = 0 self.avg_spike_shape_support = 0
experiment.setAEC(myAEC) experiment.performAEC() # Determine the refractory period ################################################################################################# # FIT STANDARD GIF ################################################################################################# # Create a new object GIF GIF_fit = GIF(sampling_time) # Define parameters GIF_fit.Tref = 6.0 GIF_fit.eta = Filter_Rect_LogSpaced() GIF_fit.eta.setMetaParameters(length=2000.0, binsize_lb=0.5, binsize_ub=500.0, slope=10.0) GIF_fit.gamma = Filter_Rect_LogSpaced() GIF_fit.gamma.setMetaParameters(length=2000.0, binsize_lb=2.0, binsize_ub=500.0, slope=5.0) for tr in experiment.trainingset_traces: tr.setROI( [[2000., sampling_time * (len(voltage_trace) - 1) - 2000.]])
def process_all_files_for_iGIF_Ca_NP(is_E_Ca_fixed=True): if is_E_Ca_fixed: spec_GIF_Ca = 'ECa_fixed_' else: spec_GIF_Ca = 'ECa_free_' Md_star = {} epsilon_V_test = {} PVar = {} # List separate experiments in separate folder data_folders_for_separate_experiments = [ 'seventh_set', 'eighth_set', 'ninth_set' ] # For all experiments, extract the cell names CellNames = {} for experiment_folder in data_folders_for_separate_experiments: folder_path = './' + experiment_folder + '/' CellNames[experiment_folder] = [ name for name in os.listdir(folder_path) if os.path.isdir(folder_path + name) and '_5HT' in name ] CellNames['eighth_set'].remove('DRN157_5HT') # problematic cell CellNames['eighth_set'].remove('DRN164_5HT') # problematic cell for experiment_folder in data_folders_for_separate_experiments: for cell_name in CellNames[experiment_folder]: print '\n\n#############################################' print '########## process cell %s ###' % cell_name print '#############################################' ################################################################################################# # Load data ################################################################################################# path_data = './' + experiment_folder + '/' + cell_name + '/' path_results = './Results/' + cell_name + '/' # Find extension of data files file_names = os.listdir(path_data) for file_name in file_names: if '.abf' in file_name: ext = '.abf' break elif '.mat' in file_name: ext = '.mat' break # Load AEC data filename_AEC = path_data + cell_name + '_aec' + ext (sampling_timeAEC, voltage_traceAEC, current_traceAEC) = load_AEC_data(filename_AEC) # Create experiment experiment = Experiment('Experiment 1', sampling_timeAEC) experiment.setAECTrace(voltage_traceAEC, 10.**-3, current_traceAEC, 10.**-12, len(voltage_traceAEC) * sampling_timeAEC, FILETYPE='Array') # Load training set data and add to experiment object filename_training = path_data + cell_name + '_training' + ext (sampling_time, voltage_trace, current_trace, time) = load_training_data(filename_training) experiment.addTrainingSetTrace(voltage_trace, 10**-3, current_trace, 10**-12, len(voltage_trace) * sampling_time, FILETYPE='Array') #Note: once added to experiment, current is converted to nA. # Load test set data filename_test = path_data + cell_name + '_test' + ext if filename_test.find('.mat') > 0: mat_contents = sio.loadmat(filename_test) analogSignals = mat_contents['analogSignals'] times_test = mat_contents['times'] times_test = times_test.reshape(times_test.size) times_test = times_test * 10.**3 sampling_time_test = times_test[1] - times_test[0] for testnum in range(analogSignals.shape[1]): voltage_test = analogSignals[0, testnum, :] current_test = analogSignals[1, testnum, :] - 5. experiment.addTestSetTrace(voltage_test, 10.**-3, current_test, 10.**-12, len(voltage_test) * sampling_time_test, FILETYPE='Array') elif filename_test.find('.abf') > 0: r = neo.io.AxonIO(filename=filename_test) bl = r.read_block() times_test = bl.segments[0].analogsignals[0].times.rescale( 'ms').magnitude sampling_time_test = times_test[1] - times_test[0] for i in xrange(len(bl.segments)): voltage_test = bl.segments[i].analogsignals[0].magnitude current_test = bl.segments[i].analogsignals[ 1].magnitude - 5. experiment.addTestSetTrace(voltage_test, 10.**-3, current_test, 10.**-12, len(voltage_test) * sampling_time_test, FILETYPE='Array') ################################################################################################# # PERFORM ACTIVE ELECTRODE COMPENSATION ################################################################################################# # Create new object to perform AEC myAEC = AEC_Badel(experiment.dt) # Define metaparametres myAEC.K_opt.setMetaParameters(length=150.0, binsize_lb=experiment.dt, binsize_ub=2.0, slope=30.0, clamp_period=1.0) myAEC.p_expFitRange = [3.0, 150.0] myAEC.p_nbRep = 15 # Assign myAEC to experiment and compensate the voltage recordings experiment.setAEC(myAEC) experiment.performAEC() ################################################################################################# # FIT GIF-Ca ################################################################################################# # Create a new object GIF iGIF_Ca_NP_fit = iGIF_Ca_NP(experiment.dt) # Define parameters iGIF_Ca_NP_fit.Tref = 6.0 iGIF_Ca_NP_fit.eta = Filter_Rect_LogSpaced() iGIF_Ca_NP_fit.eta.setMetaParameters(length=2000.0, binsize_lb=0.5, binsize_ub=500.0, slope=10.0) iGIF_Ca_NP_fit.gamma = Filter_Rect_LogSpaced() iGIF_Ca_NP_fit.gamma.setMetaParameters(length=2000.0, binsize_lb=2.0, binsize_ub=500.0, slope=5.0) for tr in experiment.trainingset_traces: tr.setROI( [[2000., sampling_time * (len(voltage_trace) - 1) - 2000.]]) # Define metaparameters used during the fit theta_inf_nbbins = 10 # Number of rect functions used to define the nonlinear coupling between theta_range_min = 10. theta_range_max = 20. theta_tau_all = np.linspace( theta_range_min, theta_range_max, theta_inf_nbbins ) # tau_theta is the timescale of the threshold-voltage coupling likelihoods = iGIF_Ca_NP_fit.fit(experiment, theta_inf_nbbins=theta_inf_nbbins, theta_tau_all=theta_tau_all, DT_beforeSpike=5.0, is_E_Ca_fixed=is_E_Ca_fixed) if iGIF_Ca_NP_fit.theta_tau < theta_tau_all[0] + 0.1 * (20. - 10.) / 9.: theta_tau_all = np.linspace(theta_range_min - 9., theta_range_max - 10., theta_inf_nbbins) likelihoods = iGIF_Ca_NP_fit.fit( experiment, theta_inf_nbbins=theta_inf_nbbins, theta_tau_all=theta_tau_all, DT_beforeSpike=5.0, is_E_Ca_fixed=is_E_Ca_fixed) while iGIF_Ca_NP_fit.theta_tau > theta_tau_all[-1] - 0.1 * ( 20. - 10.) / 9.: theta_range_min = theta_range_min + 10. theta_range_max = theta_range_max + 10. theta_tau_all = np.linspace(theta_range_min, theta_range_max, theta_inf_nbbins) print 'testing range for theta_tau = [%f, %f]...' % ( theta_range_min, theta_range_max) likelihoods = iGIF_Ca_NP_fit.fit( experiment, theta_inf_nbbins=theta_inf_nbbins, theta_tau_all=theta_tau_all, DT_beforeSpike=5.0, is_E_Ca_fixed=is_E_Ca_fixed) print 'max likelihood = %f' % np.max(np.array(likelihoods)) iGIF_Ca_NP_fit.save(path_results + cell_name + '_iGIF_Ca_NP_' + spec_GIF_Ca + 'ModelParams.pck') ################################################################################################### # EVALUATE MODEL PERFORMANCES ON THE TEST SET DATA ################################################################################################### # predict spike times in test set prediction = experiment.predictSpikes(iGIF_Ca_NP_fit, nb_rep=500) # Compute epsilon_V epsilon_V = 0. local_counter = 0. for tr in experiment.testset_traces: SSE = 0. VAR = 0. # tr.detectSpikesWithDerivative(threshold=10) (time, V_est, eta_sum_est ) = iGIF_Ca_NP_fit.simulateDeterministic_forceSpikes( tr.I, tr.V[0], tr.getSpikeTimes()) indices_tmp = tr.getROI_FarFromSpikes(5., iGIF_Ca_NP_fit.Tref) SSE += sum((V_est[indices_tmp] - tr.V[indices_tmp])**2) VAR += len(indices_tmp) * np.var(tr.V[indices_tmp]) epsilon_V += 1.0 - SSE / VAR local_counter += 1 epsilon_V = epsilon_V / local_counter epsilon_V_test[cell_name] = epsilon_V # Compute Md* Md_star[cell_name] = prediction.computeMD_Kistler( 8.0, iGIF_Ca_NP_fit.dt * 2.) fname = path_results + cell_name + '_iGIF_Ca_NP_' + spec_GIF_Ca + 'Raster.png' kernelForPSTH = 50.0 PVar[cell_name] = prediction.plotRaster(fname, delta=kernelForPSTH) ################################################################################################# # PLOT TRAINING AND TEST TRACES, MODEL VS EXPERIMENT ################################################################################################# #Comparison for training and test sets w/o inactivation V_training = experiment.trainingset_traces[0].V I_training = experiment.trainingset_traces[0].I (time, V, eta_sum, V_t, S) = iGIF_Ca_NP_fit.simulate(I_training, V_training[0]) fig = plt.figure(figsize=(10, 6), facecolor='white') plt.subplot(2, 1, 1) plt.plot(time / 1000, V, '--r', lw=0.5, label='iGIF-Ca-NP') plt.plot(time / 1000, V_training, 'black', lw=0.5, label='Data') plt.xlim(18, 20) plt.ylim(-80, 20) plt.ylabel('Voltage [mV]') plt.title('Training') V_test = experiment.testset_traces[0].V I_test = experiment.testset_traces[0].I (time, V, eta_sum, V_t, S) = iGIF_Ca_NP_fit.simulate(I_test, V_test[0]) plt.subplot(2, 1, 2) plt.plot(time / 1000, V, '--r', lw=0.5, label='iGIF-Ca-NP') plt.plot(time / 1000, V_test, 'black', lw=0.5, label='Data') plt.xlim(5, 7) plt.ylim(-80, 20) plt.xlabel('Times [s]') plt.ylabel('Voltage [mV]') plt.title('Test') plt.legend() plt.tight_layout() plt.savefig(path_results + cell_name + '_iGIF_Ca_NP_' + spec_GIF_Ca + 'simulate.png', format='png') plt.close() output_file = open( './Results/' + 'iGIF_Ca_NP_' + spec_GIF_Ca + 'FitPerformance.dat', 'w') output_file.write('#Cell name\tMd*\tEpsilonV\tPVar\n') for experiment_folder in data_folders_for_separate_experiments: for cell_name in CellNames[experiment_folder]: output_file.write(cell_name + '\t' + str(Md_star[cell_name]) + '\t' + str(epsilon_V_test[cell_name]) + '\t' + str(PVar[cell_name]) + '\n') output_file.close()
myAEC.p_expFitRange = [3.0, 150.0] myAEC.p_nbRep = 15 # Assign myAEC to experiment and compensate the voltage recordings experiment.setAEC(myAEC) experiment.performAEC() ################################################################################################# # FIT iGIF-NP model ################################################################################################# # Create a new object GIF iGIF_NP_fit = iGIF_NP(experiment.dt) # Define parameters iGIF_NP_fit.Tref = 6.0 iGIF_NP_fit.eta = Filter_Rect_LogSpaced() iGIF_NP_fit.eta.setMetaParameters(length=2000.0, binsize_lb=0.5, binsize_ub=500.0, slope=10.0) iGIF_NP_fit.gamma = Filter_Rect_LogSpaced() iGIF_NP_fit.gamma.setMetaParameters(length=2000.0, binsize_lb=2.0, binsize_ub=500.0, slope=5.0) for tr in experiment.trainingset_traces: tr.setROI( [[2000., sampling_time * (len(voltage_trace) - 1) - 2000.]]) # Define metaparameters used during the fit
myExp.setAEC(myAEC_Dummy) myExp.performAEC() """ ############################################################################################################ # STEP 3A: FIT GIF WITH RECT BASIS FUNCTIONS TO DATA ############################################################################################################ # Create a new object GIF myGIF_rect = GIF(0.1) # Define parameters myGIF_rect.Tref = 4.0 # Define eta and gamma as a sum of rectangular functions (log-spaced) myGIF_rect.eta = Filter_Rect_LogSpaced() myGIF_rect.eta.setMetaParameters(length=5000.0, binsize_lb=2.0, binsize_ub=1000.0, slope=4.5) myGIF_rect.gamma = Filter_Rect_LogSpaced() myGIF_rect.gamma.setMetaParameters(length=5000.0, binsize_lb=5.0, binsize_ub=1000.0, slope=5.0) # Perform the fit myGIF_rect.fit(myExp, DT_beforeSpike=5.0) ############################################################################################################ # STEP 3B: FIT GIF WITH EXP BASIS FUNCTIONS TO DATA ############################################################################################################ # Create a new object GIF myGIF_exp = GIF(0.1)
# Plot training and test set myExp.plotTrainingSet() myExp.plotTestSet() ############################################################################################################ # STEP 3: FIT GIF MODEL TO DATA ############################################################################################################ # Create a new object GIF myGIF = GIF(0.1) # Define parameters myGIF.Tref = 4.0 myGIF.eta = Filter_Rect_LogSpaced() myGIF.eta.setMetaParameters(length=500.0, binsize_lb=2.0, binsize_ub=1000.0, slope=4.5) myGIF.gamma = Filter_Rect_LogSpaced() myGIF.gamma.setMetaParameters(length=500.0, binsize_lb=5.0, binsize_ub=1000.0, slope=5.0) # Define the ROI of the training set to be used for the fit (in this example we will use only the first 100 s) myExp.trainingset_traces[0].setROI([[0, 100000.0]]) # To visualize the training set and the ROI call again
def process_all_files_for_GIF_K(is_E_K_fixed=True): if is_E_K_fixed: spec_GIF_K = 'EK_fixed_' else: spec_GIF_K = 'EK_free_' Md_star = {} epsilon_V_test = {} PVar = {} # List separate experiments in separate folder data_folders_for_separate_experiments = ['seventh_set', 'eighth_set', 'ninth_set', 'tenth_set'] # For all experiments, extract the cell names CellNames = {} for experiment_folder in data_folders_for_separate_experiments: folder_path = './' + experiment_folder + '/' CellNames[experiment_folder] = [name for name in os.listdir(folder_path) if os.path.isdir(folder_path + name) and '_5HT' in name] for experiment_folder in data_folders_for_separate_experiments: for cell_name in CellNames[experiment_folder]: print '\n\n#############################################' print '########## process cell %s ###' %cell_name print '#############################################' ################################################################################################# # Load data ################################################################################################# path_data = './' + experiment_folder + '/' + cell_name + '/' path_results = './Results/' + cell_name + '/' if not os.path.exists(path_results): os.makedirs(path_results) # Find extension of data files file_names = os.listdir(path_data) for file_name in file_names: if '.abf' in file_name: ext = '.abf' break elif '.mat' in file_name: ext = '.mat' break # Load AEC data filename_AEC = path_data + cell_name + '_aec' + ext (sampling_timeAEC, voltage_traceAEC, current_traceAEC) = load_AEC_data(filename_AEC) # Create experiment experiment = Experiment('Experiment 1', sampling_timeAEC) experiment.setAECTrace(voltage_traceAEC, 10.**-3, current_traceAEC, 10.**-12, len(voltage_traceAEC)*sampling_timeAEC, FILETYPE='Array') # Load training set data and add to experiment object filename_training = path_data + cell_name + '_training' + ext (sampling_time, voltage_trace, current_trace, time) = load_training_data(filename_training) experiment.addTrainingSetTrace(voltage_trace, 10**-3, current_trace, 10**-12, len(voltage_trace)*sampling_time, FILETYPE='Array') #Note: once added to experiment, current is converted to nA. # Load test set data filename_test = path_data + cell_name + '_test' + ext if filename_test.find('.mat') > 0: mat_contents = sio.loadmat(filename_test) analogSignals = mat_contents['analogSignals'] times_test = mat_contents['times']; times_test = times_test.reshape(times_test.size) times_test = times_test*10.**3 sampling_time_test = times_test[1] - times_test[0] for testnum in range(analogSignals.shape[1]): voltage_test = analogSignals[0, testnum, :] current_test = analogSignals[1, testnum, :] - 5. experiment.addTestSetTrace(voltage_test, 10. ** -3, current_test, 10. ** -12, len(voltage_test) * sampling_time_test, FILETYPE='Array') elif filename_test.find('.abf') > 0: r = neo.io.AxonIO(filename=filename_test) bl = r.read_block() times_test = bl.segments[0].analogsignals[0].times.rescale('ms').magnitude sampling_time_test = times_test[1] - times_test[0] for i in xrange(len(bl.segments)): voltage_test = bl.segments[i].analogsignals[0].magnitude current_test = bl.segments[i].analogsignals[1].magnitude - 5. experiment.addTestSetTrace(voltage_test, 10. ** -3, current_test, 10. ** -12, len(voltage_test) * sampling_time_test, FILETYPE='Array') ################################################################################################# # PERFORM ACTIVE ELECTRODE COMPENSATION ################################################################################################# # Create new object to perform AEC myAEC = AEC_Badel(experiment.dt) # Define metaparametres myAEC.K_opt.setMetaParameters(length=150.0, binsize_lb=experiment.dt, binsize_ub=2.0, slope=30.0, clamp_period=1.0) myAEC.p_expFitRange = [3.0,150.0] myAEC.p_nbRep = 15 # Assign myAEC to experiment and compensate the voltage recordings experiment.setAEC(myAEC) experiment.performAEC() ################################################################################################# # FIT GIF-K ################################################################################################# # Create a new object GIF GIF_K_fit = GIF_K(sampling_time) # Define parameters and filter characteristics GIF_K_fit.Tref = 6.0 GIF_K_fit.eta = Filter_Rect_LogSpaced() GIF_K_fit.eta.setMetaParameters(length=2000.0, binsize_lb=0.5, binsize_ub=500.0, slope=10.0) GIF_K_fit.gamma = Filter_Rect_LogSpaced() GIF_K_fit.gamma.setMetaParameters(length=2000.0, binsize_lb=2.0, binsize_ub=500.0, slope=5.0) # Define the ROI of the training set to be used for the fit for tr in experiment.trainingset_traces: tr.setROI([[2000., sampling_time * (len(voltage_trace) - 1) - 2000.]]) # Perform the fit (var_explained_dV, var_explained_V_GIF_K_train) = GIF_K_fit.fit(experiment, DT_beforeSpike=5.0, is_E_K_fixed=is_E_K_fixed) # Save the model GIF_K_fit.save(path_results + cell_name + '_GIF_K_'+spec_GIF_K+'ModelParams' + '.pck') ################################################################################################### # EVALUATE MODEL PERFORMANCES ON THE TEST SET DATA ################################################################################################### # predict spike times in test set prediction = experiment.predictSpikes(GIF_K_fit, nb_rep=500) # Compute epsilon_V epsilon_V = 0. local_counter = 0. for tr in experiment.testset_traces: SSE = 0. VAR = 0. # tr.detectSpikesWithDerivative(threshold=10) (time, V_est, eta_sum_est) = GIF_K_fit.simulateDeterministic_forceSpikes(tr.I, tr.V[0], tr.getSpikeTimes()) indices_tmp = tr.getROI_FarFromSpikes(5., GIF_K_fit.Tref) SSE += sum((V_est[indices_tmp] - tr.V[indices_tmp]) ** 2) VAR += len(indices_tmp) * np.var(tr.V[indices_tmp]) epsilon_V += 1.0 - SSE / VAR local_counter += 1 epsilon_V = epsilon_V / local_counter epsilon_V_test[cell_name] = epsilon_V # Compute Md* Md_star[cell_name] = prediction.computeMD_Kistler(8.0, GIF_K_fit.dt*2.) fname = path_results + cell_name + '_GIF_K_' + spec_GIF_K + 'Raster.png' kernelForPSTH = 50.0 PVar[cell_name] = prediction.plotRaster(fname, delta=kernelForPSTH) ################################################################################################# # PLOT TRAINING AND TEST TRACES, MODEL VS EXPERIMENT ################################################################################################# #Comparison for training and test sets w/o inactivation V_training = experiment.trainingset_traces[0].V I_training = experiment.trainingset_traces[0].I (time, V, eta_sum, V_t, S) = GIF_K_fit.simulate(I_training, V_training[0]) fig = plt.figure(figsize=(10,6), facecolor='white') plt.subplot(2,1,1) plt.plot(time/1000, V,'--r', lw=0.5, label='GIF-K') plt.plot(time/1000, V_training,'black', lw=0.5, label='Data') plt.xlim(18,20) plt.ylim(-80,20) plt.ylabel('Voltage [mV]') plt.title('Training') V_test = experiment.testset_traces[0].V I_test = experiment.testset_traces[0].I (time, V, eta_sum, V_t, S) = GIF_K_fit.simulate(I_test, V_test[0]) plt.subplot(2,1,2) plt.plot(time/1000, V,'--r', lw=0.5, label='GIF-K') plt.plot(time/1000, V_test,'black', lw=0.5, label='Data') plt.xlim(5,7) plt.ylim(-80,20) plt.xlabel('Times [s]') plt.ylabel('Voltage [mV]') plt.title('Test') plt.legend() plt.tight_layout() plt.savefig(path_results + cell_name + '_GIF_K_' + spec_GIF_K + 'simulate.png', format='png') plt.close() # Figure comparing V_model, V_data and I during training with forced spikes (time, V, eta_sum) = GIF_K_fit.simulateDeterministic_forceSpikes(I_training, V_training[0], experiment.trainingset_traces[0].getSpikeTimes()) I_K = GIF_K_fit.I_K_with_Deterministic_forceSpikes(I_training, V_training[0], experiment.trainingset_traces[0].getSpikeTimes()) fig = plt.figure(figsize=(10,6), facecolor='white') plt.subplot(2,1,1) plt.plot(time/1000, I_training,'-b', lw=0.5, label='$I$') plt.plot(time / 1000, I_K, '--r', lw=0.5, label='$I_\mathrm{K}$') plt.xlim(17,20) plt.ylabel('Current [nA]') plt.title('Training') plt.subplot(2,1,2) plt.plot(time/1000, V,'-b', lw=0.5, label='GIF') plt.plot(time/1000, V_training,'black', lw=0.5, label='Data') plt.xlim(17,20) plt.ylim(-75,0) plt.ylabel('Time [s]') plt.ylabel('Voltage [mV]') plt.legend(loc='best') plt.savefig(path_results + cell_name + '_GIF_K_' + spec_GIF_K + 'simulateForcedSpikes_Training.png', format='png') plt.close(fig) output_file = open('./Results/' + 'GIF_K_'+spec_GIF_K+'FitPerformance.dat','w') output_file.write('#Cell name\tMd*\tEpsilonV\tPVar\n') for experiment_folder in data_folders_for_separate_experiments: for cell_name in CellNames[experiment_folder]: output_file.write(cell_name + '\t' + str(Md_star[cell_name]) + '\t' + str(epsilon_V_test[cell_name]) + '\t' + str(PVar[cell_name]) + '\n') output_file.close()