def build_leave_one_out(attributed_classifier: AttributedClassifier,
feature_sets: [[FeatureType]]) -> ClassifierSummary:
subject_ids = SubjectBuilder.get_all_subject_ids()
subject_dictionary = SubjectBuilder.get_subject_dictionary()
data_splits = TrainTestSplitter.leave_one_out(subject_ids)
return ThreeClassClassifierSummaryBuilder.run_feature_sets(data_splits, subject_dictionary,
attributed_classifier,
feature_sets)
def build_monte_carlo(attributed_classifier: AttributedClassifier, feature_sets: [[FeatureType]],
number_of_splits: int) -> ClassifierSummary:
subject_ids = SubjectBuilder.get_all_subject_ids()
subject_dictionary = SubjectBuilder.get_subject_dictionary()
data_splits = TrainTestSplitter.by_fraction(subject_ids, test_fraction=0.3, number_of_splits=number_of_splits)
return ThreeClassClassifierSummaryBuilder.run_feature_sets(data_splits, subject_dictionary,
attributed_classifier,
feature_sets)
def test_build(self, mock_activity_count_fs, mock_heart_rate_fs,
mock_time_based_fs, mock_psg_label_service):
subject_id = "subjectA"
mock_activity_count_fs.get_path_to_file.return_value = activity_count_feature = np.array(
[1, 2, 3, 4, 5])
mock_heart_rate_fs.get_path_to_file.return_value = heart_rate_feature = np.array(
[6, 7, 8, 9, 10])
mock_time_based_fs.load_time.return_value = time_feature = np.array(
[11])
mock_time_based_fs.load_circadian_model.return_value = circadian_feature = np.array(
[12])
mock_time_based_fs.load_cosine.return_value = cosine = np.array([12])
mock_psg_label_service.load.return_value = labels = np.array([13])
feature_dictionary = {
FeatureType.count: activity_count_feature,
FeatureType.heart_rate: heart_rate_feature,
FeatureType.time: time_feature,
FeatureType.circadian_model: circadian_feature,
FeatureType.cosine: cosine
}
expected_subject = Subject(subject_id=subject_id,
labeled_sleep=labels,
feature_dictionary=feature_dictionary)
returned_subject = SubjectBuilder.build(subject_id)
TestHelper.assert_models_equal(self, expected_subject,
returned_subject)
def test_build_subject_dictionary(self, mock_subject_ids, mock_build):
mock_subject_ids.return_value = subject_ids = ["subject123"]
mock_build.return_value = placeholder = np.array([1, 2, 3])
subject_dictionary = SubjectBuilder.get_subject_dictionary()
mock_build.assert_called_once_with(subject_ids[0])
self.assertDictEqual({subject_ids[0]: placeholder}, subject_dictionary)
def figure_leave_one_out_roc_and_pr():
classifiers = utils.get_classifiers()
feature_sets = utils.get_base_feature_sets()
for attributed_classifier in classifiers:
if Constants.VERBOSE:
print('Running ' + attributed_classifier.name + '...')
classifier_summary = SleepWakeClassifierSummaryBuilder.build_leave_one_out(
attributed_classifier, feature_sets)
CurvePlotBuilder.make_roc_sw(classifier_summary)
CurvePlotBuilder.make_pr_sw(classifier_summary)
TableBuilder.print_table_sw(classifier_summary)
CurvePlotBuilder.combine_plots_as_grid(
classifiers, len(SubjectBuilder.get_all_subject_ids()), '_sw_pr')
CurvePlotBuilder.combine_plots_as_grid(
classifiers, len(SubjectBuilder.get_all_subject_ids()), '_sw_roc')
def build_mesa(attributed_classifier: AttributedClassifier, feature_sets: [[FeatureType]]):
apple_watch_subjects = SubjectBuilder.get_subject_dictionary()
mesa_subjects = MesaDataService.get_all_subjects()
training_set = []
testing_set = []
mesa_dictionary = {}
for subject_key in apple_watch_subjects:
training_set.append(subject_key)
for mesa_subject in mesa_subjects:
mesa_subject.subject_id = 'mesa' + mesa_subject.subject_id
testing_set.append(mesa_subject.subject_id)
mesa_dictionary[mesa_subject.subject_id] = mesa_subject
data_split = DataSplit(training_set=training_set, testing_set=testing_set)
apple_watch_subjects.update(mesa_dictionary)
return SleepWakeClassifierSummaryBuilder.run_feature_sets([data_split], apple_watch_subjects,
attributed_classifier,
feature_sets)
def build_mesa_leave_one_out(attributed_classifier: AttributedClassifier, feature_sets: [[FeatureType]]):
apple_watch_subjects = SubjectBuilder.get_subject_dictionary()
mesa_subjects = MesaDataService.get_all_subjects()
training_set = []
mesa_dictionary = {}
data_splits = []
for subject_key in apple_watch_subjects:
training_set.append(subject_key)
for mesa_subject in mesa_subjects:
mesa_subject.subject_id = 'mesa' + mesa_subject.subject_id
mesa_dictionary[mesa_subject.subject_id] = mesa_subject
testing_set = [mesa_subject.subject_id]
data_split = DataSplit(training_set=training_set, testing_set=testing_set)
data_splits.append(data_split)
apple_watch_subjects.update(mesa_dictionary)
return ThreeClassClassifierSummaryBuilder.run_feature_sets(data_splits, apple_watch_subjects,
attributed_classifier,
feature_sets, True)
from source.analysis.setup.subject_builder import SubjectBuilder
from source.preprocessing.activity_count.activity_count_service import ActivityCountService
from source.preprocessing.feature_builder import FeatureBuilder
from source.preprocessing.raw_data_processor import RawDataProcessor
from source.preprocessing.time.circadian_service import CircadianService
def run_preprocessing(subject_set):
start_time = time.time()
for subject in subject_set:
print("Cropping data from subject " + str(subject) + "...")
RawDataProcessor.crop_all(str(subject))
# ActivityCountService.build_activity_counts() # This uses MATLAB, but has been replaced with a python implementation
# CircadianService.build_circadian_model() # Both of the circadian lines require MATLAB to run
# CircadianService.build_circadian_mesa()
for subject in subject_set:
FeatureBuilder.build(str(subject))
end_time = time.time()
print("Execution took " + str((end_time - start_time) / 60) + " minutes")
subject_ids = SubjectBuilder.get_all_subject_ids()
run_preprocessing(subject_ids)
for subject in subject_ids:
DataPlotBuilder.make_data_demo(subject, False)
def test_get_all_subject_ids(self):
self.assertListEqual([
'1', '2', '4', '5', '6', '7', '8', '9', '10', '11', '12', '14',
'15', '16', '19', '20', '22', '23', '25', '27', '28', '29', '30',
'32', '33', '34', '35', '38', '39', '41', '42'
], SubjectBuilder.get_all_subject_ids())