SleePyPhases 0.7.0__tar.gz → 0.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.7.0
+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.7.0 → sleepyphases-0.8.2}/SleePyPhases/EventScorer.py

@@ -7,8 +7,8 @@ from SleepHarmonizer.PSGEventManager import PSGEventManager
 class EventScorer(Scorer):
     title = "Eventbasiert-Tolerant"
 
-    def __init__(self, numClasses=None, classNames=None, trace=False) -> None:
-        super().__init__(numClasses=numClasses, classNames=classNames, trace=trace)
+    def __init__(self, numClasses=None, classNames=None, trace=False, multilabel=False) -> None:
+        super().__init__(numClasses=numClasses, classNames=classNames, trace=trace, multilabel=multilabel)
         self.metrics = ["kappa", "accuracy"]
         self.majorityVote = False
 

{sleepyphases-0.7.0 → sleepyphases-0.8.2}/SleePyPhases/FeatureExtraction.py

@@ -84,7 +84,7 @@ class FeatureExtraction(pyPhasesFeatureExtraction, Swappable):
             array, _ = da((array, None))
             array = array.transpose(2, 1, 0)
 
-            features = model.predict(array, get_likelihood=True, returnNumpy=True)
+            features = model.predict(array, returnNumpy=True)
             _, features = da.restoreLength(None, features, length=segmentSignal.getShape()[1])
             features = features[:, :, 1]
 

{sleepyphases-0.7.0 → 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,10 +56,11 @@ 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"],
-            "evalResults": ["threshold", "evalOn", "manipulationAfterPredict", "segmentManipulationEval"],
+            "evalResults": ["threshold", "evalOn", "manipulationAfterPredict", "segmentManipulationEval", "pretraining"],
             "eventResults": ["evalResults", "eventEval"],
             "dataset-bySplit": ["dataversionmanager"],
             "dataset-training": ["dataversionmanager"],

{sleepyphases-0.7.0 → sleepyphases-0.8.2}/SleePyPhases/SleePyPhases.py

@@ -9,7 +9,7 @@ class SleePyPhases(Project):
     """
 
     @staticmethod
-    def create(configFiles=None, plugins=None):
+    def create(configFiles=None, plugins=None, projectFile=None):
         if plugins is None:
             plugins = []
 
@@ -18,7 +18,7 @@ class SleePyPhases(Project):
             "pyPhasesML",
             "pyPhasesRecordloader",
         ]
-        project = DefaultProject.create(configFiles, plugins + defaultPlugins, project=SleePyPhases())
+        project = DefaultProject.create(configFiles, plugins + defaultPlugins, project=SleePyPhases(), projectFile=projectFile)
 
         return project
     

{sleepyphases-0.7.0 → sleepyphases-0.8.2}/SleePyPhases/SleepMetaData.py

@@ -86,8 +86,9 @@ class SleepMetaData:
     def fromSleepSignalBin(self, signal, frequency = 1):
         # all time values in seconds
         trt = len(signal) / (frequency)
-        tst = sum(signal) / (frequency)
         whereSleep = np.where(signal > 0)[0]
+        tst = len(whereSleep) / (frequency)
+
         if len(whereSleep) == 0:
             sLatency = 0
         else:
@@ -107,8 +108,11 @@ class SleepMetaData:
         self.registerMetadata("sEfficiency", tst / trt * 100, unit="%")
 
     def fromSleepSignalFour(self, signal, frequency = 1):
-        whereREM = np.where(signal == 1)
-        rLatency = whereREM[0] - self.getMetaData("sLatency")
+        whereREM = np.where(signal == 1)[0]
+        if len(whereREM) > 0:
+            rLatency = whereREM[0] - self.getMetaData("sLatency")
+        else:
+            rLatency = 0
         self.registerMetadata("rLatency", rLatency)
 
     

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

@@ -1,3 +1,4 @@
+from pathlib import Path
 import random
 import numpy as np
 import pandas as pd
@@ -15,13 +16,6 @@ class Eval(Phase):
     allowTraining: bool = False
     exampleCount: int = 3
 
-    def getModel(self) -> Model:
-        modelState = self.project.getData("modelState", Model, generate=self.allowTraining)
-        model = ModelManager.getModel(True)
-        model.build()
-        model.loadState(modelState)
-        return model
-
     def getTestMetadata(self):
         if not bool(self.getConfig("evalOn", {})):
             return self.getData("metadata", list)
@@ -77,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)
@@ -93,13 +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)
-        batchSize = self.getConfig("eval.batchSize")
 
         for data in tqdm(testData):
             x, truth = data
-
             prediction = model.predict(x, returnNumpy=False)
             prediction, truth = da((prediction, truth))
 
@@ -145,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")
@@ -169,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.7.0 → 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)}
@@ -243,8 +249,11 @@ class EvalReport(Phase):
     def copyRawData(self):
         modelConfigString = self.project.getDataFromName("modelState").getTagString()
         trainingLogPath = f"logs/{modelConfigString}/"
-        shutil.copyfile(trainingLogPath + "log.csv", self.evalPath + "training.log")
-        shutil.copyfile(trainingLogPath + "project.config", self.evalPath + "project.json")
+        if Path(trainingLogPath).exists():
+            shutil.copyfile(trainingLogPath + "log.csv", self.evalPath + "training.log")
+            shutil.copyfile(trainingLogPath + "project.config", self.evalPath + "project.json")
+        else:
+            self.logError(f"training log path does not exist, could not backup training and config: {trainingLogPath}")
 
     def trainingPlot(self, logFile):
         import matplotlib.pyplot as plt

{sleepyphases-0.7.0 → 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,14 +171,16 @@ 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
 
             # tailor to targetsignals
-            signalNames = [recordSignal.getFirstSignalName(s) for s in targetSignals]
-            recordSignal = recordSignal[signalNames]
+            if tailorToTargetSignals:
+                signalNames = [recordSignal.getFirstSignalName(s) for s in targetSignals]
+                recordSignal = recordSignal[signalNames]
 
             # set the target frequency for the signal to get the correct signal length
             self.signalProcessing.preprocessingSignal(recordSignal)
@@ -186,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)
@@ -222,12 +228,14 @@ class Extract(Phase):
     """
 
     useMultiThreading = True
+    spawnMultiprocessing = False
     threads = None
 
     def getRecordProcessor(self):
         preprocessingConfig = self.getConfig("preprocessing")
         featureExtraction = FeatureExtraction.getInstance(self.project)
-        preDataManipulation = PreManipulation.getInstance(preprocessingConfig["manipulationSteps"])
+        manipulationSteps = preprocessingConfig.get("manipulationSteps", [])
+        preDataManipulation = PreManipulation.getInstance(manipulationSteps)
         processRecord = RecordProcessor(
             recordLoader=RecordLoader.get(),
             preProcessingConfig=preprocessingConfig,
@@ -281,6 +289,8 @@ class Extract(Phase):
         bp.useMultiThreading = self.useMultiThreading
         if self.threads is not None:
             bp.threads = self.threads
+        if self.spawnMultiprocessing:
+            bp.startMethod = "spawn"
 
         def combine(recordList, dataIndex):
             recordList = recordList.copy()
@@ -334,4 +344,18 @@ class Extract(Phase):
             self.registerData("removedRecordIds", removedRecordIds)
 
     def main(self):
-        self.generateData("data-processed")
+        datasets = self.getConfig("datafold.datasets", False)
+        datasets = datasets if isinstance(datasets, list) else [{"config": {}}]
+        for i, source in enumerate(datasets):
+            ds_config = source.get("config", {})
+            loader_id = ds_config.get("useLoader", f"dataset-{i}")
+            self.log(f"Processing dataset {i + 1}/{len(datasets)}: {loader_id}")
+
+            with self.project:
+                # Clear per-dataset dataversion so it gets recomputed
+                if "dataversion" in ds_config:
+                    self.project.setConfig("dataversion", {})
+                self.project.updateConfig(ds_config)
+                
+                _ = self.project.getData("data-processed", np.memmap)
+                self.logSuccess(f"Dataset '{loader_id}' – extraction done")

{sleepyphases-0.7.0 → 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.7.0 → sleepyphases-0.8.2}/SleePyPhases/phases/Predict.py

@@ -138,8 +138,9 @@ class Predict(Phase):
         recordSignal.targetFrequency = targetFrequency
         
         # Get signal names
-        signalNames = [recordSignal.getFirstSignalName(s) for s in targetSignals]
-        recordSignal = recordSignal[signalNames]
+        if self.getConfig("preprocessing.tailorToTargetSignals", False):
+            signalNames = [recordSignal.getFirstSignalName(s) for s in targetSignals]
+            recordSignal = recordSignal[signalNames]
         
         # Apply preprocessing
         signalProcessing = SignalPreprocessing.getInstance(preprocessingConfig)
@@ -167,7 +168,7 @@ class Predict(Phase):
 
         return self.predictRecordSignal(recordSignal)
 
-    def predictRecordSignal(self, recordSignal, dummyY=None):
+    def predictRecordSignal(self, recordSignal, metadata=None, dummyY=None):
         processedSignal = self.preprocessSignal(recordSignal)
 
         with self.project:
@@ -177,8 +178,10 @@ class Predict(Phase):
             # Apply segment manipulation for evaluation
             manipulationSteps = self.getConfig("segmentManipulationEval", [])
             da = DataManipulation.getInstance(manipulationSteps, "test", self.project.config)
+            da.recordMetadata = [metadata] if metadata is not None else None
+            da.currentIndex = 0
             dummyY = np.array([0]).reshape(1, -1, 1) if  dummyY is None else dummyY
-            processedSignal, dummyY = da((processedSignal, dummyY))  # Dummy label
+            processedSignal, dummyY = da((processedSignal, dummyY), index=0)  # Dummy label
 
             # Load model with optional custom weights
             weightsPath = self.getConfig("predict.weights", False)
@@ -193,7 +196,7 @@ class Predict(Phase):
                 threshold = self.getConfig("fixedThreshold", False)
                 threshold = threshold or self.getData("threshold", list, generate=False)
                 da = DataManipulation.getInstance(manipulationAfterPredict, "test", self.project.config, threshold=threshold)
-                prediction, _ = da((prediction, dummyY))
+                prediction, _ = da((prediction, dummyY), index=0)
 
         return prediction
 

{sleepyphases-0.7.0 → 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.7.0 → sleepyphases-0.8.2}/SleePyPhases/phases/ThresholdOptimisation.py

@@ -35,7 +35,7 @@ class ThresholdOptimisation(Phase):
         truth = []
         for i in tqdm(range(0, len(validationData))):
             x, t = validationData[i]
-            p = model.predict(x, get_likelihood=True, returnNumpy=False)
+            p = model.predict(x, returnNumpy=False)
             p, t = da((p, t))
             [prediction.append(x) for x in p]
             [truth.append(x) for x in t]
@@ -49,7 +49,7 @@ class ThresholdOptimisation(Phase):
         thresholdMetrics = self.getConfig("thresholdMetric", None)
         thresholdMetrics = thresholdMetrics if isinstance(thresholdMetrics, list) else [thresholdMetrics] 
 
-        classNums = self.getConfig("model.multiclassificationSize", [2])
+        classNums = self.getConfig("numClasses", [2])
         labelNames = self.getConfig("classification.labelNames")
         ignoreIndex = self.getConfig("classification.ignoreIndex", -1)
         optimizeThresholdFor = self.getConfig("optimizeThresholdFor", None)
@@ -62,6 +62,7 @@ class ThresholdOptimisation(Phase):
             s.noTN = self.getConfig("eventEval.tnStrat", "eventcount") == "noTN"
             s.trace = True
 
+        classNums = [cn if cn == 1 else 2 for cn in classNums]
 
         manipulationAfterPredict = self.getConfig("eventEval.manipulationAfterPredict", False)
         daSteps = self.getConfig("eventEval.augmentationCountThatShouldNotBeOptimized", 0)
@@ -69,11 +70,11 @@ class ThresholdOptimisation(Phase):
 
         # get Validation data
         if self.storeValidationPrediction:
-            # Calculate validation data fresh for each optimization (not stored)
-            prediction, truth = self.calculateValidationData()
-        else:
             # Use stored validation data
             prediction, truth = self.getData("validationResult", tuple)
+        else:
+            # Calculate validation data fresh for each optimization call, to save disk space
+            prediction, truth = self.calculateValidationData()
 
         def score(threshold, p, t, scorerIndex, scorerName, optimizeMetric):
             biggerIsBetter = scorer.getMetricDefinition(optimizeMetric)[2]

{sleepyphases-0.7.0 → 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.7.0 → sleepyphases-0.8.2}/SleePyPhases/phases/Validation.py

@@ -21,7 +21,7 @@ class Validation(Phase):
         validationData = self.project.generateData("dataset-validation")
 
         for x, t in tqdm(validationData):
-            p = model.predict(x, get_likelihood=True, returnNumpy=True)
+            p = model.predict(x, returnNumpy=True)
             scorer.score(t, p, trace=True)
 
         res = scorer.scoreAllRecords()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.7.0
+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.7.0 → sleepyphases-0.8.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="SleePyPhases",
-    version="v0.7.0"[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.7.0 → 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