SleePyPhases 0.3.0__tar.gz → 0.4.0__tar.gz

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.3.0
+Version: 0.4.0
 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.3.0 → sleepyphases-0.4.0}/SleePyPhases/PSGEventManager.py

@@ -74,7 +74,7 @@ class PSGEventManager(EventManager):
                 "SlowEyeMovement",
                 "Spindle-eeg",
             ],
-            "fail": [  # maximal 32 for 32bit integer
+            "fail": [  # maximal 31 for 32bit integer
                 "workingSignal",
                 "fail-channel0",
                 "fail-channel1",
@@ -106,7 +106,6 @@ class PSGEventManager(EventManager):
                 "fail-channel27",
                 "fail-channel28",
                 "fail-channel29",
-                "fail-channel30",
             ],
             "limb": ["noneLegmovement", "LegMovement-Left", "LegMovement-Right", "LegMovement"],
             "spo2": [

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/SleePyPhases/Plugin.py

@@ -3,6 +3,7 @@ from pyPhasesRecordloader import RecordLoader
 
 from SleepHarmonizer.recordwriter.RecordWriter import RecordWriter
 
+from SleePyPhases.phases.ExtractFeatures import ExtractFeatures
 from SleePyPhases.phases.Extract import Extract
 from SleePyPhases.phases.Setup import Setup
 from SleePyPhases.phases.BuildDataset import BuildDataset
@@ -12,6 +13,7 @@ from SleePyPhases.phases.Eval import Eval
 from SleePyPhases.phases.EvalReport import EvalReport
 from SleePyPhases.phases.ThresholdOptimisation import ThresholdOptimisation
 from SleePyPhases.phases.TestRun import TestRun
+from SleePyPhases.phases.ExtractFeatures import ExtractFeatures
 
 
 from pyPhases.exporter.PickleExporter import PickleExporter
@@ -33,8 +35,8 @@ class Plugin(PluginAdapter):
             "ThresholdOptimisation": (ThresholdOptimisation, ["threshold", "validationResult"]),
             "Eval": (Eval, ["evalResults", "eventResults"]),
             "EvalReport": (EvalReport, []),
-            "TestRun": (TestRun, [])
-
+            "ExtractFeatures": (ExtractFeatures, ["features"]),
+            "TestRun": (TestRun, []),
         }
         dataMap = {
             "features": ["metadata"],
@@ -69,8 +71,5 @@ class Plugin(PluginAdapter):
         project.registerExporter(ModelExporter({"basePath": dataPath}))
         project.registerExporter(MemmapRecordExporter({"basePath": dataPath}))
 
-        
-    def initPlugin(self):
-        RecordLoader.registerRecordLoader("RecordLoaderTSM", "SleePyPhases.recordloaders")
 
 

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/SleePyPhases/RecordFeatureExtraction.py

@@ -1,17 +1,16 @@
-import pandas as pd
 from typing import List
 
 import numpy as np
+import pandas as pd
 from pandas import DataFrame
+from pyPhases import Swappable
 from pyPhasesML import FeatureExtraction as pyPhasesFeatureExtraction
-from pyPhasesRecordloader import RecordSignal, Signal, Event, ChannelsNotPresent
+from pyPhasesRecordloader import ChannelsNotPresent, Event, RecordSignal, Signal
 
 from SleePyPhases.PSGEventManager import PSGEventManager
 
-class RecordFeatureExtraction(pyPhasesFeatureExtraction):
-    """batchManipulation for the physionet challenge 2023
-    segmentSignal: Recordsignal of the segment with 18 EEG channels
-    """
+
+class RecordFeatureExtraction(pyPhasesFeatureExtraction, Swappable):
 
     def step(self, stepname: str, recordSignal: RecordSignal, eventlist: List[Event], channel=None, **options) -> Signal:
         if hasattr(self, stepname):
@@ -272,67 +271,3 @@ class RecordFeatureExtraction(pyPhasesFeatureExtraction):
 
         return ret
     
-    def spindles(self, segmentSignal: RecordSignal, eventlist: List[Event], channel: str):
-        from .external.sumo.sumo.scripts.a7.butter_filter import butter_bandpass_filter, downsample
-        # from .external.sumo.a7.detect_spindles import detect_spindle
-        from .external.sumo.sumo.scripts.predict_plain_data import SimpleDataset
-        # from .external.sumo.sumo.predict_plain_data import A7
-        import pytorch_lightning as pl
-        from torch.utils.data import Dataset, DataLoader
-        import torch
-        from .external.sumo.sumo.model.sumo import SUMO
-        from .external.sumo.sumo.config.config import Config
-        # from .external.sumo.model.data import spindle_vect_to_indices
-
-        config = Config('predict', create_dirs=False)
-
-        def get_model(p):
-            # p = Path(p)
-
-            model_checkpoint = torch.load(p)
-
-            model = SUMO(config)
-            model.load_state_dict(model_checkpoint['state_dict'])
-
-            return model
-
-        eegSignal = segmentSignal.getSignalByName(channel)
-        resample_rate = 100
-        model_path = "SleePyPhases/external/sumo/sumo/output/final.ckpt"
-        
-        if len(eegSignal.signal) == 0:
-            return None
-
-        eegs = []
-        eegSignal = downsample(butter_bandpass_filter(eegSignal.signal, 0.3, 30.0, eegSignal.frequency, 10), eegSignal.frequency, resample_rate)
-        eegs.append(eegSignal)
-
-        dataset = SimpleDataset(eegs)
-        dataloader = DataLoader(dataset)
-        model = get_model(model_path)
-        trainer = pl.Trainer(num_sanity_val_steps=0, logger=False)
-        predictions = trainer.predict(model, dataloader)
-        pred = predictions[0]
-
-        # spindles_a7 = A7(x, resample_rate)
-        spindle_vect = pred[0].numpy()
-        
-        diff = np.diff(np.r_[0, spindle_vect, 0])  # be able to detect spindles at the start and end of vector
-        spindles = np.c_[np.argwhere(diff == 1), np.argwhere(diff == -1)]  / resample_rate
-        # spindles = spindle_vect_to_indices(spindle_vect) / resample_rate
-
-
-        # frequencies, psd = signal.welch(eegs[0][s.start:s.end()], 
-        #                                 fs=100,
-        #                                 nperseg=min(256, s.duration),
-        #                                 scaling='spectrum')
-        # dominant_freq = frequencies[np.argmax(psd)]
-
-        spindles = [Event("spindle", s[0], s[1] - s[0]) for s in spindles]
-
-        
-        return {
-            "spindles-count": len(spindles),
-            "spindles-mean-druation": np.array([s.duration for s in spindles]).mean()
-        }
-    

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/SleePyPhases/phases/ExtractFeatures.py

@@ -76,7 +76,7 @@ class ExtractFeatures(Phase):
         try:
             recordSignal = recordLoader.getHarmonizedSignal(recordId)
 
-            events: List[Event] = RecordFeatureExtraction(self.project).step(name, recordSignal, *options)
+            events: List[Event] = RecordFeatureExtraction.getInstance().step(name, recordSignal, *options)
 
             if channelType is not None:
                 channelType = [s.name for s in recordSignal.signals if s.typeStr == channelType]
@@ -192,7 +192,7 @@ class ExtractFeatures(Phase):
                 try:
                     idx = (recordId, c)
                     featureStep = featureConfig["type"]
-                    RecordFeatureExtraction(self.project).updateMetadataByStep(featureStep, recordSignal, eventlist, metadata=self.features, channel=c)
+                    RecordFeatureExtraction.getInstance().updateMetadataByStep(featureStep, recordSignal, eventlist, metadata=self.features, channel=c)
                 except ChannelsNotPresent as e:
                     self.logError(f"channels not present: {e.channels}")
 
@@ -209,10 +209,13 @@ class ExtractFeatures(Phase):
         self.features = None
         metadata = self.project.getData("metadata", pd.DataFrame)
         recordIds = metadata["recordId"]
-        forceCalculation = self.getConfig("featureExtraction.features", True)
+        forceCalculation = self.getConfig("featureExtraction.force", False)
 
         reqFeatures = {f["name"]: 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.iloc):
             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

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/SleePyPhases/phases/Setup.py

@@ -8,16 +8,16 @@ from pyPhasesRecordloader import RecordLoader
 
 class Setup(Phase):
     def prepareConfig(self):
-        numLabels = len(self.getConfig("classification.labelNames"))
+        numLabels = len(self.getConfig("classification.labelNames", []))
         self.setConfig("numLabels", numLabels)
 
-        numClasses = [len(c) for c in self.getConfig("classification.classNames")]
+        numClasses = [len(c) for c in self.getConfig("classification.classNames", [])]
         self.setConfig("numClasses", numClasses)
         
-        defaultValidationbatchManipulation = self.getConfig("segmentManipulationEval", self.getConfig("segmentManipulation"))
+        defaultValidationbatchManipulation = self.getConfig("segmentManipulationEval", self.getConfig("segmentManipulation", []))
         self.setConfig("segmentManipulationEval", defaultValidationbatchManipulation)
 
-        preprocessingConfig = self.getConfig("preprocessing")
+        preprocessingConfig = self.getConfig("preprocessing", {})
         if "combineChannels" in preprocessingConfig:
             RecordLoader.get().addCombinedChannels(preprocessingConfig["combineChannels"])
 

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/SleePyPhases/phases/Training.py

@@ -77,6 +77,8 @@ class Training(Phase):
 
         gridOutputs = []
         for fold in range(startfold, endfold):
+            # save model state (random initialisation or pretrained)
+            startState = ModelManager.getModel().model.state_dict()
             self.setConfig("fold", fold)
             # only train if it doesnt allready exist
             self.getData("modelState", Model)
@@ -85,6 +87,8 @@ class Training(Phase):
                 self.project.unregister("modelState")
                 self.project.unregister("modelStateConfig")
             gridOutputs.append(self.gridOutput)
+            # reset model state
+            ModelManager.getModel().model.load_state_dict(startState)
 
         self.project.gridOutput = {
             "epochs": str(np.mean([m["epochs"] for m in gridOutputs])),

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/SleePyPhases.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SleePyPhases
-Version: 0.3.0
+Version: 0.4.0
 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.3.0 → sleepyphases-0.4.0}/SleePyPhases.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ pyproject.toml
 setup.py
 SleePyPhases/DataManipulation.py
 SleePyPhases/EventScorer.py
-SleePyPhases/FeatureExtraction copy.py
 SleePyPhases/FeatureExtraction.py
 SleePyPhases/MultiScorer.py
 SleePyPhases/PSGEventManager.py

{sleepyphases-0.3.0 → sleepyphases-0.4.0}/setup.py

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

sleepyphases-0.3.0/SleePyPhases/FeatureExtraction copy.py

@@ -1,116 +0,0 @@
-from typing import List
-
-import numpy as np
-from pyPhasesML import FeatureExtraction as pyPhasesFeatureExtraction
-from pyPhasesML import ModelManager
-from pyPhasesRecordloader import RecordSignal, Event
-
-from .DataAugmentation import DataAugmentation
-
-
-class FeatureExtraction(pyPhasesFeatureExtraction):
-    """augmentation for the physionet challenge 2023
-    segmentSignal: Recordsignal of the segment with 18 EEG channels
-    """
-
-    def __init__(self, project) -> None:
-        super().__init__()
-        self.project = project
-
-    def time(self, segmentSignal: RecordSignal):
-        segmentLength = segmentSignal.getShape()[1]
-        # segmentLengthInHOurs = segmentLength / segmentSignal.targetFrequency / 3600
-        # hour, minutes = segmentSignal.start.split(":")
-        # startTimeInHours = int(hour) + int(minutes) / 60
-        # endTimeInHours = startTimeInHours + segmentLengthInHOurs
-        hour = segmentSignal.start
-        endTimeInHours = hour + 1
-        return np.linspace(hour, endTimeInHours, segmentLength)
-
-    def featureModel(self, segmentSignal: RecordSignal, featureName: str, xChannels: List[str]):
-        import torch
-        useGPU = torch.cuda.is_available() and False
-        with self.project:
-            config = self.project.config["featureConfigs", featureName]
-            self.project.config.update(config)
-            self.project.addConfig(config)
-
-            self.project.trigger("configChanged", None)
-            self.project.setConfig("trainingParameter.batchSize", 1)
-            self.project.setConfig("recordWise", True)
-
-            modelPath = self.project.getConfig("featureModel", torch)
-
-            # this is needed for mutlithreading
-            ModelManager.loadModel(self.project)
-            # get feature model
-            model = ModelManager.getModel(True)
-            model.useGPU = useGPU
-            state = model.load(modelPath)
-            model.loadState(state)
-            featureModel = model.model.eval()
-
-            featureModel = featureModel.cuda() if useGPU else featureModel.cpu()
-
-            # we assum that the segment is already preprocessed for the model
-            array = segmentSignal.getSignalArray(xChannels, transpose=True)
-
-            da = DataAugmentation(self.project.config, self.project.getConfig("datasetSplit"), recordAnnotations={})
-            array, _ = da.augmentSegment(array, None)
-            array = array.transpose(2, 1, 0)
-
-            features = model.predict(array, get_likelihood=True)
-            _, features = da.restoreLength(None, features, length=segmentSignal.getShape()[1])
-            features = features[:, :, 1]
-
-        return features
-
-    def spindles(self, segmentSignal: RecordSignal): #xChannels: List[str]
-        from .external.sumo.a7.butter_filter import butter_bandpass_filter, downsample
-        # from .external.sumo.a7.detect_spindles import detect_spindle
-        from .external.sumo.predict_plain_data import SimpleDataset
-        from .external.sumo.predict_plain_data import A7
-        import pytorch_lightning as pl
-        from torch.utils.data import Dataset, DataLoader
-        import torch
-        from .external.sumo.model.sumo import SUMO
-        from .external.sumo.model.config import Config
-        # from .external.sumo.model.data import spindle_vect_to_indices
-
-        config = Config('predict', create_dirs=False)
-
-        def get_model(p):
-            # p = Path(p)
-
-            model_checkpoint = torch.load(p)
-
-            model = SUMO(config)
-            model.load_state_dict(model_checkpoint['state_dict'])
-
-            return model
-
-        eegSignals = [s for s in segmentSignal.signals if s.typeStr == "eeg"]
-        resample_rate = 100
-        model_path = "SleePyPhases/external/sumo/model/final.ckpt"
-        
-        eegs = []
-        for eegSignal in eegSignals:
-            eegSignal = downsample(butter_bandpass_filter(eegSignal.signal, 0.3, 30.0, eegSignal.frequency, 10), eegSignal.frequency, resample_rate)
-            eegs.append(eegSignal)
-
-        dataset = SimpleDataset(eegs)
-        dataloader = DataLoader(dataset)
-        model = get_model(model_path)
-        trainer = pl.Trainer(num_sanity_val_steps=0, logger=False)
-        predictions = trainer.predict(model, dataloader)
-
-        for x, pred in zip(eegs, predictions):
-            # spindles_a7 = A7(x, resample_rate)
-            spindle_vect = pred[0].numpy()
-            
-            diff = np.diff(np.r_[0, spindle_vect, 0])  # be able to detect spindles at the start and end of vector
-            spindles = np.c_[np.argwhere(diff == 1), np.argwhere(diff == -1)]  / resample_rate
-            # spindles = spindle_vect_to_indices(spindle_vect) / resample_rate
-
-        
-        return [Event("spindle-slow", 500, 10)]