gaitsetpy.preprocessing

preprocessing: Preprocessing pipelines for gait data.

This module provides both the new class-based preprocessors and legacy function-based API. All preprocessors inherit from BasePreprocessor and are registered with the PreprocessingManager.

Features:

Clipping and normalization
Noise removal (moving average, frequency filtering)
Outlier detection and removal
Baseline and drift correction
Artifact removal and trend removal
DC offset correction

Maintainer: @aharshit123456

View Source

  1"""
  2preprocessing: Preprocessing pipelines for gait data.
  3
  4This module provides both the new class-based preprocessors and legacy function-based API.
  5All preprocessors inherit from BasePreprocessor and are registered with the PreprocessingManager.
  6
  7Features:
  8- Clipping and normalization
  9- Noise removal (moving average, frequency filtering)
 10- Outlier detection and removal
 11- Baseline and drift correction
 12- Artifact removal and trend removal
 13- DC offset correction
 14
 15Maintainer: @aharshit123456
 16"""
 17
 18# Import the new class-based preprocessors
 19from .preprocessors import (
 20    ClippingPreprocessor,
 21    NoiseRemovalPreprocessor,
 22    OutlierRemovalPreprocessor,
 23    BaselineRemovalPreprocessor,
 24    DriftRemovalPreprocessor,
 25    HighFrequencyNoiseRemovalPreprocessor,
 26    LowFrequencyNoiseRemovalPreprocessor,
 27    ArtifactRemovalPreprocessor,
 28    TrendRemovalPreprocessor,
 29    DCOffsetRemovalPreprocessor
 30)
 31
 32# Import legacy functions for backward compatibility
 33from .pipeline import (
 34    clip_sliding_windows,
 35    remove_noise,
 36    remove_outliers,
 37    remove_baseline,
 38    remove_drift,
 39    remove_artifacts,
 40    remove_trend,
 41    remove_dc_offset,
 42    remove_high_frequency_noise,
 43    remove_low_frequency_noise
 44)
 45
 46# Import managers
 47from ..core.managers import PreprocessingManager
 48
 49# Register all preprocessors with the manager
 50def _register_preprocessors():
 51    """Register all available preprocessors with the PreprocessingManager."""
 52    manager = PreprocessingManager()
 53    manager.register_preprocessor("clipping", ClippingPreprocessor)
 54    manager.register_preprocessor("noise_removal", NoiseRemovalPreprocessor)
 55    manager.register_preprocessor("outlier_removal", OutlierRemovalPreprocessor)
 56    manager.register_preprocessor("baseline_removal", BaselineRemovalPreprocessor)
 57    manager.register_preprocessor("drift_removal", DriftRemovalPreprocessor)
 58    manager.register_preprocessor("high_frequency_noise_removal", HighFrequencyNoiseRemovalPreprocessor)
 59    manager.register_preprocessor("low_frequency_noise_removal", LowFrequencyNoiseRemovalPreprocessor)
 60    manager.register_preprocessor("artifact_removal", ArtifactRemovalPreprocessor)
 61    manager.register_preprocessor("trend_removal", TrendRemovalPreprocessor)
 62    manager.register_preprocessor("dc_offset_removal", DCOffsetRemovalPreprocessor)
 63
 64# Auto-register preprocessors when module is imported
 65_register_preprocessors()
 66
 67# Convenient access to the preprocessing manager
 68def get_preprocessing_manager():
 69    """Get the singleton PreprocessingManager instance."""
 70    return PreprocessingManager()
 71
 72# Helper function to get available preprocessors
 73def get_available_preprocessors():
 74    """Get list of available preprocessor names."""
 75    return PreprocessingManager().get_available_components()
 76
 77# Helper function to preprocess data using manager
 78def preprocess_data(preprocessor_name: str, data, **kwargs):
 79    """
 80    Preprocess data using the PreprocessingManager.
 81    
 82    Args:
 83        preprocessor_name: Name of the preprocessor
 84        data: Input data to preprocess
 85        **kwargs: Additional arguments for preprocessing
 86        
 87    Returns:
 88        Preprocessed data
 89    """
 90    return PreprocessingManager().preprocess_data(preprocessor_name, data, **kwargs)
 91
 92# Pipeline function for chaining multiple preprocessors
 93def create_preprocessing_pipeline(preprocessor_names: list, **kwargs):
 94    """
 95    Create a preprocessing pipeline with multiple preprocessors.
 96    
 97    Args:
 98        preprocessor_names: List of preprocessor names to chain
 99        **kwargs: Additional arguments for individual preprocessors
100        
101    Returns:
102        Function that applies all preprocessors in sequence
103    """
104    manager = PreprocessingManager()
105    
106    def pipeline(data):
107        processed_data = data
108        for name in preprocessor_names:
109            preprocessor = manager.get_cached_instance(name, name, f"{name} preprocessor")
110            processed_data = preprocessor.fit_transform(processed_data, **kwargs.get(name, {}))
111        return processed_data
112    
113    return pipeline
114
115__all__ = [
116    # New class-based preprocessors
117    'ClippingPreprocessor',
118    'NoiseRemovalPreprocessor',
119    'OutlierRemovalPreprocessor',
120    'BaselineRemovalPreprocessor',
121    'DriftRemovalPreprocessor',
122    'HighFrequencyNoiseRemovalPreprocessor',
123    'LowFrequencyNoiseRemovalPreprocessor',
124    'ArtifactRemovalPreprocessor',
125    'TrendRemovalPreprocessor',
126    'DCOffsetRemovalPreprocessor',
127    # Legacy functions for backward compatibility
128    'clip_sliding_windows',
129    'remove_noise',
130    'remove_outliers',
131    'remove_baseline',
132    'remove_drift',
133    'remove_artifacts',
134    'remove_trend',
135    'remove_dc_offset',
136    'remove_high_frequency_noise',
137    'remove_low_frequency_noise',
138    # Manager functions
139    'get_preprocessing_manager',
140    'get_available_preprocessors',
141    'preprocess_data',
142    'create_preprocessing_pipeline'
143]

class ClippingPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

18class ClippingPreprocessor(BasePreprocessor):
19    """
20    Preprocessor for clipping values to a specified range.
21    """
22    
23    def __init__(self, min_val: float = -1, max_val: float = 1):
24        super().__init__(
25            name="clipping",
26            description="Clips values in the data to be within a specified range"
27        )
28        self.config = {
29            'min_val': min_val,
30            'max_val': max_val
31        }
32    
33    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
34        """
35        Fit the preprocessor (no fitting needed for clipping).
36        
37        Args:
38            data: Input data to fit on
39            **kwargs: Additional arguments
40        """
41        # Update config with any passed arguments
42        self.config.update({k: v for k, v in kwargs.items() if k in ['min_val', 'max_val']})
43        self.fitted = True
44    
45    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
46        """
47        Clip values in the data to be within the specified range.
48        
49        Args:
50            data: Input data to transform
51            **kwargs: Additional arguments
52            
53        Returns:
54            Clipped data
55        """
56        min_val = kwargs.get('min_val', self.config['min_val'])
57        max_val = kwargs.get('max_val', self.config['max_val'])
58        
59        return np.clip(data, min_val, max_val)

Preprocessor for clipping values to a specified range.

ClippingPreprocessor(min_val: float = -1, max_val: float = 1) View Source

23    def __init__(self, min_val: float = -1, max_val: float = 1):
24        super().__init__(
25            name="clipping",
26            description="Clips values in the data to be within a specified range"
27        )
28        self.config = {
29            'min_val': min_val,
30            'max_val': max_val
31        }

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

33    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
34        """
35        Fit the preprocessor (no fitting needed for clipping).
36        
37        Args:
38            data: Input data to fit on
39            **kwargs: Additional arguments
40        """
41        # Update config with any passed arguments
42        self.config.update({k: v for k, v in kwargs.items() if k in ['min_val', 'max_val']})
43        self.fitted = True

Fit the preprocessor (no fitting needed for clipping).

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

45    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
46        """
47        Clip values in the data to be within the specified range.
48        
49        Args:
50            data: Input data to transform
51            **kwargs: Additional arguments
52            
53        Returns:
54            Clipped data
55        """
56        min_val = kwargs.get('min_val', self.config['min_val'])
57        max_val = kwargs.get('max_val', self.config['max_val'])
58        
59        return np.clip(data, min_val, max_val)

Clip values in the data to be within the specified range.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Clipped data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class NoiseRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

 62class NoiseRemovalPreprocessor(BasePreprocessor):
 63    """
 64    Preprocessor for removing noise using moving average filter.
 65    """
 66    
 67    def __init__(self, window_size: int = 5):
 68        super().__init__(
 69            name="noise_removal",
 70            description="Applies a moving average filter to reduce noise"
 71        )
 72        self.config = {
 73            'window_size': window_size
 74        }
 75    
 76    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
 77        """
 78        Fit the preprocessor (no fitting needed for noise removal).
 79        
 80        Args:
 81            data: Input data to fit on
 82            **kwargs: Additional arguments
 83        """
 84        self.config.update({k: v for k, v in kwargs.items() if k in ['window_size']})
 85        self.fitted = True
 86    
 87    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
 88        """
 89        Apply a moving average filter to reduce noise.
 90        
 91        Args:
 92            data: Input data to transform
 93            **kwargs: Additional arguments
 94            
 95        Returns:
 96            Noise-reduced data
 97        """
 98        window_size = kwargs.get('window_size', self.config['window_size'])
 99        
100        if isinstance(data, pd.DataFrame):
101            return data.rolling(window=window_size, center=True).mean().bfill().ffill()
102        elif isinstance(data, pd.Series):
103            return data.rolling(window=window_size, center=True).mean().bfill().ffill()
104        else:
105            # For numpy arrays, use uniform filter
106            from scipy.ndimage import uniform_filter1d
107            return uniform_filter1d(data, size=window_size, mode='nearest')

Preprocessor for removing noise using moving average filter.

NoiseRemovalPreprocessor(window_size: int = 5) View Source

67    def __init__(self, window_size: int = 5):
68        super().__init__(
69            name="noise_removal",
70            description="Applies a moving average filter to reduce noise"
71        )
72        self.config = {
73            'window_size': window_size
74        }

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

76    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
77        """
78        Fit the preprocessor (no fitting needed for noise removal).
79        
80        Args:
81            data: Input data to fit on
82            **kwargs: Additional arguments
83        """
84        self.config.update({k: v for k, v in kwargs.items() if k in ['window_size']})
85        self.fitted = True

Fit the preprocessor (no fitting needed for noise removal).

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

 87    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
 88        """
 89        Apply a moving average filter to reduce noise.
 90        
 91        Args:
 92            data: Input data to transform
 93            **kwargs: Additional arguments
 94            
 95        Returns:
 96            Noise-reduced data
 97        """
 98        window_size = kwargs.get('window_size', self.config['window_size'])
 99        
100        if isinstance(data, pd.DataFrame):
101            return data.rolling(window=window_size, center=True).mean().bfill().ffill()
102        elif isinstance(data, pd.Series):
103            return data.rolling(window=window_size, center=True).mean().bfill().ffill()
104        else:
105            # For numpy arrays, use uniform filter
106            from scipy.ndimage import uniform_filter1d
107            return uniform_filter1d(data, size=window_size, mode='nearest')

Apply a moving average filter to reduce noise.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Noise-reduced data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class OutlierRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

110class OutlierRemovalPreprocessor(BasePreprocessor):
111    """
112    Preprocessor for removing outliers using Z-score method.
113    """
114    
115    def __init__(self, threshold: float = 3):
116        super().__init__(
117            name="outlier_removal",
118            description="Removes outliers beyond a given threshold using the Z-score method"
119        )
120        self.config = {
121            'threshold': threshold
122        }
123        self.mean_ = None
124        self.std_ = None
125    
126    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
127        """
128        Fit the preprocessor by computing mean and standard deviation.
129        
130        Args:
131            data: Input data to fit on
132            **kwargs: Additional arguments
133        """
134        self.config.update({k: v for k, v in kwargs.items() if k in ['threshold']})
135        
136        if isinstance(data, (pd.DataFrame, pd.Series)):
137            self.mean_ = data.mean()
138            self.std_ = data.std()
139        else:
140            self.mean_ = np.mean(data)
141            self.std_ = np.std(data)
142        
143        self.fitted = True
144    
145    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
146        """
147        Remove outliers beyond the threshold using Z-score method.
148        
149        Args:
150            data: Input data to transform
151            **kwargs: Additional arguments
152            
153        Returns:
154            Data with outliers removed
155        """
156        threshold = kwargs.get('threshold', self.config['threshold'])
157        
158        if isinstance(data, (pd.DataFrame, pd.Series)):
159            z_scores = (data - self.mean_).abs() / self.std_
160            return data[z_scores <= threshold]
161        else:
162            z_scores = np.abs(data - self.mean_) / self.std_
163            return data[z_scores <= threshold]

Preprocessor for removing outliers using Z-score method.

OutlierRemovalPreprocessor(threshold: float = 3) View Source

115    def __init__(self, threshold: float = 3):
116        super().__init__(
117            name="outlier_removal",
118            description="Removes outliers beyond a given threshold using the Z-score method"
119        )
120        self.config = {
121            'threshold': threshold
122        }
123        self.mean_ = None
124        self.std_ = None

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

mean_

std_

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

126    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
127        """
128        Fit the preprocessor by computing mean and standard deviation.
129        
130        Args:
131            data: Input data to fit on
132            **kwargs: Additional arguments
133        """
134        self.config.update({k: v for k, v in kwargs.items() if k in ['threshold']})
135        
136        if isinstance(data, (pd.DataFrame, pd.Series)):
137            self.mean_ = data.mean()
138            self.std_ = data.std()
139        else:
140            self.mean_ = np.mean(data)
141            self.std_ = np.std(data)
142        
143        self.fitted = True

Fit the preprocessor by computing mean and standard deviation.

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

145    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
146        """
147        Remove outliers beyond the threshold using Z-score method.
148        
149        Args:
150            data: Input data to transform
151            **kwargs: Additional arguments
152            
153        Returns:
154            Data with outliers removed
155        """
156        threshold = kwargs.get('threshold', self.config['threshold'])
157        
158        if isinstance(data, (pd.DataFrame, pd.Series)):
159            z_scores = (data - self.mean_).abs() / self.std_
160            return data[z_scores <= threshold]
161        else:
162            z_scores = np.abs(data - self.mean_) / self.std_
163            return data[z_scores <= threshold]

Remove outliers beyond the threshold using Z-score method.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Data with outliers removed

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class BaselineRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

166class BaselineRemovalPreprocessor(BasePreprocessor):
167    """
168    Preprocessor for removing baseline by subtracting the mean.
169    """
170    
171    def __init__(self):
172        super().__init__(
173            name="baseline_removal",
174            description="Removes baseline by subtracting the mean"
175        )
176        self.mean_ = None
177    
178    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
179        """
180        Fit the preprocessor by computing the mean.
181        
182        Args:
183            data: Input data to fit on
184            **kwargs: Additional arguments
185        """
186        if isinstance(data, (pd.DataFrame, pd.Series)):
187            self.mean_ = data.mean()
188        else:
189            self.mean_ = np.mean(data)
190        
191        self.fitted = True
192    
193    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
194        """
195        Remove baseline by subtracting the mean.
196        
197        Args:
198            data: Input data to transform
199            **kwargs: Additional arguments
200            
201        Returns:
202            Baseline-corrected data
203        """
204        return data - self.mean_

Preprocessor for removing baseline by subtracting the mean.

BaselineRemovalPreprocessor() View Source

171    def __init__(self):
172        super().__init__(
173            name="baseline_removal",
174            description="Removes baseline by subtracting the mean"
175        )
176        self.mean_ = None

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

mean_

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

178    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
179        """
180        Fit the preprocessor by computing the mean.
181        
182        Args:
183            data: Input data to fit on
184            **kwargs: Additional arguments
185        """
186        if isinstance(data, (pd.DataFrame, pd.Series)):
187            self.mean_ = data.mean()
188        else:
189            self.mean_ = np.mean(data)
190        
191        self.fitted = True

Fit the preprocessor by computing the mean.

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

193    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
194        """
195        Remove baseline by subtracting the mean.
196        
197        Args:
198            data: Input data to transform
199            **kwargs: Additional arguments
200            
201        Returns:
202            Baseline-corrected data
203        """
204        return data - self.mean_

Remove baseline by subtracting the mean.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Baseline-corrected data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; config; fitted; fit_transform; configure; get_info

class DriftRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

207class DriftRemovalPreprocessor(BasePreprocessor):
208    """
209    Preprocessor for removing low-frequency drift using high-pass filter.
210    """
211    
212    def __init__(self, cutoff: float = 0.01, fs: int = 100):
213        super().__init__(
214            name="drift_removal",
215            description="Removes low-frequency drift using a high-pass filter"
216        )
217        self.config = {
218            'cutoff': cutoff,
219            'fs': fs
220        }
221    
222    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
223        """
224        Fit the preprocessor (no fitting needed for drift removal).
225        
226        Args:
227            data: Input data to fit on
228            **kwargs: Additional arguments
229        """
230        self.config.update({k: v for k, v in kwargs.items() if k in ['cutoff', 'fs']})
231        self.fitted = True
232    
233    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
234        """
235        Remove low-frequency drift using a high-pass filter.
236        
237        Args:
238            data: Input data to transform
239            **kwargs: Additional arguments
240            
241        Returns:
242            Drift-corrected data
243        """
244        cutoff = kwargs.get('cutoff', self.config['cutoff'])
245        fs = kwargs.get('fs', self.config['fs'])
246        
247        b, a = butter(1, cutoff / (fs / 2), btype='highpass')
248        
249        if isinstance(data, (pd.DataFrame, pd.Series)):
250            return pd.Series(filtfilt(b, a, data), index=data.index)
251        else:
252            return filtfilt(b, a, data)

Preprocessor for removing low-frequency drift using high-pass filter.

DriftRemovalPreprocessor(cutoff: float = 0.01, fs: int = 100) View Source

212    def __init__(self, cutoff: float = 0.01, fs: int = 100):
213        super().__init__(
214            name="drift_removal",
215            description="Removes low-frequency drift using a high-pass filter"
216        )
217        self.config = {
218            'cutoff': cutoff,
219            'fs': fs
220        }

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

222    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
223        """
224        Fit the preprocessor (no fitting needed for drift removal).
225        
226        Args:
227            data: Input data to fit on
228            **kwargs: Additional arguments
229        """
230        self.config.update({k: v for k, v in kwargs.items() if k in ['cutoff', 'fs']})
231        self.fitted = True

Fit the preprocessor (no fitting needed for drift removal).

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

233    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
234        """
235        Remove low-frequency drift using a high-pass filter.
236        
237        Args:
238            data: Input data to transform
239            **kwargs: Additional arguments
240            
241        Returns:
242            Drift-corrected data
243        """
244        cutoff = kwargs.get('cutoff', self.config['cutoff'])
245        fs = kwargs.get('fs', self.config['fs'])
246        
247        b, a = butter(1, cutoff / (fs / 2), btype='highpass')
248        
249        if isinstance(data, (pd.DataFrame, pd.Series)):
250            return pd.Series(filtfilt(b, a, data), index=data.index)
251        else:
252            return filtfilt(b, a, data)

Remove low-frequency drift using a high-pass filter.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Drift-corrected data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class HighFrequencyNoiseRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

255class HighFrequencyNoiseRemovalPreprocessor(BasePreprocessor):
256    """
257    Preprocessor for removing high-frequency noise using low-pass filter.
258    """
259    
260    def __init__(self, cutoff: float = 10, fs: int = 100):
261        super().__init__(
262            name="high_frequency_noise_removal",
263            description="Applies a low-pass filter to remove high-frequency noise"
264        )
265        self.config = {
266            'cutoff': cutoff,
267            'fs': fs
268        }
269    
270    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
271        """
272        Fit the preprocessor (no fitting needed for filtering).
273        
274        Args:
275            data: Input data to fit on
276            **kwargs: Additional arguments
277        """
278        self.config.update({k: v for k, v in kwargs.items() if k in ['cutoff', 'fs']})
279        self.fitted = True
280    
281    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
282        """
283        Apply a low-pass filter to remove high-frequency noise.
284        
285        Args:
286            data: Input data to transform
287            **kwargs: Additional arguments
288            
289        Returns:
290            Filtered data
291        """
292        cutoff = kwargs.get('cutoff', self.config['cutoff'])
293        fs = kwargs.get('fs', self.config['fs'])
294        
295        b, a = butter(1, cutoff / (fs / 2), btype='lowpass')
296        
297        if isinstance(data, (pd.DataFrame, pd.Series)):
298            return pd.Series(filtfilt(b, a, data), index=data.index)
299        else:
300            return filtfilt(b, a, data)

Preprocessor for removing high-frequency noise using low-pass filter.

HighFrequencyNoiseRemovalPreprocessor(cutoff: float = 10, fs: int = 100) View Source

260    def __init__(self, cutoff: float = 10, fs: int = 100):
261        super().__init__(
262            name="high_frequency_noise_removal",
263            description="Applies a low-pass filter to remove high-frequency noise"
264        )
265        self.config = {
266            'cutoff': cutoff,
267            'fs': fs
268        }

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

270    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
271        """
272        Fit the preprocessor (no fitting needed for filtering).
273        
274        Args:
275            data: Input data to fit on
276            **kwargs: Additional arguments
277        """
278        self.config.update({k: v for k, v in kwargs.items() if k in ['cutoff', 'fs']})
279        self.fitted = True

Fit the preprocessor (no fitting needed for filtering).

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

281    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
282        """
283        Apply a low-pass filter to remove high-frequency noise.
284        
285        Args:
286            data: Input data to transform
287            **kwargs: Additional arguments
288            
289        Returns:
290            Filtered data
291        """
292        cutoff = kwargs.get('cutoff', self.config['cutoff'])
293        fs = kwargs.get('fs', self.config['fs'])
294        
295        b, a = butter(1, cutoff / (fs / 2), btype='lowpass')
296        
297        if isinstance(data, (pd.DataFrame, pd.Series)):
298            return pd.Series(filtfilt(b, a, data), index=data.index)
299        else:
300            return filtfilt(b, a, data)

Apply a low-pass filter to remove high-frequency noise.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Filtered data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class LowFrequencyNoiseRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

303class LowFrequencyNoiseRemovalPreprocessor(BasePreprocessor):
304    """
305    Preprocessor for removing low-frequency noise using high-pass filter.
306    """
307    
308    def __init__(self, cutoff: float = 0.5, fs: int = 100):
309        super().__init__(
310            name="low_frequency_noise_removal",
311            description="Applies a high-pass filter to remove low-frequency noise"
312        )
313        self.config = {
314            'cutoff': cutoff,
315            'fs': fs
316        }
317    
318    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
319        """
320        Fit the preprocessor (no fitting needed for filtering).
321        
322        Args:
323            data: Input data to fit on
324            **kwargs: Additional arguments
325        """
326        self.config.update({k: v for k, v in kwargs.items() if k in ['cutoff', 'fs']})
327        self.fitted = True
328    
329    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
330        """
331        Apply a high-pass filter to remove low-frequency noise.
332        
333        Args:
334            data: Input data to transform
335            **kwargs: Additional arguments
336            
337        Returns:
338            Filtered data
339        """
340        cutoff = kwargs.get('cutoff', self.config['cutoff'])
341        fs = kwargs.get('fs', self.config['fs'])
342        
343        b, a = butter(1, cutoff / (fs / 2), btype='highpass')
344        
345        if isinstance(data, (pd.DataFrame, pd.Series)):
346            return pd.Series(filtfilt(b, a, data), index=data.index)
347        else:
348            return filtfilt(b, a, data)

Preprocessor for removing low-frequency noise using high-pass filter.

LowFrequencyNoiseRemovalPreprocessor(cutoff: float = 0.5, fs: int = 100) View Source

308    def __init__(self, cutoff: float = 0.5, fs: int = 100):
309        super().__init__(
310            name="low_frequency_noise_removal",
311            description="Applies a high-pass filter to remove low-frequency noise"
312        )
313        self.config = {
314            'cutoff': cutoff,
315            'fs': fs
316        }

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

318    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
319        """
320        Fit the preprocessor (no fitting needed for filtering).
321        
322        Args:
323            data: Input data to fit on
324            **kwargs: Additional arguments
325        """
326        self.config.update({k: v for k, v in kwargs.items() if k in ['cutoff', 'fs']})
327        self.fitted = True

Fit the preprocessor (no fitting needed for filtering).

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

329    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
330        """
331        Apply a high-pass filter to remove low-frequency noise.
332        
333        Args:
334            data: Input data to transform
335            **kwargs: Additional arguments
336            
337        Returns:
338            Filtered data
339        """
340        cutoff = kwargs.get('cutoff', self.config['cutoff'])
341        fs = kwargs.get('fs', self.config['fs'])
342        
343        b, a = butter(1, cutoff / (fs / 2), btype='highpass')
344        
345        if isinstance(data, (pd.DataFrame, pd.Series)):
346            return pd.Series(filtfilt(b, a, data), index=data.index)
347        else:
348            return filtfilt(b, a, data)

Apply a high-pass filter to remove low-frequency noise.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Filtered data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class ArtifactRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

351class ArtifactRemovalPreprocessor(BasePreprocessor):
352    """
353    Preprocessor for removing artifacts by interpolating missing values.
354    """
355    
356    def __init__(self, method: str = "linear"):
357        super().__init__(
358            name="artifact_removal",
359            description="Removes artifacts by interpolating missing values"
360        )
361        self.config = {
362            'method': method
363        }
364    
365    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
366        """
367        Fit the preprocessor (no fitting needed for interpolation).
368        
369        Args:
370            data: Input data to fit on
371            **kwargs: Additional arguments
372        """
373        self.config.update({k: v for k, v in kwargs.items() if k in ['method']})
374        self.fitted = True
375    
376    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
377        """
378        Remove artifacts by interpolating missing values.
379        
380        Args:
381            data: Input data to transform
382            **kwargs: Additional arguments
383            
384        Returns:
385            Artifact-free data
386        """
387        method = kwargs.get('method', self.config['method'])
388        
389        if isinstance(data, (pd.DataFrame, pd.Series)):
390            return data.interpolate(method=method).bfill().ffill()
391        else:
392            # For numpy arrays, use linear interpolation
393            from scipy.interpolate import interp1d
394            x = np.arange(len(data))
395            valid_mask = ~np.isnan(data)
396            if np.any(valid_mask):
397                f = interp1d(x[valid_mask], data[valid_mask], kind='linear', fill_value='extrapolate')
398                return f(x)
399            else:
400                return data

Preprocessor for removing artifacts by interpolating missing values.

ArtifactRemovalPreprocessor(method: str = 'linear') View Source

356    def __init__(self, method: str = "linear"):
357        super().__init__(
358            name="artifact_removal",
359            description="Removes artifacts by interpolating missing values"
360        )
361        self.config = {
362            'method': method
363        }

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

365    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
366        """
367        Fit the preprocessor (no fitting needed for interpolation).
368        
369        Args:
370            data: Input data to fit on
371            **kwargs: Additional arguments
372        """
373        self.config.update({k: v for k, v in kwargs.items() if k in ['method']})
374        self.fitted = True

Fit the preprocessor (no fitting needed for interpolation).

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

376    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
377        """
378        Remove artifacts by interpolating missing values.
379        
380        Args:
381            data: Input data to transform
382            **kwargs: Additional arguments
383            
384        Returns:
385            Artifact-free data
386        """
387        method = kwargs.get('method', self.config['method'])
388        
389        if isinstance(data, (pd.DataFrame, pd.Series)):
390            return data.interpolate(method=method).bfill().ffill()
391        else:
392            # For numpy arrays, use linear interpolation
393            from scipy.interpolate import interp1d
394            x = np.arange(len(data))
395            valid_mask = ~np.isnan(data)
396            if np.any(valid_mask):
397                f = interp1d(x[valid_mask], data[valid_mask], kind='linear', fill_value='extrapolate')
398                return f(x)
399            else:
400                return data

Remove artifacts by interpolating missing values.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Artifact-free data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class TrendRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

403class TrendRemovalPreprocessor(BasePreprocessor):
404    """
405    Preprocessor for removing trends using polynomial fitting.
406    """
407    
408    def __init__(self, order: int = 2):
409        super().__init__(
410            name="trend_removal",
411            description="Removes trends using polynomial fitting"
412        )
413        self.config = {
414            'order': order
415        }
416    
417    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
418        """
419        Fit the preprocessor (no fitting needed for detrending).
420        
421        Args:
422            data: Input data to fit on
423            **kwargs: Additional arguments
424        """
425        self.config.update({k: v for k, v in kwargs.items() if k in ['order']})
426        self.fitted = True
427    
428    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
429        """
430        Remove trends using polynomial fitting.
431        
432        Args:
433            data: Input data to transform
434            **kwargs: Additional arguments
435            
436        Returns:
437            Detrended data
438        """
439        order = kwargs.get('order', self.config['order'])
440        
441        if isinstance(data, (pd.DataFrame, pd.Series)):
442            x = np.arange(len(data))
443            poly_coeffs = np.polyfit(x, data, order)
444            trend = np.polyval(poly_coeffs, x)
445            return data - trend
446        else:
447            x = np.arange(len(data))
448            poly_coeffs = np.polyfit(x, data, order)
449            trend = np.polyval(poly_coeffs, x)
450            return data - trend

Preprocessor for removing trends using polynomial fitting.

TrendRemovalPreprocessor(order: int = 2) View Source

408    def __init__(self, order: int = 2):
409        super().__init__(
410            name="trend_removal",
411            description="Removes trends using polynomial fitting"
412        )
413        self.config = {
414            'order': order
415        }

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

config

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

417    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
418        """
419        Fit the preprocessor (no fitting needed for detrending).
420        
421        Args:
422            data: Input data to fit on
423            **kwargs: Additional arguments
424        """
425        self.config.update({k: v for k, v in kwargs.items() if k in ['order']})
426        self.fitted = True

Fit the preprocessor (no fitting needed for detrending).

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

428    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
429        """
430        Remove trends using polynomial fitting.
431        
432        Args:
433            data: Input data to transform
434            **kwargs: Additional arguments
435            
436        Returns:
437            Detrended data
438        """
439        order = kwargs.get('order', self.config['order'])
440        
441        if isinstance(data, (pd.DataFrame, pd.Series)):
442            x = np.arange(len(data))
443            poly_coeffs = np.polyfit(x, data, order)
444            trend = np.polyval(poly_coeffs, x)
445            return data - trend
446        else:
447            x = np.arange(len(data))
448            poly_coeffs = np.polyfit(x, data, order)
449            trend = np.polyval(poly_coeffs, x)
450            return data - trend

Remove trends using polynomial fitting.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: Detrended data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; fitted; fit_transform; configure; get_info

class DCOffsetRemovalPreprocessor(gaitsetpy.core.base_classes.BasePreprocessor): View Source

453class DCOffsetRemovalPreprocessor(BasePreprocessor):
454    """
455    Preprocessor for removing DC offset by subtracting the mean.
456    """
457    
458    def __init__(self):
459        super().__init__(
460            name="dc_offset_removal",
461            description="Removes DC offset by subtracting the mean"
462        )
463        self.mean_ = None
464    
465    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
466        """
467        Fit the preprocessor by computing the mean.
468        
469        Args:
470            data: Input data to fit on
471            **kwargs: Additional arguments
472        """
473        if isinstance(data, (pd.DataFrame, pd.Series)):
474            self.mean_ = data.mean()
475        else:
476            self.mean_ = np.mean(data)
477        
478        self.fitted = True
479    
480    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
481        """
482        Remove DC offset by subtracting the mean.
483        
484        Args:
485            data: Input data to transform
486            **kwargs: Additional arguments
487            
488        Returns:
489            DC-corrected data
490        """
491        return data - self.mean_

Preprocessor for removing DC offset by subtracting the mean.

DCOffsetRemovalPreprocessor() View Source

458    def __init__(self):
459        super().__init__(
460            name="dc_offset_removal",
461            description="Removes DC offset by subtracting the mean"
462        )
463        self.mean_ = None

Initialize the preprocessor.

Args: name: Name of the preprocessor description: Description of the preprocessor

mean_

def fit( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs): View Source

465    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
466        """
467        Fit the preprocessor by computing the mean.
468        
469        Args:
470            data: Input data to fit on
471            **kwargs: Additional arguments
472        """
473        if isinstance(data, (pd.DataFrame, pd.Series)):
474            self.mean_ = data.mean()
475        else:
476            self.mean_ = np.mean(data)
477        
478        self.fitted = True

Fit the preprocessor by computing the mean.

Args: data: Input data to fit on **kwargs: Additional arguments

def transform( self, data: Union[pandas.core.frame.DataFrame, numpy.ndarray], **kwargs) -> Union[pandas.core.frame.DataFrame, numpy.ndarray]: View Source

480    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
481        """
482        Remove DC offset by subtracting the mean.
483        
484        Args:
485            data: Input data to transform
486            **kwargs: Additional arguments
487            
488        Returns:
489            DC-corrected data
490        """
491        return data - self.mean_

Remove DC offset by subtracting the mean.

Args: data: Input data to transform **kwargs: Additional arguments

Returns: DC-corrected data

Inherited Members

gaitsetpy.core.base_classes.BasePreprocessor: name; description; config; fitted; fit_transform; configure; get_info

def clip_sliding_windows(data, min_val=-1, max_val=1): View Source

15def clip_sliding_windows(data, min_val=-1, max_val=1):
16    """
17    Clip values in the sliding windows to be within a specified range.
18    """
19    return np.clip(data, min_val, max_val)

Clip values in the sliding windows to be within a specified range.

def remove_noise(data, window_size=5): View Source

21def remove_noise(data, window_size=5):
22    """
23    Apply a moving average filter to reduce noise.
24    """
25    return data.rolling(window=window_size, center=True).mean().fillna(method="bfill").fillna(method="ffill")

Apply a moving average filter to reduce noise.

def remove_outliers(data, threshold=3): View Source

27def remove_outliers(data, threshold=3):
28    """
29    Remove outliers beyond a given threshold using the Z-score method.
30    """
31    mean, std = data.mean(), data.std()
32    return data[(data - mean).abs() <= threshold * std]

Remove outliers beyond a given threshold using the Z-score method.

def remove_baseline(data): View Source

34def remove_baseline(data):
35    """
36    Remove baseline by subtracting the mean.
37    """
38    return data - data.mean()

Remove baseline by subtracting the mean.

def remove_drift(data, cutoff=0.01, fs=100): View Source

40def remove_drift(data, cutoff=0.01, fs=100):
41    """
42    Remove low-frequency drift using a high-pass filter.
43    """
44    b, a = butter(1, cutoff / (fs / 2), btype='highpass')
45    return filtfilt(b, a, data)

Remove low-frequency drift using a high-pass filter.

def remove_artifacts(data, method='interpolate'): View Source

47def remove_artifacts(data, method="interpolate"):
48    """
49    Remove artifacts by interpolating missing values.
50    """
51    return data.interpolate(method="linear").fillna(method="bfill").fillna(method="ffill")

Remove artifacts by interpolating missing values.

def remove_trend(data, order=2): View Source

53def remove_trend(data, order=2):
54    """
55    Remove trends using polynomial fitting.
56    """
57    x = np.arange(len(data))
58    poly_coeffs = np.polyfit(x, data, order)
59    trend = np.polyval(poly_coeffs, x)
60    return data - trend

Remove trends using polynomial fitting.

def remove_dc_offset(data): View Source

62def remove_dc_offset(data):
63    """
64    Remove DC offset by subtracting the mean.
65    """
66    return data - data.mean()

Remove DC offset by subtracting the mean.

def remove_high_frequency_noise(data, cutoff=10, fs=100): View Source

68def remove_high_frequency_noise(data, cutoff=10, fs=100):
69    """
70    Apply a low-pass filter to remove high-frequency noise.
71    """
72    b, a = butter(1, cutoff / (fs / 2), btype='lowpass')
73    return filtfilt(b, a, data)

Apply a low-pass filter to remove high-frequency noise.

def remove_low_frequency_noise(data, cutoff=0.5, fs=100): View Source

75def remove_low_frequency_noise(data, cutoff=0.5, fs=100):
76    """
77    Apply a high-pass filter to remove low-frequency noise.
78    """
79    b, a = butter(1, cutoff / (fs / 2), btype='highpass')
80    return filtfilt(b, a, data)

Apply a high-pass filter to remove low-frequency noise.

def get_preprocessing_manager(): View Source

69def get_preprocessing_manager():
70    """Get the singleton PreprocessingManager instance."""
71    return PreprocessingManager()

Get the singleton PreprocessingManager instance.

def get_available_preprocessors(): View Source

74def get_available_preprocessors():
75    """Get list of available preprocessor names."""
76    return PreprocessingManager().get_available_components()

Get list of available preprocessor names.

def preprocess_data(preprocessor_name: str, data, **kwargs): View Source

79def preprocess_data(preprocessor_name: str, data, **kwargs):
80    """
81    Preprocess data using the PreprocessingManager.
82    
83    Args:
84        preprocessor_name: Name of the preprocessor
85        data: Input data to preprocess
86        **kwargs: Additional arguments for preprocessing
87        
88    Returns:
89        Preprocessed data
90    """
91    return PreprocessingManager().preprocess_data(preprocessor_name, data, **kwargs)

Preprocess data using the PreprocessingManager.

Args: preprocessor_name: Name of the preprocessor data: Input data to preprocess **kwargs: Additional arguments for preprocessing

Returns: Preprocessed data

def create_preprocessing_pipeline(preprocessor_names: list, **kwargs): View Source

 94def create_preprocessing_pipeline(preprocessor_names: list, **kwargs):
 95    """
 96    Create a preprocessing pipeline with multiple preprocessors.
 97    
 98    Args:
 99        preprocessor_names: List of preprocessor names to chain
100        **kwargs: Additional arguments for individual preprocessors
101        
102    Returns:
103        Function that applies all preprocessors in sequence
104    """
105    manager = PreprocessingManager()
106    
107    def pipeline(data):
108        processed_data = data
109        for name in preprocessor_names:
110            preprocessor = manager.get_cached_instance(name, name, f"{name} preprocessor")
111            processed_data = preprocessor.fit_transform(processed_data, **kwargs.get(name, {}))
112        return processed_data
113    
114    return pipeline

Create a preprocessing pipeline with multiple preprocessors.

Args: preprocessor_names: List of preprocessor names to chain **kwargs: Additional arguments for individual preprocessors

Returns: Function that applies all preprocessors in sequence