autofuzzts 0.1.0__tar.gz

autofuzzts-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jan Timko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

autofuzzts-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: autofuzzts
+Version: 0.1.0
+Summary: Automated fuzzy time series forecasting library
+Home-page: https://github.com/jtimko16/AutoFuzzTS
+Author: Jan Timko
+Author-email: Jan Timko <jantimko16@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jtimko16/AutoFuzzTS
+Project-URL: Bug Tracker, https://github.com/jtimko16/AutoFuzzTS/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: scikit-learn>=1.5.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: xgboost>=3.0.0
+Requires-Dist: lightgbm>=4.6.0
+Requires-Dist: tpot>=1.0.0
+Requires-Dist: optuna>=4.3.0
+Requires-Dist: matplotlib>=3.10.0
+Requires-Dist: seaborn>=0.13.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: PyYAML>=6.0.0
+Requires-Dist: joblib>=1.4.0
+Requires-Dist: tqdm>=4.67.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# AutoFuzzTS
+
+Automated fuzzy time series forecasting library in Python.  
+Build and evaluate time series models automatically using fuzzy logic and AutoML techniques.
+
+## Installation
+
+```bash
+pip install autofuzzts

autofuzzts-0.1.0/README.md

@@ -0,0 +1,9 @@
+# AutoFuzzTS
+
+Automated fuzzy time series forecasting library in Python.  
+Build and evaluate time series models automatically using fuzzy logic and AutoML techniques.
+
+## Installation
+
+```bash
+pip install autofuzzts

autofuzzts-0.1.0/autofuzzts/__init__.py

@@ -0,0 +1 @@
+# __init__.py

autofuzzts-0.1.0/autofuzzts/config.py

@@ -0,0 +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)
+    return config

autofuzzts-0.1.0/autofuzzts/data/__init__.py

@@ -0,0 +1 @@
+# __init__.py

autofuzzts-0.1.0/autofuzzts/data/data_loader.py

@@ -0,0 +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)

autofuzzts-0.1.0/autofuzzts/data_validation/__init__.py

@@ -0,0 +1 @@
+# __init__.py

autofuzzts-0.1.0/autofuzzts/data_validation/validate.py

@@ -0,0 +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
+

autofuzzts-0.1.0/autofuzzts/evaluation/__init__.py

@@ -0,0 +1 @@
+# __init__.py

autofuzzts-0.1.0/autofuzzts/models/__init__.py

@@ -0,0 +1 @@
+# __init__.py

autofuzzts-0.1.0/autofuzzts/models/fuzzy_classifier.py

@@ -0,0 +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.")
+        return self.model.predict_proba(X_test)

autofuzzts-0.1.0/autofuzzts/models/mlp_nas.py

@@ -0,0 +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
+

autofuzzts-0.1.0/autofuzzts/partition/__init__.py

@@ -0,0 +1 @@
+# __init__.py

autofuzzts-0.1.0/autofuzzts/partition/fuzzy_clust_fun.py

@@ -0,0 +1,107 @@
+## Functions for fuzzy clustering
+import numpy as np
+import pandas as pd
+
+
+def fuzzy_partition_cosine(X: pd.Series, n: int):
+    """
+    Midsteps of the calculation:
+
+    D - distance vector (D) represents the relative position of each data point within the partition
+    h - height, spread of the fuzzy sets
+    """
+
+    n_rows = len(X)
+    x_min = X.min()
+    x_max = X.max()
+    
+    D = np.linspace(x_min, x_max, n)
+    h = (D[-1] - D[0]) / (n - 1)
+
+    A = np.zeros((n_rows, n))
+
+    for k in range(n_rows):
+        # First column
+        if (D[0] <= X[k]) and (X[k] <= D[1]):
+            A[k, 0] = 0.5 * (np.cos(np.pi * (X[k] - D[0]) / h) + 1)
+
+        # Last column    
+        elif (D[n - 2] <= X[k]) and (X[k] <= D[n - 1]):
+            A[k, n - 1] = 0.5 * (np.cos(np.pi * (X[k] - D[n - 1]) / h) + 1)
+
+        # All other columns    
+        for j in range(1, n - 1):
+            if (D[j - 1] <= X[k]) and (X[k] <= D[j + 1]):
+                A[k, j] = 0.5 * (np.cos(np.pi * (X[k] - D[j]) / h) + 1)
+
+    return D, A
+
+
+def fuzzy_partition_triangle(X: pd.Series, n: int):
+    """
+    Midsteps of the calculation:
+
+    D - distance vector (D) represents the relative position of each data point within the partition
+    h - height, spread of the fuzzy sets
+    """
+
+    n_rows = len(X)
+    x_min = X.min()
+    x_max = X.max()
+
+    D = np.linspace(x_min, x_max, n)
+    h = (D[-1] - D[0]) / (n - 1)
+
+    A = np.zeros((n_rows, n))
+
+    for k in range(n_rows):
+        # First column
+        if (D[0] <= X[k]) and (X[k] <= D[1]):
+            A[k, 0] = (D[1] - X[k]) / h
+        
+        # Last column
+        elif (D[n - 2] <= X[k]) and (X[k] <= D[n - 1]):
+            A[k, n - 1] = (X[k] - D[n - 2]) / h
+
+        # All other columns
+        for j in range(1, n - 1):
+            if (D[j - 1] <= X[k]) and (X[k] <= D[j]):
+                A[k, j] = (X[k] - D[j - 1]) / h
+            
+            if (D[j] <= X[k]) and (X[k] <= D[j + 1]):
+                A[k, j] = (D[j + 1] - X[k]) / h
+
+    return D, A
+
+
+def fuzzy_partition_gauss(X: pd.Series, n: int, sigma: float = 1):
+    """
+    Midsteps of the calculation:
+
+    D - distance vector (D) represents the relative position of each data point within the partition
+    h - height, spread of the fuzzy sets
+    sigma - standard deviation of the Gaussian function
+    """
+
+    n_rows = len(X)
+    x_min = X.min()
+    x_max = X.max()
+
+    D = np.linspace(x_min, x_max, n)
+    A = np.zeros((n_rows, n))
+
+    for k in range(n_rows):
+        # First column
+        if (D[0] <= X[k]) and (X[k] <= D[1]):
+            A[k, 0] = np.exp(-((X[k] - D[0]) ** 2) / (2 * sigma**2))
+        
+        # Last column
+        elif (D[n - 2] <= X[k]) and (X[k] <= D[n - 1]):
+            A[k, n - 1] = np.exp(-((X[k] - D[n - 1]) ** 2) / (2 * sigma**2))
+
+        # All other columns
+        for j in range(1, n - 1):
+            if (D[j - 1] <= X[k]) and (X[k] <= D[j + 1]):
+                A[k, j] = np.exp(-((X[k] - D[j]) ** 2) / (2 * sigma**2))
+
+    return D, A

autofuzzts-0.1.0/autofuzzts/partition/fuzzy_clust_fun_orig.py

@@ -0,0 +1,129 @@
+## Functions for fuzzy clustering
+import numpy as np
+import pandas as pd
+
+
+def fuzzy_partition_cosine(X: pd.Series, n:float):
+    '''
+
+    Midsteps of the calculation:
+
+    D - distance vector (D) represents the relative position of each data point within the partition
+    h - height, spread of the fuzzy sets 
+
+    '''
+
+    n_rows = len(X)
+    x_spread = X.max() - X.min() # spread of the data
+
+    D = np.zeros((n,1))
+    for i in range(0,n):
+        D[i] = i/(n-1)*x_spread   # D is adjusted by the x_spread
+    h = (D[-1]-D[0])/(n-1)
+ 
+    A = np.zeros((n_rows,n))
+
+    x_sorted = np.sort(X) # sort the data
+
+    for k in range(0,n_rows):
+        if (D[0] <= x_sorted[k]) and (x_sorted[k] <= D[1]):
+            A[k, 0] = 0.5*(np.cos(np.pi*(x_sorted[k]-D[0])/h)+1)
+        else:
+            if (D[n - 2] <= x_sorted[k]) and (x_sorted[k] <= D[n-1]):
+                A[k, n-1] = 0.5*(np.cos(np.pi*(x_sorted[k]-D[n-1])/h)+1)
+        for j in range(1,n-1):
+            if (D[j - 1] <= x_sorted[k]) and (x_sorted[k] <= D[j+1]):
+                A[k,j]=0.5*(np.cos(np.pi*(x_sorted[k]-D[j])/h)+1)
+
+    return D,A
+
+
+
+
+
+def fuzzy_partition_triangle(X: pd.Series, n:float):
+    '''
+
+    Midsteps of the calculation:
+
+    D - distance vector (D) represents the relative position of each data point within the partition
+    h - height, spread of the fuzzy sets 
+
+    '''
+
+    n_rows = len(X)
+    x_spread = X.max() - X.min() # spread of the data
+
+    D = np.zeros((n,1))
+    for i in range(0,n):
+        D[i] = i/(n-1)*x_spread   # D is adjusted by the x_spread
+    h = (D[-1]-D[0])/(n-1)
+ 
+    A = np.zeros((n_rows,n))
+
+    x_sorted = np.sort(X) # sort the data
+
+    for k in range(0,n_rows):
+
+        # First column
+        if (D[0] <= x_sorted[k]) and (x_sorted[k] <= D[1]):
+            A[k, 0] = (D[1]-x_sorted[k])/h
+
+        # Last column   
+        else:
+            if (D[n - 2] <= x_sorted[k]) and (x_sorted[k] <= D[n-1]):
+                A[k, n-1] =  (x_sorted[k]-D[n-2])/h
+
+        # All other columns
+        for j in range(1,n-1):
+            if (D[j - 1] <= x_sorted[k]) and (x_sorted[k]<= D[j]):
+                A[k,j] =  (x_sorted[k]-D[j-1])/h
+
+            if (D[j] <= x_sorted[k]) and (x_sorted[k] <= D[j+1]):
+                A[k,j] =  (D[j+1]-x_sorted[k])/h 
+
+    return D,A
+
+
+def fuzzy_partition_gauss(X: pd.Series, n:float, sigma:float = 1):
+    '''
+
+    Midsteps of the calculation:
+
+    D - distance vector (D) represents the relative position of each data point within the partition
+    h - height, spread of the fuzzy sets 
+
+    '''
+    
+    n_rows = len(X)
+    x_spread = X.max() - X.min() # spread of the data
+
+    D = np.zeros((n,1))
+    for i in range(0,n):
+        D[i] = i/(n-1)*x_spread   # D is adjusted by the x_spread
+    h = (D[-1]-D[0])/(n-1)
+ 
+    A = np.zeros((n_rows,n))
+
+    x_sorted = np.sort(X) # sort the data
+
+    for k in range(0,n_rows):
+
+            # First column
+            if (D[0] <= x_sorted[k]) and (x_sorted[k] <= D[1]):
+                A[k, 0] = np.exp(-(x_sorted[k] - D[0]) ** 2 / (2 * sigma ** 2))
+            
+            # Last column   
+            else:
+                if (D[n - 2] <= k) and (x_sorted[k] <= D[n-1]):
+                    A[k, n-1] =   np.exp(-(x_sorted[k] - D[n-1]) ** 2 / (2 * sigma ** 2))
+                    
+
+            # All other columns
+            for j in range(1,n-1):
+                if (D[j - 1] <= x_sorted[k]) and (x_sorted[k] <= D[j+1]):
+                    A[k,j] = np.exp(-(x_sorted[k] - D[j]) ** 2 / (2 * sigma ** 2))
+
+
+    return D,A
+

autofuzzts-0.1.0/autofuzzts/partition/partition.py

@@ -0,0 +1,110 @@
+import numpy as np
+import pandas as pd
+from typing import Union, Literal
+import warnings
+from sklearn.preprocessing import MinMaxScaler
+
+from autofuzzts.partition.fuzzy_clust_fun import (
+    fuzzy_partition_cosine,
+    fuzzy_partition_triangle,
+    fuzzy_partition_gauss,
+)
+
+class FuzzyPartition:
+    def __init__(self, fuzzy_function: Literal["cosine", "triangle", "gauss"], n_clusters: int, sigma: float, scaler: MinMaxScaler, verbosity: bool = False):
+        self.fuzzy_function = self._get_fuzzy_partition_func(fuzzy_function)
+        self.n_clusters = n_clusters
+        self.sigma = sigma
+        self.verbosity = verbosity
+        self.scaler = scaler  
+
+        if scaler is None:  # Check if scaler is None
+            warnings.warn("Scaler must be provided for inverse transformation.")
+
+    def _get_fuzzy_partition_func(self, fuzzy_part_func: Union[str, None]):
+        if fuzzy_part_func == "cosine":
+            return fuzzy_partition_cosine  # Replace with actual function
+        elif fuzzy_part_func == "triangle":
+            return fuzzy_partition_triangle  # Replace with actual function
+        elif fuzzy_part_func == "gauss":
+            return fuzzy_partition_gauss  # Replace with actual function
+        else:
+            return fuzzy_partition_cosine  # Default function
+
+    def fuzzy_partition(self, X: np.ndarray) -> pd.DataFrame:
+        """
+        Perform fuzzy partitioning on the target variable X.
+
+        Parameters:
+            X (np.ndarray): Input data to be partitioned.
+
+        Returns:
+            pd.DataFrame: DataFrame containing partition results.
+        """
+        # Perform fuzzy partitioning using the selected function
+        if self.fuzzy_function.__name__ == "fuzzy_partition_gauss":
+            D, A = self.fuzzy_function(X=X, n=self.n_clusters, sigma=self.sigma)
+        else:
+            D, A = self.fuzzy_function(X=X, n=self.n_clusters)
+
+        center_points = list(D.flatten())
+        center_points = [round(i, 2) for i in center_points]
+        center_points = np.array(center_points)
+
+        if self.verbosity:
+            print("Cluster center points:", center_points)
+
+        # Unscaled center points
+        center_points_unscaled = self.scaler.inverse_transform(
+            center_points.reshape(-1, 1)
+        )
+        self.center_points_unscaled = center_points_unscaled.flatten()
+        if self.verbosity:
+            print("Cluster center points unscaled:", self.center_points_unscaled.flatten())
+
+        # Create a DataFrame for membership values
+        A_df = pd.DataFrame(A)
+        A_df.columns = ["set_" + str(i) for i in range(A_df.shape[1])]
+        
+        # Prepare the fuzzy partition DataFrame
+        fp_df = A_df.copy()
+        fp_df.insert(0, "X_value", X)
+        fp_df["membership_value"] = fp_df.iloc[:, 1:].max(axis=1)
+        fp_df["cluster"] = fp_df.iloc[:, 1:].idxmax(axis=1)
+
+        # Initialize 'left' and 'right' columns
+        fp_df["left"] = 0
+        fp_df["right"] = 0
+
+        # Define sets for left and right logic
+        set_min = "set_0"
+        set_max = "set_" + str(len(center_points) - 1)
+
+        # Set left and right for min and max sets
+        fp_df.loc[fp_df["cluster"] == set_min, "right"] = 1
+        fp_df.loc[fp_df["cluster"] == set_max, "left"] = 1
+
+        fp_df["center_point"] = ""
+        fp_df.loc[fp_df["cluster"] == set_min, "center_point"] = 0
+        fp_df.loc[fp_df["cluster"] == set_max, "center_point"] = 1
+
+        # Logic for intermediate clusters
+        for i in range(1, len(center_points) - 1):
+            set_i = "set_" + str(i)
+            fp_df.loc[fp_df["cluster"] == set_i, "center_point"] = center_points[i]
+            fp_df.loc[
+                (fp_df["cluster"] == set_i) & (fp_df["X_value"] >= center_points[i]),
+                "right",
+            ] = 1
+            fp_df.loc[
+                (fp_df["cluster"] == set_i) & (fp_df["X_value"] < center_points[i]),
+                "left",
+            ] = 1
+
+        # Ensure membership values are non-negative
+        fp_df.loc[fp_df["membership_value"] < 0, "membership_value"] = 0
+        
+        # Keep only relevant columns
+        fp_df = fp_df.loc[:, ["X_value", "membership_value", "cluster", "left"]]
+        
+        return fp_df, center_points, center_points_unscaled.flatten()