gaitsetpy.classification.models.mlp

  1from typing import List, Dict, Any, Optional, Union
  2import joblib
  3import numpy as np
  4from sklearn.neural_network import MLPClassifier
  5from sklearn.model_selection import train_test_split
  6from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
  7from ...core.base_classes import BaseClassificationModel
  8from ..utils.preprocess import preprocess_features
  9
 10class MLPModel(BaseClassificationModel):
 11    """
 12    Multi-Layer Perceptron (MLP) classification model.
 13    Implements the BaseClassificationModel interface using scikit-learn's MLPClassifier.
 14    """
 15    def __init__(self, hidden_layer_sizes=(100,), activation='relu', solver='adam', random_state=42, max_iter=200):
 16        super().__init__(
 17            name="mlp",
 18            description="Multi-Layer Perceptron classifier for gait data classification"
 19        )
 20        self.config = {
 21            'hidden_layer_sizes': hidden_layer_sizes,
 22            'activation': activation,
 23            'solver': solver,
 24            'random_state': random_state,
 25            'max_iter': max_iter
 26        }
 27        self.model = MLPClassifier(
 28            hidden_layer_sizes=hidden_layer_sizes,
 29            activation=activation,
 30            solver=solver,
 31            random_state=random_state,
 32            max_iter=max_iter
 33        )
 34        self.feature_names = []
 35        self.class_names = []
 36
 37    def train(self, features: List[Dict], **kwargs):
 38        X, y = preprocess_features(features)
 39        self.feature_names = [f"feature_{i}" for i in range(X.shape[1])]
 40        self.class_names = list(set(y))
 41        test_size = kwargs.get('test_size', 0.2)
 42        validation_split = kwargs.get('validation_split', True)
 43        if validation_split:
 44            X_train, X_test, y_train, y_test = train_test_split(
 45                X, y, test_size=test_size, random_state=self.config['random_state']
 46            )
 47            self.model.fit(X_train, y_train)
 48            self.X_test = X_test
 49            self.y_test = y_test
 50            train_accuracy = self.model.score(X_train, y_train)
 51            test_accuracy = self.model.score(X_test, y_test)
 52            print(f"Training accuracy: {train_accuracy:.4f}")
 53            print(f"Validation accuracy: {test_accuracy:.4f}")
 54        else:
 55            self.model.fit(X, y)
 56            train_accuracy = self.model.score(X, y)
 57            print(f"Training accuracy: {train_accuracy:.4f}")
 58        self.trained = True
 59        print("MLP model trained successfully.")
 60
 61    def predict(self, features: List[Dict], **kwargs) -> Union[np.ndarray, Any]:
 62        if not self.trained:
 63            raise ValueError("Model must be trained before making predictions")
 64        X, _ = preprocess_features(features)
 65        return_probabilities = kwargs.get('return_probabilities', False)
 66        if return_probabilities:
 67            return self.model.predict_proba(X)
 68        else:
 69            return self.model.predict(X)
 70
 71    def evaluate(self, features: List[Dict], **kwargs) -> Dict[str, float]:
 72        if not self.trained:
 73            raise ValueError("Model must be trained before evaluation")
 74        if hasattr(self, 'X_test') and hasattr(self, 'y_test'):
 75            X_test, y_test = self.X_test, self.y_test
 76        else:
 77            X_test, y_test = preprocess_features(features)
 78        y_pred = self.model.predict(X_test)
 79        accuracy = accuracy_score(y_test, y_pred)
 80        conf_matrix = confusion_matrix(y_test, y_pred)
 81        metrics = {
 82            'accuracy': accuracy,
 83            'confusion_matrix': conf_matrix.tolist()
 84        }
 85        detailed_report = kwargs.get('detailed_report', False)
 86        if detailed_report:
 87            class_report = classification_report(y_test, y_pred, output_dict=True)
 88            metrics['classification_report'] = class_report
 89        return metrics
 90
 91    def save_model(self, filepath: str):
 92        if not self.trained:
 93            raise ValueError("Model must be trained before saving")
 94        model_data = {
 95            'model': self.model,
 96            'config': self.config,
 97            'feature_names': self.feature_names,
 98            'class_names': self.class_names,
 99            'trained': self.trained
100        }
101        joblib.dump(model_data, filepath)
102        print(f"MLP model saved to {filepath}")
103
104    def load_model(self, filepath: str):
105        try:
106            model_data = joblib.load(filepath)
107            if isinstance(model_data, dict):
108                self.model = model_data['model']
109                self.config = model_data.get('config', self.config)
110                self.feature_names = model_data.get('feature_names', [])
111                self.class_names = model_data.get('class_names', [])
112                self.trained = model_data.get('trained', False)
113            else:
114                self.model = model_data
115                self.trained = True
116            print(f"MLP model loaded from {filepath}")
117        except Exception as e:
118            print(f"Failed to load MLP model: {e}")