gaitsetpy.classification

 21class RandomForestModel(BaseClassificationModel):
 22    """
 23    Random Forest classification model.
 24    
 25    This class provides Random Forest classification functionality with
 26    comprehensive training, prediction, and evaluation capabilities.
 27    """
 28    
 29    def __init__(self, n_estimators: int = 100, random_state: int = 42, max_depth: Optional[int] = None):
 30        super().__init__(
 31            name="random_forest",
 32            description="Random Forest classifier for gait data classification"
 33        )
 34        self.config = {
 35            'n_estimators': n_estimators,
 36            'random_state': random_state,
 37            'max_depth': max_depth
 38        }
 39        self.model = RandomForestClassifier(
 40            n_estimators=n_estimators,
 41            random_state=random_state,
 42            max_depth=max_depth
 43        )
 44        self.feature_names = []
 45        self.class_names = []
 46        
 47    def train(self, features: List[Dict], **kwargs):
 48        """
 49        Train the Random Forest model on the given features.
 50        
 51        Args:
 52            features: List of feature dictionaries
 53            **kwargs: Additional arguments including test_size, validation_split
 54        """
 55        # Preprocess features
 56        X, y = preprocess_features(features)
 57        
 58        # Store feature and class information
 59        self.feature_names = [f"feature_{i}" for i in range(X.shape[1])]
 60        self.class_names = list(set(y))
 61        
 62        # Split data if test_size is specified
 63        test_size = kwargs.get('test_size', 0.2)
 64        validation_split = kwargs.get('validation_split', True)
 65        
 66        if validation_split:
 67            X_train, X_test, y_train, y_test = train_test_split(
 68                X, y, test_size=test_size, random_state=self.config['random_state']
 69            )
 70            
 71            # Train model
 72            self.model.fit(X_train, y_train)
 73            
 74            # Store validation data for later evaluation
 75            self.X_test = X_test
 76            self.y_test = y_test
 77            
 78            # Print training accuracy
 79            train_accuracy = self.model.score(X_train, y_train)
 80            test_accuracy = self.model.score(X_test, y_test)
 81            
 82            print(f"Training accuracy: {train_accuracy:.4f}")
 83            print(f"Validation accuracy: {test_accuracy:.4f}")
 84        else:
 85            # Train on all data
 86            self.model.fit(X, y)
 87            train_accuracy = self.model.score(X, y)
 88            print(f"Training accuracy: {train_accuracy:.4f}")
 89        
 90        self.trained = True
 91        print("Random Forest model trained successfully.")
 92    
 93    def predict(self, features: List[Dict], **kwargs) -> Union[np.ndarray, Any]:
 94        """
 95        Make predictions using the trained Random Forest model.
 96        
 97        Args:
 98            features: List of feature dictionaries
 99            **kwargs: Additional arguments including return_probabilities
100            
101        Returns:
102            Array of predictions or probabilities
103        """
104        if not self.trained:
105            raise ValueError("Model must be trained before making predictions")
106        
107        # Preprocess features
108        X, _ = preprocess_features(features)
109        
110        # Make predictions
111        return_probabilities = kwargs.get('return_probabilities', False)
112        
113        if return_probabilities:
114            return self.model.predict_proba(X)
115        else:
116            return self.model.predict(X)
117    
118    def evaluate(self, features: List[Dict], **kwargs) -> Dict[str, float]:
119        """
120        Evaluate the Random Forest model performance.
121        
122        Args:
123            features: List of feature dictionaries
124            **kwargs: Additional arguments including detailed_report
125            
126        Returns:
127            Dictionary containing evaluation metrics
128        """
129        if not self.trained:
130            raise ValueError("Model must be trained before evaluation")
131        
132        # Use validation data if available, otherwise use provided features
133        if hasattr(self, 'X_test') and hasattr(self, 'y_test'):
134            X_test, y_test = self.X_test, self.y_test
135        else:
136            X_test, y_test = preprocess_features(features)
137        
138        # Make predictions
139        y_pred = self.model.predict(X_test)
140        
141        # Calculate metrics
142        accuracy = accuracy_score(y_test, y_pred)
143        conf_matrix = confusion_matrix(y_test, y_pred)
144        
145        # Basic metrics
146        metrics = {
147            'accuracy': accuracy,
148            'confusion_matrix': conf_matrix.tolist()
149        }
150        
151        # Detailed report if requested
152        detailed_report = kwargs.get('detailed_report', False)
153        if detailed_report:
154            class_report = classification_report(y_test, y_pred, output_dict=True)
155            metrics['classification_report'] = class_report
156            
157            # Feature importance
158            if hasattr(self.model, 'feature_importances_'):
159                feature_importance = dict(zip(self.feature_names, self.model.feature_importances_))
160                metrics['feature_importance'] = feature_importance
161        
162        return metrics
163    
164    def save_model(self, filepath: str):
165        """
166        Save the trained Random Forest model to a file.
167        
168        Args:
169            filepath: Path to save the model
170        """
171        if not self.trained:
172            raise ValueError("Model must be trained before saving")
173        
174        # Save model with additional metadata
175        model_data = {
176            'model': self.model,
177            'config': self.config,
178            'feature_names': self.feature_names,
179            'class_names': self.class_names,
180            'trained': self.trained
181        }
182        
183        joblib.dump(model_data, filepath)
184        print(f"Random Forest model saved to {filepath}")
185    
186    def load_model(self, filepath: str):
187        """
188        Load a trained Random Forest model from a file.
189        
190        Args:
191            filepath: Path to the saved model
192        """
193        try:
194            model_data = joblib.load(filepath)
195            
196            # Handle legacy model format
197            if isinstance(model_data, dict):
198                self.model = model_data['model']
199                self.config = model_data.get('config', self.config)
200                self.feature_names = model_data.get('feature_names', [])
201                self.class_names = model_data.get('class_names', [])
202                self.trained = model_data.get('trained', True)
203            else:
204                # Legacy format - just the model
205                self.model = model_data
206                self.trained = True
207            
208            print(f"Random Forest model loaded from {filepath}")
209        except Exception as e:
210            print(f"Error loading model: {e}")
211            raise
212    
213    def get_feature_importance(self) -> Dict[str, float]:
214        """
215        Get feature importance scores.
216        
217        Returns:
218            Dictionary mapping feature names to importance scores
219        """
220        if not self.trained:
221            raise ValueError("Model must be trained to get feature importance")
222        
223        if hasattr(self.model, 'feature_importances_'):
224            return dict(zip(self.feature_names, self.model.feature_importances_))
225        else:
226            return {}
227    
228    def predict_single(self, single_features: Dict) -> int:
229        """
230        Make prediction for a single feature vector.
231        
232        Args:
233            single_features: Dictionary containing features for a single sample
234            
235        Returns:
236            Predicted class
237        """
238        if not self.trained:
239            raise ValueError("Model must be trained before making predictions")
240        
241        # Convert single feature dict to format expected by preprocess_features
242        features_list = [single_features]
243        X, _ = preprocess_features(features_list)
244        
245        return self.model.predict(X)[0]

249def create_random_forest_model(n_estimators=100, random_state=42, max_depth=None):
250    """
251    Create a Random Forest model with specified parameters.
252    
253    Args:
254        n_estimators: Number of trees in the forest
255        random_state: Random state for reproducibility
256        max_depth: Maximum depth of the tree
257        
258    Returns:
259        RandomForestModel instance
260    """
261    return RandomForestModel(n_estimators=n_estimators, random_state=random_state, max_depth=max_depth)

14def preprocess_features(features):
15    """
16    Convert the features dictionary into X (feature matrix) and y (labels),
17    ensuring all feature vectors have a consistent length.
18    """
19    X = []
20    y = []
21    feature_lengths = []  # Track feature lengths to standardize across sensors
22
23    for sensor_dict in features:
24        sensor_name = sensor_dict["name"]
25        sensor_features = sensor_dict["features"]
26        sensor_annotations = sensor_dict["annotations"]
27
28        num_windows = len(sensor_annotations)  # Expected number of windows
29        feature_arrays = []
30
31        for key in sensor_features:
32            feature_array = sensor_features[key]  # Extract the feature list
33            feature_array = np.array(feature_array, dtype=object)  # Convert to NumPy object array
34
35            # Ensure it's a list of equal-length vectors
36            if isinstance(feature_array[0], (list, np.ndarray)):
37                print(f"Fixing inconsistent feature '{key}' in sensor '{sensor_name}'.")
38
39                # Find max length for this feature across all windows
40                max_length = max(len(f) if isinstance(f, (list, np.ndarray)) else 1 for f in feature_array)
41                feature_lengths.append(max_length)  # Store max feature length for later
42
43                # Pad/truncate each feature to be the same length
44                feature_array = np.array([
45                    np.pad(np.ravel(f), (0, max_length - len(f)), 'constant', constant_values=0)
46                    if isinstance(f, (list, np.ndarray)) else np.array([f] + [0] * (max_length - 1))
47                    for f in feature_array
48                ])
49
50            # Ensure consistency in number of windows
51            if len(feature_array) != num_windows:
52                print(f"Skipping feature '{key}' due to mismatched length: {len(feature_array)} instead of {num_windows}.")
53                continue
54
55            feature_arrays.append(feature_array)
56
57        if not feature_arrays:
58            continue
59
60        # Concatenate features per window
61        try:
62            feature_matrix = np.column_stack(feature_arrays)
63        except ValueError:
64            print(f"Error: Features in sensor '{sensor_name}' have inconsistent shapes. Skipping sensor.")
65            continue
66
67        X.append(feature_matrix)
68        y.append(np.array(sensor_annotations))
69
70    if not X or not y:
71        raise ValueError("No valid features or labels found.")
72
73    # **Fix: Standardize feature matrix sizes across sensors**
74    max_feature_dim = max(map(lambda x: x.shape[1], X))  # Get the max feature size
75    print(f"Standardizing all feature vectors to {max_feature_dim} dimensions.")
76
77    # Pad/truncate all feature matrices to match max_feature_dim
78    X = [np.pad(x, ((0, 0), (0, max_feature_dim - x.shape[1])), 'constant', constant_values=0) if x.shape[1] < max_feature_dim else x[:, :max_feature_dim] for x in X]
79
80    # Stack all feature matrices
81    X = np.vstack(X).astype(np.float32)
82    y = np.concatenate(y)
83
84    # Remap labels to zero-based contiguous integers
85    unique_labels = np.unique(y)
86    label_map = {label: idx for idx, label in enumerate(unique_labels)}
87    y_remapped = np.array([label_map[label] for label in y])
88
89    # Also update annotations in feature_dicts
90    # This part of the code was not provided in the original file,
91    # so I'm not adding it as per instruction 1.
92
93    return X, y_remapped

12def evaluate_model(model, features):
13    """
14    Evaluates the given model on the provided features and prints accuracy and confusion matrix.
15    """
16    X, y = preprocess_features(features)
17    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
18
19    y_pred = model.predict(X_test)
20
21    acc = accuracy_score(y_test, y_pred)
22    # conf_matrix = confusion_matrix(y_test, y_pred)
23
24    print(f"Accuracy: {acc:.4f}")
25    # print(f"Confusion Matrix:\n{conf_matrix}")

44def get_classification_manager():
45    """Get the singleton ClassificationManager instance."""
46    return ClassificationManager()

49def get_available_models():
50    """Get list of available classification model names."""
51    return ClassificationManager().get_available_components()

54def train_model(model_name: str, features, **kwargs):
55    """
56    Train a classification model using the ClassificationManager.
57    
58    Args:
59        model_name: Name of the classification model
60        features: List of feature dictionaries
61        **kwargs: Additional arguments for training
62        
63    Returns:
64        Trained model instance
65    """
66    return ClassificationManager().train_model(model_name, features, **kwargs)

69def predict(model_name: str, features, **kwargs):
70    """
71    Make predictions using the ClassificationManager.
72    
73    Args:
74        model_name: Name of the classification model
75        features: List of feature dictionaries
76        **kwargs: Additional arguments for prediction
77        
78    Returns:
79        Predictions array
80    """
81    return ClassificationManager().predict(model_name, features, **kwargs)

84def evaluate_model_performance(model_name: str, features, **kwargs):
85    """
86    Evaluate a classification model using the ClassificationManager.
87    
88    Args:
89        model_name: Name of the classification model
90        features: List of feature dictionaries
91        **kwargs: Additional arguments for evaluation
92        
93    Returns:
94        Evaluation metrics dictionary
95    """
96    return ClassificationManager().evaluate_model(model_name, features, **kwargs)

 99def create_random_forest(n_estimators=100, random_state=42, max_depth=None):
100    """
101    Create a Random Forest model with specified parameters.
102    
103    Args:
104        n_estimators: Number of trees in the forest
105        random_state: Random state for reproducibility
106        max_depth: Maximum depth of the tree
107        
108    Returns:
109        RandomForestModel instance
110    """
111    return RandomForestModel(n_estimators=n_estimators, random_state=random_state, max_depth=max_depth)

113def train_random_forest(features, **kwargs):
114    """
115    Train a Random Forest model on the given features.
116    
117    Args:
118        features: List of feature dictionaries
119        **kwargs: Additional arguments for training
120        
121    Returns:
122        Trained RandomForestModel instance
123    """
124    model = RandomForestModel()
125    model.train(features, **kwargs)
126    return model