autofuzzts 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

autofuzzts/config.py

@@ -1,18 +1,18 @@
-# config.py
-
-DEFAULT_CONFIG = {
-    "n_clusters": 3,
-    "number_of_lags": 5,
-    "plot_partition": False,
-    "pred_column": "Y",
-    "fuzzy_part_func": "triangle",
-    "n_rows": 0,
-    "sigma": 1.0,
-    "verbosity": False,
-}
-
-def get_config(custom_config=None):
-    config = DEFAULT_CONFIG.copy()
-    if custom_config:
-        config.update(custom_config)
+# config.py
+
+DEFAULT_CONFIG = {
+    "n_fuzzy_sets": 3,
+    "number_of_lags": 5,
+    "plot_partition": False,
+    "pred_column": "Y",
+    "fuzzy_part_func": "triangle",
+    "n_rows": 0,
+    "sigma": 1.0,
+    "verbosity": False,
+}
+
+def get_config(custom_config=None):
+    config = DEFAULT_CONFIG.copy()
+    if custom_config:
+        config.update(custom_config)
     return config

autofuzzts/data/data_loader.py

@@ -1,7 +1,7 @@
-import os
-import pandas as pd
-
-def load_sample_data(file_name):
-    data_path = os.path.join(os.path.dirname(__file__), 'sample_datasets', file_name)
-    print(f"Loading data from: {data_path}")  # Print the constructed path
-    return pd.read_csv(data_path)
+import os
+import pandas as pd
+
+def load_sample_data(file_name):
+    data_path = os.path.join(os.path.dirname(__file__), 'sample_datasets', file_name)
+    print(f"Loading data from: {data_path}")  # Print the constructed path
+    return pd.read_csv(data_path)

autofuzzts/data_validation/validate.py

@@ -1,41 +1,41 @@
-import pandas as pd
-import warnings
-
-
-def validate_and_clean_input(df: pd.DataFrame, covariates:list[str] = None) -> pd.DataFrame:
-    """
-    Validates the input DataFrame, ensuring it contains at least one column.
-    If the DataFrame contains multiple columns, all columns except the first 
-    are removed, and a warning is issued.
-
-    Parameters:
-        df (pd.DataFrame): The input DataFrame.
-
-    Returns:
-        pd.DataFrame: A DataFrame with only the first column retained.
-    """
-    if not isinstance(df, pd.DataFrame):
-        raise ValueError("Input data must be a pandas DataFrame.")
-    
-    if df.shape[1] == 0:
-        raise ValueError("Input DataFrame must contain at least one column.")
-    
-    # If there are multiple columns, keep only the first one and warn the user
-    if df.shape[1] > 1:
-        if covariates is None:
-            warnings.warn("Input DataFrame has multiple columns. Only the first column will be used.")
-            df = df[[df.columns[0]]]
-        else:
-            warnings.warn("Input DataFrame has multiple columns. Covariates will be used for modelling.")
-            df = df[[df.columns[0]] + covariates]
-        
-        
-
-    # Standardize column name to 'Y'
-    df = df.rename(columns={df.columns[0]: 'Y'})
-
-    # Convert all selected columns to numeric and fill NaNs with 0
-    df = df.apply(pd.to_numeric, errors='coerce').fillna(0)
-    
-    return df
-
+import pandas as pd
+import warnings
+
+
+def validate_and_clean_input(df: pd.DataFrame, covariates:list[str] = None) -> pd.DataFrame:
+    """
+    Validates the input DataFrame, ensuring it contains at least one column.
+    If the DataFrame contains multiple columns, all columns except the first 
+    are removed, and a warning is issued.
+
+    Parameters:
+        df (pd.DataFrame): The input DataFrame.
+
+    Returns:
+        pd.DataFrame: A DataFrame with only the first column retained.
+    """
+    if not isinstance(df, pd.DataFrame):
+        raise ValueError("Input data must be a pandas DataFrame.")
+    
+    if df.shape[1] == 0:
+        raise ValueError("Input DataFrame must contain at least one column.")
+    
+    # If there are multiple columns, keep only the first one and warn the user
+    if df.shape[1] > 1:
+        if covariates is None:
+            warnings.warn("Input DataFrame has multiple columns. Only the first column will be used.")
+            df = df[[df.columns[0]]]
+        else:
+            warnings.warn("Input DataFrame has multiple columns. Covariates will be used for modelling.")
+            df = df[[df.columns[0]] + covariates]
+        
+        
+
+    # Standardize column name to 'Y'
+    df = df.rename(columns={df.columns[0]: 'Y'})
+
+    # Convert all selected columns to numeric and fill NaNs with 0
+    df = df.apply(pd.to_numeric, errors='coerce').fillna(0)
+    
+    return df
+

autofuzzts/models/fuzzy_classifier.py

@@ -1,83 +1,83 @@
-import xgboost as xgb
-from typing import Literal
-from tpot import TPOTClassifier
-from autofuzzts.models.mlp_nas import build_model
-from sklearn.calibration import CalibratedClassifierCV
-
-
-class FuzzyPipelineModel:
-    def __init__(self, n_clusters: int, number_of_lags: int, verbosity: bool = False):
-        self.n_clusters = n_clusters
-        self.number_of_lags = number_of_lags
-        self.verbosity = verbosity
-        self.model = None  # Placeholder for the fitted model
-
-    def fit(self, X_train, y_train, model_type:Literal['xgb', 'tpot','mlp']='xgb', **kwargs):
-        """
-        Fit the model based on the specified model type and input parameters.
-
-        Parameters:
-        - X_train: Features for training.
-        - y_train: Labels for training.
-        - model_type: 'xgboost', 'mlp', or 'tpot'.
-        - kwargs: Additional parameters for model fitting.
-        """
-        if model_type == 'xgb':
-            model = xgb.XGBClassifier(objective="multi:softmax", num_class=self.n_clusters, **kwargs)
-            self.model = model.fit(X_train, y_train)
-
-        elif model_type == 'tpot':
-            tpot = TPOTClassifier(
-                generations=kwargs.get('generations', 5),
-                population_size=kwargs.get('population_size', 10),
-                random_state=kwargs.get('random_state', 42),
-                max_time_mins=kwargs.get('max_time_mins', 2),
-            )
-            tpot.fit(X_train, y_train)
-            self.model = tpot.fitted_pipeline_
-
-        elif model_type == 'mlp':
-            mlp = build_model(X_train, y_train, **kwargs)  # Adjust as necessary
-            self.model = mlp.fit(X_train, y_train)
-
-        else:
-            raise ValueError("Invalid model type. Choose 'xgb', 'mlp', or 'tpot'.")
-
-        return self.model
-
-    def calibrate(self, X_train, y_train, method='sigmoid', cv=5):
-        """
-        Calibrate the fitted model using CalibratedClassifierCV.
-
-        Parameters:
-        - X_train: Features for training (for calibration).
-        - y_train: Labels for training (for calibration).
-        - method: Calibration method ('sigmoid' or 'isotonic').
-        - cv: Cross-validation splitting strategy.
-        """
-        if self.model is None:
-            raise ValueError("Model is not fitted yet. Call 'fit' first.")
-
-        # Ensure the model supports predict_proba
-        if not hasattr(self.model, "predict_proba"):
-            raise AttributeError("The fitted model does not support predict_proba.")
-
-        # Initialize calibrated model
-        calibrated_model = CalibratedClassifierCV(self.model, method=method, cv=cv)
-        calibrated_model.fit(X_train, y_train)
-
-        # Replace the model with the calibrated model
-        self.model = calibrated_model
-
-        return self.model
-    def predict(self, X_test):
-        """Make predictions using the fitted model."""
-        if self.model is None:
-            raise ValueError("Model is not fitted yet. Call 'fit_model' first.")
-        return self.model.predict(X_test)
-    
-    def predict_proba(self, X_test):
-        """Make predictions using the fitted model."""
-        if self.model is None:
-            raise ValueError("Model is not fitted yet. Call 'fit_model' first.")
+import xgboost as xgb
+from typing import Literal
+from tpot import TPOTClassifier
+from autofuzzts.models.mlp_nas import build_model
+from sklearn.calibration import CalibratedClassifierCV
+
+
+class FuzzyPipelineModel:
+    def __init__(self, n_fuzzy_sets: int, number_of_lags: int, verbosity: bool = False):
+        self.n_fuzzy_sets = n_fuzzy_sets
+        self.number_of_lags = number_of_lags
+        self.verbosity = verbosity
+        self.model = None  # Placeholder for the fitted model
+
+    def fit(self, X_train, y_train, model_type:Literal['xgb', 'tpot','mlp']='xgb', **kwargs):
+        """
+        Fit the model based on the specified model type and input parameters.
+
+        Parameters:
+        - X_train: Features for training.
+        - y_train: Labels for training.
+        - model_type: 'xgboost', 'mlp', or 'tpot'.
+        - kwargs: Additional parameters for model fitting.
+        """
+        if model_type == 'xgb':
+            model = xgb.XGBClassifier(objective="multi:softmax", num_class=self.n_fuzzy_sets, **kwargs)
+            self.model = model.fit(X_train, y_train)
+
+        elif model_type == 'tpot':
+            tpot = TPOTClassifier(
+                generations=kwargs.get('generations', 5),
+                population_size=kwargs.get('population_size', 10),
+                random_state=kwargs.get('random_state', 42),
+                max_time_mins=kwargs.get('max_time_mins', 2),
+            )
+            tpot.fit(X_train, y_train)
+            self.model = tpot.fitted_pipeline_
+
+        elif model_type == 'mlp':
+            mlp = build_model(X_train, y_train, **kwargs)  # Adjust as necessary
+            self.model = mlp.fit(X_train, y_train)
+
+        else:
+            raise ValueError("Invalid model type. Choose 'xgb', 'mlp', or 'tpot'.")
+
+        return self.model
+
+    def calibrate(self, X_train, y_train, method='sigmoid', cv=5):
+        """
+        Calibrate the fitted model using CalibratedClassifierCV.
+
+        Parameters:
+        - X_train: Features for training (for calibration).
+        - y_train: Labels for training (for calibration).
+        - method: Calibration method ('sigmoid' or 'isotonic').
+        - cv: Cross-validation splitting strategy.
+        """
+        if self.model is None:
+            raise ValueError("Model is not fitted yet. Call 'fit' first.")
+
+        # Ensure the model supports predict_proba
+        if not hasattr(self.model, "predict_proba"):
+            raise AttributeError("The fitted model does not support predict_proba.")
+
+        # Initialize calibrated model
+        calibrated_model = CalibratedClassifierCV(self.model, method=method, cv=cv)
+        calibrated_model.fit(X_train, y_train)
+
+        # Replace the model with the calibrated model
+        self.model = calibrated_model
+
+        return self.model
+    def predict(self, X_test):
+        """Make predictions using the fitted model."""
+        if self.model is None:
+            raise ValueError("Model is not fitted yet. Call 'fit_model' first.")
+        return self.model.predict(X_test)
+    
+    def predict_proba(self, X_test):
+        """Make predictions using the fitted model."""
+        if self.model is None:
+            raise ValueError("Model is not fitted yet. Call 'fit_model' first.")
         return self.model.predict_proba(X_test)

autofuzzts/models/mlp_nas.py

@@ -1,90 +1,90 @@
-from sklearn.neural_network import MLPClassifier  # Assuming you use sklearn's MLP
-from sklearn.model_selection import train_test_split
-import optuna
-
-
-def _objective(trial, X, y):
-    """
-    This is the objective function used for hyperparameter tuning
-    (internal function).
-    """
-    # ... Same code as before inside objective function ...
-
-    # Split data
-    x_train, x_test, y_train, y_test = train_test_split(
-        X, y, test_size=0.2, random_state=42
-    )
-
-    # Define and train the model with suggested hyperparameters
-    clf = MLPClassifier(
-        hidden_layer_sizes=tuple(
-            trial.suggest_int(f"n_units_{i}", 10, 100)
-            for i in range(trial.suggest_int("n_layers", 1, 4))
-        ),
-        activation=trial.suggest_categorical("activation", ["relu", "tanh"]),
-        solver="adam",  # Using only 'adam' solver
-        alpha=trial.suggest_float("alpha", 1e-5, 1e-1, log=True),
-        learning_rate_init=trial.suggest_float("learning_rate_init", 1e-4, 1e-2, log=True),
-        max_iter=200,
-        random_state=42,
-        early_stopping=True,
-        n_iter_no_change=10,
-    )
-    clf.fit(x_train, y_train)
-
-    # Evaluate the model
-    return clf.score(x_test, y_test)
-
-def build_model(X, y, n_trials=100):
-    """
-    This function performs hyperparameter tuning, builds, trains, and
-    returns a fitted MLP classifier model.
-
-    Args:
-        X: Training data features.
-        y: Training data labels.
-        n_trials: Number of trials for hyperparameter tuning (default: 100).
-
-    Returns:
-        A fitted MLPClassifier model.
-    """
-    # Define the neural network structure search space
-    study = optuna.create_study(direction="maximize")
-    study.optimize(lambda trial: _objective(trial, X, y), n_trials=n_trials)
-
-    # Print best parameters and best score
-    print(f"Best parameters: {study.best_params}")
-    print(f"Best score: {study.best_value}")
-
-    # Extract best hyperparameters
-    n_layers = study.best_params["n_layers"]
-    hidden_layer_sizes = tuple(
-        [study.best_params[f"n_units_{i}"] for i in range(n_layers)]
-    )
-    activation = study.best_params["activation"]
-    alpha = study.best_params["alpha"]
-    learning_rate_init = study.best_params["learning_rate_init"]
-
-    # Print model architecture
-    print("Model Architecture:")
-    print(f"\tNumber of Layers: {n_layers}")
-    print(f"\tHidden Layer Sizes: {hidden_layer_sizes}")
-    print(f"\tActivation Function: {activation}")
-    print(f"\tL2 Penalty (alpha): {alpha}")
-    print(f"\tInitial Learning Rate: {learning_rate_init}")
-
-    # Create the model with best hyperparameters
-    model = MLPClassifier(
-        hidden_layer_sizes=hidden_layer_sizes,
-        activation=activation,
-        solver="adam",
-        alpha=alpha,
-        learning_rate_init=learning_rate_init,
-        max_iter=200,
-        random_state=42,
-        early_stopping=True,
-        n_iter_no_change=10,
-    )
-
-    return model
-
+from sklearn.neural_network import MLPClassifier  # Assuming you use sklearn's MLP
+from sklearn.model_selection import train_test_split
+import optuna
+
+
+def _objective(trial, X, y):
+    """
+    This is the objective function used for hyperparameter tuning
+    (internal function).
+    """
+    # ... Same code as before inside objective function ...
+
+    # Split data
+    x_train, x_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    # Define and train the model with suggested hyperparameters
+    clf = MLPClassifier(
+        hidden_layer_sizes=tuple(
+            trial.suggest_int(f"n_units_{i}", 10, 100)
+            for i in range(trial.suggest_int("n_layers", 1, 4))
+        ),
+        activation=trial.suggest_categorical("activation", ["relu", "tanh"]),
+        solver="adam",  # Using only 'adam' solver
+        alpha=trial.suggest_float("alpha", 1e-5, 1e-1, log=True),
+        learning_rate_init=trial.suggest_float("learning_rate_init", 1e-4, 1e-2, log=True),
+        max_iter=200,
+        random_state=42,
+        early_stopping=True,
+        n_iter_no_change=10,
+    )
+    clf.fit(x_train, y_train)
+
+    # Evaluate the model
+    return clf.score(x_test, y_test)
+
+def build_model(X, y, n_trials=100):
+    """
+    This function performs hyperparameter tuning, builds, trains, and
+    returns a fitted MLP classifier model.
+
+    Args:
+        X: Training data features.
+        y: Training data labels.
+        n_trials: Number of trials for hyperparameter tuning (default: 100).
+
+    Returns:
+        A fitted MLPClassifier model.
+    """
+    # Define the neural network structure search space
+    study = optuna.create_study(direction="maximize")
+    study.optimize(lambda trial: _objective(trial, X, y), n_trials=n_trials)
+
+    # Print best parameters and best score
+    print(f"Best parameters: {study.best_params}")
+    print(f"Best score: {study.best_value}")
+
+    # Extract best hyperparameters
+    n_layers = study.best_params["n_layers"]
+    hidden_layer_sizes = tuple(
+        [study.best_params[f"n_units_{i}"] for i in range(n_layers)]
+    )
+    activation = study.best_params["activation"]
+    alpha = study.best_params["alpha"]
+    learning_rate_init = study.best_params["learning_rate_init"]
+
+    # Print model architecture
+    print("Model Architecture:")
+    print(f"\tNumber of Layers: {n_layers}")
+    print(f"\tHidden Layer Sizes: {hidden_layer_sizes}")
+    print(f"\tActivation Function: {activation}")
+    print(f"\tL2 Penalty (alpha): {alpha}")
+    print(f"\tInitial Learning Rate: {learning_rate_init}")
+
+    # Create the model with best hyperparameters
+    model = MLPClassifier(
+        hidden_layer_sizes=hidden_layer_sizes,
+        activation=activation,
+        solver="adam",
+        alpha=alpha,
+        learning_rate_init=learning_rate_init,
+        max_iter=200,
+        random_state=42,
+        early_stopping=True,
+        n_iter_no_change=10,
+    )
+
+    return model
+