paradigma 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

paradigma/classification.py

@@ -1,14 +1,19 @@
-import numpy as np
 import pickle
-
 from pathlib import Path
-from sklearn.base import BaseEstimator
 from typing import Any, Optional
 
+import numpy as np
+from sklearn.base import BaseEstimator
+from sklearn.preprocessing import StandardScaler
+
+
 class ClassifierPackage:
-    def __init__(self, classifier: Optional[BaseEstimator] = None, 
-                 threshold: Optional[float] = None, 
-                 scaler: Optional[Any] = None):
+    def __init__(
+        self,
+        classifier: Optional[BaseEstimator] = None,
+        threshold: Optional[float] = None,
+        scaler: Optional[Any] = None,
+    ):
         """
         Initialize the ClassifierPackage with a classifier, threshold, and scaler.
 
@@ -43,6 +48,18 @@ class ClassifierPackage:
             return X
         return self.scaler.transform(X)
 
+    def update_scaler(self, x_train: np.ndarray) -> None:
+        """
+        Update the scaler used for feature transformation.
+
+        Parameters
+        ----------
+        x_train : np.ndarray
+            The training data to fit the scaler.
+        """
+        scaler = StandardScaler()
+        self.scaler = scaler.fit(x_train)
+
     def predict_proba(self, X) -> float:
         """
         Make predictions using the classifier and apply the threshold.
@@ -61,7 +78,7 @@ class ClassifierPackage:
         if not self.classifier:
             raise ValueError("Classifier is not loaded.")
         return self.classifier.predict_proba(X)[:, 1]
-    
+
     def predict(self, X) -> int:
         """
         Make predictions using the classifier and apply the threshold.
@@ -80,7 +97,7 @@ class ClassifierPackage:
         if not self.classifier:
             raise ValueError("Classifier is not loaded.")
         return int(self.predict_proba(X) >= self.threshold)
-    
+
     def save(self, filepath: str | Path) -> None:
         """
         Save the ClassifierPackage to a file.
@@ -90,7 +107,7 @@ class ClassifierPackage:
         filepath : str
             The path to the file.
         """
-        with open(filepath, 'wb') as f:
+        with open(filepath, "wb") as f:
             pickle.dump(self, f)
 
     @classmethod
@@ -109,7 +126,7 @@ class ClassifierPackage:
             The loaded classifier package.
         """
         try:
-            with open(filepath, 'rb') as f:
+            with open(filepath, "rb") as f:
                 return pickle.load(f)
         except Exception as e:
-            raise ValueError(f"Failed to load classifier package: {e}") from e
+            raise ValueError(f"Failed to load classifier package: {e}") from e

paradigma/config.py

@@ -1,12 +1,17 @@
+import warnings
+from dataclasses import asdict
 from typing import Dict, List
-from paradigma.constants import DataColumns, DataUnits
+
 import numpy as np
 
+from paradigma.constants import DataColumns, DataUnits
+
+
 class BaseConfig:
     def __init__(self) -> None:
-        self.meta_filename = ''
-        self.values_filename = ''
-        self.time_filename = ''
+        self.meta_filename = ""
+        self.values_filename = ""
+        self.time_filename = ""
 
     def set_sensor(self, sensor: str) -> None:
         """Sets the sensor and derived filenames"""
@@ -15,7 +20,7 @@ class BaseConfig:
 
     def set_filenames(self, prefix: str) -> None:
         """Sets the filenames based on the prefix. This method is duplicated from `gaits_analysis_config.py`.
-        
+
         Parameters
         ----------
         prefix : str
@@ -25,48 +30,67 @@ class BaseConfig:
         self.time_filename = f"{prefix}_time.bin"
         self.values_filename = f"{prefix}_values.bin"
 
+
 class IMUConfig(BaseConfig):
+    """
+    IMU configuration that uses DataColumns() to dynamically map available channels.
+    Works even if only accelerometer or only gyroscope data is present.
+    """
 
-    def __init__(self) -> None:
+    def __init__(self, column_mapping: dict[str, str] | None = None) -> None:
         super().__init__()
-
-        self.set_filenames('IMU')
+        self.set_filenames("IMU")
 
         self.acceleration_units = DataUnits.ACCELERATION
         self.rotation_units = DataUnits.ROTATION
-
         self.axes = ["x", "y", "z"]
 
-        self.accelerometer_cols: List[str] = [
-            DataColumns.ACCELEROMETER_X,
-            DataColumns.ACCELEROMETER_Y,
-            DataColumns.ACCELEROMETER_Z,
-        ]
-        self.gyroscope_cols: List[str] = [
-            DataColumns.GYROSCOPE_X,
-            DataColumns.GYROSCOPE_Y,
-            DataColumns.GYROSCOPE_Z,
-        ]
-        self.gravity_cols: List[str] = [
-            DataColumns.GRAV_ACCELEROMETER_X,
-            DataColumns.GRAV_ACCELEROMETER_Y,
-            DataColumns.GRAV_ACCELEROMETER_Z,
+        # Generate a default mapping or override with user-provided mapping
+        default_mapping = asdict(DataColumns())
+        self.column_mapping = {**default_mapping, **(column_mapping or {})}
+
+        self.time_colname = self.column_mapping["TIME"]
+
+        self.accelerometer_colnames: List[str] = []
+        self.gyroscope_colnames: List[str] = []
+        self.gravity_colnames: List[str] = []
+
+        self.d_channels_accelerometer: Dict[str, str] = {}
+        self.d_channels_gyroscope: Dict[str, str] = {}
+
+        accel_keys = ["ACCELEROMETER_X", "ACCELEROMETER_Y", "ACCELEROMETER_Z"]
+        grav_keys = [
+            "GRAV_ACCELEROMETER_X",
+            "GRAV_ACCELEROMETER_Y",
+            "GRAV_ACCELEROMETER_Z",
         ]
+        gyro_keys = ["GYROSCOPE_X", "GYROSCOPE_Y", "GYROSCOPE_Z"]
 
-        self.d_channels_accelerometer = {
-            DataColumns.ACCELEROMETER_X: self.acceleration_units,
-            DataColumns.ACCELEROMETER_Y: self.acceleration_units,
-            DataColumns.ACCELEROMETER_Z: self.acceleration_units,
-        }
-        self.d_channels_gyroscope = {
-            DataColumns.GYROSCOPE_X: self.rotation_units,
-            DataColumns.GYROSCOPE_Y: self.rotation_units,
-            DataColumns.GYROSCOPE_Z: self.rotation_units,
+        if all(k in self.column_mapping for k in accel_keys):
+            self.accelerometer_colnames = [self.column_mapping[k] for k in accel_keys]
+
+            if all(k in self.column_mapping for k in grav_keys):
+                self.gravity_colnames = [self.column_mapping[k] for k in grav_keys]
+
+            self.d_channels_accelerometer = {
+                c: self.acceleration_units for c in self.accelerometer_colnames
+            }
+
+        if all(k in self.column_mapping for k in gyro_keys):
+            self.gyroscope_colnames = [self.column_mapping[k] for k in gyro_keys]
+
+            self.d_channels_gyroscope = {
+                c: self.rotation_units for c in self.gyroscope_colnames
+            }
+
+        self.d_channels_imu: Dict[str, str] = {
+            **self.d_channels_accelerometer,
+            **self.d_channels_gyroscope,
         }
-        self.d_channels_imu = {**self.d_channels_accelerometer, **self.d_channels_gyroscope}
 
         self.sampling_frequency = 100
         self.resampling_frequency = 100
+        self.tolerance = 3 * 1 / self.sampling_frequency
         self.lower_cutoff_frequency = 0.2
         self.upper_cutoff_frequency = 3.5
         self.filter_order = 4
@@ -74,30 +98,36 @@ class IMUConfig(BaseConfig):
 
 class PPGConfig(BaseConfig):
 
-    def __init__(self) -> None:
+    def __init__(self, column_mapping: dict[str, str] | None = None) -> None:
         super().__init__()
 
-        self.set_filenames('PPG')
+        self.set_filenames("PPG")
 
-        self.ppg_colname = DataColumns.PPG
+        # Generate a default mapping or override with user-provided mapping
+        default_mapping = asdict(DataColumns())
+        self.column_mapping = {**default_mapping, **(column_mapping or {})}
+
+        self.time_colname = self.column_mapping["TIME"]
+        self.ppg_colname = self.column_mapping["PPG"]
 
         self.sampling_frequency = 30
+        self.resampling_frequency = 30
+        self.tolerance = 3 * 1 / self.sampling_frequency
         self.lower_cutoff_frequency = 0.4
         self.upper_cutoff_frequency = 3.5
         self.filter_order = 4
 
-        self.d_channels_ppg = {
-            DataColumns.PPG: DataUnits.NONE
-        }
+        self.d_channels_ppg = {self.ppg_colname: DataUnits.NONE}
 
 
 # Domain base configs
 class GaitConfig(IMUConfig):
 
-    def __init__(self, step) -> None:
-        super().__init__()
+    def __init__(self, step, column_mapping: dict[str, str] | None = None) -> None:
+        # Pass column_mapping through to IMUConfig
+        super().__init__(column_mapping=column_mapping)
 
-        self.set_sensor('accelerometer')
+        self.set_sensor("accelerometer")
 
         # ----------
         # Segmenting
@@ -105,7 +135,7 @@ class GaitConfig(IMUConfig):
         self.max_segment_gap_s = 1.5
         self.min_segment_length_s = 1.5
 
-        if step == 'gait':
+        if step == "gait":
             self.window_length_s: float = 6
             self.window_step_length_s: float = 1
         else:
@@ -166,11 +196,15 @@ class GaitConfig(IMUConfig):
         }
 
         for mfcc_coef in range(1, self.mfcc_n_coefficients + 1):
-            self.d_channels_values[f"accelerometer_mfcc_{mfcc_coef}"] = DataUnits.GRAVITY
+            self.d_channels_values[f"accelerometer_mfcc_{mfcc_coef}"] = (
+                DataUnits.GRAVITY
+            )
 
-        if step == 'arm_activity':
+        if step == "arm_activity":
             for mfcc_coef in range(1, self.mfcc_n_coefficients + 1):
-                self.d_channels_values[f"gyroscope_mfcc_{mfcc_coef}"] = DataUnits.GRAVITY
+                self.d_channels_values[f"gyroscope_mfcc_{mfcc_coef}"] = (
+                    DataUnits.GRAVITY
+                )
 
 
 class TremorConfig(IMUConfig):
@@ -184,7 +218,7 @@ class TremorConfig(IMUConfig):
         """
         super().__init__()
 
-        self.set_sensor('gyroscope')
+        self.set_sensor("gyroscope")
 
         # ----------
         # Segmenting
@@ -195,12 +229,12 @@ class TremorConfig(IMUConfig):
         # -----------------
         # Feature extraction
         # -----------------
-        self.window_type = 'hann'
+        self.window_type = "hann"
         self.overlap_fraction: float = 0.8
         self.segment_length_psd_s: float = 3
         self.segment_length_spectrogram_s: float = 2
         self.spectral_resolution: float = 0.25
-        
+
         # PSD based features
         self.fmin_peak_search: float = 1
         self.fmax_peak_search: float = 25
@@ -223,13 +257,13 @@ class TremorConfig(IMUConfig):
         # -----------
         # Aggregation
         # -----------
-        self.aggregates_tremor_power: List[str] = ['mode_binned', 'median', '90p']
-        self.evaluation_points_tremor_power: np.ndarray = np.linspace(0, 6, 301) 
+        self.aggregates_tremor_power: List[str] = ["mode_binned", "median", "90p"]
+        self.evaluation_points_tremor_power: np.ndarray = np.linspace(0, 6, 301)
 
         # -----------------
         # TSDF data storage
         # -----------------
-        if step == 'features':
+        if step == "features":
             self.d_channels_values: Dict[str, str] = {}
             for mfcc_coef in range(1, self.n_coefficients_mfcc + 1):
                 self.d_channels_values[f"mfcc_{mfcc_coef}"] = "unitless"
@@ -237,81 +271,102 @@ class TremorConfig(IMUConfig):
             self.d_channels_values["freq_peak"] = "Hz"
             self.d_channels_values["below_tremor_power"] = "(deg/s)^2"
             self.d_channels_values["tremor_power"] = "(deg/s)^2"
-        elif step == 'classification':
+        elif step == "classification":
             self.d_channels_values = {
                 DataColumns.PRED_TREMOR_PROBA: "probability",
                 DataColumns.PRED_TREMOR_LOGREG: "boolean",
                 DataColumns.PRED_TREMOR_CHECKED: "boolean",
-                DataColumns.PRED_ARM_AT_REST: "boolean"
+                DataColumns.PRED_ARM_AT_REST: "boolean",
             }
 
-        
+
 class PulseRateConfig(PPGConfig):
-    def __init__(self, sensor: str = 'ppg', min_window_length_s: int = 30) -> None:
+    def __init__(
+        self,
+        sensor: str = "ppg",
+        ppg_sampling_frequency: int = 30,
+        imu_sampling_frequency: int | None = None,
+        min_window_length_s: int = 30,
+        accelerometer_colnames: list[str] | None = None,
+    ) -> None:
         super().__init__()
 
-        # ----------
-        # Segmenting
-        # ----------
+        self.ppg_sampling_frequency = ppg_sampling_frequency
+
+        if sensor == "imu":
+            if imu_sampling_frequency is not None:
+                self.imu_sampling_frequency = imu_sampling_frequency
+            else:
+                self.imu_sampling_frequency = IMUConfig().sampling_frequency
+                warnings.warn(
+                    f"imu_sampling_frequency not provided, using default of {self.imu_sampling_frequency} Hz"
+                )
+
+        # Windowing parameters
         self.window_length_s: int = 6
         self.window_step_length_s: int = 1
         self.window_overlap_s = self.window_length_s - self.window_step_length_s
 
-        self.accelerometer_cols = IMUConfig().accelerometer_cols
+        self.accelerometer_colnames = accelerometer_colnames
 
-        # -----------------------
-        # Signal quality analysis
-        # -----------------------
-        self.freq_band_physio = [0.75, 3] # Hz
-        self.bandwidth = 0.2   # Hz      
-        self.freq_bin_resolution = 0.05 # Hz
+        # Signal quality analysis parameters
+        self.freq_band_physio = [0.75, 3]  # Hz
+        self.bandwidth = 0.2  # Hz
+        self.freq_bin_resolution = 0.05  # Hz
 
-        # ---------------------
-        # Pulse rate estimation
-        # ---------------------
-        self.set_tfd_length(min_window_length_s)  # Set tfd length to default of 30 seconds
+        # Pulse rate estimation parameters
         self.threshold_sqa = 0.5
         self.threshold_sqa_accelerometer = 0.10
 
+        # Set initial sensor and update sampling-dependent params
+        self.set_sensor(sensor, min_window_length_s)
+
+    def set_sensor(self, sensor: str, min_window_length_s: int | None = None) -> None:
+        """Sets the active sensor and recomputes sampling-dependent parameters."""
+        if sensor not in ["ppg", "imu"]:
+            raise ValueError(f"Invalid sensor type: {sensor}")
+        self.sensor = sensor
+
+        # Decide which frequency to use
+        self.sampling_frequency = (
+            self.imu_sampling_frequency
+            if sensor == "imu"
+            else self.ppg_sampling_frequency
+        )
+
+        # Update all frequency-dependent parameters
+        if min_window_length_s is not None:
+            self._update_sampling_dependent_params(min_window_length_s)
+        else:
+            # Reuse previous tfd_length if it exists, else fallback to 30
+            self._update_sampling_dependent_params(getattr(self, "tfd_length", 30))
+
+    def _update_sampling_dependent_params(self, tfd_length: int):
+        """Compute attributes that depend on sampling frequency."""
+
+        # --- PPG-dependent parameters ---
+        self.tfd_length = tfd_length
+        self.min_pr_samples = int(round(self.tfd_length * self.ppg_sampling_frequency))
+
         pr_est_length = 2  # pulse rate estimation length in seconds
-        self.pr_est_samples = pr_est_length * self.sampling_frequency
+        self.pr_est_samples = pr_est_length * self.ppg_sampling_frequency
 
         # Time-frequency distribution parameters
-        self.kern_type = 'sep'
-        win_type_doppler = 'hamm'
-        win_type_lag = 'hamm'
+        win_type_doppler = "hamm"
+        win_type_lag = "hamm"
         win_length_doppler = 8
         win_length_lag = 1
-        doppler_samples = self.sampling_frequency * win_length_doppler
-        lag_samples = win_length_lag * self.sampling_frequency
+        doppler_samples = self.ppg_sampling_frequency * win_length_doppler
+        lag_samples = win_length_lag * self.ppg_sampling_frequency
+        self.kern_type = "sep"
         self.kern_params = {
-            'doppler': {
-                'win_length': doppler_samples,
-                'win_type': win_type_doppler,
-            },
-            'lag': {
-                'win_length': lag_samples,
-                'win_type': win_type_lag,
-            }
+            "doppler": {"win_length": doppler_samples, "win_type": win_type_doppler},
+            "lag": {"win_length": lag_samples, "win_type": win_type_lag},
         }
 
-        self.set_sensor(sensor)
-
-    def set_tfd_length(self, tfd_length: int):
-        self.tfd_length = tfd_length
-        self.min_pr_samples = int(round(self.tfd_length * self.sampling_frequency))
-
-    def set_sensor(self, sensor):
-        self.sensor = sensor 
-
-        if sensor not in ['ppg', 'imu']:
-            raise ValueError(f"Invalid sensor type: {sensor}")
-        
-        if sensor == 'imu':
-            self.sampling_frequency = IMUConfig().sampling_frequency
-        else:
-            self.sampling_frequency = PPGConfig().sampling_frequency
-
+        # --- Welch / FFT parameters based on current sensor frequency ---
         self.window_length_welch = 3 * self.sampling_frequency
         self.overlap_welch_window = self.window_length_welch // 2
-        self.nfft = len(np.arange(0, self.sampling_frequency/2, self.freq_bin_resolution))*2
+        self.nfft = (
+            len(np.arange(0, self.sampling_frequency / 2, self.freq_bin_resolution)) * 2
+        )

paradigma/constants.py

@@ -2,39 +2,40 @@ from dataclasses import dataclass
 
 
 @dataclass(frozen=True)
-class DataColumns():
+class DataColumns:
     """
     Class containing the data channels in `tsdf`.
     """
-    ACCELEROMETER_X : str = "accelerometer_x"
-    ACCELEROMETER_Y : str = "accelerometer_y"
-    ACCELEROMETER_Z : str = "accelerometer_z"
-    GYROSCOPE_X : str = "gyroscope_x"
-    GYROSCOPE_Y : str = "gyroscope_y"
-    GYROSCOPE_Z : str = "gyroscope_z"
-    PPG : str = "green"
-    TIME : str = "time"
-    SEGMENT_NR : str = "segment_nr"
+
+    ACCELEROMETER_X: str = "accelerometer_x"
+    ACCELEROMETER_Y: str = "accelerometer_y"
+    ACCELEROMETER_Z: str = "accelerometer_z"
+    GYROSCOPE_X: str = "gyroscope_x"
+    GYROSCOPE_Y: str = "gyroscope_y"
+    GYROSCOPE_Z: str = "gyroscope_z"
+    PPG: str = "green"
+    TIME: str = "time"
+    SEGMENT_NR: str = "segment_nr"
     SEGMENT_CAT: str = "segment_category"
 
-    # Gait 
-    GRAV_ACCELEROMETER_X : str = "accelerometer_x_grav"
-    GRAV_ACCELEROMETER_Y : str = "accelerometer_y_grav"
-    GRAV_ACCELEROMETER_Z : str = "accelerometer_z_grav"
+    # Gait
+    GRAV_ACCELEROMETER_X: str = "accelerometer_x_grav"
+    GRAV_ACCELEROMETER_Y: str = "accelerometer_y_grav"
+    GRAV_ACCELEROMETER_Z: str = "accelerometer_z_grav"
     PRED_GAIT_PROBA: str = "pred_gait_proba"
-    PRED_GAIT : str = "pred_gait"
+    PRED_GAIT: str = "pred_gait"
     PRED_NO_OTHER_ARM_ACTIVITY_PROBA: str = "pred_no_other_arm_activity_proba"
-    PRED_NO_OTHER_ARM_ACTIVITY : str = "pred_no_other_arm_activity"
-    ANGLE : str = "angle"
-    VELOCITY : str = "velocity"
+    PRED_NO_OTHER_ARM_ACTIVITY: str = "pred_no_other_arm_activity"
+    ANGLE: str = "angle"
+    VELOCITY: str = "velocity"
     DOMINANT_FREQUENCY: str = "dominant_frequency"
     RANGE_OF_MOTION: str = "range_of_motion"
     PEAK_VELOCITY: str = "peak_velocity"
 
     # The following are used in tremor analysis
     PRED_TREMOR_PROBA: str = "pred_tremor_proba"
-    PRED_TREMOR_LOGREG : str = "pred_tremor_logreg"
-    PRED_TREMOR_CHECKED : str = "pred_tremor_checked"
+    PRED_TREMOR_LOGREG: str = "pred_tremor_logreg"
+    PRED_TREMOR_CHECKED: str = "pred_tremor_checked"
     PRED_ARM_AT_REST: str = "pred_arm_at_rest"
 
     # Constants for PPG features
@@ -60,47 +61,51 @@ class DataColumns():
 
     # Constants for pulse rate
     PULSE_RATE: str = "pulse_rate"
-    
+
+
 @dataclass(frozen=True)
-class DataUnits():
+class DataUnits:
     """
     Class containing the data channel unit types in `tsdf`.
     """
+
     ACCELERATION: str = "m/s^2"
     """ The acceleration is in m/s^2. """
-    
+
     ROTATION: str = "deg/s"
     """ The rotation is in degrees per second. """
-    
+
     GRAVITY: str = "g"
     """ The acceleration due to gravity is in g. """
-    
+
     POWER_SPECTRAL_DENSITY: str = "g^2/Hz"
     """ The power spectral density is in g^2/Hz. """
-    
+
     FREQUENCY: str = "Hz"
     """ The frequency is in Hz. """
 
     NONE: str = "none"
     """ The data channel has no unit. """
-    
+
 
 @dataclass(frozen=True)
-class TimeUnit():
+class TimeUnit:
     """
     Class containing the `time` channel unit types in `tsdf`.
     """
-    RELATIVE_MS : str = "relative_ms"
+
+    RELATIVE_MS: str = "relative_ms"
     """ The time is relative to the start time in milliseconds. """
-    RELATIVE_S : str = "relative_s"
+    RELATIVE_S: str = "relative_s"
     """ The time is relative to the start time in seconds. """
-    ABSOLUTE_MS : str = "absolute_ms"
+    ABSOLUTE_MS: str = "absolute_ms"
     """ The time is absolute in milliseconds. """
-    ABSOLUTE_S : str = "absolute_s"
+    ABSOLUTE_S: str = "absolute_s"
     """ The time is absolute in seconds. """
-    DIFFERENCE_MS : str = "difference_ms"
+    DIFFERENCE_MS: str = "difference_ms"
     """ The time is the difference between consecutive samples in milliseconds. """
-    DIFFERENCE_S : str = "difference_s"
+    DIFFERENCE_S: str = "difference_s"
     """ The time is the difference between consecutive samples in seconds. """
 
+
 UNIX_TICKS_MS: int = 1000