def get_data_from_npy(data_folder): X_train = np.load( f'{os.path.dirname(os.path.abspath(__file__))}/{data_folder}{global_vars.get("dataset")}/X_train.npy' ) X_test = np.load( f'{os.path.dirname(os.path.abspath(__file__))}/{data_folder}{global_vars.get("dataset")}/X_test.npy' ) y_train = np.load( f'{os.path.dirname(os.path.abspath(__file__))}/{data_folder}{global_vars.get("dataset")}/y_train.npy' ) y_test = np.load( f'{os.path.dirname(os.path.abspath(__file__))}/{data_folder}{global_vars.get("dataset")}/y_test.npy' ) global_vars.set('eeg_chans', X_train.shape[1]) global_vars.set('input_height', X_train.shape[2]) if X_train.ndim > 3: global_vars.set('input_width', X_train.shape[3]) if global_vars.get('problem') == 'regression': global_vars.set('n_classes', y_train.shape[1]) else: global_vars.set('n_classes', len(np.unique(y_train))) X_train, X_val, y_train, y_val = train_test_split( X_train, y_train, test_size=global_vars.get('valid_set_fraction')) train_set, valid_set, test_set = makeDummySignalTargets( X_train, y_train, X_val, y_val, X_test, y_test) return train_set, valid_set, test_set
def target_model(model_name): input_time_len = global_vars.get('input_time_len') n_classes = global_vars.get('n_classes') eeg_chans = global_vars.get('eeg_chans') models = { 'deep': deep4.Deep4Net(eeg_chans, n_classes, input_time_len, final_conv_length='auto'), 'shallow': shallow_fbcsp.ShallowFBCSPNet(eeg_chans, n_classes, input_time_len, final_conv_length='auto'), 'eegnet': eegnet.EEGNet(eeg_chans, n_classes, input_time_length=input_time_len, final_conv_length='auto'), 'sleep_classifier': get_sleep_classifier(), 'oh_parkinson': OhParkinson } final_conv_sizes = {'deep': 2, 'shallow': 30, 'eegnet': 2} final_conv_sizes = defaultdict(int, final_conv_sizes) global_vars.set('final_conv_size', final_conv_sizes[model_name]) if model_name == 'sleep_classifier': return models[model_name] else: model = models[model_name].create_network() return model
def get_netflow_asflow_train_val_test(data_folder, shuffle=False): if global_vars.get('netflow_subfolder'): subfolder_str = f"/{global_vars.get('netflow_subfolder')}" else: subfolder_str = '' file_paths = [f"{os.path.dirname(os.path.abspath(__file__))}/{data_folder}netflow{subfolder_str}/{ats}_" \ f"{global_vars.get('date_range')}.csv" for ats in global_vars.get('autonomous_systems')] X, y, _, _ = preprocess_netflow_data( file_paths, global_vars.get('input_height'), global_vars.get('steps_ahead'), global_vars.get('jumps'), global_vars.get('prediction_buffer'), global_vars.get('netflow_handover_locations')) global_vars.set('eeg_chans', X.shape[1]) if global_vars.get('problem') != 'classification': global_vars.set('n_classes', global_vars.get('steps_ahead')) if global_vars.get('per_handover_prediction'): global_vars.set('n_classes', global_vars.get('n_classes') * X.shape[1]) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=global_vars.get('valid_set_fraction'), shuffle=shuffle) if global_vars.get('aggregate_netflow_sum'): y_train = np.sum(y_train, axis=1) y_test = np.sum(y_test, axis=1) global_vars.set('n_classes', 1) if global_vars.get('problem') == 'classification' and not global_vars.get( 'highest_handover_overflow'): global_vars.set('n_classes', 2) X_train, X_val, y_train, y_val = train_test_split( X_train, y_train, test_size=global_vars.get('valid_set_fraction'), shuffle=shuffle) train_set, valid_set, test_set = makeDummySignalTargets( X_train, y_train, X_val, y_val, X_test, y_test) return train_set, valid_set, test_set
def update_global_vars_from_config_dict(config_dict): for inner_key, inner_value in config_dict['DEFAULT'].items(): global_vars.set(inner_key, inner_value) for key, inner_dict in config_dict.items(): if inner_key != 'DEFAULT': for inner_key, inner_value in inner_dict.items(): global_vars.set(inner_key, inner_value)
def breed_layers_modules(first_model, second_model, first_model_state=None, second_model_state=None, cut_point=None): second_model = copy.deepcopy(second_model) if cut_point is None: cut_point = random.randint(0, len(first_model) - 1) for i in range(cut_point): second_model[i] = first_model[i] save_weights = global_vars.get( 'inherit_weights_crossover') and global_vars.get( 'inherit_weights_normal') if check_legal_model(second_model): if save_weights: finalized_new_model = finalize_model(second_model) finalized_new_model_state = finalized_new_model.state_dict() if None not in [first_model_state, second_model_state]: for i in range(cut_point): add_layer_to_state(finalized_new_model_state, second_model[i], i, first_model_state) for i in range(cut_point + 1, global_vars.get('num_layers')): add_layer_to_state(finalized_new_model_state, second_model[i - cut_point], i, second_model_state) else: finalized_new_model_state = None return second_model, finalized_new_model_state, cut_point else: global_vars.set('failed_breedings', global_vars.get('failed_breedings') + 1) return None, None, None
def get_settings(): if global_vars.get('cropping'): global_vars.set('original_input_time_len', global_vars.get('input_time_len')) global_vars.set('input_time_len', global_vars.get('input_time_cropping')) stop_criterion, iterator, loss_function, monitors = get_cropped_settings() else: stop_criterion, iterator, loss_function, monitors = get_normal_settings() return stop_criterion, iterator, loss_function, monitors
def set_gpu(): try: torch.cuda.current_device() if not global_vars.get('force_gpu_off'): global_vars.set('cuda', True) print('using CUDA') except AssertionError as e: print('no cuda available, using CPU')
def set_seeds(): random_seed = global_vars.get('random_seed') if not random_seed: random_seed = random.randint(0, 2**32 - 1) global_vars.set('random_seed', random_seed) random.seed(random_seed) torch.manual_seed(random_seed) if global_vars.get('cuda'): torch.cuda.manual_seed_all(random_seed) np.random.seed(random_seed)
def test_remove_all_edges_from_input(self): global_vars.set('grid', True) global_vars.set('parallel_paths_experiment', True) layer_grid_1 = models_generation.random_grid_model([5, 10]) layer_grid_1.remove_edge('input', (0, 0)) layer_grid_1.remove_edge('input', (1, 0)) layer_grid_1.remove_edge('input', (2, 0)) layer_grid_1.remove_edge('input', (3, 0)) layer_grid_1.remove_edge('input', (4, 0)) model = models_generation.ModelFromGrid(layer_grid_1)
def main(_config): global FIRST_RUN, FIRST_DATASET, FOLDER_NAMES try: set_params_by_dataset('EEGNAS/configurations/dataset_params.ini') set_moabb() set_gpu() set_seeds() if type(global_vars.get('subjects_to_check')) == list: subjects = global_vars.get('subjects_to_check') else: subjects = random.sample(range(1, global_vars.get('num_subjects')), global_vars.get('subjects_to_check')) exp_folder = f"results/{exp_name}" atexit.register(exit_handler, exp_folder, args.debug_mode) create_folder(exp_folder) FOLDER_NAMES.append(exp_name) write_config(global_vars.config, f"{exp_folder}/config_{exp_name}.ini") csv_file = f"{exp_folder}/{exp_name}.csv" report_file = f"{exp_folder}/report_{exp_name}.csv" if 'cross_subject' in multiple_values and not global_vars.get('cross_subject'): global_vars.set('num_generations', global_vars.get('num_generations') * global_vars.get('cross_subject_compensation_rate')) start_time = time.time() if global_vars.get('exp_type') in ['target', 'benchmark']: target_exp(exp_name, csv_file, subjects) elif global_vars.get('exp_type') == 'from_file': target_exp(exp_name, csv_file, subjects, model_from_file=f"EEGNAS/models/{global_vars.get('models_dir')}/{global_vars.get('model_file_name')}") elif global_vars.get('exp_type') == 'leave_one_out': with open(csv_file, 'a', newline='') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=FIELDNAMES) writer.writeheader() for subject in subjects: best_model_filename = leave_one_out_exp(exp_name, csv_file, subject) target_exp_leave_one_out(exp_name, csv_file, subject, best_model_filename) else: best_model_filenames = exp_funcs[global_vars.get('exp_type')](exp_name, csv_file, subjects) for best_model_filename in best_model_filenames: target_exp(exp_name, csv_file, subjects, model_from_file=best_model_filename, write_header=False) global_vars.set('total_time', str(time.time() - start_time)) write_config(global_vars.config, f"{exp_folder}/final_config_{exp_name}.ini") result = generate_report(csv_file, report_file) ex.add_artifact(report_file) except Exception as e: with open(f"error_logs/error_log_{exp_name}.txt", "w") as err_file: print('experiment failed. Exception message: %s' % (str(e)), file=err_file) print(traceback.format_exc(), file=err_file) print('experiment failed. Exception message: %s' % (str(e))) print(traceback.format_exc()) shutil.rmtree(exp_folder) FOLDER_NAMES.remove(exp_name) raise Exception(str(e)) return result
def test_hash_model(self): model1 = uniform_model(10, ActivationLayer) model2 = uniform_model(10, ActivationLayer) global_vars.set('mutation_rate', 1) model3, _ = breed_layers(1, model1, model2) model_set = [] genome_set = [] EEGNAS.utilities.NAS_utils.hash_model(model1, model_set, genome_set) EEGNAS.utilities.NAS_utils.hash_model(model2, model_set, genome_set) EEGNAS.utilities.NAS_utils.hash_model(model3, model_set, genome_set) assert (len(model_set)) == 1 or 2 assert (len(genome_set)) == 1 or 2
def breed_layers(mutation_rate, first_individual, second_individual, first_model_state=None, second_model_state=None, cut_point=None, bb_population=None): first_model = first_individual['model'] second_model = second_individual['model'] if bb_population is not None: if random.random() < global_vars.get('puzzle_usage_rate'): cut_point = choose_cutpoint_by_bb(bb_population, first_model, second_model) second_model = copy.deepcopy(second_model) if cut_point is None: cut_point = random.randint(0, len(first_model) - 1) if global_vars.get('cut_point_modulo'): while (cut_point + 1) % global_vars.get('cut_point_modulo') != 0: cut_point = random.randint(0, len(first_model) - 1) for i in range(cut_point): second_model[i] = first_model[i] save_weights = global_vars.get( 'inherit_weights_crossover') and global_vars.get( 'inherit_weights_normal') this_module = sys.modules[__name__] if type(global_vars.get('mutation_method')) == list: mutation_method = random.choice(global_vars.get('mutation_method')) else: mutation_method = global_vars.get('mutation_method') getattr(this_module, mutation_method)(second_individual, mutation_rate) new_model = new_model_from_structure_pytorch(second_model, applyFix=True) if save_weights: finalized_new_model = finalize_model(new_model) finalized_new_model_state = finalized_new_model.state_dict() if None not in [first_model_state, second_model_state]: for i in range(cut_point): add_layer_to_state( finalized_new_model_state, second_model[i], i, first_model_state, first_individual['weight_inheritance_alpha']) for i in range(cut_point + 1, global_vars.get('num_layers')): add_layer_to_state( finalized_new_model_state, second_model[i - cut_point], i, second_model_state, second_individual['weight_inheritance_alpha']) else: finalized_new_model_state = None if check_legal_model(new_model): return new_model, finalized_new_model_state, cut_point else: global_vars.set('failed_breedings', global_vars.get('failed_breedings') + 1) return None, None, None
def load_values_from_config(config_file, keys): configuration = {} f = open(config_file, 'r') list_of_lines = f.readlines() for line in list_of_lines: line_split = line.split('\t') configuration[line_split[0]] = line_split[1][:-1] for key in keys: if key in configuration: try: global_vars.set(key, eval(configuration[key])) except SyntaxError: global_vars.set(key, configuration[key])
def evolution_deap_modules(self): creator.create("FitnessMax", base.Fitness, weights=(1.0, )) creator.create("Individual", dict, fitness=creator.FitnessMax) creator.create("Module", Module, fitness=creator.FitnessMax) self.toolbox = base.Toolbox() self.toolbox.register("individual", creator.Individual) self.toolbox.register("module", tools.initRepeat, creator.Module, random_layer, n=global_vars.get('module_size')) self.toolbox.register("model_population", tools.initRepeat, list, self.toolbox.individual) self.toolbox.register("module_population", tools.initRepeat, list, self.toolbox.module) self.toolbox.register("evaluate", self.evaluate_ind_deap) self.toolbox.register("evaluate_module", self.evaluate_module_deap) self.toolbox.register("mate", breed_layers_modules_deap, self.toolbox) self.toolbox.register("mutate", mutate_layers_deap_modules) self.toolbox.register("select", selTournament, tournsize=3) self.population = self.toolbox.model_population( global_vars.get('pop_size')) self.modules = self.toolbox.module_population( global_vars.get('module_pop_size')) for idx, module in enumerate(self.modules): module.module_idx = idx self.current_generation = 0 global_vars.set('modules', self.modules) initialize_deap_population(self.population, self.models_set, self.genome_set) stats = tools.Statistics(key=lambda ind: ind.fitness.values) stats.register("avg", np.mean) stats.register("std", np.std) stats.register("min", np.min) stats.register("max", np.max) final_population, logbook = self.eaDual( self.population, self.modules, self.toolbox, 0.2, global_vars.get('mutation_rate'), global_vars.get('num_generations'), stats=stats, verbose=True) best_model_filename = self.save_best_model(final_population) pickle.dump( self.population, open(f'{self.exp_folder}/{self.exp_name}_architectures.p', 'wb')) return best_model_filename
def breed_layers(mutation_rate, first_model, second_model, first_model_state=None, second_model_state=None, cut_point=None): second_model = copy.deepcopy(second_model) save_weights = False if random.random() < global_vars.get('breed_rate'): if cut_point is None: cut_point = random.randint(0, len(first_model) - 1) for i in range(cut_point): second_model[i] = first_model[i] save_weights = global_vars.get( 'inherit_weights_crossover') and global_vars.get( 'inherit_weights_normal') this_module = sys.modules[__name__] getattr(this_module, global_vars.get('mutation_method'))(second_model, mutation_rate) new_model = new_model_from_structure_pytorch(second_model, applyFix=True) if save_weights: finalized_new_model = finalize_model(new_model) if torch.cuda.device_count() > 1 and global_vars.get('parallel_gpu'): finalized_new_model.cuda() with torch.cuda.device(0): finalized_new_model = nn.DataParallel( finalized_new_model.cuda(), device_ids=[ int(s) for s in global_vars.get('gpu_select').split(',') ]) finalized_new_model_state = finalized_new_model.state_dict() if None not in [first_model_state, second_model_state]: for i in range(cut_point): add_layer_to_state(finalized_new_model_state, second_model[i], i, first_model_state) for i in range(cut_point + 1, global_vars.get('num_layers')): add_layer_to_state(finalized_new_model_state, second_model[i - cut_point], i, second_model_state) else: finalized_new_model_state = None if check_legal_model(new_model): return new_model, finalized_new_model_state, cut_point else: global_vars.set('failed_breedings', global_vars.get('failed_breedings') + 1) return None, None, None
def get_fold_idxs(AS): if global_vars.get('k_fold_time'): kf = TimeSeriesSplit(n_splits=global_vars.get('n_folds')) else: kf = KFold(n_splits=global_vars.get('n_folds'), shuffle=True) prev_autonomous_systems = global_vars.get('autonomous_systems') global_vars.set('autonomous_systems', [AS]) dataset = get_dataset('all') concat_train_val_sets(dataset) dataset = unify_dataset(dataset) fold_idxs = {i: {} for i in range(global_vars.get('n_folds'))} for fold_num, (train_index, test_index) in enumerate(kf.split(list(range(len(dataset.X))))): fold_idxs[fold_num]['train_idxs'] = train_index fold_idxs[fold_num]['test_idxs'] = test_index global_vars.set('autonomous_systems', prev_autonomous_systems) return fold_idxs
def get_tuh_train_val_test(data_folder): preproc_functions = create_preproc_functions( sec_to_cut_at_start=global_vars.get('sec_to_cut_at_start'), sec_to_cut_at_end=global_vars.get('sec_to_cut_at_end'), duration_recording_mins=global_vars.get('duration_recording_mins'), max_abs_val=global_vars.get('max_abs_val'), clip_before_resample=global_vars.get('clip_before_resample'), sampling_freq=global_vars.get('sampling_freq'), divisor=global_vars.get('divisor')) test_preproc_functions = create_preproc_functions( sec_to_cut_at_start=global_vars.get('sec_to_cut_at_start'), sec_to_cut_at_end=global_vars.get('sec_to_cut_at_end'), duration_recording_mins=global_vars.get('test_recording_mins'), max_abs_val=global_vars.get('max_abs_val'), clip_before_resample=global_vars.get('clip_before_resample'), sampling_freq=global_vars.get('sampling_freq'), divisor=global_vars.get('divisor')) training_set = DiagnosisSet( n_recordings=global_vars.get('n_recordings'), max_recording_mins=global_vars.get('max_recording_mins'), preproc_functions=preproc_functions, train_or_eval='train', sensor_types=global_vars.get('sensor_types')) test_set = DiagnosisSet(n_recordings=global_vars.get('n_recordings'), max_recording_mins=None, preproc_functions=test_preproc_functions, train_or_eval='eval', sensor_types=global_vars.get('sensor_types')) X, y = training_set.load() global_vars.set('input_height', X[0].shape[1]) splitter = TrainValidSplitter(10, i_valid_fold=0, shuffle=global_vars.get('shuffle')) train_set, valid_set = splitter.split(X, y) test_X, test_y = test_set.load() test_set = SignalAndTarget(test_X, test_y) train_set.X = np.array(train_set.X) valid_set.X = np.array(valid_set.X) test_set.X = np.array(test_set.X) return train_set, valid_set, test_set
def set_moabb(): if global_vars.get('dataset') in MOABB_DATASETS: paradigm = MotorImagery() dataset_names = [ type(dataset).__name__ for dataset in paradigm.datasets ] dataset = paradigm.datasets[dataset_names.index( global_vars.get('dataset'))] global_vars.set('subjects_to_check', dataset.subject_list) X, y, metadata = paradigm.get_data(dataset=dataset, subjects=[dataset.subject_list[0]]) global_vars.set('eeg_chans', X.shape[1]) global_vars.set('input_height', X.shape[2]) global_vars.set('n_classes', len(np.unique(y))) if global_vars.get('time_limit_seconds'): global_vars.set( 'time_limit_seconds', int( global_vars.get('time_limit_seconds') / len(dataset.subject_list)))
def run_target_model(self): global_vars.set('max_epochs', global_vars.get('final_max_epochs')) global_vars.set('max_increase_epochs', global_vars.get('final_max_increase_epochs')) stats = {} if self.model_from_file is not None: if type(self.model_from_file) == list: model = [torch.load(f) for f in self.model_from_file] else: model = torch.load(self.model_from_file) else: model = target_model(global_vars.get('model_name')) if global_vars.get('target_pretrain'): self.datasets['train']['pretrain'], self.datasets['valid']['pretrain'], self.datasets['test']['pretrain'] = \ get_pure_cross_subject(global_vars.get('data_folder')) nn_trainer = NN_Trainer(self.iterator, self.loss_function, self.stop_criterion, self.monitors) dataset = self.get_single_subj_dataset('pretrain', final_evaluation=False) _, _, model, _, _ = nn_trainer.train_and_evaluate_model( model, dataset) dataset = self.get_single_subj_dataset(self.subject_id, final_evaluation=True) nn_trainer = NN_Trainer(self.iterator, self.loss_function, self.stop_criterion, self.monitors) _, _, model, _, _ = nn_trainer.train_and_evaluate_model( model, dataset, final_evaluation=True) final_time, evaluations, model, model_state, num_epochs =\ nn_trainer.train_and_evaluate_model(model, dataset) stats['final_train_time'] = str(final_time) NAS_utils.add_evaluations_to_stats(stats, evaluations, str_prefix="final_") if self.model_from_file is not None: if type(self.model_from_file) == list: model_name = f'ensemble_top_{global_vars.get("ensemble_size")}' else: model_name = re.findall(r'\d+', self.model_from_file)[-1] else: model_name = global_vars.get('model_name') self.write_to_csv(stats, generation='final', model=model_name)
def cross_subject_exp(exp_name, csv_file, subjects): stop_criterion, iterator, loss_function, monitors = get_settings() if not global_vars.get('cross_subject_sampling_rate'): global_vars.set('cross_subject_sampling_rate', len(subjects)) with open(csv_file, 'a', newline='') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=FIELDNAMES) writer.writeheader() train_set_all = {} val_set_all = {} test_set_all = {} for subject_id in subjects: dataset = get_dataset(subject_id) train_set_all[subject_id], val_set_all[subject_id], test_set_all[subject_id] = dataset['train'],\ dataset['valid'], dataset['test'] evolution_file = f'results/{exp_name}/archs.txt' eegnas = EEGNAS_evolution(iterator=iterator, exp_folder=f"results/{exp_name}", exp_name=exp_name, train_set=train_set_all, val_set=val_set_all, test_set=test_set_all, stop_criterion=stop_criterion, monitors=monitors, loss_function=loss_function, subject_id=subject_id, fieldnames=FIELDNAMES, strategy='cross_subject', evolution_file=evolution_file, csv_file=csv_file) return [eegnas.evolution()]
def test_perm_ensemble_fitness(self): global_vars.set('pop_size', 10) global_vars.set('ensemble_size', 2) global_vars.set('ga_objective', 'accuracy') global_vars.set('permanent_ensembles', True) dummy_weighted_pop = [{ 'val_raw': [[1 - (1 / i), 0, 0, 1 / i]], 'val_target': [3] } for i in range(1, 11)] old_len = len(dummy_weighted_pop) NAS_utils.permanent_ensemble_fitness(dummy_weighted_pop) NAS_utils.sort_population(dummy_weighted_pop) assert len(dummy_weighted_pop) == old_len print(dummy_weighted_pop[-1])
def set_params_by_dataset(params_config_path): config_dict = config_to_dict(params_config_path) if global_vars.get('dataset') in config_dict.keys(): key = global_vars.get('dataset') elif global_vars.get('problem') == 'regression': key = 'default_regression' else: key = 'default' for param_name in config_dict[key]: global_vars.set_if_not_exists(param_name, config_dict[key][param_name]) if global_vars.get('ensemble_iterations'): global_vars.set( 'evaluation_metrics', global_vars.get('evaluation_metrics') + ['raw', 'target']) if not global_vars.get('ensemble_size'): global_vars.set('ensemble_size', int(global_vars.get('pop_size') / 100)) if global_vars.get('dataset') == 'netflow_asflow' and global_vars.get( 'all_netflow_files'): file_paths = os.listdir( f'{os.path.dirname(os.path.abspath(__file__))}/../data/netflow/all_AS' ) file_paths = [ f for f in file_paths if (os.path.getsize(f'../eegnas/EEGNAS/data/netflow/all_AS/{f}') >> 20) > global_vars.get('min_netflow_file_size') ] global_vars.set('netflow_file_names', file_paths)
def breed_grid(mutation_rate, first_model, second_model, first_model_state=None, second_model_state=None, cut_point=None): global_vars.set('total_breedings', global_vars.get('total_breedings') + 1) child_model = copy.deepcopy(first_model) child_model_state = None if random.random() < global_vars.get('breed_rate'): if cut_point is None: cut_point = random.randint(0, first_model.graph['width'] - 1) for i in range(first_model.graph['height']): for j in range(cut_point, first_model.graph['width']): child_model.nodes[(i, j)]['layer'] = second_model.nodes[( i, j)]['layer'] remove_edges = [] add_edges = [] for edge in child_model.edges([(i, j)]): if (i, j) == edge[0]: remove_edges.append(edge) for edge in second_model.edges([(i, j)]): if (i, j) == edge[0]: add_edges.append(edge) for edge in remove_edges: child_model.remove_edge(edge[0], edge[1]) for edge in add_edges: child_model.add_edge(edge[0], edge[1]) if not check_legal_grid_model(child_model): global_vars.set('failed_breedings', global_vars.get('failed_breedings') + 1) return None, None, None if global_vars.get( 'inherit_weights_crossover' ) and first_model_state is not None and second_model_state is not None: child_model_state = ModelFromGrid(child_model).state_dict() inherit_grid_states(first_model.graph['width'], cut_point, child_model_state, first_model_state, second_model_state) if random.random() < mutation_rate: mutations = { 'add_random_connection': add_random_connection, 'remove_random_connection': remove_random_connection, 'add_parallel_connection': add_parallel_connection, 'swap_random_layer': swap_random_layer } available_mutations = list( set(mutations.keys()).intersection( set(global_vars.get('mutations')))) chosen_mutation = mutations[random.choice(available_mutations)] chosen_mutation(child_model) if check_legal_grid_model(child_model): return child_model, child_model_state, cut_point else: global_vars.set('failed_breedings', global_vars.get('failed_breedings') + 1) return None, None, None
def setUp(self): args = parse_args( ['-e', 'tests', '-c', '../configurations/config.ini']) init_config(args.config) configs = get_configurations(args.experiment) assert (len(configs) == 1) global_vars.set_config(configs[0]) global_vars.set('eeg_chans', 22) global_vars.set('num_subjects', 9) global_vars.set('input_time_len', 1125) global_vars.set('n_classes', 4) set_params_by_dataset() input_shape = (50, global_vars.get('eeg_chans'), global_vars.get('input_time_len')) class Dummy: def __init__(self, X, y): self.X = X self.y = y dummy_data = Dummy(X=np.ones(input_shape, dtype=np.float32), y=np.ones(50, dtype=np.longlong)) self.iterator = BalancedBatchSizeIterator( batch_size=global_vars.get('batch_size')) self.loss_function = F.nll_loss self.monitors = [ LossMonitor(), MisclassMonitor(), GenericMonitor('accuracy', acc_func), RuntimeMonitor() ] self.stop_criterion = Or([ MaxEpochs(global_vars.get('max_epochs')), NoDecrease('valid_misclass', global_vars.get('max_increase_epochs')) ]) self.naiveNAS = NaiveNAS(iterator=self.iterator, exp_folder='../tests', exp_name='', train_set=dummy_data, val_set=dummy_data, test_set=dummy_data, stop_criterion=self.stop_criterion, monitors=self.monitors, loss_function=self.loss_function, config=global_vars.config, subject_id=1, fieldnames=None, model_from_file=None)
def ranking_correlations(weighted_population, stats): old_ensemble_iterations = global_vars.get('ensemble_iterations') fitness_funcs = { 'ensemble_fitness': ensemble_fitness, 'normal_fitness': normal_fitness } for num_iterations in global_vars.get( 'ranking_correlation_num_iterations'): rankings = [] global_vars.set('ensemble_iterations', num_iterations) for fitness_func in global_vars.get( 'ranking_correlation_fitness_funcs'): weighted_pop_copy = deepcopy(weighted_population) for i, pop in enumerate(weighted_pop_copy): pop['order'] = i fitness_funcs[fitness_func](weighted_pop_copy) weighted_pop_copy = sorted(weighted_pop_copy, key=lambda x: x['fitness'], reverse=True) ranking = [pop['order'] for pop in weighted_pop_copy] rankings.append(ranking) correlation = spearmanr(*rankings) stats[f'ranking_correlation_{num_iterations}'] = correlation[0] global_vars.set('ensemble_iterations', old_ensemble_iterations)
def set_global_vars_by_sktime(train_file, test_file): X_train_ts, y_train = load_from_tsfile_to_dataframe(train_file) X_test_ts, y_test = load_from_tsfile_to_dataframe(test_file) train_max_len = max( [len(X_train_ts.iloc[i]['dim_0']) for i in range(len(X_train_ts))]) test_max_len = max( [len(X_test_ts.iloc[i]['dim_0']) for i in range(len(X_test_ts))]) max_len = max(train_max_len, test_max_len) global_vars.set('input_height', max_len) global_vars.set('eeg_chans', len(X_train_ts.columns)) global_vars.set('n_classes', len(np.unique(y_train)))
def test_state_inheritance_breeding(self): global_vars.set('inherit_breeding_weights', True) global_vars.set('num_layers', 4) global_vars.set('mutation_rate', 0) model1 = uniform_model(4, ConvLayer) model1_state = finalize_model(model1).state_dict() model2 = uniform_model(4, ConvLayer) model2_state = finalize_model(model2).state_dict() model3, model3_state, _ = breed_layers(0, model1, model2, model1_state, model2_state, 2) for s1, s3 in zip(list(model1_state.values())[:4], list(model3_state.values())[:4]): assert((s1==s3).all()) for s2, s3 in zip(list(model2_state.values())[6:8], list(model3_state.values())[6:8]): assert((s2==s3).all())
def get_MTS_benchmark_train_val_test(data_folder): Data = Data_utility( f'{os.path.dirname(os.path.abspath(__file__))}/{data_folder}MTS_benchmarks/' f'{global_vars.get("dataset")}.txt', 0.6, 0.2, device='cpu', window=24 * 7, horizon=12) train_set, valid_set, test_set = makeDummySignalTargets( np.swapaxes(Data.train[0], 1, 2), Data.train[1], np.swapaxes(Data.valid[0], 1, 2), Data.valid[1], np.swapaxes(Data.test[0], 1, 2), Data.test[1]) global_vars.set('eeg_chans', train_set.X.shape[1]) global_vars.set('input_height', train_set.X.shape[2]) global_vars.set('n_classes', train_set.y.shape[1]) return train_set, valid_set, test_set
matplotlib.use('qt5agg') args = parse_args(['-e', 'tests', '-c', '../configurations/config.ini']) global_vars.init_config(args.config) configs = get_configurations(args.experiment) assert (len(configs) == 1) global_vars.set_config(configs[0]) subject_id = 1 low_cut_hz = 0 fs = 250 valid_set_fraction = 0.2 dataset = 'BCI_IV_2a' data_folder = '../data/' global_vars.set('dataset', dataset) set_params_by_dataset() global_vars.set('cuda', True) model_select = 'deep4' model_dir = '143_x_evolution_layers_cross_subject' model_name = 'best_model_9_8_6_7_2_1_3_4_5.th' train_set = {} val_set = {} test_set = {} train_set[subject_id], val_set[subject_id], test_set[subject_id] =\ get_train_val_test(data_folder, subject_id) # Set if you want to use GPU # You can also use torch.cuda.is_available() to determine if cuda is available on your machine. cuda = True set_random_seeds(seed=20170629, cuda=cuda)
def get_evaluator(evaluator_type, fold_idx=None): if global_vars.get('top_handovers'): channels = global_vars.get('top_handovers') elif global_vars.get('max_handovers'): channels = global_vars.get('max_handovers') elif global_vars.get('handovers'): channels = len(global_vars.get('handovers')) if global_vars.get('per_handover_prediction'): output_size = global_vars.get('steps_ahead') * channels else: output_size = global_vars.get('steps_ahead') if type(evaluator_type) == list: models = [get_evaluator(ev, fold_idx) for ev in global_vars.get('evaluator')] if not global_vars.get('true_ensemble_avg'): model = BasicEnsemble(models, output_size) else: model = AveragingEnsemble(models, global_vars.get('true_ensemble_avg')) model.cpu() return model if evaluator_type == 'cnn': if global_vars.get('cnn_ensemble'): all_population_files = os.listdir('eegnas_models') global_vars.set('current_fold_idx', fold_idx) pop_files = list(filter(filter_eegnas_population_files, all_population_files)) assert len(pop_files) == 1 pop_file = pop_files[0] model = create_ensemble_from_population_file(f'eegnas_models/{pop_file}', 5) if not global_vars.get('skip_cnn_training'): for mod in model.models: reset_model_weights(mod) model.cpu() else: model = torch.load( f'../EEGNAS/EEGNAS/models/{global_vars.get("models_dir")}/{global_vars.get("model_file_name")}') reset_model_weights(model) model.cpu() load_values_from_config(f'../EEGNAS/EEGNAS/models/{global_vars.get("models_dir")}' f'/config_{global_vars.get("models_dir")}.ini', ['input_height', 'start_hour', 'start_point', 'date_range', 'prediction_buffer', 'steps_ahead', 'jumps', 'normalize_netflow_data', 'per_handover_prediction']) return model elif evaluator_type == 'nsga': nsga_file = 'nsga_models/best_genome_normalized.pkl' if global_vars.get('top_handovers'): nsga_file = f'{nsga_file[:-4]}_top{global_vars.get("top_handovers")}.pkl' if global_vars.get('per_handover_prediction'): nsga_file = f'{nsga_file[:-4]}_per_handover.pkl' if global_vars.get('same_handover_locations'): nsga_file = f'{nsga_file[:-4]}_samelocs.pkl' if global_vars.get('handovers'): nsga_file = f'{nsga_file[:-4]}_handovers.pkl' if fold_idx is not None: nsga_file = f'{nsga_file[:-4]}_fold{fold_idx}.pkl' with open(nsga_file, 'rb') as f: genotype = pickle.load(f) genotype = decode(convert(genotype)) model = NetworkCIFAR(24, output_size, channels, 11, False, genotype) model.droprate = 0.0 model.single_output = True return model elif evaluator_type == 'rnn': if global_vars.get('highest_handover_overflow'): model = LSTMMulticlassClassification(channels, 100, global_vars.get('batch_size'), global_vars.get('input_height'), num_layers=global_vars.get('lstm_layers'), eegnas=True) elif global_vars.get('per_handover_prediction'): model = MultivariateParallelMultistepLSTM(channels, 100, global_vars.get('batch_size'), global_vars.get('input_height'), num_layers=global_vars.get('lstm_layers'), eegnas=True) else: model = MultivariateLSTM(channels, 100, global_vars.get('batch_size'), global_vars.get('input_height'), global_vars.get('steps_ahead'), num_layers=global_vars.get('lstm_layers'), eegnas=True) model.cpu() return model elif evaluator_type == 'LSTNet': model = LSTNetModel(channels, output_size, window=global_vars.get('input_height')) model.cpu() return model elif evaluator_type == 'MHANet': model = MHANetModel(channels, output_size) model.cpu() return model elif evaluator_type == 'WaveNet': model = WaveNet(input_channels=channels, output_channels=1, horizon=global_vars.get('steps_ahead')) model.cpu() return model elif evaluator_type == 'xgboost': model = MultiOutputRegressor(XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1, colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0, max_depth=3, min_child_weight=1, missing=None, n_estimators=1000, n_jobs=1, nthread=None, objective='reg:linear', random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None, silent=True, subsample=1, tree_method='gpu_hist', gpu_id=0)) return model elif evaluator_type == 'autokeras': return ak.ImageRegressor(max_trials=3)