SleePyPhases 0.8.1__tar.gz → 0.8.2__tar.gz

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.8.1
+Version: 0.8.2
 Summary: A framwork for creating deep learning pipelines for sleep data
 Home-page: https://gitlab.com/sleep-is-all-you-need/sleepyphases
 Author: Franz Ehrlich

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases/Plugin.py

@@ -33,7 +33,7 @@ class Plugin(PluginAdapter):
             "Setup": (Setup, ["dataversionmanager"]),
             "Extract": (Extract, ["removedRecordIds", "data-processed", "data-features", "record-preprocessed"]),
             "BuildDataset": (BuildDataset, ["dataset-training", "dataset-validation", "dataset-test", "dataset-bySplit", "record-data"]),
-            "Training": (Training, ["modelState", "modelStateConfig"]),
+            "Training": (Training, ["modelState", "modelStateConfig", "trainedModel"]),
             "Validation": (Validation, []),
             "ThresholdOptimisation": (ThresholdOptimisation, ["threshold", "validationResult"]),
             "Eval": (Eval, ["evalResults", "eventResults"]),
@@ -56,6 +56,7 @@ class Plugin(PluginAdapter):
             "dataversionmanager": ["data-processed", "datafold", "dataversion"],
             "removedRecordIds": ["data-processed"],
             "modelState": ["dataset-bySplit", "modelName", "model", "inputShape", "segmentManipulation", "trainingParameter", "fold"],
+            "trainedModel": ["dataset-bySplit", "modelName", "model", "inputShape", "segmentManipulation", "trainingParameter", "fold", "pretraining"],
             "modelStateConfig": ["modelState"],
             "threshold": ["modelState", "eventEval", "thresholdMetric", "fixedThreshold"],
             "validationResult": ["modelState", "segmentManipulationEval", "thresholdMetric", "optimizeOn"],

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases/phases/Eval.py

@@ -16,30 +16,6 @@ class Eval(Phase):
     allowTraining: bool = False
     exampleCount: int = 3
 
-    def getModel(self) -> Model:
-        import torch
-
-        pretrainedPath = self.getConfig("pretraining.pretrainedModel")
-        
-        if not Path(pretrainedPath).exists():            
-            with self.project:
-                pretrainingConfig = self.getConfig("pretraining")
-                self.project.config["dataversion"] = {}
-                self.project.config.update(pretrainingConfig)
-                self.project.trigger("configChanged", None)
-                preModelState = self.project.getData("modelState", Model)
-
-        else:
-            deviceName = "cuda" if torch.cuda.is_available() else "cpu"
-            preModelState = torch.load(pretrainedPath, map_location=torch.device(deviceName))
-        
-        # set pretrain        
-        model = ModelManager.getModel(True)
-        model.build()
-        model.loadState(preModelState)
-
-        return model
-
     def getTestMetadata(self):
         if not bool(self.getConfig("evalOn", {})):
             return self.getData("metadata", list)
@@ -95,10 +71,9 @@ class Eval(Phase):
     def segmentEvaluation(self, name):
         testData = self.getTestData()
         self.setConfig("datasetSplits", list(self.getConfig("dataversion.split", {}).keys()))
-        model = self.getModel()
+        model = self.getData("trainedModel")
 
-        # setup data and scorer
-        
+        # setup data and scorer        
         classNums = self.getConfig("numClasses", [2])
         labelNames = self.getConfig("classification.labelNames")
         ignoreIndex = self.getConfig("classification.ignoreIndex", -1)
@@ -111,12 +86,11 @@ class Eval(Phase):
         threshold = threshold or self.getData("threshold", list)
         scorer.setThresholds(threshold)
 
-        manipulationAfterPredict = self.getConfig("manipulationAfterPredict", False)
+        manipulationAfterPredict = self.getConfig("manipulationAfterPredict", [])
         da = DataManipulation.getInstance(manipulationAfterPredict, "test", self.project.config, threshold=threshold)
 
         for data in tqdm(testData):
             x, truth = data
-
             prediction = model.predict(x, returnNumpy=False)
             prediction, truth = da((prediction, truth))
 
@@ -162,7 +136,7 @@ class Eval(Phase):
         with self.project:
             self.project.config.update(self.getConfig("eventEval", {}))
 
-            evalMetrics = self.getConfig("eval.metrics")
+            evalMetrics = self.getConfig("eval.metrics", self.getConfig("trainingParameter.validationMetrics"))
             classNums = self.getConfig("numClasses", [2])
             labelNames = self.getConfig("classification.labelNames")
             predictionNames = self.getConfig("classification.predictionSignals")
@@ -186,7 +160,7 @@ class Eval(Phase):
             # metaData["indexArousal"] = metaData["indexArousal"].astype(float)
             numClasses = self.getConfig("numClasses")
 
-            model = self.getModel()
+            model = self.getData("trainedModel")
             
             resultRows = []
             result = {}

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases/phases/EvalReport.py

@@ -177,11 +177,13 @@ class EvalReport(Phase):
         
     def main(self):
         import pandas as pd
+        eventEvalEnabled = bool(self.getConfig("eventEval", True))
         
         threshold = self.getConfig("fixedThreshold", False)
         self.threshold = threshold or self.getData("threshold", float)
 
-        modelConfigString = self.project.getDataFromName("eventResults").getTagString()
+        resultDataName = "eventResults" if eventEvalEnabled else "evalResults"
+        modelConfigString = self.project.getDataFromName(resultDataName).getTagString()
 
         evalPath = self.getConfig("eval-path", "eval/")
         evalPath = f"{evalPath}/{modelConfigString}/"
@@ -206,13 +208,16 @@ class EvalReport(Phase):
         df.to_csv(f"{evalPath}recordResultsSegment.csv", index=False)
 
         self.logSuccess(f"result segments: {segmentResults}")
-        resultRows, result = self.getData("eventResults", list)
-        self.logSuccess(f"result events: {result}")
-        df = pd.DataFrame(resultRows)
+        if eventEvalEnabled:
+            resultRows, result = self.getData("eventResults", list)
+            self.logSuccess(f"result events: {result}")
+            df = pd.DataFrame(resultRows)
+        else:
+            result = {}
 
         
         metrics = self.getConfig("trainingParameter.validationMetrics")
-        evalMetrics = self.getConfig("eval.metrics")
+        evalMetrics = self.getConfig("eval.metrics", metrics)
         labelNames = self.getConfig("classification.labelNames")
 
         results = {}
@@ -225,12 +230,13 @@ class EvalReport(Phase):
                 if metricName in segmentResults:
                     results[f"{metricName}-seg"] = segmentResults[metricName]
 
-        relMetaData = self.getConfig("eval.clinicalMetrics")
-        for m in relMetaData:
-            df[f"{m}-prediction-diff"] = df[f"{m}-prediction"] - df[f"{m}-truth"]
-            df[f"{m}-prediction-error"] = df[f"{m}-prediction-diff"].abs()
+        if eventEvalEnabled:
+            relMetaData = self.getConfig("eval.clinicalMetrics")
+            for m in relMetaData:
+                df[f"{m}-prediction-diff"] = df[f"{m}-prediction"] - df[f"{m}-truth"]
+                df[f"{m}-prediction-error"] = df[f"{m}-prediction-diff"].abs()
 
-        df.to_csv(f"{evalPath}recordResultsEvents.csv", index=False)
+            df.to_csv(f"{evalPath}recordResultsEvents.csv", index=False)
 
         self.logSuccess(f"Results: {results}")
         results = {k: float(v) for k, v in results.items() if not isinstance(v, Iterable)}

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases/phases/Extract.py

@@ -51,6 +51,7 @@ class RecordProcessor:
             if "sleepStage" not in eventSignal:
                 raise ChannelsNotPresent("sleepStage")
             eventSignal = eventSignal["sleepStage"]
+            labelSignalArray[eventSignal == 0] = -1
             labelSignalArray[eventSignal == PSGEventManager.INDEX_WAKE] = 0
             labelSignalArray[eventSignal == PSGEventManager.INDEX_REM] = 1
             labelSignalArray[eventSignal == PSGEventManager.INDEX_NREM1] = 2
@@ -170,8 +171,8 @@ class RecordProcessor:
             recordSignal, events = self.recordLoader.loadRecord(recordId)
 
             targetSignals = self.preProcessingConfig["targetChannels"] if "targetChannels" in self.preProcessingConfig else []
-            targetFrequency = self.preProcessingConfig["targetFrequency"] if "targetFrequency" in self.preProcessingConfig else []
-            labelFrequency = self.preProcessingConfig["labelFrequency"] if "labelFrequency" in self.preProcessingConfig else []
+            targetFrequency = self.preProcessingConfig["targetFrequency"] if "targetFrequency" in self.preProcessingConfig else 0
+            labelFrequency = self.preProcessingConfig["labelFrequency"] if "labelFrequency" in self.preProcessingConfig else targetFrequency
             featureChannels = self.preProcessingConfig["featureChannels"] if "featureChannels" in self.preProcessingConfig else []
             tailorToTargetSignals = self.preProcessingConfig["tailorToTargetSignals"] if "tailorToTargetSignals" in self.preProcessingConfig else False
             recordSignal.targetFrequency = targetFrequency
@@ -188,11 +189,14 @@ class RecordProcessor:
             self.featureExtraction.extractChannelsByConfig(recordSignal, featureChannels)
 
             signalLength = round(recordSignal.getSignalLength() * labelFrequency / targetFrequency)
+            sleepEvents = [e for e in events if e.name in ["R", "N1", "N2", "N3", "W", "undefined"]]
+            lastDefaultEventDuration = sleepEvents[-1].duration if sleepEvents and sleepEvents[-1].duration > 0 else 30 * labelFrequency
             eventSignal = self.eventManager.getEventSignalFromList(
                 events,
                 signalLength,
                 targetFrequency=labelFrequency,
                 forceGapBetweenEvents=False,
+                lastDefaultEventDuration=lastDefaultEventDuration,
             )
             # signalLength * 30
             eventSignal = self.preparelabelChannels(eventSignal, signalLength)

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases/phases/ExtractFeatures.py

@@ -1,6 +1,6 @@
 from typing import List
 from pyPhases import Phase
-from tqdm import tqdm
+from pyPhases.util import BatchProgress
 import pandas as pd
 
 from pyPhasesRecordloader import AnnotationNotFound, RecordLoader, ChannelsNotPresent, Event, ParseError
@@ -8,10 +8,62 @@ from pyPhasesRecordloader import AnnotationNotFound, RecordLoader, ChannelsNotPr
 from SleePyPhases.RecordFeatureExtraction import RecordFeatureExtraction
 from SleePyPhases.SleepMetaData import SleepMetaData
 
+
+
+class RecordFeatureProcessor:
+    """Processor class for multithreaded/multiprocess record feature extraction"""
+
+    def __init__(self, featureConfigs, recordLoader, recordFeatureExtraction):
+        self.featureConfigs = featureConfigs
+        self.recordLoader = recordLoader
+        self.recordFeatureExtraction = recordFeatureExtraction
+
+    def __call__(self, recordId):
+        recordLoader = self.recordLoader
+        try:
+            recordSignal, eventlist = recordLoader.loadRecord(recordId)
+        except AnnotationNotFound as e:
+            print(f"\033[31;1;4m\033[0mAnnotation missing in {recordId}: {e.name} ... skipping record")
+            return None
+        except ChannelsNotPresent as e:
+            print(f"\033[31;1;4m\033[0mChannels missing in {recordId}: {e.channels} ... skipping record")
+            return None
+        except ParseError as e:
+            print(f"\033[31;1;4m\033[0mParseError in record {recordId}, record will be skipped: {e}")
+            return None
+
+        features = pd.DataFrame(
+            index=pd.MultiIndex(levels=[[], []], codes=[[], []], names=["recordId", "channel"])
+        )
+
+        for featureConfig in self.featureConfigs:
+            checkedCol = featureConfig["name"] + "_checked"
+            channels = featureConfig["channels"]
+            for c in channels:
+                idx = (recordId, c)
+                try:
+                    featureStep = featureConfig["type"]
+                    self.recordFeatureExtraction.updateMetadataByStep(
+                        featureStep, recordSignal, eventlist, metadata=features, channel=c
+                    )
+                except ChannelsNotPresent as e:
+                    print(f"\033[31;1;4m\033[0mChannels not present in {recordId}: {e.channels}")
+
+                features.loc[idx, "recordId"] = recordId
+                features.loc[idx, "channel"] = c
+                features.loc[idx, checkedCol] = True
+
+        return features
+
+
 class ExtractFeatures(Phase):
     allowTraining = False
     features = None
 
+    useMultiThreading = True
+    spawnMultiprocessing = False
+    threads = None
+
     def getChannelMetadata(self, recordId):
         recordLoader = RecordLoader.get()
         recordLoader.getSignalHeaders(recordId)
@@ -212,16 +264,52 @@ class ExtractFeatures(Phase):
         recordIds = metadata["recordId"]
         forceCalculation = self.getConfig("featureExtraction.force", False)
 
-        reqFeatures = {f["name"] + "_checked": True for f in self.getConfig("featureExtraction.features", [])}
-
         recordId = self.getConfig("recordId", False)
-        recordIds = [recordId] if recordId else recordIds.iloc
-
-        for recordId in tqdm(recordIds):
-            if forceCalculation:
-                # the parameter forced has no meaning, it is just known to be not in the metadata, so the record will always be recalculated
-                reqFeatures["forced"] = True # should never be found
-            rows = self.getData("features", pd.DataFrame, recordId=recordId, **reqFeatures)
-            if len(rows) == 0:
-                self.logError(f"no features for {recordId}")
+        recordIds = [recordId] if recordId else recordIds.tolist()
+
+        featureConfigs = self.getConfig("featureExtraction.features", [])
+        checkedCols = [f["name"] + "_checked" for f in featureConfigs]
+
+        self.features = self.getData("features", pd.DataFrame)
+
+        if not forceCalculation and len(self.features) > 0:
+            # a record is complete if all _checked columns are True for it
+            completedIds = set()
+            if all(col in self.features.columns for col in checkedCols):
+                byRecord = self.features.groupby(level="recordId")
+                for rid, group in byRecord:
+                    if group[checkedCols].all(axis=None):
+                        completedIds.add(rid)
+
+            pendingIds = [r for r in recordIds if r not in completedIds]
+            self.logSuccess(f"Skipping {len(recordIds) - len(pendingIds)} already-calculated records, {len(pendingIds)} to process")
+        else:
+            pendingIds = recordIds
+
+        if len(pendingIds) == 0:
+            self.logSuccess("All records already have features calculated")
+            return
+
+        recordLoader = RecordLoader.get()
+        recordFeatureExtraction = RecordFeatureExtraction.getInstance()
+        processor = RecordFeatureProcessor(featureConfigs, recordLoader, recordFeatureExtraction)
+
+        bp = BatchProgress(pendingIds)
+        bp.useMultiThreading = self.useMultiThreading
+        if self.threads is not None:
+            bp.threads = self.threads
+        if self.spawnMultiprocessing:
+            bp.startMethod = "spawn"
+
+        def combine(resultList, dataIndex):
+            for result in resultList:
+                if result is None:
+                    continue
+                if len(result) > 0:
+                    self.features = pd.concat([self.features, result])
+                else:
+                    self.logError(f"no features for record at index {dataIndex}")
+            self.registerData("features", self.features)
+
+        bp.start(processor, afterBatch=combine)
                 

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases/phases/Setup.py

@@ -28,6 +28,9 @@ class Setup(Phase):
         # default fold is 0 if none is set
         self.setConfig("fold", self.getConfig("fold", 0))
         # self.setConfig("datasetSplits", list(self.getConfig("dataversion.split", {}).keys()))
+        namedFolds = self.getConfig("dataversion.namedFolds", False)
+        if namedFolds:
+            self.setConfig("dataversion.folds", len(namedFolds))
         self.setConfig("hasFolds", self.getConfig("dataversion.folds", 0) > 0)
 
         s = Scorer(5)
@@ -75,13 +78,33 @@ class Setup(Phase):
 
         dm = DataversionManager(groupedRecords, seed=seed)
 
+        # named fold presets: dataversion.namedFolds resolved by name (foldName) or integer index (fold)
+        namedFolds = self.getConfig("dataversion.namedFolds", False)
+        if namedFolds:
+            foldNames = list(namedFolds.keys())
+            foldName = self.getConfig("foldName", False)
+            if not foldName:
+                foldIndex = self.getConfig("fold", 0)
+                if foldIndex >= len(foldNames):
+                    raise Exception("fold index %i out of range for namedFolds (len %i)" % (foldIndex, len(foldNames)))
+                foldName = foldNames[foldIndex]
+            elif foldName not in namedFolds:
+                raise Exception("foldName '%s' not found in dataversion.namedFolds. Available: %s" % (foldName, foldNames))
+            foldConfig = namedFolds[foldName]
+            self.log(f"Using named fold '{foldName}'")
+            for splitName in ["training", "validation", "test"]:
+                if splitName in foldConfig:
+                    dm.addSplitBySlices(splitName, foldConfig[splitName])
+            dm.validatDatasetVersion(raiseException=self.getConfig("validatDataset", True))
+            return dm
+
         # add manual addes splits
         for splitName in ["training", "validation", "test"]:
             if splitName in splits:
                 dm.addSplitBySlices(splitName, splits[splitName])
 
         # add training folding splits
-        if "trainval" in splits:
+        if "trainval" in splits and splits["trainval"] is not None:
             foldcount = self.getConfig("dataversion.folds", 0)
             if foldcount > 0:
                 dm.addSplitsByFold("training", "validation", splits["trainval"], self.getConfig("dataversion.folds", 0), self.getConfig("fold", 0))
@@ -92,7 +115,7 @@ class Setup(Phase):
             if "training" in splits or "validation" in splits:
                 raise Exception("trainval and training/validation split are mutually exclusive. Please remove one of them from the config. This can be caused by loading multiple configs with different splits.")
 
-        if "trainvaltest" in splits:
+        if "trainvaltest" in splits and splits["trainvaltest"] is not None:
             foldCount = self.getConfig("dataversion.folds")
             currentFold = self.getConfig("fold", 0)
             testSlice, trainingSlice = dm.getSplitsByPercentage(

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases/phases/Training.py

@@ -57,9 +57,37 @@ class Training(Phase):
         return trainedModel
 
     def generateData(self, name):
-        trainedModel = self.train()
-        self.project.registerData("modelState", trainedModel)
-        self.project.registerData("modelStateConfig", self.project.getDataFromName("modelState").getDependencyDict())
+        if name == "modelState":
+            trainedModel = self.train()
+            self.project.registerData("modelState", trainedModel)
+        elif name == "modelStateConfig":
+            self.project.registerData("modelStateConfig", self.project.getDataFromName("modelState").getDependencyDict())
+        elif name == "trainedModel":
+              
+            model = ModelManager.getModel(True)
+            pretrainingConfig = self.getConfig("pretraining", {})
+            
+            pretrainedPath = pretrainingConfig.get("pretrainedModel", False)
+            preModelState = None
+
+            if pretrainedPath:
+                if not Path(pretrainedPath).exists():
+                    err = f"model path for evaluation does not exist (pretraining.pretrainedModel): {pretrainedPath}"
+                    self.logError(err)
+                    raise Exception(err)
+                else:
+                    preModelState = model.load(pretrainedPath)
+                    
+            if preModelState is None:
+                with self.project:
+                    self.project.config["dataversion"] = {}
+                    self.project.config.update(pretrainingConfig)
+                    self.project.trigger("configChanged", None)
+                    preModelState = self.project.getData("modelState", Model)
+            
+            model.build()
+            model.loadState(preModelState)
+            return model
 
     def main(self):
         startfold = self.getConfig("startFold", 0)
@@ -88,9 +116,9 @@ class Training(Phase):
                 self.project.unregister("modelStateConfig")
             gridOutputs.append(self.gridOutput)
             # reset model state
-            ModelManager.getModel().model.load_state_dict(startState)
+            ModelManager.getModel().resetParameters()
 
-        self.project.gridOutput = {
+        self.project.gridOutput= {
             "epochs": str(np.mean([m["epochs"] for m in gridOutputs])),
             "best": str(np.mean([m["best"] for m in gridOutputs])),
             "folds": len(gridOutputs),

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/SleePyPhases.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.8.1
+Version: 0.8.2
 Summary: A framwork for creating deep learning pipelines for sleep data
 Home-page: https://gitlab.com/sleep-is-all-you-need/sleepyphases
 Author: Franz Ehrlich

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="SleePyPhases",
-    version="v0.8.1"[1:],
+    version="v0.8.2"[1:],
     author="Franz Ehrlich",
     author_email="fehrlichd@gmail.com",
     description="A framwork for creating deep learning pipelines for sleep data",

{sleepyphases-0.8.1 → sleepyphases-0.8.2}/tests/unit/test_Extract.py

@@ -117,6 +117,7 @@ class TestExtract(TestCase):
             signalLength,
             targetFrequency=1,
             forceGapBetweenEvents=False,
+            lastDefaultEventDuration=10 # (Event("N1", 0, duration=10)])
         )
 
         # Check that the sliced recordSignal has the correct targetFrequency