def create_meaned_amp_pred_corrs(
prefix='',
folder='data/models/paper/ours/cnt/deep4/car/',
params='default',
perturb_names=('no_dev', 'rand_mad', 'rand_std')):
"""This takes computed cov_vars and transforms them to corrs
and saves corrs."""
if params == 'default':
params = dict(cnt_preprocessors="$cz_zero_resample_car_demean",
trial_start=1500,
trial_stop=4000)
res_pool = ResultPool()
res_pool.load_results(folder, params=params)
result_file_names = res_pool.result_file_names()
results = res_pool.result_objects()
# sort by dataset filename
sort_order = np.argsort(
[r.parameters['dataset_filename'] for r in results])
result_file_names = np.array(result_file_names)[sort_order]
results = np.array(results)[sort_order]
all_base_names = [
name.replace('.result.pkl', '') for name in result_file_names
]
if prefix != '':
prefix = '.' + prefix
for i_file, base_name in enumerate(all_base_names):
log.info("Loading {:s}".format(
results[i_file].parameters['dataset_filename']))
create_meaned_amp_pred_corrs_for_file(base_name, prefix, perturb_names)
def _collect_parameters_and_results(self, start, stop, params):
self._result_pool = ResultPool()
self._result_pool.load_results(self._folder_name, start, stop, params)
if (self._result_pool.have_varying_datasets()
or self._result_pool.have_varying_leave_out()):
self._dataset_averaged_results = DatasetAveragedResults()
self._dataset_averaged_results.extract_results(self._result_pool)
def create_all_amplitude_perturbation_corrs(folder_name,
params,
start,
stop,
with_square,
with_square_cov,
after_softmax,
n_samples,
perturbations='default'):
if perturbations == 'default':
perturbations = (
(
'no_dev',
FuncAndArgs(
rand_diff,
with_blocks=False, #just return 1
deviation_func=lambda arr, axis, keepdims: 1)),
('rand_mad',
FuncAndArgs(rand_diff,
with_blocks=False,
deviation_func=median_absolute_deviation)),
('rand_std',
FuncAndArgs(rand_diff, with_blocks=False, deviation_func=np.std)),
)
elif perturbations == 'simple_no_scale':
perturbations = (
(
'no_dev',
FuncAndArgs(
rand_diff,
with_blocks=False, #just return 1
deviation_func=lambda arr, axis, keepdims: 1)), )
assert not (with_square and with_square_cov)
res_pool = ResultPool()
res_pool.load_results(folder_name, params=params)
res_file_names = res_pool.result_file_names()
all_base_names = [
name.replace('.result.pkl', '') for name in res_file_names
]
start = start or 0
stop = stop or len(all_base_names)
for i_file, base_name in enumerate(all_base_names[start:stop]):
log.info("Running {:s} ({:d} of {:d})".format(base_name,
i_file + start + 1,
stop))
create_amplitude_perturbation_corrs(base_name,
with_square=with_square,
with_square_cov=with_square_cov,
after_softmax=after_softmax,
n_samples=n_samples,
perturbations=perturbations)
def load_data_frame(folder, params=None, shorten_headers=True):
res_pool = ResultPool()
res_pool.load_results(folder, params=params)
result_objs = res_pool.result_objects()
varying_params = res_pool.varying_params()
constant_params = res_pool.constant_params()
file_names = res_pool.result_file_names()
data_frame = to_data_frame(file_names,
result_objs,
varying_params,
constant_params,
shorten_headers=shorten_headers)
data_frame.attrs = {'folder': folder, 'params': params}
return data_frame
def create_unit_output_class_corrs_for_files(folder_name, params, start, stop,
i_all_layers):
res_pool = ResultPool()
res_pool.load_results(folder_name, params=params)
res_file_names = res_pool.result_file_names()
all_base_names = [
name.replace('.result.pkl', '') for name in res_file_names
]
start = start or 0
stop = stop or len(all_base_names)
for i_file, basename in enumerate(all_base_names[start:stop]):
log.info("Running {:s} ({:d} of {:d})".format(basename,
i_file + start + 1,
stop))
create_unit_output_class_corrs(basename, i_all_layers)
def create_env_class_corrs(folder, params, start, stop):
res_pool = ResultPool()
res_pool.load_results(folder, params=params)
res_file_names = res_pool.result_file_names()
all_base_names = [
name.replace('.result.pkl', '') for name in res_file_names
]
start = start or 0
stop = stop or len(all_base_names)
with_square = True
for i_exp, base_name in enumerate(all_base_names[start:stop]):
log.info("Running {:s} ({:d} of {:d})".format(base_name,
i_exp + start + 1, stop))
create_env_class_corr_file(base_name, with_square)
def create_envelopes(folder_name, params, start, stop):
res_pool = ResultPool()
res_pool.load_results(folder_name, params=params)
res_file_names = res_pool.result_file_names()
log.info("{:d} files found.".format(len(res_file_names)))
yaml_file_names = [name.replace('.result.pkl', '.yaml')
for name in res_file_names]
stop = stop or len(yaml_file_names)
i_file = start
for i_file in xrange(start, stop):
file_name = yaml_file_names[i_file]
log.info("Running {:s} ({:d} of {:d})".format(
file_name, i_file+1, stop))
log.info("Parameters {:s}".format(
str(res_pool.result_objects()[i_file].parameters)))
create_envelopes_for_experiment(file_name)
def dataset_to_env_file(wanted_dataset_filename):
""" For any dataset filename, give envelope filename
These experiments are, where envelopes were calculated from originally"""
res_pool= ResultPool()
res_pool.load_results('data/models-backup/paper/ours/cnt/deep4/car/',
params=dict(cnt_preprocessors="$cz_zero_resample_car_demean",
trial_start=1500, trial_stop=4000))
dataset_to_env_file_name = dict()
for result, res_file_name in zip(res_pool.result_objects(), res_pool.result_file_names()):
dataset_file_name = result.parameters['dataset_filename']
envelope_file_name = res_file_name.replace('.result.pkl', '.env.npy')
assert os.path.isfile(envelope_file_name)
dataset_to_env_file_name[dataset_file_name] = envelope_file_name
return dataset_to_env_file_name[wanted_dataset_filename]
def create_env_corrs(folder_name, params, start, stop):
from braindecode.analysis.create_env_class_corrs import create_env_class_corr_file
res_pool = ResultPool()
res_pool.load_results(folder_name, params=params)
res_file_names = res_pool.result_file_names()
all_base_names = [name.replace('.result.pkl', '')
for name in res_file_names]
start = start or 0
stop = stop or len(all_base_names)
# Hackhack hardcoded layers, since I know this is correct layers atm
i_all_layers = [8,14,20,26,28] #for shallow [3, 4, 5, 7]
for i_file, base_name in enumerate(all_base_names[start:stop]):
with_square = True
log.info("Running {:s} ({:d} of {:d})".format(
base_name, i_file+start+1, stop))
create_topo_env_corrs_files(base_name, i_all_layers, with_square)
create_env_class_corr_file(base_name, with_square)
def load_amp_corrs(with_square, with_square_corr, cov_or_corr):
assert not (with_square and with_square_corr)
assert cov_or_corr == 'cov' or cov_or_corr == 'corr'
res_pool = ResultPool()
res_pool.load_results('data/models/paper/ours/cnt/deep4/car/',
params=dict(sensor_names="$all_EEG_sensors",
batch_modifier="null",
low_cut_off_hz="null",
first_nonlin="$elu"))
result_file_names = res_pool.result_file_names()
results = res_pool.result_objects()
# sort by dataset filename
sort_order = np.argsort(
[r.parameters['dataset_filename'] for r in results])
result_file_names = np.array(result_file_names)[sort_order]
results = np.array(results)[sort_order]
all_base_names = [
name.replace('.result.pkl', '') for name in result_file_names
]
clean_mask = []
all_corrs = dict()
for i_file, base_name in enumerate(all_base_names):
if any(s in results[i_file].parameters['dataset_filename']
for s in unclean_sets):
clean_mask.append(False)
else:
clean_mask.append(True)
for perturb_name in ('rand_mad', 'rand_std', 'no_dev'):
file_name_end = '.{:s}.amp_{:s}s.npy'.format(
perturb_name, cov_or_corr)
if with_square:
file_name_end = '.square' + file_name_end
if with_square_corr:
file_name_end = ".corrtosquare" + file_name_end
file_name = base_name + file_name_end
assert os.path.isfile(file_name), "Expect {:s} to exist".format(
file_name)
this_arr = all_corrs.pop(perturb_name, [])
this_arr.append(np.load(file_name))
all_corrs[perturb_name] = this_arr
clean_mask = np.array(clean_mask)
return all_corrs, clean_mask
def load_patterns(folder='data/models/paper/ours/csp/car/'):
res_pool = ResultPool()
res_pool.load_results(folder)
result_file_names = res_pool.result_file_names()
results = res_pool.result_objects()
# sort by dataset filename
sort_order = np.argsort([r.parameters['dataset_filename'] for r in results])
result_file_names = np.array(result_file_names)[sort_order]
results = np.array(results)[sort_order]
# now sorted
dataset_names = [r.parameters['dataset_filename'] for r in results]
all_patterns = []
clean_mask = []
all_exps = []
for file_name, dataset in zip(result_file_names, dataset_names):
log.info("Loading for {:s}".format(dataset))
model_file_name = file_name.replace('.result.pkl', '.pkl')
csp_exp = np.load(model_file_name)
patterns = csp_exp.binary_csp.patterns
pattern_arr = patterns_to_single_array(patterns)
pattern_arr = pattern_arr.squeeze()
assert not np.any(np.isnan(pattern_arr))
all_patterns.append(pattern_arr)
all_exps.append(csp_exp)
if any([s in dataset for s in unclean_sets]):
clean_mask.append(False)
else:
clean_mask.append(True)
all_patterns = np.array(all_patterns)
clean_mask = np.array(clean_mask)
return all_patterns, clean_mask, all_exps
def load_analysis_results(folder, params, file_name_end):
result_pool = ResultPool()
result_pool.load_results(folder, params=params)
result_file_names = result_pool.result_file_names()
results = result_pool.result_objects() # sort by dataset filename
sort_order = np.argsort(
[r.parameters['dataset_filename'] for r in results])
result_file_names = np.array(result_file_names)[sort_order]
results = np.array(results)[sort_order]
analysis_result_per_person = []
clean_mask = []
for file_name, result in zip(result_file_names, results):
analysis_result_file = file_name.replace('.result.pkl', file_name_end)
assert os.path.isfile(analysis_result_file)
analysis_result = np.load(analysis_result_file)
if any(s in result.parameters['dataset_filename']
for s in unclean_sets):
clean_mask.append(False)
else:
clean_mask.append(True)
analysis_result_per_person.append(analysis_result)
analysis_result_per_person = np.array(analysis_result_per_person)
clean_mask = np.array(clean_mask)
return analysis_result_per_person, clean_mask
def load_meaned_amp_pred_corrs(prefix='',
folder='data/models/paper/ours/cnt/deep4/car/',
params='default',
perturb_names=('no_dev', 'rand_mad',
'rand_std')):
if params == 'default':
params = dict(cnt_preprocessors="$cz_zero_resample_car_demean",
trial_start=1500,
trial_stop=4000)
res_pool = ResultPool()
res_pool.load_results(folder, params=params)
result_file_names = res_pool.result_file_names()
results = res_pool.result_objects()
if prefix != '':
prefix = '.' + prefix
# sort by dataset filename
sort_order = np.argsort(
[r.parameters['dataset_filename'] for r in results])
result_file_names = np.array(result_file_names)[sort_order]
results = np.array(results)[sort_order]
all_base_names = [
name.replace('.result.pkl', '') for name in result_file_names
]
clean_mask = []
all_corrs = dict()
for i_file, base_name in enumerate(all_base_names):
# Check that all perturbations exist
all_perturbations_exist = True
for perturb_name in perturb_names:
filename_end = '{:s}.{:s}.amp_cov_var_corrs.npy'.format(
prefix, perturb_name)
filename = base_name + filename_end
if not os.path.isfile(filename):
all_perturbations_exist = False
log.warn("{:s} does not exist".format(filename))
if not all_perturbations_exist:
log.warn("Skipping {:s} since not all perturbations exist".format(
base_name))
continue
# Check that all exist for subject
if any(s in results[i_file].parameters['dataset_filename']
for s in unclean_sets):
clean_mask.append(False)
else:
clean_mask.append(True)
for perturb_name in perturb_names:
filename_end = '{:s}.{:s}.amp_cov_var_corrs.npy'.format(
prefix, perturb_name)
filename = base_name + filename_end
assert os.path.isfile(filename), (
"Expect {:s} to exist".format(filename))
this_arr = all_corrs.pop(perturb_name, [])
this_corrs = np.load(filename)
this_arr.append(this_corrs)
all_corrs[perturb_name] = this_arr
clean_mask = np.array(clean_mask)
return all_corrs, clean_mask
