def __init__(self, runner): Experiment.__init__(self, runner) runner.paths = \ [ ["B29", "B16", "B15", "B1"] , ["B29", "B17", "B15", "B1"] , ["B29", "B14", "B1"] , ["B29", "B12", "B1"] , ["B29", "B13", "B1"] , ["B29", "B11", "B1"] , ["B29", "B18", "B1"] , ["B29", "B28", "B26", "B1"] , ["B29", "B27", "B26", "B1"] , ["B29", "B20", "B19", "B1"] , ["B29", "B25", "B1"] , ["B29", "B10", "B8", "B1"] , ["B29", "B24", "B23", "B1"] , ["B29", "B22", "B21", "B1"] , ["B29", "B6", "B1"] , ["B29", "B4", "B2", "B1"] , ["B29", "B3", "B1"] , ["B29", "B7", "B5", "B1"] , ["B29", "B9", "B1"] ] runner.lineMap = \ { "B29": 46 , "B28": 47 , "B27": 49 , "B26": 52 , "B25": 57 , "B24": 59 , "B23": 61 , "B22": 63 , "B21": 65 , "B20": 67 , "B19": 70 , "B18": 79 , "B17": 80 , "B16": 81 , "B15": 83 , "B14": 86 , "B13": 88 , "B12": 96 , "B11": 98 , "B10": 100 , "B9": 101 , "B8": 103 , "B7": 105 , "B6": 106 , "B5": 108 , "B4": 110 , "B3": 111 , "B2": 113 , "B1": 116 , "B0": 122 } self.minInput = -10 self.maxInput = 10
def menuButton5(self, control): exampleHead = Head() exampleHeadModel = HeadModel(exampleHead) exampleHead.setSamplingFrequency(256) exampleHead.addRegistrationSite([0, 0, 0]) exampleExperiment = Experiment(exampleHead.getSamplingFrequency(), 100.0) # Randomizing stimuli times stimuli = [] for i in range(100): stimuli.append( i + 0.2 +random()/2 ) exampleExperiment.setStimulusTimes([stimuli]) exampleStimulus = Stimulus('Stim', exampleHead) exampleStimulus.setStimulusTimes(exampleExperiment.getStimulusTimes()[0]) # Creating many generators with random frequencies in the range 2-20 Hz and # random phases. Connecting some of them to the stimulus generator exampleGenerators = [] exampleConnections = [] for i in range(100): randomFrequency = 2.0 + random() * 18 randomPhaseShift = random() exampleGenerators.append(GeneratorSine('Gen', exampleHead, frequency=randomFrequency, phaseShift=randomPhaseShift)) if(random() > 0.75): exampleConnections.append(Connection('Con', exampleHead, exampleStimulus, exampleGenerators[i])) exampleExperiment.setRecording(exampleHead.runSimulation(exampleExperiment.getDuration())) exampleExperiment.plotRecording()
def test_experiment_not_transformed_test(self): file_path = "../Datasets/HIV_37_Samples/MergedDataset.csv" loaded_data = FileLoader.load_file(file_path) data_manager = DataManager() data_manager.set_data(loaded_data) data_manager.split_data(test_split=0.19, train_split=0.62) learning_model = FakePredictionModel() exp = Experiment(data_manager, learning_model) exp.run_experiment() self.assertEquals(0, exp.get_r2(SplitTypes.Test))
def test_experiment(self): output_filename_header = FileLoader.create_output_file() time.sleep(1) loaded_algorithm_combinations = FileLoader.read_csv_file("../Datasets/test.csv") file_path = "../Datasets/HIV_37_Samples/MergedDataset.csv" loaded_data = FileLoader.load_file(file_path) # feature_eliminator = SelectKBest(f_regression,k=k_value) print (loaded_algorithm_combinations[0]) output_filename = FileLoader.create_output_file() for i in range(0, 80): normalizer = self.getnormalizer(loaded_algorithm_combinations[i][0]) feature_eliminator = self.getfeature_eliminator(loaded_algorithm_combinations[i][1]) the_model = self.get_model(loaded_algorithm_combinations[i][2]) print "taking ", type(normalizer).__name__, "and feature selector ", type( feature_eliminator ).__name__, "model", type(the_model).__name__ FileLoader.write_model_in_file( output_filename_header, type(normalizer).__name__, type(feature_eliminator).__name__, type(the_model).__name__, "", "", "", "", "", ) the_data_manager = DataManager(feature_eliminator, normalizer=normalizer) the_data_manager.set_data(loaded_data) the_data_manager.split_data(test_split=0.15, train_split=0.70) exp = Experiment(the_data_manager, the_model) exp.run_experiment() # arr_selected = feature_eliminator.get_support(indices=True) # if(exp.get_r2(SplitTypes.Train) > 0 and exp.get_r2(SplitTypes.Valid) > 0 and exp.get_r2(SplitTypes.Test) > 0): FileLoader.write_model_in_file( output_filename, type(normalizer).__name__, type(feature_eliminator).__name__, type(the_model).__name__, "", exp.fitness_matrix[0], exp.get_r2(SplitTypes.Train), exp.get_r2(SplitTypes.Valid), exp.get_r2(SplitTypes.Test), )
def test_experiment_all_zeros_r2_1(self): the_data_manager = DataManager() array_all_zeroes = np.zeros((37, 397)) the_data_manager.set_data(array_all_zeroes) the_data_manager.split_data(test_split=0.19, train_split=0.62) the_model = svm.SVR() exp = Experiment(the_data_manager, the_model) exp.run_experiment() r2_train = exp.get_r2(SplitTypes.Train) expected = 1.0 self.assertEqual(r2_train, expected)
def test_experiment_svm_svr_37dataset_r2_train(self): file_path = "../Datasets/HIV_37_Samples/MergedDataset.csv" loaded_data = FileLoader.load_file(file_path) the_data_manager = DataManager() the_data_manager.set_data(loaded_data) the_data_manager.split_data(test_split=0.19, train_split=0.62) the_model = svm.SVR() exp = Experiment(the_data_manager, the_model) exp.run_experiment() r2_train = exp.get_r2(SplitTypes.Train) expected_svm_r2_value = 0.93994377385638073 self.assertEqual(r2_train, expected_svm_r2_value)
def __init__(self, measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory): Experiment.__init__(self,measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory) # parameters of the top sphere self.spherePositionX=self.objectSizeX / 2 self.spherePositionY=self.objectSizeY / 2 self.spherePositionZ=self.objectSizeZ / 2 self.sphereRadius=5 self.sphereIntensity=100 self.background=0.000001 self.directory=homeDirectory+"/Sphere/"
def test_experiment_sum_of_squares_zeros_test(self): the_data_manager = DataManager() an_array_of_all_ones = np.ones((37, 397)) the_model = svm.SVR() the_data_manager.set_data(an_array_of_all_ones) the_data_manager.split_data(test_split=0.19, train_split=0.62) exp = Experiment(the_data_manager, the_model) exp.run_experiment() sum_of_squares_test = exp.get_sum_of_squares(SplitTypes.Test) expected = 0 self.assertEquals(expected, sum_of_squares_test)
def menuButton1(self, control): exampleHead = Head() exampleHeadModel = HeadModel(exampleHead) exampleHead.setSamplingFrequency(10) exampleHead.addRegistrationSite([0, 0, 0]) exampleStimulus = StimulusDummy('Stim', exampleHead) exampleGenerator = GeneratorDummy('Gen', exampleHead) exampleConnection = ConnectionDummy('Con', exampleHead, exampleStimulus, exampleGenerator) exampleExperiment = Experiment(exampleHead.getSamplingFrequency(), 1.0, exampleHead.runSimulation( 1.0 )) output = str(exampleExperiment.getRecording()) self.log.SetValue(output) self.logWindow.Show()
def test_experiment_svr_37dataset_r2_test(self): file_path = "../Datasets/HIV_37_Samples/MergedDataset.csv" loaded_data = FileLoader.load_file(file_path) the_data_manager = DataManager() the_data_manager.set_data(loaded_data) the_data_manager.split_data(test_split=0.19, train_split=0.62) the_model = svm.SVR() exp = Experiment(the_data_manager, the_model) exp.run_experiment() r2_test = exp.get_r2(SplitTypes.Test) expected_svm_r2_value = -0.33005242525900247 self.assertEqual(r2_test, expected_svm_r2_value)
def test_experiment_sum_of_squares_real37_test(self): file_path = "../Datasets/HIV_37_Samples/MergedDataset.csv" loaded_data = FileLoader.load_file(file_path) the_data_manager = DataManager() the_data_manager.set_data(loaded_data) the_model = svm.SVR() the_data_manager.split_data(test_split=0.19, train_split=0.62) exp = Experiment(the_data_manager, the_model) exp.run_experiment() sum_of_squares_test = exp.get_sum_of_squares(SplitTypes.Test) expected = 6.708898437500002 self.assertAlmostEqual(expected, sum_of_squares_test)
def load_merged_traces_experiments_from_list(cells, verbose=True): """ Load experiments where IDRest traces have been merged. This function will try to load an experiment with merged IDRest traces for all cells in the list and just skip the ones for which it is not found. If no experiments were found, None is returned. Params: - cells: List with cell names or dictionairy where the keys are the cell names. See also: load_single_traces_experiments_from_list() """ if type(cells) is dict: cell_names = list(cells.keys()) else: cell_names = cells expms = [] for i in range(len(cell_names)): current_expm_name = 'Experiment_Cell_' + cell_names[i] + '_merged_idrest_traces.pkl' current_expm_path = os.path.join(EXPM_PATH, current_expm_name) try: current_expm = Experiment.load(current_expm_path, verbose=verbose) expms.append(current_expm) except: pass if not len(expms) == 0: return expms else: return None
def load_single_traces_experiments_from_list(cells, verbose=True): """ Load experiments where traces have been added separately. Params: - cells: List with cell names or dictionairy where the keys are the cell names. See also: load_merged_traces_experiments_from_list() """ if type(cells) is dict: cell_names = list(cells.keys()) else: cell_names = cells expms = [] for i in range(len(cell_names)): current_expm_name = 'Experiment_Cell_' + cell_names[i] + '_single_traces.pkl' current_expm_path = os.path.join(EXPM_PATH, current_expm_name) try: current_expm = Experiment.load(current_expm_path, verbose=verbose) expms.append(current_expm) except: pass if not len(expms) == 0: return expms else: return None
def menuButton4(self, control): exampleHead = Head() exampleHeadModel = HeadModel(exampleHead) exampleHead.setSamplingFrequency(128) exampleHead.addRegistrationSite([0, 0, 0]) exampleExperiment = Experiment(exampleHead.getSamplingFrequency(), 10.0) exampleExperiment.setStimulusTimes([[0.3, 1.75, 2.16, 3.87, 4.31, 5.183, 6.34, 7.13]]) exampleStimulus = Stimulus('Stim', exampleHead) exampleStimulus.setStimulusTimes(exampleExperiment.getStimulusTimes()[0]) exampleGenerator = GeneratorSine('Gen', exampleHead) exampleConnection = Connection('Con', exampleHead, exampleStimulus, exampleGenerator) exampleExperiment.setRecording(exampleHead.runSimulation(exampleExperiment.getDuration())) exampleExperiment.plotRecording()
def __init__(self, runner): Experiment.__init__(self, runner) runner.paths = \ [ [ 1 ] , [ 2, 3, 4 ] , [ 2, 3, 5 ] , [ 6 ] ] runner.lineMap = \ { 1: 16 , 2: 17 , 3: 26 , 4: 21 , 5: 23 , 6: 30 } self.minInput = -1000 self.maxInput = 1000
def __init__(self, measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory): Experiment.__init__(self,measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory) # parameters of the top sphere self.spherePositionX=self.objectSizeX / 2 self.spherePositionY=self.objectSizeY / 2 self.spherePositionZ=self.objectSizeZ / 2 - 27 self.sphereRadius=6 self.zRadius=2 self.sphereIntensity=100 # parameters of the bottom sphere self.spherePosition2X=self.objectSizeX / 2 self.spherePosition2Y=self.objectSizeY / 2 self.spherePosition2Z=self.objectSizeZ / 2 self.sphereRadius2=6 self.szRadium=2 self.sphereIntensity2=100 self.background=0.000001 self.directory=homeDirectory+"/Tester2/"
def menuButton3(self, control): exampleHead = Head() exampleHeadModel = HeadModel(exampleHead) exampleHead.setSamplingFrequency(10) exampleHead.addRegistrationSite([0, 0, 0]) exampleExperiment = Experiment(exampleHead.getSamplingFrequency(), 1.0) exampleExperiment.setStimulusTimes([[0.3, 0.6], [0.5]]) exampleStimulus1 = Stimulus('Stim1', exampleHead) exampleStimulus2 = Stimulus('Stim2', exampleHead) exampleStimulus1.setStimulusTimes(exampleExperiment.getStimulusTimes()[0]) exampleStimulus2.setStimulusTimes(exampleExperiment.getStimulusTimes()[1]) exampleGenerator1 = GeneratorNumberIncrementing('Gen1', exampleHead) exampleGenerator2 = GeneratorNumberIncrementing('Gen2', exampleHead) exampleConnection1 = Connection('Con1', exampleHead, exampleStimulus1, exampleGenerator1) exampleConnection2 = Connection('Con2', exampleHead, exampleStimulus2, exampleGenerator2) exampleExperiment.setRecording(exampleHead.runSimulation(exampleExperiment.getDuration())) output = str(exampleExperiment.getRecording()) self.log.SetValue(output) self.logWindow.Show()
from skopt import gp_minimize, dummy_minimize from skopt.plots import plot_convergence import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import pickle import seaborn as sns import os from Experiment import Experiment def eggholder_function(x): """Returns eggholder function. Minimum -959.6407 at (512,404.23)""" return -(x[1] + 47) * np.sin(np.sqrt(np.abs(x[0] / 2 + ( x[1] + 47)))) - x[0] * np.sin(np.sqrt(np.abs(x[0] - (x[1] + 47)))) if __name__ == '__main__': search_space = list() search_space.append(Real(-513, 513, 'uniform', name='x')) search_space.append(Real(-513, 513, 'uniform', name='y')) experiment = Experiment(1, eggholder_function, search_space, numberOfEpochs=10, numberOfRepetitions=1, numberOfRandom=10) experiment.run('EI') experiment.plot_convergence() plt.show()
def __init__(self, project, dataset, session): Experiment.__init__(self, project, dataset, session) self.kind = 'ActiveLearning' self.labeling_method = None
from LIF import LIF def open_filterd_list(filtername): with open('/home/andrej/Dropbox/Arbeit/MKP/gif_fitting/BlueBrain/' + filtername + '_infos.pkl', 'rb') as f: filtered_list = pickle.load(f) return filtered_list soms = open_filterd_list('som_animals') vips = open_filterd_list('vip_animals') pvs = open_filterd_list('pv_animals') cell_names = list(vips.keys()) expms = [] for i in range(len(vips)): current_expm_name = 'Experiment_Cell_' + cell_names[i] + '_merged_idrest_traces.pkl' current_expm_path = os.path.join(expm_path,current_expm_name) try: current_expm = Experiment.load(current_expm_path) expms.append(current_expm) except: pass my_expm = expms[0] mylif = LIF(my_expm.dt) mylif.Tref = 4.0 my_expm.detectSpikes_cython() mylif.fitVoltageReset(my_expm,4.0) tr = my_expm.trainingset_traces[0]
lista = [] for i in range(tam): lista.append(i) random.shuffle(lista) return lista def geraListaReversa(tam): lista = [] for i in range(tam): lista.append(i) lista.reverse() return lista ''' vet = bubbleSort([7, 6, 5, 4, 3, 2, 1]) print(vet.vet) #print(vet.stats.swaps) vet.sort() print(vet.vet) #print(vet.stats.swaps) ''' intervals = [100, 200, 300, 400, 500] vectMelhor = bubbleSort(geraListaOrdenada(500), intervals) vectPior = bubbleSort(geraListaReversa(500), intervals) vect = bubbleSort(geraLista(500), intervals) E1 = Experiment([vect, vectMelhor, vectPior], intervals, title="Bubble Sort") E1.calculaTempos(bubbleSort) E1.plotar() x = 1
from Experiment import Experiment exper = Experiment( '../Benchmarks', boogiePath='../Tools/Ours/VarElim/Boogie/Binaries/Boogie.exe', proverPath='../Tools/z3.exe', learnerPath='../Tools/Ours/IDT4Inv/build/', ) exper.cleanIntermediateResult() exper.setRunMode(Experiment.RunMode.IDT) exper.setExperiment(limitedTime=60, itemSleep=0, roundSleep=0) result = exper.experimentAllBplSerially() exper.GenXlsxFromDict('../Results', result, infoExtra='Elim', titleAdd='Elim')
# the StimuliSet for the experiment (consisting of set_size/2 transformed samples of each) set_transform_function = transform.stochastic_release # The function to use when generating each transformed stimulus set_transform_params = dict( # The parameters with which to execute the specified transformation function release_duration=3, number_of_vesicles=20, stimulus_duration=stimulus_duration, release_probability=0.5) # Append underscore to condition name # %% Running and controlling the experiment # Set up the experiment experiment = Experiment(stimuli_creation_params=stimuli_creation_params, model=model_params, training_params=training_params, origin_transform_function=origin_transform_function, origin_transform_params=origin_transform_params, set_transform_function=set_transform_function, set_transform_params=set_transform_params, repetitions=number_of_repetitions) # Run the experiment experiment.run() # Saving all experiment data experiment.save(report_folder, condition_name) # Save backup copy of this file with open(__file__, 'r') as file: this_file = file.read() with open(path.join(report_folder, f'{condition_name}experiment_template.py'), 'w') as template_file:
def toJson(self): conf = Experiment.toJson(self) conf['__type__'] = 'ValidationExperiment' return conf
seed = 1337 tensorboard_dir = path_prefix + '/tensorboard/' #Set initial seed np.random.seed(seed) #Load flat matrix dataset = SIDLoader(dataset_dir, patch_fn=None, keep_raw=False, keep_gt=True, set_id='test') #Set up experiments expList = [] expList.append( Experiment(name='Sony', model_fn={'fn': ModelBuilder.build_loadable_cchen}, device="/device:GPU:0", tensorboard_dir=tensorboard_dir, checkpoint_dir='../checkpoint', dataset=dataset)) #expList.append(Experiment(name='cchen_sony_noflip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp},device="/device:GPU:0",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='unet_s_sony_noflip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp},device="/device:GPU:1",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='deep_isp_noflip',model_fn={'fn':ModelBuilder.build_deep_isp_exp},device="/device:GPU:2",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='cchen_resize_sony_noflip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp_resize},device="/device:GPU:3",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='unet_s_resize_sony_noflip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp_resize},device="/device:GPU:4",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='cchen_sony_flip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp},device="/device:GPU:0",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='unet_s_sony_flip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp},device="/device:GPU:1",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='deep_isp_flip',model_fn={'fn':ModelBuilder.build_deep_isp_exp},device="/device:GPU:2",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='cchen_resize_sony_flip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp_resize},device="/device:GPU:3",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='unet_s_resize_sony_flip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp_resize},device="/device:GPU:4",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='unet_self_amp2',model_fn={'fn':ModelBuilder.build_unet_self_scale},device="/device:GPU:0",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) #expList.append(Experiment(name='unet_amp_infer2',model_fn={'fn':ModelBuilder.build_unet_amp_infer},device="/device:GPU:1",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir,dataset=dataset)) epoch = 0
parameters = json.load(open(arg_parameter_file)) # Verify parameters supp_fig_file_types = [ 'ps', 'eps', 'pdf', 'pgf', 'png', 'raw', 'rgba', 'svg', 'svgz', 'jpg', 'jpeg', 'tif', 'tiff' ] assert exp['algorithm'] in [ 'FORCE', 'RMHL', 'SUPERTREX' ], "algorithm must be FORCE, RMHL or SUPERTREX." assert exp['task_type'] in [1, 2, 3], "task_type must be 1, 2 or 3." assert exp['n_segs'] > 0, "n_seg must be greater than zero." assert len(exp['arm_len']) == exp['n_segs'], "arm_len size " + str( len(exp['arm_len'])) + " is not the same as n_seg." assert len(exp['arm_cost']) == exp['n_segs'], "arm_cost size " + str( len(exp['arm_cost'])) + " is not the same as n_seg." assert exp['display_plot'] in ['Yes', 'No'], "display_plot must be Yes or No" assert exp[ 'plot_format'] in supp_fig_file_types, "plot_format must be a valid image format for savefig: " + str( supp_fig_file_types) assert parameters[ 'n_train_trials'] >= 5, "n_train_trials must be greater than 4." # Simulate experiment experiment = Experiment(exp, parameters) # Initialise experiment experiment.run( exp) # Comment if you want to replot previously saved results experiment.plot(exp) # Plot results and saves figures os.system('say "your program has finished"')
def getExperiment(appName, howManyRuns): durations = getDurationsForWorkloadName(appName, howManyRuns) if appName.startswith("numa-remote"): appName = appName.replace("numa-remote", "numaR") return Experiment(1, appName, durations)
import sys, argparse from Experiment import Experiment if __name__ == '__main__': # Parse command line input parameters parser = argparse.ArgumentParser(description='Run one experiment once') parser.add_argument('outdir', type=str, help='Output folder for results') parser.add_argument( '--n_trials', default=400, type=int, help='Number of trials in the experiment (default 400)') args = parser.parse_args() # Build experiment exp = Experiment() # Tweeks go here: aversion = True exp.brain.striatum.w = .25 exp.brain.striatum.J_intra = exp.brain.striatum.w * exp.brain.striatum.J_inter exp.brain.vta.DA_pars['A_minus'] = 0. # Run experiment exp.train_brain(n_trials=args.n_trials, aversion=aversion, save_dir=args.outdir)
def testExperimentDesign(self): check = 0 try: generateCompatibleFormat( exp_path=os.path.abspath("tests/NTU_Experiment"), device="eyelink", stim_list_mode='NA', start='start_trial', stop='stop_trial', eye='B') check = 1 finally: self.assertEqual(check, 1) check = 0 try: exp = Experiment(json_file=os.path.abspath( "tests/NTU_Experiment/NTU_Experiment.json")) check = 1 finally: self.assertEqual(check, 1) check = 0 try: exp.metaMatrixInitialisation(standardise_flag=False, average_flag=False) check = 1 finally: self.assertEqual(check, 1) check = 0 try: exp.analyse(parameter_list={"all"}, between_factor_list=["Subject_type", "Gender"], within_factor_list=["Stimuli_type"], statistical_test="anova", file_creation=True) exp.analyse(parameter_list={"all"}, statistical_test="anova", file_creation=True) exp.analyse(parameter_list={"all"}, statistical_test="ttest", file_creation=True) exp.analyse(parameter_list={"all"}, statistical_test="RM_anova", file_creation=True) exp.analyse(statistical_test="None", file_creation=True) check = 1 finally: self.assertEqual(check, 1) check = 0 try: subject_name = "sub_222" stimulus_name = "Alpha1" single_meta = exp.getMetaData(sub=subject_name, stim=stimulus_name) agg_type_meta = exp.getMetaData(sub=subject_name, stim=None) check = 1 finally: self.assertEqual(check, 1)
def Training(): args = argument.get_args() logger = get_logger() currentModel = -1 if args.overwrite else dataProcessor.getLatestNetworkID() trainWorker = NetworkTraining() replayBuffer = [] Loss = [] WinRate = [] rollout0 = None balance0 = 0 if args.rolloutMode == 'network': rollout0 = None balance0 = 0 elif args.rolloutMode == 'minmax': rollout0 = minMaxRolloutFn(1) balance0 = 1 elif args.rolloutMode == 'random': rollout0 = randomRolloutFn(20) balance0 = 1 elif args.rolloutMode == 'mix_minmax': rollout0 = minMaxRolloutFn(1) balance0 = args.balance elif args.rolloutMode == 'mix_random': rollout0 = randomRolloutFn(30) balance0 = args.balance else: rollout0 = None balance0 = 1 for rd in range(1, args.trainround + 1): logger.info("round:%d" % rd) if currentModel != -1: model = dataProcessor.loadNetwork(args, currentModel) else: model = PolicyValueFn(args).to(device=args.device) eta = math.log(args.trainround / rd) + 1 file = os.path.join(args.data_folder, f"selfplay-{currentModel+1}.txt") #rollout =randomRolloutFn(cnt=7) agent1 = Agent.SelfplayAgent(args.numOfIterations, model, file, eta, rollout=rollout0, balance=balance0) b = Board.Board(args.size, args.numberForWin) g = Game.Game(agent0=agent1, agent1=agent1, simulator=b) for i in range(1, args.epochs + 1): logger.info("epoch %d" % i) TimeID = timer.startTime("play time") g.run() timer.endTime(TimeID) timer.showTime(TimeID) if i % args.n_save_step == 0: agent1.saveData() if args.openReplayBuffer and len(replayBuffer) > args.buffersize: buffer = [] for i in range(args.buffersize): buffer.append(random.choice(replayBuffer)) trainWorker.train(args.miniTrainingEpochs, currentModel, buffer, update=False) #if args.openReplayBuffer and len(replayBuffer): # trainWorker.train(args.miniTrainingEpochs, currentModel, replayBuffer, update=False) agent1.saveData() dataList = dataProcessor.retrieveData(file) replayBuffer = replayBuffer + dataList if len(replayBuffer) > args.maxBufferSize: replayBuffer = replayBuffer[-args.maxBufferSize:] currentModel += 1 TimeID = timer.startTime("network training") Loss.append(trainWorker.train(args.trainepochs, currentModel, dataList)) timer.endTime(TimeID) timer.showTime(TimeID) #if args.openReplayBuffer: # TimeID = timer.startTime("update replay buffer") # replayBuffer = trainWorker.getReplayData(currentModel, dataList) # timer.endTime(TimeID) # timer.showTime(TimeID) agentTest = Agent.IntelligentAgent(args.numOfIterations, dataProcessor.loadNetwork(args), rolloutFn=rollout0, balance=balance0) exp = Experiment() WinRate.append(exp.evaluationWithBaseLine(agentTest)) logger.info("WinRate: %.3f" % WinRate[-1]) return Loss, WinRate
def __init__(self, measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory): Experiment.__init__(self,measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory) self.numpoints=100; self.background=0.000001; self.directory=homeDirectory+"/RandomPoints2/"
def main(): experiment = Experiment() experiment.gatherResults() experiment.plotHist(experiment.results)
#!/usr/bin/env python # -*- coding: utf-8 -*- from builders import ErdosRenyi, Barabasi from Experiment import Experiment from Estimator import MonteCarlo, Greedy, GreedyRestart, Annealing config = { 'graph_maker': ErdosRenyi(n=100, p=5.0/100), 'num_trials': 10000, 'filename': 'results/Erdos-Renyi-1e2.tsv', 'estimator_types': [MonteCarlo, Greedy, GreedyRestart, Annealing], 'budgets': [i + 1 for i in range(10)] } e = Experiment(**config) e.run() config = { 'graph_maker': ErdosRenyi(n=1000, p=5.0/1000), 'num_trials': 10000, 'filename': 'results/Erdos-Renyi-1e3.tsv', 'estimator_types': [MonteCarlo, Greedy, GreedyRestart, Annealing], 'budgets': [10 * (i + 1) for i in range(10)] } e = Experiment(**config) e.run() config = { 'graph_maker': ErdosRenyi(n=10000, p=5.0/10000), 'num_trials': 10000, 'filename': 'results/Erdos-Renyi-1e4.tsv',
} # batch_size_train = 100 # learning_rate = 0.01 seed = 42 uid = randomString(stringLength=6) # batch_size_test = 1000 # n_epochs = 100 device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") if torch.cuda.is_available(): torch.cuda.manual_seed(seed) else: torch.manual_seed(seed) experiment = Experiment(device) if params_dict["type"] == "Pruning": pruning = Pruning(percentage=params_dict["percentage"]) elif params_dict["type"] == "Growing": growing = Growing(percentage=params_dict["percentage"]) elif params_dict["type"] == "Shifting": growing = Growing(percentage=params_dict["percentage2"]) pruning = Pruning(percentage=params_dict["percentage"]) model_dict = { "network": { 'input_layer': { "units": 784, }, 'hidden_layer': [{
#dataset = dataset.MNISTDataset(config) #config = config.ConfigLSTM() #dataset = dataset.SequenceLearningOneToOne() # model = model.LSTM(input_size=10, seq_length=1, num_layers=1, # out_size=10, hidden_size=10, batch_size=1, device=config.DEVICE) dataX = [[(i % 4) / 4, (i % 4) / 4.0] for i in range(0, 1000)] dataY = [] for i in range(len(dataX)): if i % 4 == 3: dataY.append(0) elif i % 4 == 2: dataY.append(1) elif i % 4 == 1: dataY.append(2) else: dataY.append(3) print(np.asarray(dataX)) print(np.asarray(dataY)) dataset = dataset.MLPToyDataset(dataX=np.asarray(dataX), dataY=np.asarray(dataY)) #model = model.LSTM(input_size=config.INPUT_SIZE, seq_length=config.SEQ_LEN, num_layers=2, # out_size=config.OUTPUT_SIZE, hidden_size=5, batch_size=config.TRAIN_BATCH_SIZE, # device=config.DEVICE) # model = model.MLP(input_size=2, output_size=4) # experiment = Experiment(config=config, model=model, dataset=dataset) experiment.run()
# set up the backend for the plot plt.rcdefaults() # construct the arms and build the corresponding environment env = Environment([Bernoulli(p) for p in [0.7, 0.3]]) n_arms = env.n_arms print("### Environment\n" + str(env)) # prepare the algorithm ucb_params = StructType() ucb_params.scaling = 1.0 alg = UCB(n_arms, ucb_params) print("### Algorithm\n" + str(alg)) # prepare the experiment exp = Experiment(1000) # execute the experiment and collect the results res = execute(exp, env, alg) # type : Result # compute statistics stats = res.compute_statistics() # plot a chart with the cumulative regret cum_exp_regret = np.cumsum(stats.exp_regret) print(cum_exp_regret) plt.plot(np.arange(exp.n_steps), cum_exp_regret, linewidth=2.5, linestyle="-") plt.legend(loc='upper left', frameon=False) plt.xlabel("steps") plt.ylabel("cumulative regret")
def __init__( self ): ## source table, needed for adding singletons self.mTableNameSource = "nrdb40" ## mapping table, needed for mapping domains onto nrdb100 self.mTableNameMapping = "pairsdb_100x40" ## destination tables self.mTableNameFamilies = None self.mTableNameDomains = None self.mTableNameMappedDomains = None self.mTableNameMappedFamilies = None self.mTableNameRepresentatives = None self.mWorkSpace = "temp" self.mDatabase = "pairsdb" ## whether to remove domains overlapping with repeats self.mFilterRepeats = None self.mShortOptions += 'D:f:d:e:g:h:s:r:m:' self.mLongOptions += ['Database=', 'families=','domains=', 'mapped_families=','mapped_domains=', 'workspace=', "representatives=", 'source=', 'repeats=', "mapping=", 'filter_repeats','combine_overlaps', 'min_domain_length='] self.mShortOptions += 'i:M:' self.mLongOptions += ['input=', "filename_map=" ] self.mFileNameMapNids = None self.mMinSingletonLength = 30 self.mMinDomainLength = 20 self.mCombineOverlaps = 0 Experiment.__init__( self ) dbhandle = Pairsdb.Pairsdb() dbhandle.Connect( dbname = self.mDatabase ) self.dbhandle = dbhandle self.dbhandle = dbhandle self.mFileNameFamilies = None self.mFileNameDomains = None # get suffix x = string.rfind( self.mTableNameDomains, "_") if x >= 1: self.mGeneralSuffix = self.mTableNameDomains[x:] else: self.mGeneralSuffix = "" if not self.mTableNameDomains: raise "no table domains specified" if not self.mTableNameFamilies: raise "no table families specified" if string.find( self.mTableNameFamilies, ".") == -1: self.mTableNameFamilies = self.mWorkSpace + "." + self.mTableNameFamilies if string.find( self.mTableNameDomains, ".") == -1: self.mTableNameDomains = self.mWorkSpace + "." + self.mTableNameDomains self.mTableNrdb = Table_nrdb( self.dbhandle ) if self.mTableNameSource: self.mTableNids = TableNids( self.dbhandle ) self.mTableNids.SetName( self.mTableNameSource ) self.mTableNrdb.SetName( self.mTableNameSource ) self.mTableFamilies = TableFamilies( dbhandle, "generic" ) self.mTableDomains = TableDomains( dbhandle, "generic" ) self.mTableFamilies.SetName( self.mTableNameFamilies ) self.mTableDomains.SetName( self.mTableNameDomains )
import sys from Expert import Expert from Experiment import Experiment parser = argparse.ArgumentParser() parser.add_argument("--input","-i",type=str, default="input.txt", help="адрес папки с входными данными. По умолчанию ./input.txt") parser.add_argument("--output","-o",type=str, default="output.txt", help="адрес файла с выходными данными. По умолчанию ./output.txt") parser.add_argument("--compitence","-c", type=int, help="расчет коэффициентов компетентности экспертов, c заданой точностью") parser.add_argument("--mediana","-m", action = "store_true", help="расчет медианы") parser.add_argument("--generalized","-g", action = "store_true", help="расчет обобщенной выборки") parser.add_argument("--significant","-s", help="Значимость оценок, коэффициент Спирмена, критический интервал", action = "store_true") parser.add_argument("--kendal","-k", help="коэффициент конкордации Кендалла", action = "store_true") args = parser.parse_args() experiment = Experiment() if (args.compitence): out = open(args.output, 'w') directory = args.input files = os.listdir(directory) a = files[0].endswith('txt') documents = list(filter(lambda x: x.endswith('.txt'), files)) #Добавляем в класс эксперимент экспертов ex = Expert(args.input,files[0]) for document in documents: expert = Expert(args.input,document) experiment.addExpert(expert)
def addOrGetExperience(label, actionType): experiment = Experiment(label, actionType) EXPERIENCES[label] = experiment return EXPERIENCES[label]
def __init__(self): exp = Experiment() exp.go(100)
def create_experiments_from_list(cells, cell_type, verbose=True): """ Creates Experiment objects for cells in cells, adds all existing traces and saves them. Params: - cells: List with cell names or dictionairy where the keys are the cell names. """ if type(cells) is dict: cell_names = list(cells.keys()) else: cell_names = cells ncells = len(cell_names) for i in range(ncells): PATH = os.path.join(ROOT_PATH, cell_names[i]) animal_files = sorted(os.listdir(PATH)) ntraces = int(len(animal_files) / 2) current_exp = Experiment('Cell_' + cell_names[i] + '_single_traces', cell_type=cell_type) exp_merged_traces = Experiment('Cell_' + cell_names[i] + '_merged_idrest_traces', cell_type=cell_type) nincluded_idrest_traces = 0 for j in np.arange(ntraces): # files end with 'recordingType_recordingNumber.ibw' file_split = str.split(animal_files[j][0:-4], '_') file_identifier = file_split[-2] + '_' + file_split[-1] + '.ibw' current_recording_type = file_split[-2] # find indeces of matching files in folder (current file always comes first because it's always Ch0) file_idc = [i for i, elem in enumerate(animal_files) if file_identifier in elem] current_file = animal_files[file_idc[0]] voltage_file = animal_files[file_idc[1]] current_exp.add_trainingset_trace(os.path.join(PATH, voltage_file), 10 ** -3, os.path.join(PATH, current_file), 10 ** -12, FILETYPE='Igor', verbose=verbose) tr = current_exp.trainingset_traces[j] tr.recording_type = current_recording_type tr.estimate_input_amp() if current_recording_type == 'IDRest': exp_merged_traces.add_trainingset_trace(os.path.join(PATH, voltage_file), 10 ** -3, os.path.join(PATH, current_file), 10 ** -12, FILETYPE='Igor', verbose=verbose) tr = current_exp.trainingset_traces[nincluded_idrest_traces] tr.recording_type = current_recording_type tr.estimate_input_amp() nincluded_idrest_traces += 1 if not len(exp_merged_traces.trainingset_traces) < 3: exp_merged_traces.mergeTrainingTraces() exp_merged_traces.save(os.path.join(EXPM_PATH), verbose=verbose) current_exp.save(os.path.join(EXPM_PATH), verbose=verbose)
import time, datetime, os, glob path_prefix = '.' checkpoint_dir = path_prefix + '/chk' dataset_dir = path_prefix + '/dataset' valid_freq = 100 seed = 1337 tensorboard_dir = path_prefix + '/tensorboard' #Set initial seed np.random.seed(seed) #Set up experiments expList = [] expList.append( Experiment(name='unet_self_amp2', model_fn={'fn': ModelBuilder.build_unet_self_scale}, device="/device:GPU:0", tensorboard_dir=tensorboard_dir, checkpoint_dir=checkpoint_dir)) expList.append( Experiment(name='unet_amp_infer2', model_fn={'fn': ModelBuilder.build_unet_amp_infer}, device="/device:GPU:1", tensorboard_dir=tensorboard_dir, checkpoint_dir=checkpoint_dir)) #Load flat matrix dataset = SIDLoader(dataset_dir, patch_fn=SIDLoader.patch_unprocessed_sony, keep_raw=True, keep_gt=True) validSet = None
def toJson(self): conf = Experiment.toJson(self) conf['__type__'] = 'ActiveLearningExperiment' conf['labeling_method'] = self.labeling_method conf['conf'] = self.conf.toJson() return conf
test_dataset = torchvision.datasets.FashionMNIST( '../data/', train=False, download=True, transform=torchvision.transforms.Compose( [torchvision.transforms.ToTensor(), ReshapeTransform((-1, ))])) dataset = torch.utils.data.ConcatDataset([train_dataset, test_dataset]) kf = KFold(n_splits=5, shuffle=True, random_state=seed) for i_fold, (train_index, test_index) in enumerate(kf.split(dataset)): print("Fold: {}".format(i_fold + 1)) # new fold - network from scratch experiment = Experiment(device) model = Network(model_dict) params_dict["fold"] = i_fold + 1 # set the dataloaders for the fold train = torch.utils.data.Subset(dataset, train_index) test = torch.utils.data.Subset(dataset, test_index) train_loader = torch.utils.data.DataLoader( train, batch_size=params_dict["batch_size_train"], shuffle=True) test_loader = torch.utils.data.DataLoader( test, batch_size=params_dict["batch_size_test"], shuffle=True) # set up the experiment experiment.set_metadata(params_dict) experiment.set_network(model_dict) experiment.set_loaders(train_loader, test_loader) experiment.set_loss(torch.nn.CrossEntropyLoss())
import time, datetime, os, glob path_prefix = '.' checkpoint_dir = path_prefix + '/chk' dataset_dir = path_prefix + '/dataset' valid_freq = 20 seed = 1337 tensorboard_dir = path_prefix + '/tensorboard' #Set initial seed np.random.seed(seed) #Set up experiments expList = [] expList.append( Experiment(name='cchen_sony_noflip', model_fn={'fn': ModelBuilder.build_cchen_sony_exp}, device="/device:GPU:0", tensorboard_dir=tensorboard_dir, checkpoint_dir=checkpoint_dir)) expList.append( Experiment(name='unet_s_sony_noflip', model_fn={'fn': ModelBuilder.build_unet_s_sony_exp}, device="/device:GPU:1", tensorboard_dir=tensorboard_dir, checkpoint_dir=checkpoint_dir)) expList.append( Experiment(name='deep_isp_noflip', model_fn={'fn': ModelBuilder.build_deep_isp_exp}, device="/device:GPU:2", tensorboard_dir=tensorboard_dir, checkpoint_dir=checkpoint_dir)) expList.append(
def test(): # Building the wrapper wrapper = Experiment(test=True) wrapper.test()
var = argv[2] output_file = argv[3] f = open(filename) experiment_values = [] times = [] experiments = [] for line in f: l = line.split() # remove comments if '#' in l: l = l[0:l.index('#')] if len(l) == 0: # create experiment objects for exp_val in experiment_values: exp = Experiment(times, exp_val, var) experiments.append(exp) experiment_values = [] times = [] continue times.append(l[0]) if (experiment_values == []): nof_exp_per_line = len(l) - 1 experiment_values = [[] for i in range(len(l) - 1)] for i in range(1, len(l)): experiment_values[i - 1].append(float(l[i])) if experiment_values != []: for exp_val in experiment_values: exp = Experiment(times, exp_val, var)
plt.xlabel('Training epochs (1e3)', fontsize=28) plt.ylabel('Mean reward over ' + str(bracket) + ' epochs', fontsize=28) #plt.title('Mean Reward over ' + str(bracket) + ' epochs with training') plt.tick_params(labelsize=24) plt.savefig( 'D:\\Documents_Data\\UoM\\Projects\\First Year\\RL - Bioprocesses\\WorkBooks\\Reinforcement-Learning-for-Bioprocesses\\Accumulated_reward_' + str(pNo_mean) + 'MC.png') # running experiement for i in range(0, xi_.shape[0]): for j in range(0, disc1.shape[0]): for k in range(0, disc2.shape[0]): #run training env = Model_env(p, steps_, tf, x0, modulus) # calling environment agent = greedye_MCL(num_actions, modulus, state_UB, disc1[j], disc2[k], steps_) # calling agent experiment = ExpTrain(env, agent, controls, episodes_train, xi_[i]) # calling training experiment reward_training[:, i, j, k], d = experiment.simulation( ) # running training experiment agent = Greedye_MCLearned(num_actions, d, steps_) # calling learned agent exp_done = ExpValid(env, agent, controls, episodes_valid, 0) # calling validation experiment reward_validation[:, i, j, k] = exp_done.simulation( ) # running validation experiment reward_train_mean = EpochNoMean(reward_training[:, i, j, k], bracket) x_o = Plotting(reward_train_mean, bracket, "rule_allocation")
kw = ["cancer"] x.insert_keywords(kw) dic = {"samplecount" : "[200 TO 500]"} #dic = {} x.insert_criteria(dic) x.url_generator("experiments") # Creates the URL to be requested request = File_Requester(x.get_url()) #print(request.get_url()) request.do_request() request.get_request() request.do_content() # Returns the content of the requested URL #print(request.get_content()) decoder = MetaData(request.get_content(), request.get_url()) decoder.decode_json() # Decodes the content JSON #print(decoder.get_decoded()) exp = Experiment(decoder.get_decoded()["experiments"]["experiment"][13]) # Created an Experiment Instance #print(exp.__dict__) #print(exp.accession) #exp.do_files_url() #print(exp.get_files_url()) #exp.json_files_requester() #print(exp.get_json_files_request()) #exp.json_files_decoder() #print(exp.get_decoded_json_files()) #exp.create_files() #print(exp.files) #exp.download_all_files("C:/Users/utilizador/Google Drive/drive/Bioinformática/1_ano/2_Semestre/Projeto/Scripts/Downloads") exp.do_idf_file("C:/Users/utilizador/Google Drive/drive/Bioinformática/1_ano/2_Semestre/Projeto/Scripts/Downloads") # Downloads and creates an data with IDF data #print(exp.get_idf_file()) exp.do_sdrf_file("C:/Users/utilizador/Google Drive/drive/Bioinformática/1_ano/2_Semestre/Projeto/Scripts/Downloads") #Downloads and creates an data structure with SDRF data #print(exp.get_sdrf_file())
from Experiment import Experiment exper = Experiment( '../Benchmarks', boogiePath='../Tools/Ours/Exp2/Boogie/Binaries/Boogie.exe', proverPath ='../Tools/z3.exe' ) exper.cleanIntermediateResult() #exper.setRunMode(Experiment.RunMode.IDT) exper.setRunMode(Experiment.RunMode.DT_Penalty) exper.IDTParser = True exper.setExperiment(limitedTime=60,itemSleep=0,roundSleep=0) result = exper.experimentAllBplSerially() exper.GenXlsxFromDict('../Results',result,infoExtra='Exp2',titleAdd='Exp2')
Plotter.save_confusion_matrix_as_png(confMatrix, [l for l in labels_all], 'tmp.png', normalize=True, cmap=plt.cm.YlGn) temp() exit() server = "/run/user/477015036/gvfs/sftp:host=sonic.sb.dfki.de,user=mumu01" exps_root_dir = server + "/home/mumu01/exps" # exps = ["53", "54"] exps = ["55"] for exp_num in exps: exp_dir = exps_root_dir + '/exp' + exp_num exp_obj = Experiment(exp_dir) m_g = MetricsGenerator(exp_obj, eval_dataset="cs") # m_g.complete_pipeline() # m_g.pipeline_3() # m_g.pipeline_4() m_g.pipeline_5() # evaluator = CityscapesEvaluationWrapper(exp_obj, "cityscapes") # if re_eval: # print("Evaluating for cityscapes") # evaluator.evaluate_using_CS_script() # evaluator = CityscapesEvaluationWrapper(exp_obj, "gta") # if re_eval: # print("Evaluating for GTA") # evaluator.evaluate_using_CS_script(is_gta=True)
def fromJson(obj, session): experiment = ValidationExperiment(obj['project'], obj['dataset'], session) Experiment.expParamFromJson(experiment, obj) return experiment
def __init__(self, measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory): Experiment.__init__(self,measurementSizeX, measurementSizeY, measurementSizeZ, psfSizeX, psfSizeY, psfSizeZ, homeDirectory) self.numpoints=7; self.background=100; self.directory=homeDirectory+"/RandomSpheresZRatio/"
gamma=params[3], n_jobs=-1, colsample_bytree=params[4], eval_metric='mlogloss') # subsample=0.9 cv = RepeatedStratifiedKFold(n_splits=3, n_repeats=1, random_state=1) n_scores = cross_val_score(model, X_train, y_train, scoring='accuracy', cv=cv, n_jobs=-1, verbose=1) return 1 - mean(n_scores) if __name__ == '__main__': search_space = init_space() experiment = Experiment(evaluate_model, search_space, numberOfEpochs=129, numberOfRepetitions=1, numberOfRandom=10) experiment.run(['EI']) experiment.plot_convergence() plt.legend() plt.show() #=============================================================================== # # Viri in literatura # https://www.kaggle.com/prashant111/a-guide-on-xgboost-hyperparameters-tuning
def main(jsonPath, testRun, setTarg, seed): """ example: python Experimenter.py -j "../../Experiments/experiments.json" """ # jsonPath = "./experiments.json" expIDs = getExpIDs(jsonPath) for expID in expIDs: experiment = Experiment(expID, loadPath=jsonPath) print("--- Experiment with ID:", experiment.ID, "---") if experiment.stage == "ready": trainModel(experiment, testRun, setTarg, seed) experiment.stage = "trained" experiment.saveToJson(jsonPath) if experiment.stage == "trained": writeModelOutput(experiment, testRun, seed) experiment.stage = "readyForTest" experiment.saveToJson(jsonPath) if experiment.stage == "readyForTest": testModel(experiment, testRun, setTarg, seed) experiment.stage = "tested" experiment.saveToJson(jsonPath) if experiment.stage == "tested": print("Model is trained and tested! results:", str(experiment.evaluation))
print( "taking care of ", type(normalizer).__name__, "and feature selector ", type(feature_eliminator).__name__, "model", type(the_model).__name__, ) file_path = "../Datasets/HIV_37_Samples/MergedDataset.csv" loaded_data = FileLoader.load_file(file_path) # feature_eliminator = SelectKBest(f_regression,k=k_value) the_data_manager = DataManager(feature_eliminator, normalizer=normalizer) the_data_manager.set_data(loaded_data) the_data_manager.split_data(test_split=0.15, train_split=0.70) exp = Experiment(the_data_manager, the_model) exp.run_experiment() arr_selected = feature_eliminator.get_support(indices=True) if ( exp.get_r2(SplitTypes.Train) > 0 and exp.get_r2(SplitTypes.Valid) > 0 and exp.get_r2(SplitTypes.Test) > 0 ): print( feature_eliminator.get_support(indices=True), type(normalizer).__name__, type(feature_eliminator).__name__, type(the_model).__name__, "Fitness",