def main(seed=0): Experiment1 = Experiment(False, 0.7, 0.001) log1_1 = Experiment1.setExperiment() log1_2 = Experiment1.setExperiment() log1_3 = Experiment1.setExperiment() getPlot(log1_1, log1_2, log1_3, 'Experiment1') Experiment2 = Experiment(True, 0.4, 0.001) log2_1 = Experiment2.setExperiment() log2_2 = Experiment2.setExperiment() log2_3 = Experiment2.setExperiment() getPlot(log2_1, log2_2, log2_3, 'Experiment2') Experiment3 = Experiment(True, 0.1, 0.001) log3_1 = Experiment3.setExperiment() log3_2 = Experiment3.setExperiment() log3_3 = Experiment3.setExperiment() getPlot(log3_1, log3_2, log3_3, 'Experiment3') Experiment4 = Experiment(True, 0.7, 0.01) log4_1 = Experiment4.setExperiment() log4_2 = Experiment4.setExperiment() log4_3 = Experiment4.setExperiment() getPlot(log4_1, log4_2, log4_3, 'Experiment4') Experiment5 = Experiment(True, 0.7, 0.1) log5_1 = Experiment5.setExperiment() log5_2 = Experiment5.setExperiment() log5_3 = Experiment5.setExperiment() getPlot(log5_1, log5_2, log5_3, 'Experiment5') return
def open_file(filename, trigger, *args): binfile = filename[0:-4] + "_data.bin" if len(args) == 0: exp = Experiment.Experiment(binfile, filename, trigger) if len(args) == 1: exp = Experiment.Experiment(binfile, filename, trigger, stim_length=args[0]) experiments[filename[0:-4]] = exp names.update(exp.stim_names)
def importdata(self): # Data[0] = Voltage, Data[1] = Current, Data[2] = Time self.trainData, self.testData = loading.Loader().dataload() self.myExp = Experiment('Experiment 1', .1) for n in self.trainData: print "Trials" print n self.myExp.addTrainingSetTrace(n[0], self.V_units, n[1], self.I_units, np.size(n[2]) / 10, FILETYPE='Array') self.myExp.trainingset_traces[n].setROI([[1000, 120000.0]]) for n in self.testData: self.myExp.addTestSetTrace([n][0], self.V_units, [n][1], self.I_units, np.size([n][2]) / 10, FILETYPE='Array') self.myExp.testset_traces[n].setROI([[1000, 20000]]) self.fitaec(self, self.myExp)
def adience_baseline_experiment_sgd(dataset): """Ejecuta un experimento entero (entrenamiento y test) con la configuración baseline con el optimizador SGD de nesterov con el dataset Adience. :param dataset: Dataset para realizar el experimento. """ # RUN ADIENCE BASELINE #Create net architecture baseline_resnet = Resnet_2x4() model = Model(inputs=baseline_resnet.inputs, outputs=baseline_resnet.get_net()) #Create experiment experiment = Experiment.Experiment(dataset, model) arguments = { 'epochs': 100, 'optimizer': SGD, 'learning_rate': 1e-2, 'momentum': 0.9, 'loss_fn': 'categorical_crossentropy', 'metrics': ['accuracy'] } callbacks = ['ModelCheckpoint'] #Train experiment.train('adience_baseline', '/TFG/ordinal_unimodal_mio/src/logs/', arguments=arguments, callbacks=callbacks) #Test experiment.test()
def adience_poisson_experiment(dataset, tau_mode, tau=1.): """Ejecuta un experimento entero (entrenamiento y test) con la configuración poisson con el dataset Adience. :param dataset: Dataset para realizar el experimento. :param tau_mode: Modo de ejecución del parámetro tau en el experimento (constante o aprender valor) :param tau: Valor del parámetro tau. Valor inicial si se va a aprender, o valor constante. """ # RUN ADIENCE POISSON assert tau_mode in ["non_learnable", "sigm_learnable"] #Create net architecture poisson_resnet = Resnet_2x4_poisson(tau_mode) model = Model(inputs=poisson_resnet.inputs, outputs=poisson_resnet.get_net()) #Create experiment experiment = Experiment.Experiment(dataset, model) #Train experiment.train('adience_poisson_t=' + tau_mode, '/TFG/ordinal_unimodal_mio/src/logs/') #Test experiment.test()
def suggest_analysis_layout(solid_runs): """Generate a bash script to build the analysis directory scheme Given a set of SolidRuns, print a set of script commands for running the build_analysis_dir.py program to create and populate the analysis directories. The script can be edited before being executed by the user. Arguments: solid_runs: a list of SolidRun objects. """ print "#!/bin/sh\n#\n# Script commands to build analysis directory structure" for run in solid_runs: build_analysis_dir_cmd = 'build_analysis_dir.py' top_dir = os.path.abspath( os.path.join(os.getcwd(), os.path.basename(run.run_dir))) for sample in run.samples: for project in sample.projects: # Create one experiment per project cmd_line = [] expt = Experiment.Experiment() expt.name = project.getProjectName() expt.type = "expt" expt.sample = project.getSample().name expt.library = project.getLibraryNamePattern() # Print the arguments for the layout cmd_line.extend( (build_analysis_dir_cmd, "--top-dir=%s_analysis" % top_dir, "--link=absolute", "--naming-scheme=partial")) cmd_line.append(expt.describe()) cmd_line.append(run.run_dir) print "#\n%s" % (' \\\n').join(cmd_line)
def experiment(args, logger, dataProcessor): exp = Experiment.Experiment() model = dataProcessor.loadNetwork(args, 0) #PolicyValueFn.PolicyValueFn(args).to(args.device) data = exp.evaluationWithDifferentMinMaxSearchAgent(model) # data = exp.evaluationForNetworkWithFourRollout(model,start=10,end=50,step=10,random_cnt=1,numOfEvaluations=1) logger.info(data)
def make_experiment(): kwargs = { 'agent': agent, 'environment': env, 'numPolicyChecks': numPolicyChecks, 'numEpisodesPerCheck': numEpisodesPerCheck, 'numTrainEpisodes': numTrainEpisodes, } for key, value in sorted(kwargs.items(), key=lambda x: x[0]): logging.info('\t%s = %s' % (str(key, ), str(value))) experiment = Experiment.Experiment(**kwargs) return experiment
def train(args, logger, dataProcessor): Loss, WinRate = Training.Training() exp = Experiment.Experiment() fig = exp.simplePlot(range(args.trainround), Loss, "Training Loss Curve", xlabel='Training Rounds', ylabel='Training Loss', color='blue', linestyle='-.') exp.saveFig(fig,name="Training Loss Curve") fig = exp.simplePlot(range(args.trainround), WinRate, "Winning Rate Curve", xlabel='Training Rounds', ylabel='Winning Rate', color='blue', linestyle='-.') exp.saveFig(fig, name="Winning Rate Curve") logger.info("Loss and Winning Rate") loss_log = '' for i in Loss: loss_log += str(i) + ',' logger.info(loss_log) loss_log = '' for i in WinRate: loss_log += str(i) + ',' logger.info(loss_log)
def adience_baseline_experiment(dataset): """Ejecuta un experimento entero (entrenamiento y test) con la configuración baseline con el dataset Adience. :param dataset: Dataset para realizar el experimento. """ # RUN ADIENCE BASELINE #Create net architecture baseline_resnet = Resnet_2x4() model = Model(inputs=baseline_resnet.inputs, outputs=baseline_resnet.get_net()) #Create experiment experiment = Experiment.Experiment(dataset, model) #Train experiment.train('adience_baseline', '/TFG/ordinal_unimodal_mio/src/logs/') #Test experiment.test()
def simulate(self): # start experiments for exp in range(self.num_experiments): # create a new experiment instance experiment = Experiment(self.run_time, self.sizeBlue, self.sizeRed) print("Experiment: ", exp, "\t") agents = self.create_agents() # normalizer for accumulated utility # why 0.6? experiment.normalizer = 0.6 * (len(agents) - 1) # run the algorithm # for each round from 1000 for current_round in range(self.run_time): self.simulate_round(current_round, agents, experiment, self.print_round_results) self.results.append(experiment)
def run(self, csv_f=None, csv_b=None, csv_e=None, experiments=None, verbose=False): # 1. Can't run if no one or no where if not self.walker or not self.grid or not self.walker.grid(): return None # 2. Start with no results results = [] # 3. Loop for all possible experiments if experiments == None: exps = range(len(EXPERIMENTS)) else: exps = [experiments] for exp in exps: # 4. Determine the rewards for the experiment initial_rewards = REWARDS[EXPERIMENTS[exp][INITIAL]] changed_rewards = REWARDS[EXPERIMENTS[exp][CHANGED]] rewards = (initial_rewards, changed_rewards) # 5. Create the experiment experiment = Experiment.Experiment(walker=self.walker, grid=self.grid, rewards=rewards, switch=self.switch, stop=self.stop) if verbose: print "%s %2d" % (self.walker, exp), sys.stdout.flush() # 6. Loop for the number of repeats prefix = None rewards = 0 for num in range(self.repeats): # 7. Run the experiment experiment.reset() if csv_f: if csv_b: prefix = '%s%d,%d,' % (csv_b, exp, num) else: prefix = '%d,%d,' % (exp, num) if verbose: sys.stdout.write('.') sys.stdout.flush() rewards += experiment.run(csv_f=csv_f, csv_b=prefix, csv_e=csv_e) # 8. Save the results if verbose: print rewards results.append(rewards) # 9. Return the total reward return results
def xxx_testNoPerturbLong(self): g = Grid.Grid() l = QLearner.QLearner() e = Experiment(g, l) r = e.run() self.assertEqual(len(r), STOP_TURN)
def csv_header(self): exp = Experiment.Experiment(walker=self.walker, grid=self.grid) return CSV_HEADER + exp.csv_header()
' o-o-o-o-o o-o-o-o-o ', ' | | | | ', 'o-o-o o-o-o o-o-o o-o-o', ], 'start position': (7, 0), # 'reward locations': {(8, 14): 1}, # one reward, no switch 'reward locations': {}, # no rewards 'change reward location': False, 'allow reversals': True }, # { # 'maze type': 'Binary', # 'maze name': '6level_binary_maze', # 'number of levels': 6, # # 'reward locations': {(5, 17): 10}, # no reward switching # 'reward locations': {}, # no reward switching # 'change reward location': False, # # 'reward locations': {0: {(3,2): 100}, 50: {(3,3): 100}}, # change-episode, location (index from 0), reward # 'allow reversals': True # }, # To test additional environments, insert here (must match with number of agents) ] # Run experiment Experiment = Experiment(name=experiment_name, environments=env, agents=agents, nb_episodes=3000, nb_trials=50)
from Experiment import * from ExpList_1_1 import * experiment = Experiment(Exp7) experiment.start() experiment = Experiment(Exp8) experiment.start() experiment = Experiment(Exp9) experiment.start()
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,
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()
def open_file(filename, trigger): binfile = filename[0:-4] + "_data.bin" exp = Experiment.Experiment(binfile, filename, trigger) experiments[filename[0:-4]] = exp names.update(exp.stim_names)
print(y_features['Class'].value_counts()) """ ====================================== Fitting model_00: Logistic Regression (baseline) Include all reducing features without ranking the important of features ====================================== """ """Sampling a training set and a testing set = 80:20""" X_train_baseline, X_test_baseline, y_train_baseline, y_test_baseline = train_test_split( X_features, y_features, test_size=0.20, random_state=0, stratify=y_features) model_logr_baseline = exp.Experiment(X=X_train_baseline, y=y_train_baseline).logistic_regression() """Intercept and Coefficients""" print("\n Intercept \n" + str(model_logr_baseline["tuned_model"].intercept_[0])) print("\n Coefficients \n" + str(model_logr_baseline["tuned_model"].coef_[0])) """Evaluate and predict""" model_logr_baseline["pop_DR"] = model_logr_baseline[ "tuned_model"].predict_proba(X_test_baseline)[:, 1] model_logr_baseline["yhat"] = model_logr_baseline["tuned_model"].predict( X_test_baseline) model_logr_baseline["con_matrix"] = confusion_matrix( y_test_baseline, model_logr_baseline["yhat"], labels=[0, 1]) model_logr_baseline["class_report"] = classification_report(
#################################################### dataArray = l.expLoad()[0] dataPath = l.expLoad()[1] V = [dataArray[n][0] for n, k in enumerate(dataPath)] I = [dataArray[n][1] for n, k in enumerate(dataPath)] V_units = 10**-3 I_units = 10**-9 assert np.size(I) == np.size(V) # These need to be equal #################################################### # Load Training Set #################################################### experiment = Experiment('Experiment 1', 0.1) experiment.addTrainingSetTrace(V[0], V_units, I[0], I_units, np.size(V[1]) / 10, FILETYPE='Array') for n, k in enumerate(dataPath[1:]): experiment.addTestSetTrace(V[n], V_units, I[n], I_units, np.size(V[n]) / 10, FILETYPE='Array') ####################################################
def run(self, csv_f=None, csv_b=None, csv_e=None, experiments=None, verbose=False): # 1. Can't run if no one or no where if not self.walker or not self.grid or not self.walker.grid(): return None # 2. Start with no results results = [] '''# resultsForGraph=[] stepsForGraph=[] totalSteps=0 rewardsForGraph=0 plt.show() axes = plt.gca() axes.set_xlim(0, 10000000) axes.set_ylim(0, 100000000) line, = axes.plot(stepsForGraph, resultsForGraph, 'r-')''' # 3. Loop for all possible experiments if experiments == None: exps = range(len(EXPERIMENTS)) else: exps = [experiments] for exp in exps: # 4. Determine the rewards for the experiment initial_rewards = REWARDS[EXPERIMENTS[exp][INITIAL]] changed_rewards = REWARDS[EXPERIMENTS[exp][CHANGED]] rewards = (initial_rewards, changed_rewards) # 5. Create the experiment experiment = Experiment.Experiment(walker=self.walker, grid=self.grid, rewards=rewards, switch=self.switch, stop=self.stop) if verbose: print "%s %2d" % (self.walker, exp), sys.stdout.flush() # 6. Loop for the number of repeats prefix = None rewards = 0 for num in range(self.repeats): # 7. Run the experiment experiment.reset() if csv_f: if csv_b: prefix = '%s%d,%d,' % (csv_b, exp, num) else: prefix = '%d,%d,' % (exp, num) if verbose: sys.stdout.write('.') sys.stdout.flush() rewards += experiment.run(csv_f=csv_f, csv_b=prefix, csv_e=csv_e) # 8. Save the results if verbose: print rewards results.append(rewards) # '''#update graph flow here rewardsForGraph+=rewards if totalSteps%20000==0: stepsForGraph.append(totalSteps) resultsForGraph.append(rewardsForGraph) line.set_xdata(stepsForGraph) line.set_ydata(resultsForGraph) plt.draw() plt.pause(1e-17) time.sleep(0.1) rewardsForGraph=0 totalSteps+=1''' showRewardsOnGraph(results) # 9. Return the total reward return results
""" This script fit 2 GIF models on the same experimental data: - model 1 myGIF_rect : a standard GIF in which eta and gamma are expanded in a set of rectangular basis functions (as in Pozzorini et al. PLOS Comp. Biol. 2015) - model 2 myGIF_exp : a GIF model in which eta and gamma are expanded in a set of exponential functions with given timescales, (this alternative approach can be used to fit a model in which the adaptation processes can be efficiently simulated by solving linear differential equations). Note that the timescales are not free parameters but must be specifyied by the user. A plot is produced in which the optimal model parameters are plotted on top of eaach others. """ ############################################################################################################ # STEP 1: LOAD EXPERIMENTAL DATA ############################################################################################################ myExp = Experiment('Experiment 1', 0.1) PATH = '../../data/gif_test/' # Load AEC data myExp.setAECTrace(PATH + 'Cell3_Ger1Elec_ch2_1007.ibw', 1.0, PATH + 'Cell3_Ger1Elec_ch3_1007.ibw', 1.0, 10000.0, FILETYPE='Igor') # Load training set data myExp.addTrainingSetTrace(PATH + 'Cell3_Ger1Training_ch2_1008.ibw', 1.0, PATH + 'Cell3_Ger1Training_ch3_1008.ibw', 1.0, 120000.0, FILETYPE='Igor') # Specify the region of the training set that will be used to fit the models (here first 60 seconds) myExp.trainingset_traces[0].setROI([[0,60000.0]]) # Load test set data myExp.addTestSetTrace(PATH + 'Cell3_Ger1Test_ch2_1009.ibw', 1.0, PATH + 'Cell3_Ger1Test_ch3_1009.ibw', 1.0, 20000.0, FILETYPE='Igor')
params['temp_prob'] = [1,1,1,1,0] # determine number of trials for (practice) block # 50 targets by abs/pres by short/long block by house/face/letter = 600 trials; divided by 6 blocks = 100 trials per block # this gives 168 trials per category, collapsed over conditions #### GO #### # first a practice block with task instructions and example trials params['block_type'] = 'practice' params['ready_text'] = 'stimuli/ready_practice.txt' params['ntrials'] = 24 # needs to be divided by 3 categories params['rep_check'] = (12,4) # in chuncks of 12 trials, it is checked whether repetitions of 4 or more occur for absent/present params['nblocks'] = 1 exp = Experiment(params) exp.run_instruction('stimuli/instruct1.txt') exp.run_example_trial(['face',inFiles[0][0],'present','short']) exp.run_instruction('stimuli/instruct2.txt') exp.run_example_trial(['house',inFiles[1][10],'absent','long']) exp.run_instruction('stimuli/instruct3.txt') exp.run() exp.run_instruction('stimuli/finish_practice.txt') ## # experimental block with only long intervals params['block_type'] = 'long' params['ready_text'] = 'stimuli/ready_long.txt' params['ntrials'] = 300 # needs to be divided by 3*2 (category by absent/present) -> for real experiment 300 params['rep_check'] = (30,5) # 300 trials are divided up in chuncks of 30 where absent/present is shuffled such that no 5 repetitions are allowed params['nblocks'] = 4 # -> for real experiment 4 exp = Experiment(params)
def loadExperimentFile(pickle): experiment = Experiment.Experiment(os.path.split(pickle)[0], os.path.split(pickle)[1].split(".")[0]) return experiment
def main(): # Parse options and arguments parser = OptionParser() parser.set_usage("wrapping.py <optimizer> [-s seed] [-t title]" + "[--restore=/directory/]") parser.add_option("-p", "--print", action="store_true", dest="printcmd", default=False, help="If set print the command instead of executing it") parser.add_option("-s", "--seed", dest="seed", default=1, type=int, help="Set the seed of the optimizer") parser.add_option("-t", "--title", dest="title", default=None, help="A title for the experiment") restore_help_string = "Restore the state from a given directory" parser.add_option("--restore", default=None, dest="restore", help=restore_help_string) (options, args) = parser.parse_args() # find out which optimizer we are supposed to use if len(args) < 1: parser.print_help(file=sys.stderr) sys.exit(1) optimizer = args[0] experiment_dir = os.getcwd() # _check_runsolver, _check_modules(), _check_config(experiment_dir) check_before_start._check_first(experiment_dir) # build call config_file = os.path.join(experiment_dir, "config.cfg") config = parse_config(config_file, allow_no_value=True, optimizer_module=optimizer) wrapping_dir = os.path.dirname(os.path.realpath(__file__)) cmd = "export PYTHONPATH=$PYTHONPATH:" + wrapping_dir + "\n" # Load optimizer try: optimizer_module = imp.load_source( optimizer, wrapping_dir + "/" + optimizer + ".py") except (ImportError, IOError): print "Optimizer module", optimizer, "not found" import traceback print traceback.format_exc() sys.exit(1) optimizer_call, optimizer_dir = optimizer_module.main( config=config, options=options, experiment_dir=experiment_dir) cmd += optimizer_call # _check_function check_before_start._check_second(experiment_dir, optimizer_dir) # initialize/reload pickle file if options.restore: try: os.remove(os.path.join(optimizer_dir, optimizer + ".pkl.lock")) except OSError: pass folds = config.getint('DEFAULT', 'numberCV') trials = Experiment.Experiment(optimizer_dir, optimizer, folds=folds, max_wallclock_time=config.get( 'DEFAULT', 'cpu_limit'), title=options.title) trials.optimizer = optimizer if options.restore: # Old versions did store NaNs instead of the worst possible result for # crashed runs in the instance_results. In order to be able to load # these files, these NaNs are replaced for i, trial in enumerate(trials.instance_order): _id, fold = trial instance_result = trials.get_trial_from_id( _id)['instance_results'][fold] if not np.isfinite(instance_result): # Make sure that we do delete the last job which was running but # did not finish if i == len(trials.instance_order) - 1 and \ len(trials.cv_starttime) != len(trials.cv_endtime): # The last job obviously did not finish correctly, do not # replace it pass else: trials.get_trial_from_id(_id)['instance_results'][fold] = \ config.getfloat('DEFAULT', 'result_on_terminate') # Pretty sure we need this here: trials.get_trial_from_id(_id)['instance_status'][fold] = \ Experiment.BROKEN_STATE #noinspection PyBroadException try: restored_runs = optimizer_module.restore( config=config, optimizer_dir=optimizer_dir, cmd=cmd) except: print "Could not restore runs for %s" % options.restore import traceback print traceback.format_exc() sys.exit(1) print "Restored %d runs" % restored_runs trials.remove_all_but_first_runs(restored_runs) fh = open(os.path.join(optimizer_dir, optimizer + ".out"), "a") fh.write("#" * 80 + "\n" + "Restart! Restored %d runs.\n" % restored_runs) fh.close() if len(trials.endtime) < len(trials.starttime): trials.endtime.append(trials.cv_endtime[-1]) trials.starttime.append(time.time()) else: trials.starttime.append(time.time()) #noinspection PyProtectedMember trials._save_jobs() del trials sys.stdout.flush() # Run call if options.printcmd: print cmd return 0 else: print cmd output_file = os.path.join(optimizer_dir, optimizer + ".out") fh = open(output_file, "a") process = subprocess.Popen(cmd, stdout=fh, stderr=fh, shell=True, executable="/bin/bash") print "-----------------------RUNNING----------------------------------" ret = process.wait() trials = Experiment.Experiment(optimizer_dir, optimizer) trials.endtime.append(time.time()) #noinspection PyProtectedMember trials._save_jobs() # trials.finish_experiment() print "Finished with return code: " + str(ret) total_time = 0 print trials.get_best() #noinspection PyBroadException try: for starttime, endtime in zip(trials.starttime, trials.endtime): total_time += endtime - starttime print "Needed a total of %f seconds" % total_time print "The optimizer %s took %f seconds" % \ (optimizer, calculate_optimizer_time(trials)) print "The overhead of the wrapping software is %f seconds" % \ (calculate_wrapping_overhead(trials)) print "The algorithm itself took %f seconds" % \ trials.total_wallclock_time except: pass del trials return ret
plotTestFitness("CountOnesFitnessTest.png", CountOnesFitnessResults, "N", "Fitness Value", "Count Ones Fitness") plotTestFitness("FourPeaksFitnessTest.png", FourPeaksFitnessResults, "N", "Fitness Value", "Four Peaks Fitness") plotTestFitness("KnapsackFitnessTest.png", KnapSackFitnessResults, "N", "Fitness Value", "Knapsack Fitness") plotTestFitness("CountOneComputeTime.png", CountOnesComputeTime, "N", "Time", "Count Ones Compute Time") plotTestFitness("FourPeaksComputeTime.png", FourPeaksComputeTime, "N", "Time", "Four Peaks Compute Time") plotTestFitness("KnapSackComputTime.png", KnapSackComputeTime, "N", "Time", "Knapsack Compute Time") def plotTestFitness(fileName, data, labelX, labelY, title): plt.figure() plt.title(title) plt.plot(data[:, 0], data[:, 1], "-o", label="Random Hill Climbing") plt.plot(data[:, 0], data[:, 2], "-o", label="Simulated Annealing") plt.plot(data[:, 0], data[:, 3], "-o", label="Genetic Algorithm") plt.plot(data[:, 0], data[:, 4], "-o", label="Mimic") plt.xlabel(labelX) plt.ylabel(labelY) plt.legend(loc="best") plt.grid() plt.xlim(20, 100) plt.savefig(fileName) if __name__ == "__main__": testAlgs() exp = ex.Experiment() print 'hello'
from Experiment import * from ExpList_1_1 import * experiment = Experiment(Exp4) experiment.start() experiment = Experiment(Exp5) experiment.start() experiment = Experiment(Exp6) experiment.start()
from Experiment import * from ExpList_1_1 import * experiment = Experiment(Exp1) experiment.start() experiment = Experiment(Exp2) experiment.start() experiment = Experiment(Exp3) experiment.start()
folderName = c['folderName'] groupBy_fn_ = c['groupBy_fn'] select_fn_ = c['select_fn'] lineLabel_fn_ = c['lineLabel_fn'] xLabel = c['xLabel'] xlog = c['xlog'] ylog = c['ylog'] # Run Experiments if rangeOverNumPartitions: assert len(numPartitions) == 2 start = numPartitions[0] end = numPartitions[1] numPartitions = [i for i in range(start, end + 1)] E = Experiment(buildSizes, probeSizes, memSizes, F, numPartitions) E.run() for r in E.runs: print(r.join, r.join.stats()) print("recursion: ", r.join.getRecursionDepth()) print("build: ", r.join.build.stats()) print("probe: ", r.join.probe.stats()) # Do plots buildDone = False for ph in ['build', 'probe', 'total']: for m in Stats.getAttrNames(): P = Plot( runs=E.runs, phase=ph, outFolder=folderName + '/' + ph,