gaitsetpy.core.base_classes

  1"""
  2Base classes for GaitSetPy components.
  3
  4This module defines abstract base classes that all components should inherit from.
  5Each base class defines the interface and common functionality for its respective component type.
  6
  7Maintainer: @aharshit123456
  8"""
  9
 10from abc import ABC, abstractmethod
 11from typing import Any, Dict, List, Optional, Tuple, Union
 12import pandas as pd
 13import numpy as np
 14
 15
 16class BaseDatasetLoader(ABC):
 17    """
 18    Base class for all dataset loaders.
 19    
 20    All dataset loaders should inherit from this class and implement the required methods.
 21    """
 22    
 23    def __init__(self, name: str, description: str = ""):
 24        """
 25        Initialize the dataset loader.
 26        
 27        Args:
 28            name: Name of the dataset
 29            description: Description of the dataset
 30        """
 31        self.name = name
 32        self.description = description
 33        self.data = None
 34        self.metadata = {}
 35    
 36    @abstractmethod
 37    def load_data(self, data_dir: str, **kwargs) -> Tuple[List[pd.DataFrame], List[str]]:
 38        """
 39        Load dataset from the specified directory.
 40        
 41        Args:
 42            data_dir: Directory containing the dataset
 43            **kwargs: Additional arguments specific to the dataset
 44            
 45        Returns:
 46            Tuple of (data_list, names_list)
 47        """
 48        pass
 49    
 50    @abstractmethod
 51    def create_sliding_windows(self, data: List[pd.DataFrame], names: List[str], 
 52                             window_size: int = 192, step_size: int = 32) -> List[Dict]:
 53        """
 54        Create sliding windows from the loaded data.
 55        
 56        Args:
 57            data: List of DataFrames
 58            names: List of names corresponding to the data
 59            window_size: Size of each sliding window
 60            step_size: Step size for sliding windows
 61            
 62        Returns:
 63            List of dictionaries containing sliding windows
 64        """
 65        pass
 66    
 67    @abstractmethod
 68    def get_supported_formats(self) -> List[str]:
 69        """
 70        Get list of supported file formats.
 71        
 72        Returns:
 73            List of supported file extensions
 74        """
 75        pass
 76    
 77    def get_info(self) -> Dict[str, Any]:
 78        """
 79        Get information about the dataset.
 80        
 81        Returns:
 82            Dictionary containing dataset information
 83        """
 84        return {
 85            'name': self.name,
 86            'description': self.description,
 87            'metadata': self.metadata,
 88            'supported_formats': self.get_supported_formats()
 89        }
 90
 91
 92class BaseFeatureExtractor(ABC):
 93    """
 94    Base class for all feature extractors.
 95    
 96    All feature extractors should inherit from this class and implement the required methods.
 97    """
 98    
 99    def __init__(self, name: str, description: str = ""):
100        """
101        Initialize the feature extractor.
102        
103        Args:
104            name: Name of the feature extractor
105            description: Description of the feature extractor
106        """
107        self.name = name
108        self.description = description
109        self.config = {}
110    
111    @abstractmethod
112    def extract_features(self, windows: List[Dict], fs: int, **kwargs) -> List[Dict]:
113        """
114        Extract features from sliding windows.
115        
116        Args:
117            windows: List of sliding window dictionaries
118            fs: Sampling frequency
119            **kwargs: Additional arguments for feature extraction
120            
121        Returns:
122            List of feature dictionaries
123        """
124        pass
125    
126    @abstractmethod
127    def get_feature_names(self) -> List[str]:
128        """
129        Get names of features extracted by this extractor.
130        
131        Returns:
132            List of feature names
133        """
134        pass
135    
136    def configure(self, config: Dict[str, Any]):
137        """
138        Configure the feature extractor.
139        
140        Args:
141            config: Configuration dictionary
142        """
143        self.config.update(config)
144    
145    def get_info(self) -> Dict[str, Any]:
146        """
147        Get information about the feature extractor.
148        
149        Returns:
150            Dictionary containing feature extractor information
151        """
152        return {
153            'name': self.name,
154            'description': self.description,
155            'config': self.config,
156            'feature_names': self.get_feature_names()
157        }
158
159
160class BasePreprocessor(ABC):
161    """
162    Base class for all preprocessors.
163    
164    All preprocessors should inherit from this class and implement the required methods.
165    """
166    
167    def __init__(self, name: str, description: str = ""):
168        """
169        Initialize the preprocessor.
170        
171        Args:
172            name: Name of the preprocessor
173            description: Description of the preprocessor
174        """
175        self.name = name
176        self.description = description
177        self.config = {}
178        self.fitted = False
179    
180    @abstractmethod
181    def fit(self, data: Union[pd.DataFrame, np.ndarray], **kwargs):
182        """
183        Fit the preprocessor to the data.
184        
185        Args:
186            data: Input data to fit on
187            **kwargs: Additional arguments for fitting
188        """
189        pass
190    
191    @abstractmethod
192    def transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
193        """
194        Transform the data using the fitted preprocessor.
195        
196        Args:
197            data: Input data to transform
198            **kwargs: Additional arguments for transformation
199            
200        Returns:
201            Transformed data
202        """
203        pass
204    
205    def fit_transform(self, data: Union[pd.DataFrame, np.ndarray], **kwargs) -> Union[pd.DataFrame, np.ndarray]:
206        """
207        Fit the preprocessor and transform the data.
208        
209        Args:
210            data: Input data to fit and transform
211            **kwargs: Additional arguments
212            
213        Returns:
214            Transformed data
215        """
216        self.fit(data, **kwargs)
217        return self.transform(data, **kwargs)
218    
219    def configure(self, config: Dict[str, Any]):
220        """
221        Configure the preprocessor.
222        
223        Args:
224            config: Configuration dictionary
225        """
226        self.config.update(config)
227    
228    def get_info(self) -> Dict[str, Any]:
229        """
230        Get information about the preprocessor.
231        
232        Returns:
233            Dictionary containing preprocessor information
234        """
235        return {
236            'name': self.name,
237            'description': self.description,
238            'config': self.config,
239            'fitted': self.fitted
240        }
241
242
243class BaseEDAAnalyzer(ABC):
244    """
245    Base class for all EDA analyzers.
246    
247    All EDA analyzers should inherit from this class and implement the required methods.
248    """
249    
250    def __init__(self, name: str, description: str = ""):
251        """
252        Initialize the EDA analyzer.
253        
254        Args:
255            name: Name of the EDA analyzer
256            description: Description of the EDA analyzer
257        """
258        self.name = name
259        self.description = description
260        self.config = {}
261    
262    @abstractmethod
263    def analyze(self, data: Union[pd.DataFrame, List[pd.DataFrame]], **kwargs) -> Dict[str, Any]:
264        """
265        Perform analysis on the data.
266        
267        Args:
268            data: Input data to analyze
269            **kwargs: Additional arguments for analysis
270            
271        Returns:
272            Dictionary containing analysis results
273        """
274        pass
275    
276    @abstractmethod
277    def visualize(self, data: Union[pd.DataFrame, List[pd.DataFrame]], **kwargs):
278        """
279        Create visualizations of the data.
280        
281        Args:
282            data: Input data to visualize
283            **kwargs: Additional arguments for visualization
284        """
285        pass
286    
287    def configure(self, config: Dict[str, Any]):
288        """
289        Configure the EDA analyzer.
290        
291        Args:
292            config: Configuration dictionary
293        """
294        self.config.update(config)
295    
296    def get_info(self) -> Dict[str, Any]:
297        """
298        Get information about the EDA analyzer.
299        
300        Returns:
301            Dictionary containing EDA analyzer information
302        """
303        return {
304            'name': self.name,
305            'description': self.description,
306            'config': self.config
307        }
308
309
310class BaseClassificationModel(ABC):
311    """
312    Base class for all classification models.
313    
314    All classification models should inherit from this class and implement the required methods.
315    """
316    
317    def __init__(self, name: str, description: str = ""):
318        """
319        Initialize the classification model.
320        
321        Args:
322            name: Name of the classification model
323            description: Description of the classification model
324        """
325        self.name = name
326        self.description = description
327        self.model = None
328        self.config = {}
329        self.trained = False
330    
331    @abstractmethod
332    def train(self, features: List[Dict], **kwargs):
333        """
334        Train the classification model.
335        
336        Args:
337            features: List of feature dictionaries
338            **kwargs: Additional arguments for training
339        """
340        pass
341    
342    @abstractmethod
343    def predict(self, features: List[Dict], **kwargs) -> np.ndarray:
344        """
345        Make predictions using the trained model.
346        
347        Args:
348            features: List of feature dictionaries
349            **kwargs: Additional arguments for prediction
350            
351        Returns:
352            Array of predictions
353        """
354        pass
355    
356    @abstractmethod
357    def evaluate(self, features: List[Dict], **kwargs) -> Dict[str, float]:
358        """
359        Evaluate the model performance.
360        
361        Args:
362            features: List of feature dictionaries
363            **kwargs: Additional arguments for evaluation
364            
365        Returns:
366            Dictionary containing evaluation metrics
367        """
368        pass
369    
370    @abstractmethod
371    def save_model(self, filepath: str):
372        """
373        Save the trained model to a file.
374        
375        Args:
376            filepath: Path to save the model
377        """
378        pass
379    
380    @abstractmethod
381    def load_model(self, filepath: str):
382        """
383        Load a trained model from a file.
384        
385        Args:
386            filepath: Path to the saved model
387        """
388        pass
389    
390    def configure(self, config: Dict[str, Any]):
391        """
392        Configure the classification model.
393        
394        Args:
395            config: Configuration dictionary
396        """
397        self.config.update(config)
398    
399    def get_info(self) -> Dict[str, Any]:
400        """
401        Get information about the classification model.
402        
403        Returns:
404            Dictionary containing model information
405        """
406        return {
407            'name': self.name,
408            'description': self.description,
409            'config': self.config,
410            'trained': self.trained
411        }