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)
