py-neuromodulation 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

packages/realtime_decoding/build/lib/realtime_decoding/decoder.py

@@ -1,104 +0,0 @@
-import multiprocessing
-import multiprocessing.synchronize
-import pathlib
-import pickle
-import queue
-import tkinter
-import tkinter.filedialog
-from datetime import datetime, timezone
-
-import numpy as np
-import pandas as pd
-import pylsl
-
-import realtime_decoding
-
-from .helpers import _PathLike
-
-_timezone = timezone.utc
-
-
-class Decoder(multiprocessing.Process):
-    """Make predictions in real time."""
-
-    def __init__(
-        self,
-        queue_decoding: multiprocessing.Queue,
-        queue_features: multiprocessing.Queue,
-        interval: float,
-        out_dir: _PathLike,
-        verbose: bool,
-        model_path: _PathLike,
-    ) -> None:
-        super().__init__(name="DecodingProcess")
-        self.queue_decoding = queue_decoding
-        self.queue_feat = queue_features
-        self.interval = interval
-        self.verbose = verbose
-        self.out_dir = pathlib.Path(out_dir)
-
-        self._threshold: float = 0.5
-
-        self.filename = pathlib.Path(model_path)
-
-        with open(self.filename, "rb") as file:
-            self._model = pickle.load(file)
-        self._save_model()
-
-    def _save_model(self) -> None:
-        with open(self.out_dir / self.filename.name, "wb") as file:
-            pickle.dump(self._model, file)
-
-    def clear_queue(self) -> None:
-        for q in (self.queue_feat, self.queue_decoding):
-            realtime_decoding.clear_queue(q)
-
-    def run(self) -> None:
-        labels = ["Prediction", "Probability", "Threshold"]
-
-        info = pylsl.StreamInfo(
-            name="Decoding",
-            type="EEG",
-            channel_count=3,
-            channel_format="double64",
-            source_id="decoding_1",
-        )
-        channels = info.desc().append_child("channels")
-        for label in labels:
-            channels.append_child("channel").append_child_value("label", label)
-        outlet = pylsl.StreamOutlet(info)
-        while True:
-            try:
-                sample = self.queue_feat.get(timeout=10.0)
-            except queue.Empty:
-                break
-            else:
-                if self.verbose:
-                    print("Got features.")
-                if sample is None:
-                    print("Found None value, terminating decoder process.")
-                    break
-
-                # Predict
-                sample_ = sample[[i for i in sample.index if i != "label_train"]]
-
-                y = float(self._model.predict_proba(np.expand_dims(sample_.to_numpy(), 0))[0, 1])
-                print(f"pr: {y}")
-
-                timestamp = np.datetime64(datetime.now(_timezone), "ns")
-
-                output = pd.DataFrame(
-                    [[y >= self._threshold, y, self._threshold]],
-                    columns=labels,
-                    index=[timestamp],
-                )
-                outlet.push_sample(
-                    x=list(output.to_numpy().squeeze()),
-                    timestamp=timestamp.astype(float),
-                )
-        try:
-            self.queue_decoding.put(None, timeout=3.0)
-        except queue.Full:
-            pass
-        self.clear_queue()
-        print(f"Terminating: {self.name}")

packages/realtime_decoding/build/lib/realtime_decoding/features.py

@@ -1,163 +0,0 @@
-import json
-import multiprocessing
-import multiprocessing.synchronize
-import pathlib
-import queue
-import tkinter
-import tkinter.filedialog
-from datetime import datetime
-
-import numpy as np
-import py_neuromodulation as nm
-import pylsl
-from numpy_ringbuffer import RingBuffer
-
-import realtime_decoding
-
-from .helpers import _PathLike
-
-
-class Features(multiprocessing.Process):
-    """Process class to calculate features from LSL stream."""
-
-    def __init__(
-        self,
-        name: str,
-        source_id: str,
-        n_feats: int,
-        sfreq: int,
-        interval: float,
-        queue_raw: multiprocessing.Queue,
-        queue_features: multiprocessing.Queue,
-        path_nm_settings: _PathLike,
-        path_nm_channels: _PathLike,
-        out_dir: _PathLike,
-        verbose: bool,
-        path_grids: str | None = None,
-        line_noise: int | float | None = None,
-        training_samples: int = 60,
-        training_enabled: bool = False,
-    ) -> None:
-        super().__init__(name=f"{name}Process")
-        self.interval = interval
-        self.sfreq = sfreq
-        self.queue_raw = queue_raw
-        self.queue_features = queue_features
-        self.verbose = verbose
-        self.out_dir = pathlib.Path(out_dir)
-        self.finished = multiprocessing.Event()
-        self.path_nm_settings = path_nm_settings
-        self.path_nm_channels = path_nm_channels
-
-        self.processor = nm.nm_run_analysis.DataProcessor(
-            sfreq=self.sfreq,
-            settings=path_nm_settings,
-            nm_channels=path_nm_channels,
-            line_noise=line_noise,
-            path_grids=path_grids,
-            verbose=self.verbose,
-        )
-        self.num_channels = len(self.processor.nm_channels)
-        self.buffer = RingBuffer(
-            capacity=self.sfreq,
-            dtype=(float, self.num_channels),  # type: ignore
-            allow_overwrite=True,
-        )
-        # Channels * Number of different features
-        self.n_feats_total = (
-            sum(self.processor.nm_channels["used"] == 1) * n_feats
-        )
-        self.source_id = source_id
-        self.outlet = None
-        self._save_settings()
-
-        print(f"value of training enabled: {training_enabled}")
-        self.training_enabled = training_enabled
-        if training_enabled is True:
-            print("training is enabled")
-            self.training_counter = 0
-            self.training_samples = training_samples
-            self.training_class = 0 # REST
-
-            # the labels are sent as an additional LSL channel
-            self.n_feats_total = self.n_feats_total + 1
-
-    def _save_settings(self) -> None:
-        # print("SAVING DATA ....")
-        self.processor.nm_channels.to_csv(
-            self.out_dir / self.path_nm_channels, index=False
-        )
-        with open(
-            self.out_dir / self.path_nm_settings,
-            "w",
-            encoding="utf-8",
-        ) as outfile:
-            json.dump(self.processor.settings, outfile)
-
-    def clear_queue(self) -> None:
-        realtime_decoding.clear_queue(self.queue_raw)
-
-    def run(self) -> None:
-        while True:
-            try:
-                sd = self.queue_raw.get(timeout=10.0)
-                # data = self.queue_raw.get(timeout=10.0)
-            except queue.Empty:
-                break
-            else:
-                # print("Got data")
-                if sd is None:
-                    print("Found None value, terminating features process.")
-                    break
-                if self.verbose:
-                    print("Found raw input sample.")
-                # Reshape the samples retrieved from the queue
-                data = np.reshape(
-                    sd.samples,
-                    (sd.num_samples_per_sample_set, sd.num_sample_sets),
-                    order="F",
-                )
-                # data = np.array(samples)  # shape (time, ch)
-                self.buffer.extend(data.T)
-                if not self.buffer.is_full:
-                    continue
-                features = self.processor.process(self.buffer[:].T)
-                timestamp = np.datetime64(datetime.utcnow(), "ns")
-
-                if self.training_enabled is True:
-
-                    # the analog channel data is stored in self.buffer
-                    # this channel can be added to the calculated features, and simply finished with escape
-                    #print(self.buffer[:].T)
-                    #print(f"buffer shape: {self.buffer.shape}")
-                    features["label_train"] = np.mean(self.buffer[-409:, 24])  # get index from analog 
-                try:
-                    self.queue_features.put(features, timeout=self.interval)
-                except queue.Full:
-                    if self.verbose:
-                        print("Features queue Full. Skipping sample.")
-                if self.outlet is None:
-                    info = pylsl.StreamInfo(
-                        name=self.name,
-                        type="EEG",
-                        channel_count=self.n_feats_total,
-                        nominal_srate=self.sfreq,
-                        channel_format="double64",
-                        source_id=self.source_id,
-                    )
-                    channels = info.desc().append_child("channels")
-                    for label in features.index:
-                        channels.append_child("channel").append_child_value(
-                            "label", label
-                        )
-                    self.outlet = pylsl.StreamOutlet(info)
-                self.outlet.push_sample(
-                    x=features.tolist(), timestamp=timestamp.astype(float)
-                )
-
-        try:
-            self.queue_features.put(None, timeout=3.0)
-        except queue.Full:
-            pass
-        self.clear_queue()
-        print(f"Terminating: {self.name}")

packages/realtime_decoding/build/lib/realtime_decoding/helpers.py

@@ -1,15 +0,0 @@
-import os
-import queue
-
-_PathLike = str | os.PathLike
-
-
-def clear_queue(q) -> None:
-    print("Emptying queue.")
-    try:
-        while True:
-            q.get(block=False)
-    except queue.Empty:
-        print("Queue emptied.")
-    except ValueError:  # Queue is already closed
-        print("Queue was already closed.")

packages/realtime_decoding/build/lib/realtime_decoding/run_decoding.py

@@ -1,345 +0,0 @@
-import multiprocessing
-import multiprocessing.synchronize
-import os
-import pathlib
-import queue
-import signal
-import sys
-import time
-from pynput.keyboard import Key, Listener
-from contextlib import contextmanager
-from dataclasses import dataclass, field
-import tkinter
-import tkinter.filedialog
-from typing import Generator, Literal
-
-import TMSiFileFormats
-import TMSiSDK
-
-import realtime_decoding
-
-from .helpers import _PathLike
-
-
-@contextmanager
-def open_tmsi_device(
-    out_dir: _PathLike,
-    tmsi_cfg_file: _PathLike,
-    verbose: bool = True,
-) -> Generator[TMSiSDK.SagaDevice, None, None]:
-
-    out_dir = pathlib.Path(out_dir)
-
-    tmsi_cfg_file = pathlib.Path(tmsi_cfg_file)
-    device = None
-    try:
-        print("Initializing TMSi device...")
-        # Initialise the TMSi-SDK first before starting using it
-        TMSiSDK.initialize()
-        # Execute a device discovery. This returns a list of device-objects.
-        discovery_list = TMSiSDK.discover(
-            TMSiSDK.DeviceType.saga,
-            TMSiSDK.DeviceInterfaceType.docked,
-            TMSiSDK.DeviceInterfaceType.usb,  # .network
-        )
-        if len(discovery_list) == 0:
-            raise ValueError(
-                "No TMSi device found. Please check your connections."
-            )
-        if len(discovery_list) > 1:
-            raise ValueError(
-                "More than one TMSi device found. Please check your"
-                f" connections. Found: {discovery_list}."
-            )
-        # Get the handle to the first discovered device.
-        device = discovery_list[0]
-        print(f"Found device: {device}")
-        device.open()
-        print("Connected to device.")
-        # cfg_file = TMSiSDK.get_config(saga_config)
-        device.load_config(tmsi_cfg_file)
-        TMSiSDK.xml_saga_config.xml_write_config(
-            filename=out_dir / tmsi_cfg_file.name, saga_config=device.config
-        )
-        if verbose:
-            print("\nThe active channels are : ")
-            for idx, ch in enumerate(device.channels):
-                print(
-                    "[{0}] : [{1}] in [{2}]".format(idx, ch.name, ch.unit_name)
-                )
-            print("\nCurrent device configuration:")
-            print(
-                f"Base-sample-rate: \t\t\t{device.config.base_sample_rate} Hz"
-            )
-            print(f"Sample-rate: \t\t\t\t{device.config.sample_rate} Hz")
-            print(f"Reference Method: \t\t\t{device.config.reference_method}")
-            print(
-                f"Sync out configuration: \t{device.config.get_sync_out_config()}"
-            )
-
-        device.start_measurement()
-        if device is None:
-            raise ValueError("No TMSi device found!")
-        yield device
-    except TMSiSDK.TMSiError as error:
-        print("!!! TMSiError !!! : ", error.code)
-        if (
-            device is not None
-            and error.code == TMSiSDK.error.TMSiErrorCode.device_error
-        ):
-            print("  => device error : ", hex(device.status.error))
-            TMSiSDK.DeviceErrorLookupTable(hex(device.status.error))
-    except Exception as exception:
-        if device is not None:
-            if device.status.state == TMSiSDK.DeviceState.sampling:
-                print("Stopping TMSi measurement...")
-                device.stop_measurement()
-            if device.status.state == TMSiSDK.DeviceState.connected:
-                print("Closing TMSi device...")
-                device.close()
-        raise exception
-
-
-@contextmanager
-def open_lsl_stream(
-    device,
-) -> Generator[TMSiFileFormats.FileWriter, None, None]:
-    lsl_stream = TMSiFileFormats.FileWriter(
-        TMSiFileFormats.FileFormat.lsl, "SAGA"
-    )
-    try:
-        lsl_stream.open(device)
-        yield lsl_stream
-    except Exception as exception:
-        print("Closing LSL stream...")
-        lsl_stream.close()
-        raise exception
-
-
-@contextmanager
-def open_poly5_writer(
-    device,
-    out_file: _PathLike,
-) -> Generator[TMSiFileFormats.file_writer.FileWriter, None, None]:
-    out_file = str(out_file)
-    file_writer = TMSiFileFormats.file_writer.FileWriter(
-        TMSiFileFormats.file_writer.FileFormat.poly5, out_file
-    )
-    try:
-        print("Opening poly5 writer")
-        file_writer.open(device)
-        print("Poly 5 writer opened")
-        yield file_writer
-    except Exception as exception:
-        print("Closing Poly5 file writer")
-        file_writer.close()
-        raise exception
-
-
-@dataclass
-class ProcessManager:
-    device: TMSiSDK.SagaDevice
-    lsl_stream: TMSiFileFormats.FileWriter
-    file_writer: TMSiFileFormats.FileWriter
-    out_dir: _PathLike
-    settings: dict
-    timeout: float = 0.05
-    verbose: bool = True
-    _terminated: bool = field(init=False, default=False)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        if isinstance(exc_type, BaseException):
-            if not self._terminated:
-                self.terminate()
-            return False
-
-    def __post_init__(self) -> None:
-        self.out_dir = pathlib.Path(self.out_dir)
-        self.queue_source = multiprocessing.Queue(
-            int(self.timeout * 1000 * 20)
-        )  # seconds/sample * ms/s * s
-        self.queue_raw = multiprocessing.Queue(int(self.timeout * 1000))
-        self.queue_features = multiprocessing.Queue(1)
-        self.queue_decoding = multiprocessing.Queue(1)
-        self.queues = [
-            self.queue_raw,
-            self.queue_features,
-            self.queue_decoding,
-            self.queue_source,
-        ]
-        for q in self.queues:
-            q.cancel_join_thread()
-
-    def start(self) -> None:
-        def on_press(key) -> None:
-            pass
-
-        def on_release(key) -> Literal[False] | None:
-            if key == Key.esc:
-                print("Received stop key.")
-                self.terminate()
-                return False
-
-        listener = Listener(on_press=on_press, on_release=on_release)
-        listener.start()
-        print("Listener started.")
-
-        TMSiSDK.sample_data_server.registerConsumer(
-            self.device.id, self.queue_source
-        )
-        features = realtime_decoding.Features(
-            name="Features",
-            source_id="features_1",
-            n_feats=7,
-            sfreq=self.device.config.sample_rate,
-            interval=self.timeout,
-            queue_raw=self.queue_source,
-            queue_features=self.queue_features,
-            path_nm_settings=self.settings["PATH_pynm_SETTINGS"],
-            path_nm_channels=self.settings["PATH_pynm_CHANNELS"],
-            out_dir=self.out_dir,
-            path_grids=None,
-            line_noise=50,
-            verbose=self.verbose,
-            training_enabled=True,
-            training_samples=20*50
-        )
-        decoder = realtime_decoding.Decoder(
-            queue_decoding=self.queue_decoding,
-            queue_features=self.queue_features,
-            interval=self.timeout,
-            out_dir=self.out_dir,
-            verbose=self.verbose,
-            model_path=self.settings["PATH_MODEL_PREDICT"]
-        )
-        processes = [features, decoder]
-        for process in processes:
-            process.start()
-            time.sleep(0.5)
-        print("Decoding started.")
-
-    def terminate(self) -> None:
-        """Terminate all workers."""
-        print("Terminating experiment...")
-        self._terminated = True
-        try:
-            self.queue_source.put(None, block=False)
-        except queue.Full:
-            self.queue_source.get(block=False)
-            try:
-                self.queue_source.put(None, block=False)
-            except queue.Full:
-                pass
-        print("Set terminating event.")
-        TMSiSDK.sample_data_server.unregisterConsumer(
-            self.device.id, self.queue_source
-        )
-        print("Unregistered consumer.")
-
-        try:
-            self.lsl_stream.close()
-        except Exception:
-            pass
-        try:
-            self.file_writer.close()
-        except Exception:
-            pass
-        if self.device.status.state == TMSiSDK.DeviceState.sampling:
-            self.device.stop_measurement()
-            print("Controlled stopping TMSi measurement...")
-        if self.device.status.state == TMSiSDK.DeviceState.connected:
-            self.device.close()
-            print("Controlled closing TMSi device...")
-
-        # Check if all processes have terminated
-        active_children = multiprocessing.active_children()
-        if not active_children:
-            print("No alive processes found.")
-            sys.exit()
-
-        # Wait for processes to temrinate on their own
-        print(f"Alive processes: {list(p.name for p in active_children)}")
-        print("Waiting for processes to finish. Please wait...")
-        self.wait(active_children, timeout=5)
-        active_children = multiprocessing.active_children()
-        if not active_children:
-            print("No alive processes found.")
-            sys.exit()
-
-        # Try flushing all queues
-        print(f"Alive processes: {(p.name for p in active_children)}")
-        print("Flushing all queues. Please wait...")
-        for queue_ in self.queues:
-            realtime_decoding.clear_queue(queue_)
-        self.wait(active_children, timeout=5)
-        active_children = multiprocessing.active_children()
-        if not active_children:
-            print("No alive processes found.")
-            sys.exit()
-
-        # Try killing all processes gracefully
-        print(f"Alive processes: {(p.name for p in active_children)}")
-        print("Trying to kill processes gracefully. Please wait...")
-        interrupt = (
-            signal.CTRL_C_EVENT if sys.platform == "win32" else signal.SIGINT
-        )
-        for process in active_children:
-            if process.is_alive():
-                os.kill(process.pid, interrupt)
-        self.wait(active_children, timeout=5)
-        active_children = multiprocessing.active_children()
-        if not active_children:
-            print("No alive processes found.")
-            sys.exit()
-
-        # Try forcefully terminating processes
-        print(f"Alive processes: {(p.name for p in active_children)}")
-        print("Terminating processes forcefully.")
-        for process in active_children:
-            if process.is_alive():
-                process.terminate()
-        sys.exit()
-
-    @staticmethod
-    def wait(processes, timeout=None) -> None:
-        """Wait for all workers to die."""
-        if not processes:
-            return
-        start = time.time()
-        while True:
-            try:
-                if all(not process.is_alive() for process in processes):
-                    return
-                if timeout and time.time() - start >= timeout:
-                    return
-                time.sleep(0.1)
-            except Exception:
-                pass
-
-
-def run(
-    config_settings: dict,
-) -> None:
-    """Initialize data processing by launching all necessary processes."""
-    out_dir = pathlib.Path(config_settings["PATH_OUT_DIR"])
-    file_name = config_settings["filename"]
-
-    with (
-        open_tmsi_device(out_dir, config_settings["PATH_XML_CONFIG"]) as device,
-        open_poly5_writer(device, out_dir / file_name) as file_writer,
-        open_lsl_stream(device) as stream,
-    ):
-        manager = ProcessManager(
-            device=device,
-            lsl_stream=stream,
-            file_writer=file_writer,
-            out_dir=out_dir,
-            timeout=0.05,
-            verbose=False,
-            settings=config_settings
-        )
-
-        manager.start()

packages/realtime_decoding/build/lib/realtime_decoding/trainer.py

@@ -1,54 +0,0 @@
-"""
-Read saved features from timeflux .hdf5 file and train model
-"""
-from sklearn import linear_model, model_selection, metrics
-import pickle
-import pandas as pd
-import os
-import numpy as np
-#from matplotlib import pyplot as plt
-
-if __name__ == "__main__":
-
-    sub = "487_train"
-
-    PATH_HDF5_FEATURES = rf"C:\CODE\py_neuromodulation\realtime_experiment\data\sub-{sub}\ses-EcogLfpMedOff01\sub-{sub}_ses-EcogLfpMedOff01_task-RealtimeDecodingR_acq-StimOff_run-1_ieeg.hdf5"
-    PATH_MODEL_SAVE = os.path.join(
-        rf"C:\CODE\py_neuromodulation\realtime_experiment\data\sub-{sub}\ses-EcogLfpMedOff01",
-        "model_trained.p"
-    )
-
-    df = pd.read_hdf(PATH_HDF5_FEATURES, key="features")
-
-    y = np.abs(np.diff(df["label_train"]))
-    X = df[[f for f in df.columns if "time" not in f and "label" not in f]].iloc[1:, :]
-
-    #from matplotlib import pyplot as plt
-    #plt.figure()
-    #plt.plot(np.array(df["label_train"]))
-    #plt.plot(y)
-    #plt.show()
-
-    X_lim = X.iloc[850:, :]
-    y_lim = y[850:]
-
-
-    model = linear_model.LogisticRegression()
-
-    model = model.fit(X, y>0.01)
-    model = model.fit(X_lim, y_lim>0.01)
-
-    with open(PATH_MODEL_SAVE, "wb") as fid:
-        pickle.dump(model, fid)
-
-    pr = model_selection.cross_val_predict(
-        estimator=linear_model.LinearRegression(),
-        X=X_lim,
-        y=y_lim>0.01,
-        cv=model_selection.KFold(n_splits=3, shuffle=False)
-    )
-
-    plt.figure()
-    plt.plot(pr)
-    plt.plot(y_lim)
-    plt.show()