def create_accuracies_matrix(classifiers_list, features_list, dataset):
classifiers_dict = create_dict(classifiers_list)
features_dict = create_dict(features_list)
config = Configuration_BCI.Configuration_BCI('BCI_Framework', dataset)
subjects_dict = create_dict(config.configuration["subject_names_str"])
opt_error_matrix = np.zeros(shape=(len(classifiers_dict),
len(features_dict),
len(subjects_dict)))
cv_error_matrix = np.zeros(
(len(classifiers_dict), len(features_dict), len(subjects_dict)))
n_csps = -1
if config.configuration['number_of_channels'] > 5:
n_csps = 1
for classifier in classifiers_dict.keys():
for feature in features_dict.keys():
bcic = Main.Main('BCI_Framework', dataset, classifier, feature,
'ALL', n_csps, 'python')
for subject in bcic.config.configuration['subject_names_str']:
temp, temp, cv_err = bcic.find_learners_optimal_params(
subject)
opt_error = bcic.find_opt_error(subject)
opt_error_matrix[classifiers_dict[classifier],
features_dict[feature],
subjects_dict[subject]] = opt_error
cv_error_matrix[classifiers_dict[classifier],
features_dict[feature],
subjects_dict[subject]] = cv_err
return cv_error_matrix, opt_error_matrix
def __init__(self, dir, learner_name, feature_extractor_name,
dataset_name): #, channels, number_of_csps):
""" """
self.logging = logging
# number_of_csps = int(number_of_csps)
self.config = Configuration_BCI.Configuration_BCI(
dir, dataset_name) #, channels)
# self.config.set_numberof_channels(number_of_csps)
if self.config.configuration['logging_level_str'] == 'INFO':
self.logging.basicConfig(format='%(asctime)s %(message)s',
level=logging.INFO)
else:
self.logging.basicConfig(level=logging.NOTSET)
self.logging.info('begin creating Simple_Job_Runner')
self.results_path = self.config.configuration['results_path_str']
self.results_opt_path = self.config.configuration[
'results_opt_path_str']
self.results_path, self.results_opt_path = Single_Job_Runner.set_results_path(
self.results_path, self.results_opt_path, learner_name,
feature_extractor_name)
self.feature_matrix_path = os.path.join(
self.config.configuration['feature_matrix_dir_name_str'],
feature_extractor_name)
self.my_Learner_Manager = Learner_Manager.Learner_Manager(
self.config, learner_name, feature_extractor_name)
self.logging.info(
'Simple_Job_Runner instance created, learning algorithm is: %s resutls_path is: %s results_opt_path is: %s',
learner_name, self.results_path, self.results_opt_path)
def __init__(self,
dir,
dataset_name,
learner_name,
feature_extractor_name,
optimization_type,
BO_selection_type,
channels='ALL',
number_of_CSPs=-1):
""""""
self.dir = dir
self.dataset_name = dataset_name
self.config = Configuration_BCI.Configuration_BCI(
dir, self.dataset_name)
self.config.set_channel_type(channels, number_of_CSPs)
self.logging = logging
if self.config.configuration['logging_level_str'] == 'INFO':
self.logging.basicConfig(format='%(asctime)s %(message)s',
level=logging.INFO)
else:
self.logging.basicConfig(level=logging.CRITICAL)
self.learner_name = learner_name
self.feature_extractor_name = feature_extractor_name
self.channels = channels
self.number_of_CSPs = number_of_CSPs
self.myPython_path = 'python'
self.optimization_type = optimization_type
self.BO_selection_type = BO_selection_type
self.results_path = self.config.configuration['results_path_str']
self.opt_results_path = self.config.configuration[
'results_opt_path_str']
self.bash_script = [
"#!/bin/bash\n", "#PBS -S /bin/bash\n",
"#PBS -M [email protected]\n", "#PBS -m bea\n",
"#PBS -l mem=4gb\n", "module load application/python/2.7.3\n",
"module load python/2.7.5.anaconda\n",
"module load python/2.7.3\n", 'cd $PBS_O_WORKDIR',
'\n echo "Current working directory is `pwd`"\n',
'echo "Starting: run at: `date`"\n',
self.myPython_path + " ./BCI_Framework/Single_Job_runner.py",
'echo "Program finished with exit code $? at: `date`"\n'
]
self.python_run_cmd_ind = 11
self.set_results_path()
self.logging.info(
'dataset: %s learning algorithm: %s feature extraction method: %s channels: %s Number of CSPs: %s python path: %s'
+ ' results path: %s optimal results path: %s', self.dataset_name,
self.learner_name, self.feature_extractor_name, self.channels,
self.number_of_CSPs, self.myPython_path, self.results_path,
self.opt_results_path)
def generate_all_candidates(dataset_name, optimization_type):
##########################################################################################################################################################
# the following code block generates potential candidates for Bayesian Optimizer
# different BO types
# type 1 -> only search for time window
# type 2 -> search for time and frequency window
# type 3 -> search for time window and channels
# type 4 -> search for time window and search for frequency window and channels
# type 3-1 -> search for time window and search for frequency window for each channel separately
# type 5 -> search for time window and search for frequency window for each channel separately
BO_type = optimization_type
config = Configuration_BCI.Configuration_BCI('BCI_Framework', dataset_name)
sampling_rate = config.configuration['sampling_rate']
all_subjects_candidates_list = []
for subj_ind, subj in enumerate(config.configuration['subject_names_str']):
mv_size = config.configuration['movement_trial_size_list'][subj_ind]
all_mvs_have_same_lebngth = all(
map(lambda x: x == mv_size,
config.configuration['movement_trial_size_list']))
n_channels = config.configuration['number_of_channels']
candidates_list = []
if BO_type == 1:
window_start_list = map(
int, np.arange(0, mv_size - sampling_rate,
sampling_rate / 4.0))
window_length_list = map(
int,
np.arange(0.75 * sampling_rate, mv_size + 1,
sampling_rate / 4.0))
window_list = generate_window_list_time(window_start_list,
window_length_list,
mv_size)
candidates_list = window_list
# all_initial_cands = read_initial_candidates('BCI_Framework/BO_type1_initial_candidates.txt', config)
elif BO_type == 2:
window_start_list = map(
int, np.arange(0, mv_size - sampling_rate,
sampling_rate / 4.0))
window_length_list = map(
int,
np.arange(0.75 * sampling_rate, mv_size + 1,
sampling_rate / 4.0))
window_list_mv = generate_window_list_time(window_start_list,
window_length_list,
mv_size)
candidates_list.append(window_list_mv)
# window_start_list_freq = np.arange(2, 6, 0.5)
# window_length_list_freq = np.arange(26, 30, 0.75)
# window_list_freq = generate_window_list_freq(window_start_list_freq, window_length_list_freq, 32)
# window_list_freq = zip(window_list_freq, window_list_freq)
# window_list_freq = revise_candidates(window_list_freq, 0)
window_list_freq = []
alpha_beta_candidates = []
window_start_list_freq = np.arange(7, 9.5, 0.5)
window_length_list_freq = np.arange(4, 6, 0.75)
window_list_freq_alpha = generate_window_list_freq(
window_start_list_freq, window_length_list_freq, 14)
alpha_beta_candidates.append(window_list_freq_alpha)
window_start_list_freq = np.arange(15, 19, 0.5)
window_length_list_freq = np.arange(5, 10, 0.75)
window_list_freq_beta = generate_window_list_freq(
window_start_list_freq, window_length_list_freq, 26)
alpha_beta_candidates.append(window_list_freq_beta)
raw_candidates_alpha_beta = list(
itertools.product(*alpha_beta_candidates))
candidates_list_alpha_beta = revise_candidates(
raw_candidates_alpha_beta, BO_type)
window_list_freq = window_list_freq + candidates_list_alpha_beta
candidates_list.append(window_list_freq)
# candidates_list.append(candidates_list_alpha_beta)
# all_initial_cands = read_initial_candidates('BCI_Framework/BO_type2_initial_candidates.txt', config)
elif BO_type == 3:
window_start_list = map(
int, np.arange(0, mv_size - sampling_rate,
sampling_rate / 4.0))
window_length_list = map(
int,
np.arange(0.75 * sampling_rate, mv_size + 1,
sampling_rate / 4.0))
window_list_mv = generate_window_list_time(window_start_list,
window_length_list,
mv_size)
candidates_list.append(window_list_mv)
# channels_list = [['ALL'], ['CSP2'], ['CSP4'], ['CSP6'], ['CS']]
channels_list = [
[0], [1], [2], [3], [4]
] #???????????????????????????????????????????????????????????????????????????????????????????
candidates_list.append(channels_list)
# all_initial_cands = read_initial_candidates('BCI_Framework/BO_type3_initial_candidates.txt', config)
elif BO_type == 4:
window_start_list = map(
int, np.arange(0, mv_size - sampling_rate,
sampling_rate / 4.0))
window_length_list = map(
int,
np.arange(0.75 * sampling_rate, mv_size + 1,
sampling_rate / 4.0))
window_list_mv = generate_window_list_time(window_start_list,
window_length_list,
mv_size)
candidates_list.append(window_list_mv)
window_start_list_freq = np.arange(2, 6, 0.5)
window_length_list_freq = np.arange(26, 30, 0.75)
window_list_freq = generate_window_list_freq(
window_start_list_freq, window_length_list_freq, 32)
window_list_freq = zip(window_list_freq, window_list_freq)
window_list_freq = revise_candidates(window_list_freq, 0)
alpha_beta_candidates = []
window_start_list_freq = np.arange(7, 9.5, 0.5)
window_length_list_freq = np.arange(4, 6, 0.75)
window_list_freq_alpha = generate_window_list_freq(
window_start_list_freq, window_length_list_freq, 14)
alpha_beta_candidates.append(window_list_freq_alpha)
window_start_list_freq = np.arange(15, 19, 0.5)
window_length_list_freq = np.arange(5, 10, 0.75)
window_list_freq_beta = generate_window_list_freq(
window_start_list_freq, window_length_list_freq, 26)
alpha_beta_candidates.append(window_list_freq_beta)
raw_candidates_alpha_beta = list(
itertools.product(*alpha_beta_candidates))
candidates_list_alpha_beta = revise_candidates(
raw_candidates_alpha_beta, BO_type)
window_list_freq = window_list_freq + candidates_list_alpha_beta
candidates_list.append(window_list_freq)
channels_list = [
[0], [1], [2], [3], [4]
] #???????????????????????????????????????????????????????????????????????????????????????????
candidates_list.append(channels_list)
# all_initial_cands = read_initial_candidates('BCI_Framework/BO_type4_initial_candidates.txt', config)
# elif BO_type == 5:
#
# window_start_list = map(int, np.arange(0, mv_size - sampling_rate, sampling_rate/4.0))
# window_length_list = map(int, np.arange(0.75 * sampling_rate, mv_size+1, sampling_rate/4.0))
# window_list_mv = generate_window_list_time(window_start_list, window_length_list, mv_size)
# candidates_list.append(window_list_mv)
#
# indices_list = generate_channel_indices(n_channels)
# candidates_list.append(indices_list)
# all_initial_cands = read_initial_candidates('BCI_Framework/BO_type4_initial_candidates.txt', config)
if BO_type != 1:
raw_candidates = list(itertools.product(*candidates_list))
candidates_list = revise_candidates(raw_candidates, BO_type)
# candidates_list = all_initial_cands + candidates_list ################################################
# Job_Params.n_initial_candidates = len(all_initial_cands) ############################################
all_subjects_candidates_list.append(candidates_list)
if all_mvs_have_same_lebngth:
break
##########################################################################################################################################################
return all_subjects_candidates_list, 0
print dataset, feature, bo_type, optimization_type
class Job_Params:
job_dir = '../Candidates'
num_all_jobs = 40
dataset = dataset
from random import randrange
seed = randrange(50)
classifier_name = classifier
feature_extraction = feature
n_concurrent_jobs = 1
chooser_module = bo_type
Job_Params.n_initial_candidates = 0
config = Configuration_BCI.Configuration_BCI(
'BCI_Framework', dataset)
complete_jobs = np.zeros(
config.configuration['number_of_subjects'])
all_mvs_have_same_lebngth = all(
map(
lambda x: x == config.configuration[
'movement_trial_size_list'][0],
config.configuration['movement_trial_size_list']))
for subj_ind, subj in enumerate(
config.configuration['subject_names_str']):
if all_mvs_have_same_lebngth:
all_subjects_candidates_list = all_subjects_candidates_dict[
(dataset_ind, optimization_type)][0]
import sys
sys.path.append('./BCI_Framework')
import Configuration_BCI
import os
if __name__ == '__main__':
classifiers_dict = {
'Boosting': 0,
'LogisticRegression': 1,
'RANDOM_FOREST': 2,
'SVM': 3,
'LDA': 4,
'QDA': 5,
'MLP': 6
}
features_dict = {'BP': 0, 'logbp': 1, 'morlet': 2, 'AR': 3}
config = Configuration_BCI.Configuration_BCI("BCI_Framework", 'SM2', 'CSP')
for classifier in classifiers_dict.keys():
for feature in features_dict.keys():
print classifier + '-' + feature + '-' + str(
len(
os.listdir(config.configuration['results_path_str'] + '/' +
classifier + '/' + feature)))
os.chdir('../bci_framework')
sys.path.append('./BCI_Framework')
import Main
import Configuration_BCI
import numpy as np
import spearmint_lite
class Job_Params:
job_dir = 'BCI_Framework'
num_all_jobs = 100
dataset = 'BCICIV2b'
seed = 1
classifier_name = 'LogisticRegression'
feature_extraction = 'BP'
n_concurrent_jobs = 3
chooser_module = "GPEIOptChooser"
n_initial_candidates = 12
if __name__ == '__main__':
BO_type = 2
config = Configuration_BCI.Configuration_BCI('BCI_Framework', 'BCICIV2b')
sp = spearmint_lite.spearmint_lite(Job_Params, [], config, BO_type)
params = [687.0, 1.0, 1.5, 3.5]
subj = '100'
sp.run_job(params, subj)
pass
sig_mat_pow = np.exp2(sig_mat)
pow_sig_mat = np.zeros(shape=(sig_mat_pow.shape[0] - window_size,
sig_mat_pow.shape[1]))
for i in range(len(sig_mat_pow) - window_size):
pow_sig_mat[i, :] = np.sum(sig_mat_pow[i:i + window_size, :], axis=0)
return pow_sig_mat
if __name__ == '__main__':
channels = 'C34'
number_of_CSPs = -1
params_list = [0, 0, 0, 0, -1, 0]
config = Configuration_BCI.Configuration_BCI('./BCI_Framework', 'BCICIV2a',
channels)
for subject_ind, subject in enumerate(
config.configuration['subject_names_str']):
dp = Data_Proc.Data_Preprocessor(config, channels, subject, 'raw',
number_of_CSPs)
raw_X, raw_Y = dp.load_dataset_train(subject)
filters = ['delta', 'alpha', 'beta']
cutoff_frequencies_low = np.array([[4, 8., 16.], [4, 8., 16.]])
cutoff_frequencies_high = np.array([[8, 12., 24.], [8, 12., 24.]])
for filt_number in range(cutoff_frequencies_low.shape[1]):
cutoff_freq_low = cutoff_frequencies_low[:, filt_number]
cutoff_freq_high = cutoff_frequencies_high[:, filt_number]
os.chdir('../bci_framework')
sys.path.append('./BCI_Framework')
import Configuration_BCI
import Main
import Single_Job_runner as SJR
import numpy as np
if __name__ == '__main__':
feature_list = ['BP', 'AR', 'logbp', 'morlet', 'wackerman']
dataset_name = 'BCICIII3b'
myPython_path = 'python'
dir = 'BCI_Framework'
config = Configuration_BCI.Configuration_BCI(dir, dataset_name)
list_of_classifiers = config.configuration['durations_dict'].keys()
for subject in config.configuration['subject_names_str']:
for feature in feature_list:
minimum = np.inf
for classifier_name in list_of_classifiers:
bcic = Main.Main(dir, dataset_name, classifier_name, feature,
'ALL', -1, myPython_path)
res_dir = os.path.join(
config.configuration['results_path_str'],
classifier_name + '/' + feature)
# if os.path.exists(res_dir):
