def main():
config = Configuration()
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder,
config,
training=False)
else:
dataset: FullDataset = FullDataset(config.training_data_folder,
config,
training=False)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(
config, dataset)
checker = ConfigChecker(config, dataset, 'snn', training=False)
checker.pre_init_checks()
architecture = initialise_snn(config, dataset, False)
checker.post_init_checks(architecture)
inference = Inference(config, architecture, dataset)
if config.print_model:
tf.keras.utils.plot_model(architecture.encoder.model,
to_file='model.png',
show_shapes=True,
expand_nested=True)
print('Ensure right model file is used:')
print(config.directory_model_to_use, '\n')
inference.infer_test_dataset()
def main():
config = Configuration()
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder, config, training=False)
else:
dataset: FullDataset = FullDataset(config.training_data_folder, config, training=False)
dataset.load()
# select which part of the test dataset to test
start_index = 0 # dataset.num_test_instances
end_index = dataset.num_test_instances # dataset.num_test_instances
# Output interval of how many examples have been compared so far. < 0 for no output
temp_output_interval = -1
use_relevant_only = True
implemented_algorithms = ['dtw', 'dtw_weighting_nbr_features', 'feature_based']
algorithm_used = implemented_algorithms[0]
distance_to_sim_methods = ['1/(1+d)', 'div_max', 'min_max_scaling']
distance_to_sim_method = distance_to_sim_methods[0]
relevant_type = 'Individual' if config.individual_relevant_feature_selection else 'Group based'
print('Algorithm used:', algorithm_used)
print('Used relevant only:', use_relevant_only)
print('Type of feature selection:', relevant_type)
print('Start index:', start_index)
print('End index:', end_index)
print('Number of parallel threads:', config.max_parallel_cores)
print('Case Based used for inference:', config.case_base_for_inference)
print()
execute_baseline_test(dataset, start_index, end_index, config.max_parallel_cores, algorithm_used, config.k_of_knn,
temp_output_interval, use_relevant_only, distance_to_sim_method)
def execute_baseline_test(dataset: FullDataset, start_index, end_index, nbr_threads, algorithm, k_of_knn,
temp_output_interval, use_relevant_only=False, conversion_method=None):
evaluator = Evaluator(dataset, end_index - start_index, k_of_knn)
if algorithm == 'feature_based':
# Load features from TSFresh
dataset.load_feature_based_representation()
start_time = perf_counter()
for test_index in range(start_index, end_index):
results = np.zeros(dataset.num_train_instances)
# Split the training examples into n chunks, where n == the number of threads that should be used.
chunks = np.array_split(range(dataset.num_train_instances), nbr_threads)
threads = []
counter = Counter(dataset.num_train_instances, temp_output_interval)
manager = multiprocessing.Manager()
return_dict = manager.dict()
for i, chunk in enumerate(chunks):
# Important: Passing object instances as args to multiprocessing.Process may lead to problems
# Use carefully and ensure correct passing
# proc_id, return_dict, counter, dataset, test_index, indices_train_examples, algorithm, relevant_only
# chunk, dataset, test_index, use_relevant_only, counter, algorithm_used, i, return_dict
args = (i, return_dict, counter, dataset, test_index, chunk, algorithm, use_relevant_only)
t = multiprocessing.Process(target=run, args=args)
t.start()
threads.append(t)
for i, chunk in enumerate(chunks):
threads[i].join()
results[chunk] = return_dict.get(i)
# If algorithm returns distance instead of similarity
if algorithm in ['dtw', 'dtw_weighting_nbr_features', 'feature_based']:
results = distance_to_sim(results, conversion_method)
# Add additional empty line if temp. outputs are enabled
if temp_output_interval > 0:
print('')
evaluator.add_single_example_results(results, test_index)
elapsed_time = perf_counter() - start_time
evaluator.calculate_results()
evaluator.print_results(elapsed_time)
def main():
config = Configuration()
config.print_detailed_config_used_for_training()
dataset = FullDataset(config.training_data_folder, config, training=True)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(
config, dataset)
checker = ConfigChecker(config, dataset, 'snn', training=True)
checker.pre_init_checks()
snn = initialise_snn(config, dataset, True)
snn.print_detailed_model_info()
if config.print_model:
tf.keras.utils.plot_model(snn.encoder.model,
to_file='model.png',
show_shapes=True,
expand_nested=True)
checker.post_init_checks(snn)
start_time_string = datetime.now().strftime("%m-%d_%H-%M-%S")
print('---------------------------------------------')
print('Training:')
print('---------------------------------------------')
print()
optimizer = SNNOptimizer(snn, dataset, config)
optimizer.optimize()
print()
print('---------------------------------------------')
print('Inference:')
print('---------------------------------------------')
print()
change_model(config, start_time_string)
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder,
config,
training=False)
else:
dataset: FullDataset = FullDataset(config.training_data_folder,
config,
training=False)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(
config, dataset)
snn = initialise_snn(config, dataset, False)
inference = Inference(config, snn, dataset)
inference.infer_test_dataset()
def main():
config = Configuration()
p = psutil.Process()
cores = p.cpu_affinity()
p.cpu_affinity(cores[0:config.max_parallel_cores])
# Feature extraction for full dataset is disabled by default because of high computational demands
# dataset = FullDataset(config.training_data_folder, config, training=True)
# dataset.load()
# rp: TSFreshRepresentation = TSFreshRepresentation(config, dataset)
# rp.create_representation()
dataset = FullDataset(config.case_base_folder, config, training=True)
dataset.load()
rp: TSFreshRepresentation = TSFreshRepresentation(config, dataset)
rp.create_representation(for_case_base=True)
def main():
config = Configuration()
dataset = FullDataset(config.training_data_folder, config, training=True)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(
config, dataset)
checker = ConfigChecker(config, dataset, 'snn', training=True)
checker.pre_init_checks()
snn = initialise_snn(config, dataset, True)
snn.print_detailed_model_info()
checker.post_init_checks(snn)
print('Training:')
optimizer = SNNOptimizer(snn, dataset, config)
optimizer.optimize()
def main():
# suppress debugging messages of TensorFlow
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
config = Configuration()
dataset = FullDataset(config.training_data_folder, config, training=True)
dataset.load()
checker = ConfigChecker(config, dataset, 'snn', training=True)
checker.pre_init_checks()
snn = initialise_snn(config, dataset, True)
snn.print_detailed_model_info()
checker.post_init_checks(snn)
print('Training:')
optimizer = SNNOptimizer(snn, dataset, config)
optimizer.optimize()
def init_architecture(self, selection):
if selection == 'snn':
dataset: FullDataset = FullDataset(
self.config.training_data_folder, self.config, training=False)
dataset.load()
self.architecture = initialise_snn(self.config, dataset, False)
elif selection == 'cbs':
self.architecture = CBS(self.config, False)
else:
raise ValueError('Unknown architecture variant')
def inference_during_training(self, epoch):
if self.config.use_inference_test_during_training and epoch != 0:
if epoch % self.config.inference_during_training_epoch_interval == 0:
print("Inference at epoch: ", epoch)
dataset2: FullDataset = FullDataset(self.config.training_data_folder, self.config, training=False)
dataset2.load()
self.config.directory_model_to_use = self.dir_name_last_model_saved
print("self.dir_name_last_model_saved: ", self.dir_name_last_model_saved)
print("self.config.filename_model_to_use: ", self.config.directory_model_to_use)
architecture2 = initialise_snn(self.config, dataset2, False)
inference = Inference(self.config, architecture2, dataset2)
inference.infer_test_dataset()
def main():
# suppress debugging messages of TensorFlow
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
config = Configuration()
config.print_detailed_config_used_for_training()
dataset = FullDataset(config.training_data_folder, config, training=True)
dataset.load()
checker = ConfigChecker(config, dataset, 'snn', training=True)
checker.pre_init_checks()
snn = initialise_snn(config, dataset, True)
snn.print_detailed_model_info()
checker.post_init_checks(snn)
start_time_string = datetime.now().strftime("%m-%d_%H-%M-%S")
print('---------------------------------------------')
print('Training:')
print('---------------------------------------------')
print()
optimizer = SNNOptimizer(snn, dataset, config)
optimizer.optimize()
print()
print('---------------------------------------------')
print('Inference:')
print('---------------------------------------------')
print()
change_model(config, start_time_string)
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder,
config,
training=False)
else:
dataset: FullDataset = FullDataset(config.training_data_folder,
config,
training=False)
dataset.load()
snn = initialise_snn(config, dataset, False)
inference = Inference(config, snn, dataset)
inference.infer_test_dataset()
def main():
# suppress debugging messages of TensorFlow
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
config = Configuration()
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder,
config,
training=False)
else:
dataset: FullDataset = FullDataset(config.training_data_folder,
config,
training=False)
dataset.load()
checker = ConfigChecker(config, dataset, 'snn', training=False)
checker.pre_init_checks()
architecture = initialise_snn(config, dataset, False)
checker.post_init_checks(architecture)
inference = Inference(config, architecture, dataset)
if config.print_model:
tf.keras.utils.plot_model(architecture.encoder.model,
to_file='model.png',
show_shapes=True,
expand_nested=True)
print('Ensure right model file is used:')
print(config.directory_model_to_use, '\n')
inference.infer_test_dataset()
def main():
config = Configuration()
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder,
config,
training=False)
else:
dataset: FullDataset = FullDataset(config.training_data_folder,
config,
training=False)
dataset.load()
# Select which part of the test dataset to infer, mainly for debugging
start_index = 0
end_index = dataset.num_test_instances # dataset.num_test_instances
relevant_type = 'Individual' if config.individual_relevant_feature_selection else 'Group based'
print('Algorithm used:', config.baseline_algorithm)
print('Used relevant only:', config.baseline_use_relevant_only)
print('Type of feature selection:', relevant_type)
print('Start index:', start_index)
print('End index:', end_index)
print('Number of parallel threads:', config.max_parallel_cores)
print('Case Based used for inference:', config.case_base_for_inference)
print()
if dataset.is_third_party_dataset and (
config.baseline_use_relevant_only or config.baseline_algorithm
== BaselineAlgorithm.FEATURE_BASED_TS_FRESH):
raise ValueError(
'Third party datasets can not be used in combination with feature restriction, '
'e.g. reduction to relevant feature or the ts fresh algorithm.')
execute_baseline_test(config, dataset, start_index, end_index)
def main():
config = Configuration()
config.print_detailed_config_used_for_training()
dataset = FullDataset(config.training_data_folder, config, training=True, model_selection=True)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(config, dataset)
checker = ConfigChecker(config, dataset, 'snn', training=True)
checker.pre_init_checks()
snn = initialise_snn(config, dataset, True)
snn.print_detailed_model_info()
if config.print_model:
tf.keras.utils.plot_model(snn.encoder.model, to_file='model.png', show_shapes=True, expand_nested=True)
checker.post_init_checks(snn)
start_time_string = datetime.now().strftime("%m-%d_%H-%M-%S")
print('---------------------------------------------')
print('Training:')
print('---------------------------------------------')
print()
optimizer = SNNOptimizer(snn, dataset, config)
optimizer.optimize()
print()
print('---------------------------------------------')
print('Selecting (of the model for final evaluation):')
print('---------------------------------------------')
print()
num_of_selection_tests = config.number_of_selection_tests
config.use_masking_regularization = False
score_valid_to_model_loss = {}
for i in range(num_of_selection_tests):
loss_of_selected_model = change_model(config, start_time_string, num_of_selction_iteration=i)
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder, config, training=False, model_selection=True)
else:
dataset: FullDataset = FullDataset(config.training_data_folder, config, training=False, model_selection=True)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(config, dataset)
snn = initialise_snn(config, dataset, False)
inference = Inference(config, snn, dataset)
curr_model_score = inference.infer_test_dataset()
score_valid_to_model_loss[curr_model_score] = loss_of_selected_model
print("score_valid_to_model_loss: ", score_valid_to_model_loss)
print()
print('---------------------------------------------')
print('Inference:')
print('---------------------------------------------')
print()
max_score = max(list(score_valid_to_model_loss.keys()))
min_loss = score_valid_to_model_loss[max_score]
print("Model with the following loss is selected for the final evaluation:", min_loss)
change_model(config, start_time_string, get_model_by_loss_value=min_loss)
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder, config, training=False)
else:
dataset: FullDataset = FullDataset(config.training_data_folder, config, training=False)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(config, dataset)
snn = initialise_snn(config, dataset, False)
inference = Inference(config, snn, dataset)
inference.infer_test_dataset()
def main():
config = Configuration()
dataset = FullDataset(config.training_data_folder, config, training=True)
dataset.load()
rp: RocketRepresentation = RocketRepresentation(config, dataset)
rp.create_representation()
dataset = FullDataset(config.case_base_folder, config, training=True)
dataset.load()
rp: RocketRepresentation = RocketRepresentation(config, dataset)
rp.create_representation(for_case_base=True)
dataset = FullDataset(config.training_data_folder,
config,
training=False,
model_selection=True)
dataset.load()
rp: RocketRepresentation = RocketRepresentation(config, dataset)
rp.create_representation(for_valid=True)
def main():
config = Configuration()
# Define different version of original configuration
#config_2 = copy(config)
#config_2.hyper_file = config_2.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_2_a.json' # wie Standard, aber owl2vec als Graph Features added
config_3 = copy(config)
config_3.hyper_file = config_3.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_2_b.json' # wie Standard, aber Linear transformation an
config_4 = copy(config)
config_4.hyper_file = config_4.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_2_c.json' # wie Standard, aber nur Context Ausgabe
####
'''
config_2 = copy(config)
config_2.batch_distribution = {
BatchSubsetType.DISTRIB_BASED_ON_DATASET: 0.75,
BatchSubsetType.EQUAL_CLASS_DISTRIB: 0.25
}
config_3 = copy(config)
config_3.hyper_file = config_3.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_2.json' # Owl2vec after 2DCNN Removed, film on
config_4 = copy(config)
config_4.hyper_file = config_4.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_3.json' # Owl2vec after 2DCNN Removed, film off
config_5 = copy(config)
config_5.hyper_file = config_5.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_4.json' # wie Standard, aber Gradient Cap 1
config_6 = copy(config)
config_6.hyper_file = config_6.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_5.json' # wie Standard, aber 256,128,64
config_7 = copy(config)
config_7.hyper_file = config_7.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_6.json' # wie Standard, aber 512,256,128
config_8 = copy(config)
config_8.hyper_file = config_8.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_7.json' # wie Standard, aber 128,64,32
config_9 = copy(config)
config_9.hyper_file = config_9.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_8.json' # wie Standard, aber 256,128,128
config_10 = copy(config)
config_10.hyper_file = config_10.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_9.json' # wie Standard, aber 128,128,128, FC 386-256, CNN2d 128,64,3
config_11 = copy(config)
config_11.hyper_file = config_11.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_10.json' # wie Standard, aber 128,64,64, FC 386-256, CNN2d 128,64,3
config_12 = copy(config)
config_12.hyper_file = config_12.hyper_file_folder + 'cnn2d_withAddInput_Graph_o1_GlobAtt_o2_2_HO_11.json' # wie Standard, aber 256,128,128 nur mit allem aktiviert
'''
'''
config_3 = copy(config)
config_3.hyper_file = config_3.hyper_file_folder + 'cnn2d_with_graph_test_Readout_WOowl2vec.json'
config_4 = copy(config)
config_4.hyper_file = config_4.hyper_file_folder + 'cnn2d_with_graph_test_Readout_lrSmaller.json'
config_5 = copy(config)
config_5.hyper_file = config_5.hyper_file_folder + 'cnn2d_with_graph_test_Readout_WOAttributeWise.json'
'''
#list_of_configs = [config_3, config_4, config_5, config_6, config_7, config_8, config_9,config_10, config_11]
list_of_configs = [config, config_3, config_4]
#list_of_configs = [config, config_2, config_3,config_4,config_5, config_6,config_7,config_8,config_9,config_10,config_11]
for i, config in enumerate(list_of_configs):
print("Run number of config:", i)
config.print_detailed_config_used_for_training()
dataset = FullDataset(config.training_data_folder,
config,
training=True,
model_selection=True)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(
config, dataset)
checker = ConfigChecker(config, dataset, 'snn', training=True)
checker.pre_init_checks()
snn = initialise_snn(config, dataset, True)
snn.print_detailed_model_info()
if config.print_model:
tf.keras.utils.plot_model(snn.encoder.model,
to_file='model.png',
show_shapes=True,
expand_nested=True)
checker.post_init_checks(snn)
start_time_string = datetime.now().strftime("%m-%d_%H-%M-%S")
print('---------------------------------------------')
print('Training:')
print('---------------------------------------------')
print()
optimizer = SNNOptimizer(snn, dataset, config)
optimizer.optimize()
print()
print('---------------------------------------------')
print('Evaluation of the current config:')
print('---------------------------------------------')
print()
num_of_selection_tests = config.number_of_selection_tests
score_valid_to_model_loss = {}
for i in range(num_of_selection_tests):
loss_of_selected_model = change_model(config,
start_time_string,
num_of_selction_iteration=i)
if config.case_base_for_inference:
dataset: FullDataset = FullDataset(config.case_base_folder,
config,
training=False,
model_selection=True)
else:
dataset: FullDataset = FullDataset(config.training_data_folder,
config,
training=False,
model_selection=True)
dataset.load()
dataset = Representation.convert_dataset_to_baseline_representation(
config, dataset)
snn = initialise_snn(config, dataset, False)
inference = Inference(config, snn, dataset)
curr_model_score = inference.infer_test_dataset()
score_valid_to_model_loss[
curr_model_score] = loss_of_selected_model
# loop to sum all values to compute the mean:
res = 0
for val in score_valid_to_model_loss.values():
res += val
loss_mean = res / len(score_valid_to_model_loss)
for val in score_valid_to_model_loss.keys():
res += val
mean_score = res / len(score_valid_to_model_loss)
# printing result
print("Run: ", i, " loss mean:" + str(loss_mean),
" score mean: " + str(mean_score))
print("Run: ", i, " score_valid_to_model_loss:",
score_valid_to_model_loss)
'''
def create_representation(self, for_case_base=False, for_valid=False):
rocket = Rocket(num_kernels=self.config.rocket_kernels,
normalise=False,
random_state=self.config.rocket_random_seed)
# Cast is necessary because rocket seems to expect 64 bit values
x_train_casted = self.dataset.x_train.astype('float64')
x_test_casted = self.dataset.x_test.astype('float64')
print('Transforming from array to dataframe...\n')
x_train_df = self.array_to_ts_df(x_train_casted)
x_test_df = self.array_to_ts_df(x_test_casted)
if for_case_base and self.config.force_fit_on_full_training_data:
print('Forced fitting on the full training dataset is enabled. '
'Loading full training dataset before fitting...\n')
dataset_full_train = FullDataset(self.config.training_data_folder,
self.config,
training=True)
dataset_full_train.load()
full_train_casted = dataset_full_train.x_train.astype('float64')
full_train_df = self.array_to_ts_df(full_train_casted)
print('Started fitting ...')
rocket.fit(full_train_df)
else:
print('Started fitting ...')
rocket.fit(x_train_df)
print('Finished fitting.')
self.x_train_features = rocket.transform(x_train_df).values
print('\nFinished fitting the train dataset. Shape:',
self.x_train_features.shape)
self.x_test_features = rocket.transform(x_test_df).values
print('\nFinished fitting the test dataset. Shape:',
self.x_test_features.shape)
if for_valid == True:
#print("Saved as: ", self.dataset.dataset_folder + self.config.rocket_features_train_file)
np.save(
self.dataset.dataset_folder +
self.config.rocket_features_train_file, self.x_train_features)
#print('\nSaved the train dataset. Shape:', self.x_train_features.shape)
print(
"Saved as: ", self.dataset.dataset_folder +
self.config.rocket_features_valid_file)
np.save(
self.dataset.dataset_folder +
self.config.rocket_features_valid_file, self.x_test_features)
print('\nSaved the train dataset. Shape:',
self.x_test_features.shape)
else:
print(
"Saved as: ", self.dataset.dataset_folder +
self.config.rocket_features_train_file)
np.save(
self.dataset.dataset_folder +
self.config.rocket_features_train_file, self.x_train_features)
print('\nSaved the train dataset. Shape:',
self.x_train_features.shape)
print(
"Saved as: ", self.dataset.dataset_folder +
self.config.rocket_features_test_file)
np.save(
self.dataset.dataset_folder +
self.config.rocket_features_test_file, self.x_test_features)
print('\nSaved the train dataset. Shape:',
self.x_test_features.shape)