gaitsetpy.features.physionet_features

  1'''
  2PhysioNet VGRF Feature Extractor.
  3Maintainer: @aharshit123456
  4
  5This module contains feature extractors specific to the PhysioNet VGRF dataset,
  6including Local Binary Pattern (LBP) and Fourier series analysis.
  7'''
  8
  9from typing import List, Dict, Any
 10import numpy as np
 11import pandas as pd
 12from scipy.integrate import simpson
 13from scipy.signal import find_peaks
 14from scipy.optimize import curve_fit
 15from scipy import fftpack
 16import logging
 17from tqdm import tqdm
 18from ..core.base_classes import BaseFeatureExtractor
 19
 20# Set up logging
 21logging.basicConfig(level=logging.INFO)
 22logger = logging.getLogger(__name__)
 23
 24
 25class LBPFeatureExtractor(BaseFeatureExtractor):
 26    """
 27    Local Binary Pattern (LBP) feature extractor for VGRF data.
 28    
 29    This extractor converts time-series data into LBP codes and extracts
 30    histogram features from the LBP representation.
 31    """
 32    
 33    def __init__(self, verbose: bool = True):
 34        super().__init__(
 35            name="lbp_features",
 36            description="Local Binary Pattern feature extractor for VGRF time-series data"
 37        )
 38        self.verbose = verbose
 39        self.config = {
 40            'radius': 2,  # LBP radius (number of neighbors)
 41            'n_bins': 256,  # Number of histogram bins
 42            'normalize': True  # Normalize histogram
 43        }
 44        
 45        if self.verbose:
 46            print("🔍 LBP Feature Extractor initialized!")
 47    
 48    def lbp_1d(self, data: np.ndarray, radius: int = 2) -> str:
 49        """
 50        Compute 1D Local Binary Pattern for time-series data.
 51        
 52        Args:
 53            data: Input time-series data
 54            radius: Radius for LBP computation
 55            
 56        Returns:
 57            LBP code as binary string
 58        """
 59        n = len(data)
 60        lbp_code = ''
 61        
 62        for i in range(n):
 63            pattern = ''
 64            for j in range(i - radius, i + radius + 1):
 65                if j < 0 or j >= n:
 66                    pattern += '0'
 67                elif data[j] >= data[i]:
 68                    pattern += '1'
 69                else:
 70                    pattern += '0'
 71            lbp_code += pattern
 72        
 73        return lbp_code
 74    
 75    def lbp_to_histogram(self, lbp_code: str, n_bins: int = 256, normalize: bool = True) -> np.ndarray:
 76        """
 77        Convert LBP code to histogram features.
 78        
 79        Args:
 80            lbp_code: Binary LBP code string
 81            n_bins: Number of histogram bins
 82            normalize: Whether to normalize histogram
 83            
 84        Returns:
 85            Histogram features as numpy array
 86        """
 87        # Convert LBP code to integer values
 88        if len(lbp_code) == 0:
 89            return np.zeros(n_bins)
 90        
 91        # Process LBP code in chunks of 8 bits (or smaller)
 92        chunk_size = 8
 93        lbp_values = []
 94        
 95        for i in range(0, len(lbp_code), chunk_size):
 96            chunk = lbp_code[i:i + chunk_size]
 97            if len(chunk) > 0:
 98                # Convert binary string to integer
 99                try:
100                    value = int(chunk, 2)
101                    lbp_values.append(value % n_bins)  # Ensure within bin range
102                except ValueError:
103                    continue
104        
105        if len(lbp_values) == 0:
106            return np.zeros(n_bins)
107        
108        # Create histogram
109        hist, _ = np.histogram(lbp_values, bins=n_bins, range=(0, n_bins))
110        
111        if normalize and np.sum(hist) > 0:
112            hist = hist / np.sum(hist)
113        
114        return hist
115    
116    def extract_features(self, windows: List[Dict], fs: int, **kwargs) -> List[Dict]:
117        """
118        Extract LBP features from sliding windows.
119        
120        Args:
121            windows: List of sliding window dictionaries
122            fs: Sampling frequency (unused for LBP)
123            **kwargs: Additional arguments
124            
125        Returns:
126            List of feature dictionaries
127        """
128        # Update config with any passed arguments
129        radius = kwargs.get('radius', self.config['radius'])
130        n_bins = kwargs.get('n_bins', self.config['n_bins'])
131        normalize = kwargs.get('normalize', self.config['normalize'])
132        
133        if self.verbose:
134            print(f"\n🔍 LBP Feature Extraction")
135            print(f"📊 Radius: {radius}, Bins: {n_bins}, Normalize: {normalize}")
136        
137        features = []
138        
139        for window_dict in tqdm(windows, desc="Processing LBP features", disable=not self.verbose):
140            sensor_name = window_dict['name']
141            window_data = window_dict['data']
142            
143            # Skip annotation windows
144            if sensor_name == 'annotations':
145                continue
146            
147            sensor_features = {'name': sensor_name, 'features': {}}
148            
149            # Extract LBP features for each window
150            lbp_histograms = []
151            lbp_means = []
152            lbp_stds = []
153            
154            for window in window_data:
155                # Ensure window is numpy array
156                if hasattr(window, 'values'):
157                    window = window.values
158                
159                # Compute LBP
160                lbp_code = self.lbp_1d(window, radius)
161                
162                # Convert to histogram
163                hist = self.lbp_to_histogram(lbp_code, n_bins, normalize)
164                lbp_histograms.append(hist)
165                
166                # Extract summary statistics
167                lbp_means.append(np.mean(hist))
168                lbp_stds.append(np.std(hist))
169            
170            # Store features
171            sensor_features['features'] = {
172                'lbp_histograms': lbp_histograms,
173                'lbp_mean': lbp_means,
174                'lbp_std': lbp_stds,
175                'lbp_energy': [np.sum(hist**2) for hist in lbp_histograms],
176                'lbp_entropy': [self._calculate_entropy(hist) for hist in lbp_histograms]
177            }
178            
179            features.append(sensor_features)
180        
181        return features
182    
183    def _calculate_entropy(self, hist: np.ndarray) -> float:
184        """Calculate entropy of histogram."""
185        # Avoid log(0) by adding small value
186        hist = hist + 1e-10
187        return -np.sum(hist * np.log2(hist))
188    
189    def get_feature_names(self) -> List[str]:
190        """Get names of LBP features."""
191        return [
192            'lbp_histograms', 'lbp_mean', 'lbp_std', 
193            'lbp_energy', 'lbp_entropy'
194        ]
195
196
197class FourierSeriesFeatureExtractor(BaseFeatureExtractor):
198    """
199    Fourier Series feature extractor for VGRF data.
200    
201    This extractor fits Fourier series to time-series data and extracts
202    coefficients and reconstruction features.
203    """
204    
205    def __init__(self, verbose: bool = True):
206        super().__init__(
207            name="fourier_features",
208            description="Fourier series feature extractor for VGRF time-series data"
209        )
210        self.verbose = verbose
211        self.config = {
212            'n_terms': 10,  # Number of Fourier terms
213            'period': 3.0,  # Period for Fourier series
214            'extract_coefficients': True,
215            'extract_reconstruction_error': True
216        }
217        
218        if self.verbose:
219            print("🌊 Fourier Series Feature Extractor initialized!")
220    
221    def fit_fourier_series(self, signal: np.ndarray, time_points: np.ndarray, 
222                          period: float = 3.0, n_terms: int = 10) -> Dict[str, Any]:
223        """
224        Fit Fourier series to signal.
225        
226        Args:
227            signal: Input signal
228            time_points: Time points
229            period: Period of the Fourier series
230            n_terms: Number of Fourier terms
231            
232        Returns:
233            Dictionary containing Fourier series parameters
234        """
235        try:
236            # Calculate Fourier coefficients
237            L = period
238            
239            # Calculate a0 (DC component)
240            a0 = 2/L * simpson(signal, time_points)
241            
242            # Calculate an and bn coefficients
243            an = []
244            bn = []
245            
246            for n in range(1, n_terms + 1):
247                # Calculate an coefficient
248                an_val = 2.0/L * simpson(signal * np.cos(2.*np.pi*n*time_points/L), time_points)
249                an.append(an_val)
250                
251                # Calculate bn coefficient
252                bn_val = 2.0/L * simpson(signal * np.sin(2.*np.pi*n*time_points/L), time_points)
253                bn.append(bn_val)
254            
255            # Reconstruct signal
256            reconstructed = np.full_like(time_points, a0/2)
257            for n in range(n_terms):
258                reconstructed += an[n] * np.cos(2.*np.pi*(n+1)*time_points/L)
259                reconstructed += bn[n] * np.sin(2.*np.pi*(n+1)*time_points/L)
260            
261            # Calculate reconstruction error
262            reconstruction_error = np.mean((signal - reconstructed)**2)
263            
264            return {
265                'a0': a0,
266                'an': an,
267                'bn': bn,
268                'reconstructed': reconstructed,
269                'reconstruction_error': reconstruction_error,
270                'fourier_energy': a0**2 + 2*np.sum(np.array(an)**2 + np.array(bn)**2)
271            }
272            
273        except Exception as e:
274            if self.verbose:
275                print(f"Error in Fourier series fitting: {e}")
276            return {
277                'a0': 0,
278                'an': [0] * n_terms,
279                'bn': [0] * n_terms,
280                'reconstructed': np.zeros_like(time_points),
281                'reconstruction_error': float('inf'),
282                'fourier_energy': 0
283            }
284    
285    def extract_features(self, windows: List[Dict], fs: int, **kwargs) -> List[Dict]:
286        """
287        Extract Fourier series features from sliding windows.
288        
289        Args:
290            windows: List of sliding window dictionaries
291            fs: Sampling frequency
292            **kwargs: Additional arguments
293            
294        Returns:
295            List of feature dictionaries
296        """
297        # Update config with any passed arguments
298        n_terms = kwargs.get('n_terms', self.config['n_terms'])
299        period = kwargs.get('period', self.config['period'])
300        
301        if self.verbose:
302            print(f"\n🌊 Fourier Series Feature Extraction")
303            print(f"📊 Terms: {n_terms}, Period: {period}")
304        
305        features = []
306        
307        for window_dict in tqdm(windows, desc="Processing Fourier features", disable=not self.verbose):
308            sensor_name = window_dict['name']
309            window_data = window_dict['data']
310            
311            # Skip annotation windows
312            if sensor_name == 'annotations':
313                continue
314            
315            sensor_features = {'name': sensor_name, 'features': {}}
316            
317            # Extract Fourier features for each window
318            a0_values = []
319            an_values = []
320            bn_values = []
321            reconstruction_errors = []
322            fourier_energies = []
323            
324            for window in window_data:
325                # Ensure window is numpy array
326                if hasattr(window, 'values'):
327                    window = window.values
328                
329                # Create time points
330                time_points = np.linspace(0, period, len(window))
331                
332                # Fit Fourier series
333                fourier_result = self.fit_fourier_series(window, time_points, period, n_terms)
334                
335                # Store results
336                a0_values.append(fourier_result['a0'])
337                an_values.append(fourier_result['an'])
338                bn_values.append(fourier_result['bn'])
339                reconstruction_errors.append(fourier_result['reconstruction_error'])
340                fourier_energies.append(fourier_result['fourier_energy'])
341            
342            # Store features
343            sensor_features['features'] = {
344                'fourier_a0': a0_values,
345                'fourier_an': an_values,
346                'fourier_bn': bn_values,
347                'fourier_reconstruction_error': reconstruction_errors,
348                'fourier_energy': fourier_energies,
349                'fourier_an_mean': [np.mean(an) for an in an_values],
350                'fourier_bn_mean': [np.mean(bn) for bn in bn_values],
351                'fourier_an_std': [np.std(an) for an in an_values],
352                'fourier_bn_std': [np.std(bn) for bn in bn_values]
353            }
354            
355            features.append(sensor_features)
356        
357        return features
358    
359    def get_feature_names(self) -> List[str]:
360        """Get names of Fourier series features."""
361        return [
362            'fourier_a0', 'fourier_an', 'fourier_bn', 
363            'fourier_reconstruction_error', 'fourier_energy',
364            'fourier_an_mean', 'fourier_bn_mean',
365            'fourier_an_std', 'fourier_bn_std'
366        ]
367
368
369class PhysioNetFeatureExtractor(BaseFeatureExtractor):
370    """
371    Combined feature extractor for PhysioNet VGRF data.
372    
373    This extractor combines LBP and Fourier series features along with
374    basic statistical features specific to VGRF data.
375    """
376    
377    def __init__(self, verbose: bool = True):
378        super().__init__(
379            name="physionet_features",
380            description="Combined feature extractor for PhysioNet VGRF data including LBP and Fourier features"
381        )
382        self.verbose = verbose
383        self.lbp_extractor = LBPFeatureExtractor(verbose=False)
384        self.fourier_extractor = FourierSeriesFeatureExtractor(verbose=False)
385        
386        if self.verbose:
387            print("🚀 PhysioNet Feature Extractor initialized!")
388    
389    def extract_features(self, windows: List[Dict], fs: int, **kwargs) -> List[Dict]:
390        """
391        Extract combined features from sliding windows.
392        
393        Args:
394            windows: List of sliding window dictionaries
395            fs: Sampling frequency
396            **kwargs: Additional arguments
397            
398        Returns:
399            List of feature dictionaries
400        """
401        # Extract features from each extractor
402        extract_lbp = kwargs.get('extract_lbp', True)
403        extract_fourier = kwargs.get('extract_fourier', True)
404        extract_statistical = kwargs.get('extract_statistical', True)
405        
406        if self.verbose:
407            print(f"\n🔍 PhysioNet Feature Extraction")
408            print(f"📊 LBP: {extract_lbp}, Fourier: {extract_fourier}, Statistical: {extract_statistical}")
409        
410        features = []
411        
412        # Extract LBP features
413        if extract_lbp:
414            lbp_features = self.lbp_extractor.extract_features(windows, fs, **kwargs)
415        else:
416            lbp_features = []
417        
418        # Extract Fourier features
419        if extract_fourier:
420            fourier_features = self.fourier_extractor.extract_features(windows, fs, **kwargs)
421        else:
422            fourier_features = []
423        
424        # Extract statistical features
425        if extract_statistical:
426            statistical_features = self._extract_statistical_features(windows)
427        else:
428            statistical_features = []
429        
430        # Combine features
431        for i, window_dict in enumerate(windows):
432            sensor_name = window_dict['name']
433            
434            # Skip annotation windows
435            if sensor_name == 'annotations':
436                continue
437            
438            combined_features = {'name': sensor_name, 'features': {}}
439            
440            # Add LBP features
441            if extract_lbp and i < len(lbp_features):
442                combined_features['features'].update(lbp_features[i]['features'])
443            
444            # Add Fourier features
445            if extract_fourier and i < len(fourier_features):
446                combined_features['features'].update(fourier_features[i]['features'])
447            
448            # Add statistical features
449            if extract_statistical and i < len(statistical_features):
450                combined_features['features'].update(statistical_features[i]['features'])
451            
452            features.append(combined_features)
453        
454        return features
455    
456    def _extract_statistical_features(self, windows: List[Dict]) -> List[Dict]:
457        """Extract basic statistical features."""
458        features = []
459        
460        for window_dict in windows:
461            sensor_name = window_dict['name']
462            window_data = window_dict['data']
463            
464            # Skip annotation windows
465            if sensor_name == 'annotations':
466                continue
467            
468            sensor_features = {'name': sensor_name, 'features': {}}
469            
470            # Extract statistical features for each window
471            means = []
472            stds = []
473            maxs = []
474            mins = []
475            ranges = []
476            
477            for window in window_data:
478                # Ensure window is numpy array
479                if hasattr(window, 'values'):
480                    window = window.values
481                
482                means.append(np.mean(window))
483                stds.append(np.std(window))
484                maxs.append(np.max(window))
485                mins.append(np.min(window))
486                ranges.append(np.max(window) - np.min(window))
487            
488            # Store features
489            sensor_features['features'] = {
490                'vgrf_mean': means,
491                'vgrf_std': stds,
492                'vgrf_max': maxs,
493                'vgrf_min': mins,
494                'vgrf_range': ranges
495            }
496            
497            features.append(sensor_features)
498        
499        return features
500    
501    def get_feature_names(self) -> List[str]:
502        """Get names of all features."""
503        feature_names = []
504        feature_names.extend(self.lbp_extractor.get_feature_names())
505        feature_names.extend(self.fourier_extractor.get_feature_names())
506        feature_names.extend(['vgrf_mean', 'vgrf_std', 'vgrf_max', 'vgrf_min', 'vgrf_range'])
507        return feature_names
508
509
510# Legacy functions for backward compatibility
511def extract_lbp_features(windows: List[Dict], fs: int, **kwargs) -> List[Dict]:
512    """
513    Legacy function to extract LBP features.
514    
515    Args:
516        windows: List of sliding window dictionaries
517        fs: Sampling frequency
518        **kwargs: Additional arguments
519        
520    Returns:
521        List of feature dictionaries
522    """
523    extractor = LBPFeatureExtractor(verbose=kwargs.get('verbose', True))
524    return extractor.extract_features(windows, fs, **kwargs)
525
526
527def extract_fourier_features(windows: List[Dict], fs: int, **kwargs) -> List[Dict]:
528    """
529    Legacy function to extract Fourier series features.
530    
531    Args:
532        windows: List of sliding window dictionaries
533        fs: Sampling frequency
534        **kwargs: Additional arguments
535        
536    Returns:
537        List of feature dictionaries
538    """
539    extractor = FourierSeriesFeatureExtractor(verbose=kwargs.get('verbose', True))
540    return extractor.extract_features(windows, fs, **kwargs)
541
542
543def extract_physionet_features(windows: List[Dict], fs: int, **kwargs) -> List[Dict]:
544    """
545    Legacy function to extract combined PhysioNet features.
546    
547    Args:
548        windows: List of sliding window dictionaries
549        fs: Sampling frequency
550        **kwargs: Additional arguments
551        
552    Returns:
553        List of feature dictionaries
554    """
555    extractor = PhysioNetFeatureExtractor(verbose=kwargs.get('verbose', True))
556    return extractor.extract_features(windows, fs, **kwargs)