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 get_sleep_classifier():
model = nn.Sequential()
model.add_module('permute_1',
Expression(MyModel._transpose_shift_and_swap))
model.add_module(
'conv_1',
nn.Conv2d(1,
global_vars.get('eeg_chans'),
kernel_size=(global_vars.get('eeg_chans'), 1)))
model.add_module('permute_2',
Expression(MyModel._transpose_channels_with_length))
model.add_module('conv_2', nn.Conv2d(1, 8, kernel_size=(1, 64), stride=1))
model.add_module('pool_1', nn.MaxPool2d(kernel_size=(1, 16),
stride=(1, 1)))
model.add_module('conv_3', nn.Conv2d(8, 8, kernel_size=(1, 64), stride=1))
model.add_module('pool_2', nn.MaxPool2d(kernel_size=(1, 16),
stride=(1, 1)))
model.add_module('flatten', Flatten())
model.add_module('dropout', nn.Dropout(p=0.5))
input_shape = (2, global_vars.get('eeg_chans'),
global_vars.get('input_time_len'), 1)
out = model.forward(np_to_var(np.ones(input_shape, dtype=np.float32)))
dim = 1
for muldim in out.shape[1:]:
dim *= muldim
model.add_module(
'dense',
nn.Linear(in_features=dim, out_features=global_vars.get('n_classes')))
model.add_module('softmax', nn.Softmax())
return model
def get_netflow_threshold(file, stds, handover='sum'):
df = get_whole_netflow_data(file)
values = df[handover].values
values = values.reshape(-1, 1)
if global_vars.get('normalize_netflow_data'):
scaler = MinMaxScaler()
scaler.fit(values)
values = scaler.transform(values)
if stds == 'auto':
for std in reversed(np.arange(-3, 3.1, 0.1)):
if global_vars.get('k_fold'):
relevant_df = df.iloc[2234:]
else:
relevant_df = df.iloc[20457:]
relevant_df = relevant_df[np.logical_and(
17 <= relevant_df.index.hour, relevant_df.index.hour <= 21)]
relevant_values = relevant_df[handover].values.reshape(-1, 1)
relevant_values = relevant_values.reshape(-1, 5).max(axis=1)
relevant_values = scaler.transform(relevant_values.reshape(-1, 1))
thresh_to_test = values.mean() + values.std() * std
num_over = np.count_nonzero(relevant_values > thresh_to_test)
num_under = np.count_nonzero(relevant_values <= thresh_to_test)
overflow_ratio = num_over / (num_over + num_under)
if 0.07 <= overflow_ratio <= 0.2:
stds = std
return values.mean() + values.std() * stds, stds
for r in reversed(sorted(relevant_values)):
num_over = np.count_nonzero(relevant_values > r)
num_under = np.count_nonzero(relevant_values <= r)
overflow_ratio = num_over / (num_over + num_under)
if 0.07 <= overflow_ratio:
return r[0], 'custom'
else:
return values.mean() + values.std() * stds, stds
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_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 avg_class_tf_report(model, dataset, folder_name):
report_file_name = f'{folder_name}/{global_vars.get("report")}.pdf'
if os.path.isfile(report_file_name):
return
eeg_chans = list(range(global_vars.get('eeg_chans')))
dataset = unify_dataset(dataset)
class_examples = []
for class_idx in range(global_vars.get('n_classes')):
class_examples.append(dataset.X[np.where(dataset.y == class_idx)])
if global_vars.get('to_eeglab'):
tensor_to_eeglab(class_examples[-1], f'{folder_name}/avg_class_tf/{label_by_idx(class_idx)}.mat')
chan_data = np.zeros((global_vars.get('n_classes'), len(eeg_chans), global_vars.get('num_frex'), global_vars.get('input_height')))
for class_idx in range(global_vars.get('n_classes')):
for eeg_chan in eeg_chans:
chan_data[class_idx, eeg_chan] = get_tf_data_efficient(class_examples[class_idx], eeg_chan,
global_vars.get('frequency'), global_vars.get('num_frex'),
dB=global_vars.get('db_normalization'))
max_value = np.max(chan_data)
tf_plots = []
for class_idx in range(global_vars.get('n_classes')):
tf_plots.append(tf_plot(chan_data[class_idx], f'average TF for {label_by_idx(class_idx)}', max_value))
story = [get_image(tf) for tf in tf_plots]
create_pdf_from_story(report_file_name, story)
for tf in tf_plots:
os.remove(tf)
def generate_dummy_data(batch_size):
dummy_data = DummySignalTarget(
np.random.rand(batch_size, global_vars.get('eeg_chans'),
global_vars.get('input_time_len')),
np.random.randint(0,
global_vars.get('n_classes') - 1, batch_size))
return dummy_data, dummy_data, dummy_data
def run_one_epoch(self, datasets, model):
model.train()
batch_generator = self.iterator.get_batches(datasets['train'],
shuffle=True)
for inputs, targets in batch_generator:
input_vars = np_to_var(inputs,
pin_memory=global_vars.get('pin_memory'))
target_vars = np_to_var(targets,
pin_memory=global_vars.get('pin_memory'))
if self.cuda:
with torch.cuda.device(0):
input_vars = input_vars.cuda()
target_vars = target_vars.cuda()
self.optimizer.zero_grad()
outputs = model(input_vars)
if self.loss_function == F.mse_loss:
target_vars = target_vars.float()
loss = self.loss_function(outputs.squeeze(), target_vars)
loss.backward()
self.optimizer.step()
self.monitor_epoch(datasets, model)
if global_vars.get('log_epochs'):
self.log_epoch()
if global_vars.get('remember_best'):
self.rememberer.remember_epoch(self.epochs_df, model,
self.optimizer)
def __init__(self,
kernel_height=None,
kernel_width=None,
filter_num=None,
stride=None,
dilation_height=None,
name=None):
Layer.__init__(self, name)
if kernel_height is None:
kernel_height = random.randint(
1, global_vars.get('kernel_height_max'))
if kernel_width is None:
kernel_width = random.randint(1,
global_vars.get('kernel_width_max'))
if filter_num is None:
filter_num = random.randint(1, global_vars.get('filter_num_max'))
if stride is None:
stride = random.randint(1, global_vars.get('conv_stride_max'))
if dilation_height is None:
dilation_height = random.randint(
1, global_vars.get('max_dilation_height'))
self.kernel_height = kernel_height
self.kernel_width = kernel_width
self.filter_num = filter_num
self.stride = stride
self.dilation_height = dilation_height
def check_grid_shapes(layer_grid):
input_chans = global_vars.get('eeg_chans')
input_time = global_vars.get('input_time_len')
input_shape = {'time': input_time, 'chans': input_chans}
layers = layer_grid.copy()
layers.nodes['input']['shape'] = input_shape
descendants = nx.descendants(layers, 'input')
descendants.add('input')
to_remove = []
for node in list(layers.nodes):
if node not in descendants:
to_remove.append(node)
for node in to_remove:
layers.remove_node(node)
nodes_to_check = list(nx.topological_sort(layers))
for node in nodes_to_check[1:]:
predecessors = list(layers.predecessors(node))
try:
pred_shapes = [
layers.nodes[pred]['shape']['time'] for pred in predecessors
]
min_time = int(min(pred_shapes))
sum_chans = int(
sum([
layers.nodes[pred]['shape']['chans']
for pred in predecessors
]))
layers.nodes[node]['shape'] = calc_shape_channels(
{
'time': min_time,
'chans': sum_chans
}, layers.nodes[node]['layer'])
except ValueError:
return False
return True
def test_draw_grid_model(self):
layer_grid = create_empty_copy(nx.to_directed(nx.grid_2d_graph(5, 5)))
for node in layer_grid.nodes.values():
node['layer'] = models_generation.random_layer()
layer_grid.add_node('input')
layer_grid.add_node('output_conv')
layer_grid.nodes['output_conv']['layer'] = models_generation.IdentityLayer()
layer_grid.nodes[(0,0)]['layer'] = ConvLayer(filter_num=50)
layer_grid.nodes[(0,1)]['layer'] = ConvLayer(filter_num=50)
layer_grid.nodes[(0,2)]['layer'] = DropoutLayer()
layer_grid.add_edge('input', (0, 0))
layer_grid.add_edge((0, 5 - 1), 'output_conv')
for i in range(5 - 1):
layer_grid.add_edge((0, i), (0, i + 1))
layer_grid.graph['height'] = 5
layer_grid.graph['width'] = 5
if models_generation.check_legal_grid_model(layer_grid):
print('legal model')
else:
print('illegal model')
# model = models_generation.random_grid_model(10)
layer_grid.add_edge((0,0), (0, 2))
real_model = models_generation.ModelFromGrid(layer_grid)
# model = models_generation.random_model(10)
# real_model = finalize_model(model)
# for i in range(100):
# add_random_connection(model)
input_shape = (60, global_vars.get('eeg_chans'), global_vars.get('input_time_len'), 1)
out = real_model(np_to_var(np.ones(input_shape, dtype=np.float32)))
s = Source(make_dot(out), filename="test.gv", format="png")
s.view()
def activate_model_evaluation(self,
model,
state=None,
subject=None,
final_evaluation=False,
ensemble=False):
print(
f'free params in network:{NAS_utils.pytorch_count_params(model)}')
if subject is None:
subject = self.subject_id
if self.cuda:
torch.cuda.empty_cache()
if final_evaluation:
self.stop_criterion = Or([
MaxEpochs(global_vars.get('final_max_epochs')),
NoIncreaseDecrease(
'valid_accuracy',
global_vars.get('final_max_increase_epochs'))
])
if global_vars.get('cropping'):
self.set_cropping_for_model(model)
dataset = self.get_single_subj_dataset(subject, final_evaluation)
nn_trainer = NN_Trainer(self.iterator, self.loss_function,
self.stop_criterion, self.monitors)
return nn_trainer.train_and_evaluate_model(model, dataset, state=state)
def find_optimal_samples_report(pretrained_model, dataset, folder_name):
report_file_name = f'{folder_name}/{global_vars.get("report")}.pdf'
if os.path.isfile(report_file_name):
return
eeg_chans = list(range(global_vars.get('eeg_chans')))
plot_dict = OrderedDict()
dataset = unify_dataset(dataset)
for layer_idx, layer in list(enumerate(pretrained_model.children()))[global_vars.get('layer_idx_cutoff'):]:
max_examples = get_max_examples_per_channel(dataset.X, layer_idx, pretrained_model)
for chan_idx, example_idx in enumerate(max_examples):
tf_data = []
for eeg_chan in eeg_chans:
tf_data.append(get_tf_data_efficient(dataset.X[example_idx][None, :, :], eeg_chan, 250))
max_value = np.max(np.array(tf_data))
class_str = ''
if layer_idx >= len(list(pretrained_model.children())) - 3:
class_str = f', class:{label_by_idx(chan_idx)}'
plot_dict[(layer_idx, chan_idx)] = tf_plot(tf_data,
f'TF plot of example {example_idx} for layer '
f'{layer_idx}, channel {chan_idx}{class_str}',max_value)
print(f'plot most activating TF for layer {layer_idx}, channel {chan_idx}')
img_paths = list(plot_dict.values())
story = []
story.append(Paragraph('<br />\n'.join([f'{x}:{y}' for x,y in pretrained_model._modules.items()]), style=styles["Normal"]))
for im in img_paths:
story.append(get_image(im))
create_pdf_from_story(report_file_name, story)
for im in img_paths:
os.remove(im)
def get_data_by_balanced_folds(ASs, fold_idxs, required_num_samples=None):
prev_autonomous_systems = global_vars.get('autonomous_systems')
folds = {i: {'X_train': [], 'X_test': [], 'y_train': [], 'y_test': []} for i in range(global_vars.get('n_folds'))}
for AS in ASs:
global_vars.set('autonomous_systems', [AS])
dataset = get_dataset('all')
concat_train_val_sets(dataset)
dataset = unify_dataset(dataset)
if np.count_nonzero(dataset.X) == 0:
print(f'dropped AS {AS} - no common handovers')
continue
try:
if required_num_samples is not None:
assert len(dataset.X) == required_num_samples
for fold_idx in range(global_vars.get('n_folds')):
folds[fold_idx]['X_train'].extend(dataset.X[fold_idxs[fold_idx]['train_idxs']])
folds[fold_idx]['X_test'].extend(dataset.X[fold_idxs[fold_idx]['test_idxs']])
folds[fold_idx]['y_train'].extend(dataset.y[fold_idxs[fold_idx]['train_idxs']])
folds[fold_idx]['y_test'].extend(dataset.y[fold_idxs[fold_idx]['test_idxs']])
except IndexError:
print(f'dropped AS {AS}')
except AssertionError:
print(f'dropped AS {AS}')
for key in folds.keys():
for inner_key in folds[key].keys():
folds[key][inner_key] = np.stack(folds[key][inner_key], axis=0)
global_vars.set('autonomous_systems', prev_autonomous_systems)
return folds
def maintain_bb_population(bb_population, weighted_population):
for bb_idx, bb in enumerate(bb_population):
found = False
for pop in weighted_population:
if is_sublist(bb['bb'], pop['model'])[0]:
found = True
break
if not found:
rand_pop = random.choice(weighted_population)['model']
rand_idx = random.randint(0, len(rand_pop) - 2)
bb = rand_pop[rand_idx:rand_idx + 2]
bb_population[bb_idx] = {'bb': bb, 'fitness': 0}
else:
if random.random() < global_vars.get('puzzle_expansion_rate'):
for pop in weighted_population:
sblst, sblst_idx = is_sublist(bb['bb'], pop['model'])
if sblst:
if random.random() < 0.5:
if sblst_idx < len(pop['model']) - len(bb['bb']):
bb['bb'].append(pop['model'][sblst_idx +
len(bb['bb'])])
else:
if sblst_idx > 0:
bb['bb'].insert(0, pop['model'][sblst_idx - 1])
break
if random.random() < global_vars.get('puzzle_replacement_rate'):
rand_pop = random.choice(weighted_population)['model']
rand_idx = random.randint(0, len(rand_pop) - 2)
bb = rand_pop[rand_idx:rand_idx + 2]
bb_population[bb_idx] = {'bb': bb, 'fitness': 0}
for elem in [[str(bbi) for bbi in bb['bb']] for bb in bb_population]:
print(elem)
def __init__(self, iterator, exp_folder, exp_name, loss_function,
train_set, val_set, test_set, stop_criterion, monitors,
subject_id, fieldnames, strategy, evolution_file, csv_file):
global model_train_times
model_train_times = []
self.iterator = iterator
self.exp_folder = exp_folder
self.exp_name = exp_name
self.monitors = monitors
self.loss_function = loss_function
self.stop_criterion = stop_criterion
self.subject_id = subject_id
self.datasets = OrderedDict(
(('train', train_set), ('valid', val_set), ('test', test_set)))
self.cuda = global_vars.get('cuda')
self.loggers = [Printer()]
self.fieldnames = fieldnames
self.models_set = []
self.genome_set = []
self.evo_strategy = {
'per_subject': self.one_strategy,
'cross_subject': self.all_strategy
}[strategy]
self.csv_file = csv_file
self.evolution_file = evolution_file
self.current_model_index = -1
if isinstance(self.subject_id, int):
self.current_chosen_population_sample = [self.subject_id]
else:
self.current_chosen_population_sample = []
self.mutation_rate = global_vars.get('mutation_rate')
def add_model_to_stats(pop, model_index, model_stats):
if global_vars.get('grid'):
if global_vars.get('grid_as_ensemble'):
for key, value in pop['weighted_avg_params'].items():
model_stats[key] = value
else:
for i, layer in enumerate(pop['model']):
model_stats[f'layer_{i}'] = type(layer).__name__
for key, value in vars(layer).items():
model_stats[f'layer_{i}_{key}'] = value
if global_vars.get('perm_ensembles'):
model_stats['ensemble_role'] = (model_index %
global_vars.get('ensemble_size'))
assert pop['perm_ensemble_role'] == model_stats['ensemble_role']
model_stats['perm_ensemble_id'] = pop['perm_ensemble_id']
if global_vars.get('delete_finalized_models'):
finalized_model = finalize_model(pop['model'])
else:
finalized_model = pop['finalized_model']
model_stats['trainable_params'] = pytorch_count_params(finalized_model)
layer_stats = {
'average_conv_width': (ConvLayer, 'kernel_width'),
'average_conv_height': (ConvLayer, 'kernel_height'),
'average_conv_filters': (ConvLayer, 'filter_num'),
'average_pool_width': (PoolingLayer, 'pool_height'),
'average_pool_stride': (PoolingLayer, 'stride_height')
}
for stat in layer_stats.keys():
model_stats[stat] = get_average_param([pop['model']],
layer_stats[stat][0],
layer_stats[stat][1])
def one_strategy(self, weighted_population):
self.current_chosen_population_sample = [self.subject_id]
for i, pop in enumerate(weighted_population):
start_time = time.time()
if NAS_utils.check_age(pop):
weighted_population[i] = weighted_population[i - 1]
weighted_population[i]['train_time'] = 0
weighted_population[i]['num_epochs'] = 0
continue
finalized_model = finalize_model(pop['model'])
self.current_model_index = i
final_time, evaluations, model, model_state, num_epochs = \
self.activate_model_evaluation(finalized_model, pop['model_state'], subject=self.subject_id)
if global_vars.get('grid_as_ensemble') and global_vars.get(
'delete_finalized_models'):
pop['weighted_avg_params'] = model
self.current_model_index = -1
NAS_utils.add_evaluations_to_weighted_population(
weighted_population[i], evaluations)
weighted_population[i]['model_state'] = model_state
weighted_population[i]['train_time'] = final_time
weighted_population[i]['finalized_model'] = model
weighted_population[i]['num_epochs'] = num_epochs
end_time = time.time()
show_progress(end_time - start_time, self.exp_name)
print('trained model %d in generation %d' %
(i + 1, self.current_generation))
def random_grid_model(dim):
layer_grid = create_empty_copy(
nx.to_directed(nx.grid_2d_graph(dim[0], dim[1])))
for node in layer_grid.nodes.values():
if global_vars.get('simple_start'):
node['layer'] = IdentityLayer()
else:
node['layer'] = random_layer()
layer_grid.add_node('input')
layer_grid.nodes['input']['layer'] = IdentityLayer()
if global_vars.get('grid_as_ensemble'):
for row in range(dim[0]):
layer_grid.add_node(f'output_conv_{row}')
layer_grid.nodes[f'output_conv_{row}']['layer'] = IdentityLayer()
layer_grid.add_edge((row, dim[1] - 1), f'output_conv_{row}')
else:
layer_grid.add_node('output_conv')
layer_grid.nodes['output_conv']['layer'] = IdentityLayer()
layer_grid.add_edge((0, dim[1] - 1), 'output_conv')
layer_grid.add_edge('input', (0, 0))
for i in range(dim[1] - 1):
layer_grid.add_edge((0, i), (0, i + 1))
layer_grid.graph['height'] = dim[0]
layer_grid.graph['width'] = dim[1]
if global_vars.get('parallel_paths_experiment'):
set_parallel_paths(layer_grid)
if check_legal_grid_model(layer_grid):
return layer_grid
else:
return random_grid_model(dim)
def train_model_for_netflow(model, dataset, trainer):
print(f'start training model: {type(model).__name__}')
if 'MultiOutputRegressor' == type(model).__name__:
train_sklearn_for_netflow(model, dataset)
elif 'ImageRegressor' == type(model).__name__:
train_autokeras_for_netflow(model, dataset)
elif 'Ensemble' in type(model).__name__:
for mod in model.models:
mod.cuda()
mod.train()
train_model_for_netflow(mod, dataset, trainer)
if type(model) == BasicEnsemble:
model.freeze_child_models(False)
trainer.train_model(model, dataset, final_evaluation=True)
model.freeze_child_models(True)
else:
if global_vars.get('dataset') in ['solar', 'electricity', 'exchange_rate'] and global_vars.get('training_method') == 'LSTNet':
data = Data_utility(f'../EEGNAS/EEGNAS/data/MTS_benchmarks/'
f'{global_vars.get("dataset")}.txt', 0.6, 0.2, device='cuda', window=24 * 7, horizon=12)
optim = Optim(model.parameters(), 'adam', 0.001, 10.)
criterion = torch.nn.MSELoss(size_average=False)
MTS_train(model, data, criterion, optim, 100, 128)
else:
if type(model).__name__ == 'Sequential' and global_vars.get('skip_cnn_training'):
print('skipping CNN training')
return
trainer.train_model(model, dataset, final_evaluation=True)
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 __init__(self, X, y, y_type=np.longlong):
self.X = np.array(X, dtype=np.float32)
if global_vars.get('autoencoder'):
y_type = np.float32
if global_vars.get('problem') == 'regression':
self.y = np.array(y)
else:
self.y = np.array(y, dtype=y_type)
def calculate_ensemble_fitness(weighted_population, ensemble):
if global_vars.get('cross_subject'):
ensemble_fit = 0
for subject in range(1, global_vars.get('num_subjects') + 1):
ensemble_fit += one_ensemble_fitness(weighted_population, ensemble)
return ensemble_fit / global_vars.get('num_subjects')
else:
return one_ensemble_fitness(weighted_population, ensemble)
def __init__(self, models):
super(AveragingEnsemble, self).__init__()
self.avg_layer = LinearWeightedAvg(global_vars.get('n_classes'),
global_vars.get('ensemble_size'),
true_avg=True)
self.models = models
self.softmax = nn.Softmax()
self.flatten = _squeeze_final_output()
def _stack_input_by_time(x):
if global_vars.config['DEFAULT']['channel_dim'] == 'one':
return x.view(x.shape[0], -1,
int(x.shape[2] / global_vars.get('time_factor')),
x.shape[3])
else:
return x.view(x.shape[0], x.shape[1],
int(x.shape[2] / global_vars.get('time_factor')), -1)
def train_time_penalty(weighted_population):
train_time_indices = [
i[0] for i in sorted(enumerate(weighted_population),
key=lambda x: x[1]['train_time'])
]
for rank, idx in enumerate(train_time_indices):
weighted_population[idx]['fitness'] -= (rank / global_vars.get('pop_size')) * \
weighted_population[idx]['fitness'] * global_vars.get('penalty_factor')
def ea_deap(self,
population,
toolbox,
ngen,
stats=None,
verbose=__debug__):
history = History()
toolbox.decorate("mate", history.decorator)
history.update(population)
logbook = tools.Logbook()
logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])
# Evaluate all individuals
fitnesses = toolbox.map(toolbox.evaluate, population)
for ind, fit in zip(population, fitnesses):
ind.fitness.values = fit
record = stats.compile(population) if stats else {}
logbook.record(gen=0, nevals=len(population), **record)
if verbose:
print(logbook.stream)
# Begin the generational process
for gen in range(1, ngen + 1):
self.current_generation += 1
# Select the next generation individuals
old_offspring = deepcopy(population)
offspring = toolbox.select(population, len(population))
# Vary the pool of individuals
new_offspring = toolbox.mate(deepcopy(offspring), toolbox)
hash_models_deap(old_offspring, new_offspring, self.genome_set,
self.models_set)
self.update_mutation_rate()
# Evaluate the individuals with an invalid fitness
fitnesses = toolbox.map(toolbox.evaluate, new_offspring)
for ind, fit in zip(new_offspring, fitnesses):
ind.fitness.values = fit
ind['age'] += 1
# Replace the current population by the offspring
population[:] = new_offspring
# Append the current generation statistics to the logbook
record = stats.compile(population) if stats else {}
logbook.record(gen=gen, nevals=len(population), **record)
if verbose:
print(logbook.stream)
pop_stats = self.calculate_stats(self.population)
for stat, val in pop_stats.items():
global_vars.get('sacred_ex').log_scalar(
f'avg_{stat}', val, self.current_generation)
self.write_to_csv({k: str(v)
for k, v in pop_stats.items()},
self.current_generation)
self.print_to_evolution_file(self.population,
self.current_generation)
return population, logbook
def show_progress(train_time, exp_name):
global model_train_times
total_trainings = global_vars.get('num_generations') * global_vars.get(
'pop_size') * len(global_vars.get('subjects_to_check'))
model_train_times.append(train_time)
avg_model_train_time = sum(model_train_times) / len(model_train_times)
time_left = (total_trainings -
len(model_train_times)) * avg_model_train_time
print(f"Experiment: {exp_name}, time left: {time_f(time_left)}")
def one_ensemble_fitness(weighted_population, ensemble):
if global_vars.get('cross_subject'):
ensemble_fit = 0
for subject in global_vars.get('subjects_to_check'):
ensemble_fit += one_subject_one_ensemble_fitness(
weighted_population, ensemble, str_prefix=f'{subject}_')
return ensemble_fit / len(global_vars.get('subjects_to_check'))
else:
return one_subject_one_ensemble_fitness(weighted_population, ensemble)
