def main():
config_dir = "config_files"
config = StudyConfig(config_dir)
# the object with variable definitions based on the specified configuration file. It includes data description,
# definitions of run parameters (independent of deep definitions vs not)
parameters = config.populate_study_parameters("CTS_UbiComp2020_1sample.toml")
print(parameters)
data = DataConstructor(parameters)
test_data = data.test_subj_dataset
all_categories = [str(i) for i in range(0, 36)]
for i, cat in enumerate(all_categories):
if len(cat) == 1:
all_categories[i] = "button00" + cat
elif len(cat) == 2:
all_categories[i] = "button0" + cat
model_subdir = join(parameters.study_name, "trained_models")
saved_model_dir = utils.create_dir(join(utils.get_root_path("saved_objects"), model_subdir))
model_name = "LSTM-batch-128-CTS_UbiComp2020_DescType.RawData_SeqLen.ExtendEdge_lstm_stat_2000e-fold-2-10.pt"
model_path = join(saved_model_dir, model_name)
predicted_val = sample_val(test_data, model_path)
print(f"Predicted Category is {predicted_val}.")
def main():
config_dir = "config_files"
config = StudyConfig(config_dir)
# create a template of a configuration file with all the fields initialized to None
config.create_config_file_template()
# the object with variable definitions based on the specified configuration file. It includes data description,
# definitions of run parameters (independent of deep definitions vs not)
parameters_firm = config.populate_study_parameters(
"CTS_one_subj_firm.toml")
data_firm = DataConstructor(parameters_firm)
subject_dict_firm = data_firm.get_subject_dataset()
new_subject_dict_firm = relabel_whole_dataset(subject_dict_firm, "Firm")
parameters_soft = config.populate_study_parameters(
"CTS_one_subj_soft.toml")
data_soft = DataConstructor(parameters_soft)
subject_dict_soft = data_soft.get_subject_dataset()
new_subject_dict_soft = relabel_whole_dataset(subject_dict_soft, "Soft")
parameters_variable = config.populate_study_parameters(
"CTS_one_subj_variable.toml")
data_variable = DataConstructor(parameters_variable)
subject_dict_variable = data_variable.get_subject_dataset()
new_subject_dict_variable = relabel_whole_dataset(subject_dict_variable,
"Variable")
assert parameters_firm.nfft == parameters_soft.nfft and parameters_firm.nfft == parameters_variable.nfft
assert parameters_firm.sampling_freq == parameters_soft.sampling_freq and parameters_firm.sampling_freq == \
parameters_variable.sampling_freq
parameters = parameters_firm
all_subj_dict = {
**new_subject_dict_firm,
**new_subject_dict_soft,
**new_subject_dict_variable
}
hash_matcher = HashMatcher(all_subj_dict, parameters)
if point < 0:
neg = neg + point
if point > 0:
pos = pos + point
all_gradients.append([pos, neg])
gradient_sums = np.array(all_gradients).flatten()
return gradient_sums
if __name__ == "__main__":
print("Running feature_constructor module...")
print("Is cuda available?", torch.cuda.is_available())
config_dir = "config_files"
config = StudyConfig(config_dir)
# create a template of a configuration file with all the fields initialized to None
config.create_config_file_template()
parameters = config.populate_study_parameters("CTS_5taps_per_button.toml")
# generating the data from files
data = DataConstructor(parameters)
subject_dict = data.get_subject_dataset()
# define a category balancer (implementing the abstract CategoryBalancer)
category_balancer = WithinSubjectOversampler()
dataset_processor = StatDatasetProcessor(parameters, balancer=category_balancer)
feature_constructor = BoTWFeatureConstructor(dataset_processor, parameters, feature_axis=2)
dataset_desc_name = "CTS_firm_chunk_" + str(parameters.samples_per_chunk) + "_interval_" + str(
@property
def mult_attr(self) -> int:
return self.__mult_attr
def _produce_specific_features(self, subject_dataset: types.subj_dataset) -> Optional[types.subj_dataset]:
# feature_dataset = self.descriptor_computer.dataset_descriptors
feature_dataset = self.descriptor_computer.produce_dataset_descriptors(subject_dataset)
return feature_dataset
if __name__ == "__main__":
print("Running msbsd_feature_constructor module...")
config_dir = "config_files"
config = StudyConfig(config_dir)
# create a template of a configuration file with all the fields initialized to None
config.create_config_file_template()
parameters = config.populate_study_parameters("CTS_Keyboard_simple.toml")
# generating the data from files
data = DataConstructor(parameters)
subject_dict = data.get_subject_dataset()
category_balancer = WithinSubjectOversampler()
dataset_processor = StatDatasetProcessor(parameters, balancer=category_balancer)
descriptor_computer = DescriptorComputer(DescType.MSD, subject_dict, parameters, normalize=True, extra_name="")
feature_constructor = KeypointFeatureConstructor(parameters, descriptor_computer)
def main():
parser = argparse.ArgumentParser(description='BioHCI arguments')
parser.add_argument('--disable-cuda',
action='store_true',
help='Disable CUDA')
parser.add_argument('--visualization',
action='store_true',
help='Generate plots to visualize the raw data')
parser.add_argument('--verbose',
'-v',
action='store_true',
help='Display more details during the run')
args = parser.parse_args()
# checking whether cuda is available and enabled
args.cuda = not args.disable_cuda and torch.cuda.is_available()
print("Is cuda available?", torch.cuda.is_available())
print("Is the option to use cuda set?", args.cuda)
# for reproducible results
seed = 0
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(seed)
# printing style of numpy arrays
np.set_printoptions(precision=3, suppress=True)
# """
config_dir = "config_files"
config = StudyConfig(config_dir)
# create a template of a configuration file with all the fields initialized to None
config.create_config_file_template()
# the object with variable definitions based on the specified configuration file. It includes data description,
# definitions of run parameters (independent of deep definitions vs not)
# parameters = config.populate_study_parameters("CTS_UbiComp2020.toml")
parameters = config.populate_study_parameters("CTS_4Electrodes.toml")
print(parameters)
# generating the data from files
data = DataConstructor(parameters)
cv_subject_dict = data.cv_subj_dataset
# for subj_name, subj in cv_subject_dict.items():
# print(f"Subject name: {subj_name}")
# unique_categories = list(set(subj.categories))
# for unique_cat in unique_categories:
# for i, cat in enumerate(subj.categories):
# data_to_plot = []
# if unique_cat == cat:
# data = subj.data[i]
# data_to_plot.append(data)
# x = np.arange(0, data.shape[0])
# for i in range (0, data.shape[1]):
# feature = data[:, i]
# plt.plot(x, feature, label=str(i))
# plt.legend()
# plt.show()
# print("")
test_subject_dict = data.test_subj_dataset
category_balancer = WithinSubjectOversampler()
# define a data splitter object (to be used for setting aside a testing set, as well as train/validation split
# data_splitter = AcrossSubjectSplitter(cv_subject_dict)
data_splitter = WithinSubjectSplitter(cv_subject_dict)
cv_descriptor_computer = DescriptorComputer(DescType.RawData,
cv_subject_dict,
parameters,
seq_len=SeqLen.ExtendEdge,
extra_name="_100_samples_")
feature_constructor = KeypointFeatureConstructor(parameters,
cv_descriptor_computer)
# estimating number of resulting features based on the shape of the dataset, to be passed later to the feature
# constructor
input_size = estimate_num_features(cv_subject_dict, feature_constructor)
# input_size = input_size * 250
dataset_categories = data.get_all_dataset_categories()
assert parameters.neural_net is True
button_learning_def = NeuralNetworkDefinition(
input_size=input_size,
output_size=len(dataset_categories),
use_cuda=args.cuda)
# learning analyser
assert parameters.neural_net is True
analyser = NNAnalyser(data_splitter, feature_constructor,
category_balancer, parameters, button_learning_def,
dataset_categories,
cv_descriptor_computer.dataset_desc_name)
analyser.perform_cross_validation(cv_subject_dict)
analyser.evaluate_all_models(test_subject_dict)
analyser.close_logger()
# """
# cm_obj_name = "LSTM-batch-128-CTS_UbiComp2020_DescType.RawData_SeqLen.ExtendEdge_lstm_stat_2000e_test_confusion_matrix.pt"
# cm_obj_path = "/home/dq38/remote_pycharm/BioHCI-Project/BioHCI/saved_objects/CTS_UbiComp2020/confusion_matrices/" + cm_obj_name
# save_fig_path = "/home/dq38/remote_pycharm/BioHCI-Project/Results/CTS_UbiComp2020/learning_logs/LSTM-batch-128-CTS_UbiComp2020_DescType.RawData_SeqLen.ExtendEdge_lstm_stat_2000e_test_confusion_matrix.pdf"
# generate_confusion_matrix_fig_from_obj_name(cm_obj_path, save_fig_path)
print("\nEnd of main program.")
for label in label_list:
img_sub_list = []
pattern = "_" + str(label) + ".png"
for paths, files in path_files.items():
for f in files:
fname = os.path.basename(f)
if fname.endswith(pattern):
img_sub_list.append(f)
fig_name = os.path.join(save_dir,
"p1_all_cond_" + str(label) + ".png")
self.create_figure(img_sub_list, fig_name, 1, 3, save_dir)
if __name__ == "__main__":
config_dir = "config_files"
config = StudyConfig(config_dir)
# create a template of a configuration file with all the fields initialized to None
config.create_config_file_template()
# the object with variable definitions based on the specified configuration file. It includes data description,
# definitions of run parameters (independent of deep definitions vs not)
# parameters = config.populate_study_parameters("CTS_one_subj_variable.toml")
parameters = config.populate_study_parameters("CTS_4Electrodes.toml")
data = DataConstructor(parameters)
cv_subject_dict = data.cv_subj_dataset
# build a visualizer object for the class to plot the dataset in different forms
# we use the subject dataset as a source (a dictionary subj_name -> subj data split in categories)
saveplot_dir_path = "Results/" + parameters.study_name + "/dataset plots"
raw_data_vis = RawDataVisualizer(cv_subject_dict,
Args:
heatmap_name: the name of the pickled heatmap object to convert into a figure
"""
assert heatmap_name.endswith(".pkl")
path = join(self.dataset_eval_dir, heatmap_name)
if os.path.exists(path):
with (open(path, "rb")) as openfile:
heatmap = pickle.load(openfile)
self.generate_heatmap_fig_from_obj(heatmap)
if __name__ == "__main__":
np.set_printoptions(threshold=10000, linewidth=100000, precision=1)
config_dir = "config_files"
config = StudyConfig(config_dir)
# create a template of a configuration file with all the fields initialized to None
config.create_config_file_template()
# parameters = config.populate_study_parameters("CTS_5taps_per_button.toml")
parameters = config.populate_study_parameters("CTS_EICS2020.toml")
# generating the data from files
data = DataConstructor(parameters)
subject_dataset = data.get_subject_dataset()
# get all the categories of the dataset
all_dataset_categories = data.get_all_dataset_categories()
# determine the shape of the array
heatmap_shape = (len(set(all_dataset_categories)), len(set(all_dataset_categories)))
assert mean_array.shape[-1] == 2
diff = np.log(mean_array[:, :, 0]) - np.log(mean_array[:, :, 1])
diff = np.expand_dims(diff, axis=feature_axis)
return diff
@property
def mult_attr(self) -> int:
return self.__mult_attr
if __name__ == "__main__":
print("Running feature_constructor module...")
config_dir = "config_files"
config = StudyConfig(config_dir)
# create a template of a configuration file with all the fields initialized to None
config.create_config_file_template()
parameters = config.populate_study_parameters("EEG_Workload.toml")
# generating the data from files
data = DataConstructor(parameters)
subject_dict = data.get_subject_dataset()
category_balancer = WithinSubjectOversampler()
dataset_processor = StatDatasetProcessor(parameters)
feature_constructor = StatFeatureConstructor(parameters, dataset_processor)
feature_dataset = feature_constructor.produce_feature_dataset(subject_dict)