autofuzzts 0.1.0__py3-none-any.whl

autofuzzts/__init__.py

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

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/data/__init__.py

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

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/data_validation/__init__.py

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

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/evaluation/__init__.py

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

autofuzzts/models/__init__.py

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

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/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/partition/__init__.py

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

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/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/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()

autofuzzts/partition/visualize_partition.py

@@ -0,0 +1,32 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def visualize_partition(fp_df, center_points):
+    plt.figure(figsize=(6, 3))
+
+    # Scatter plot with size based on membership value
+    plt.scatter(
+        fp_df["X_value"],
+        fp_df["membership_value"],
+        c=fp_df["cluster"].astype("category").cat.codes,
+        cmap="viridis",
+        s=50,
+    )
+    plt.xlabel("X")
+    plt.ylabel("Membership Value")
+    plt.title("Fuzzy Partition")
+
+    # Plot center points with horizontal line at y=0.5
+    plt.plot(center_points, np.ones_like(center_points) * 0.5, "x", markersize=10)
+
+    # Add labels for center points with slight vertical offset
+    for i, txt in enumerate(center_points):
+        plt.annotate(
+            txt,
+            (center_points[i], 0.5 + 0.015),
+            horizontalalignment="center",
+            fontsize=8,
+        )
+
+    plt.show()

autofuzzts/pipeline.py

@@ -0,0 +1,383 @@
+# pipeline.py
+import pandas as pd
+from typing import Dict, Literal
+import optuna
+import numpy as np
+
+from autofuzzts.config import get_config
+from autofuzzts.data import data_loader
+from autofuzzts.data_validation.validate import validate_and_clean_input
+from autofuzzts.partition.partition import FuzzyPartition
+from autofuzzts.preprocess.preprocess import preprocess_data,preprocess_data_val
+from autofuzzts.preprocess.prep_for_model import prepare_for_model,prepare_for_model_val_set
+from autofuzzts.models.fuzzy_classifier import FuzzyPipelineModel
+
+from sklearn.model_selection import ParameterGrid
+from sklearn.calibration import CalibratedClassifierCV
+
+
+## Import RMSE and MAE
+from sklearn.metrics import root_mean_squared_error, mean_absolute_error,mean_squared_error
+
+# Example custom configuration
+custom_config = {
+    "n_clusters": 5,
+    "verbosity": True,
+}
+
+# Retrieve the final configuration
+selected_config = get_config(custom_config)
+
+
+
+def run_pipeline(datasetet_name: str, config: dict = selected_config):
+    # Load data
+
+    data = data_loader.load_sample_data(datasetet_name)
+    print(data.head(5))
+    print('Evaluated configuration is')
+    print(config)
+
+    pass
+  
+
+def train_val_pipeline(train_set:pd.DataFrame,val_set:pd.DataFrame,config:Dict = selected_config, metric:Literal['rmse','mse','mae'] = 'rmse', 
+                       diff_type:Literal['perc','abs'] = 'perc', covariates:list[str] = None) -> float:
+    train_set = validate_and_clean_input(train_set, covariates)
+    val_set = validate_and_clean_input(val_set, covariates)
+
+    print('train set length:', len(train_set))
+
+    if covariates :
+        train_covariates = train_set[covariates].copy()
+        val_covariates = val_set[covariates].copy() 
+
+
+    train_set_preprocessed, scaler_train = preprocess_data(train_set, diff_type)
+    val_set_preprocessed = preprocess_data_val(df=val_set, df_train=train_set, diff_type=diff_type, scaler=scaler_train)
+
+       
+    fp = FuzzyPartition(fuzzy_function=config['fuzzy_part_func'], n_clusters=config['n_clusters'], sigma=config['sigma'], scaler=scaler_train, verbosity=config['verbosity'])
+
+    # Prepare train and validation fuzzy partitions
+    X_training = train_set_preprocessed['diff_scaled'].values
+    X_validation = val_set_preprocessed['diff_scaled'].values
+
+
+    train_fuzzy_partition,_,_  = fp.fuzzy_partition(X_training)
+    val_fuzzy_partition, _,center_points_unscaled_test_val  = fp.fuzzy_partition(X_validation)
+
+    X_train, y_train = prepare_for_model(train_fuzzy_partition.copy(), config['number_of_lags'])
+    X_val, y_val = prepare_for_model_val_set(df_val_fp = val_fuzzy_partition.copy(),df_train_fp = train_fuzzy_partition.copy(),n_lags = config['number_of_lags'])
+
+       
+    if covariates:
+        X_train = pd.concat([X_train, train_covariates], axis=1)
+        X_val = pd.concat([X_val, val_covariates], axis=1)
+
+    model = FuzzyPipelineModel(n_clusters=config['n_clusters'], number_of_lags=config['number_of_lags'], verbosity=config['verbosity'])
+
+
+    model.fit(X_train, y_train, model_type='xgb')
+
+    pred_cluster = model.predict(X_val)
+
+
+    ## Convert prediction to crips number using center points of clusters
+    y_val_pred_center_point = [center_points_unscaled_test_val[i] for i in pred_cluster]
+
+
+
+
+    ## Recalculate percentage difference to actual values
+    y_val_pred= [None] * len(val_set)
+
+    # Set the first prediction using the last known value from the train set
+    last_train_value = train_set['Y'].iloc[-1]  # Assuming `df_train` holds the training data
+    y_val_pred[0] = last_train_value * (1 + y_val_pred_center_point[0])
+
+    # Loop to calculate each subsequent prediction based on the actual previous value in `df_test['Y']`
+
+    if diff_type == 'perc':
+        for i in range(1, len(val_set)):
+            prev_Y = val_set['Y'].iloc[i-1]  # Use the previous actual value from `df_test`
+            perc_change = y_val_pred_center_point[i]
+            y_val_pred[i] = prev_Y * (1 + perc_change)
+
+    elif diff_type == 'abs':
+        for i in range(1, len(val_set)):
+            prev_Y = val_set['Y'].iloc[i-1]
+            y_val_pred[i] = prev_Y + y_val_pred_center_point[i]
+        
+
+    if metric == 'rmse':
+        metric_value = root_mean_squared_error(val_set['Y'], y_val_pred)
+    elif metric == 'mse':
+        metric_value = root_mean_squared_error(val_set['Y'], y_val_pred)**2
+    elif metric == 'mae':
+        metric_value = mean_absolute_error(val_set['Y'], y_val_pred)
+    else:
+        raise ValueError(f"Invalid metric {metric}. Please choose one of 'rmse', 'mse', 'mae'")
+  
+    return metric_value
+
+def train_model(dataset: pd.DataFrame, config: Dict, model_type: Literal['xgb','mlp','tpot'] = 'xgb'):
+    '''
+    Function to train a model on the dataset provided.
+
+    Parameters:
+    dataset: pd.DataFrame
+        The dataset to train the model on.
+    config: dict
+        The configuration dictionary for the model.
+    model_type: str
+        The type of model to train. Default is 'xgb'.
+    
+    '''
+    config = get_config(config)
+
+    df = validate_and_clean_input(dataset)
+    
+    df_preprocessed, scaler_train = preprocess_data(df, diff_type='perc')
+
+       
+    fp = FuzzyPartition(fuzzy_function=config['fuzzy_part_func'], n_clusters=config['n_clusters'], sigma=config['sigma'], scaler=scaler_train, verbosity=config['verbosity'])
+
+    X_training = df_preprocessed['diff_scaled'].values
+
+    train_fuzzy_partition,_,_  = fp.fuzzy_partition(X_training)
+
+    X_train, y_train = prepare_for_model(train_fuzzy_partition.copy(), config['number_of_lags'])
+
+    model_train = FuzzyPipelineModel(n_clusters=config['n_clusters'], number_of_lags=config['number_of_lags'], verbosity=config['verbosity'])
+
+    model_train.fit(X_train, y_train, model_type=model_type)
+  
+    
+    return model_train, scaler_train
+
+def tune_hyperparameters_bayes(train_set: pd.DataFrame, val_set: pd.DataFrame, n_trials: int = 315, metric: Literal['rmse', 'mse', 'mae'] = 'rmse', 
+                               diff_type: Literal['perc', 'abs'] = 'perc', covariates: list[str] = None):
+    def objective(trial):
+        # Define search space based on your specifications
+        config = {
+            'n_clusters': trial.suggest_int('n_clusters', 4, 40),  # Number of fuzzy sets
+            'number_of_lags': trial.suggest_int('number_of_lags', 1, 10),  # Number of lags
+            'fuzzy_part_func': trial.suggest_categorical('fuzzy_part_func', ['Triangle', 'Cosine', 'Gaussian']),  # Partition function type
+        }
+
+        if config['fuzzy_part_func'] == 'Gaussian':
+            config['sigma'] = trial.suggest_float('sigma', 0.1, 4, log=True)
+        else:
+            config['sigma'] = None
+
+        selected_config = get_config(config)
+
+        # Use train_val_pipeline to evaluate this configuration
+        metric_value = train_val_pipeline(train_set, val_set, selected_config, metric, diff_type, covariates=covariates)
+        return metric_value
+
+
+    # Create and optimize the Optuna study
+    study = optuna.create_study(direction="minimize")
+    study.optimize(objective, n_trials=n_trials)
+
+    # Extract the best configuration and score
+    best_config = study.best_params
+    best_metric_value = study.best_value
+
+    print(f"Best Config: {best_config}")
+    print(f"Best {metric.upper()}: {best_metric_value}")
+    return best_config, best_metric_value
+
+
+def tune_hyperparameters_bayes_Henon(train_set: pd.DataFrame, val_set: pd.DataFrame, n_trials: int = 315, metric: Literal['rmse', 'mse', 'mae'] = 'rmse', diff_type: Literal['perc', 'abs'] = 'perc'):
+    def objective(trial):
+        config = {
+        'n_clusters': trial.suggest_int('n_clusters', 2, 29),  # Number of fuzzy sets
+        'number_of_lags': trial.suggest_int('n_lags', 2, 5),  # Number of lags
+        'fuzzy_part_func': trial.suggest_categorical('fuzzy_part_func', ['Triangle', 'Cosine', 'Gaussian']),
+        }
+
+        if config['fuzzy_part_func'] == 'Gaussian':
+            config['sigma'] = trial.suggest_float('sigma', 0.1, 4, log=True)
+        else:
+            config['sigma'] = None
+        
+        selected_config = get_config(config)
+
+        # Use train_val_pipeline to evaluate this configuration
+        metric_value = train_val_pipeline(train_set, val_set, selected_config, metric,diff_type)
+        return metric_value
+
+
+    # Create and optimize the Optuna study
+    study = optuna.create_study(direction="minimize")
+    study.optimize(objective, n_trials=n_trials)
+
+    # Extract the best configuration and score
+    best_config = study.best_params
+    best_metric_value = study.best_value
+
+    print(f"Best Config: {best_config}")
+    print(f"Best {metric.upper()}: {best_metric_value}")
+    return best_config, best_metric_value
+
+
+
+
+
+def tune_hyperparameters_grid(train_set: pd.DataFrame, val_set: pd.DataFrame,n_trials: int = 315, metric: Literal['rmse', 'mse', 'mae'] = 'rmse', diff_type: Literal['perc', 'abs'] = 'perc'):
+    
+    # Define grid for Gaussian fuzzy function (includes 'sigma')
+    grid_gauss = {
+        'n_lags': [1, 3, 5, 7, 9],
+        'n_clusters': [4, 6, 8, 10, 12, 14, 16, 18, 20],
+        'sigma': [0.1, 0.5, 1, 5, 9],
+        'fuzzy_part_func': ['matrix_F_transform_gauss']
+    }
+
+    # Define grid for non-Gaussian fuzzy functions (excludes 'sigma')
+    grid_non_gauss = {
+        'n_lags': [1, 3, 5, 7, 9],
+        'n_clusters': [4, 6, 8, 10, 12, 14, 16, 18, 20],
+        'sigma': [None],  # Set sigma to None for non-Gaussian functions
+        'fuzzy_part_func': ['matrix_F_transform_cosine', 'matrix_F_transform_triangle']
+    }
+
+    # Combine the grids
+    grid_gauss = list(ParameterGrid(grid_gauss))
+    grid_non_gauss = list(ParameterGrid(grid_non_gauss))
+    combined_grid = grid_gauss + grid_non_gauss
+
+    ## Run the grid search------------------------------------------------------------------------------------------------------
+    best_metric_value = float("inf")
+    best_config = None
+    num_evaluations = 0
+
+    for config in combined_grid:
+        selected_config = get_config(config)
+        # Count the configuration being evaluated
+        num_evaluations += 1
+
+        if num_evaluations >= n_trials:
+            break
+
+        ## If number of evaluation is divisible by 20 print the number of evaluations
+        if num_evaluations % 20 == 0:
+            print(f"Number of evaluations done: {num_evaluations}")
+
+        # Evaluate the config on the validation set using train_val_pipeline
+        metric_value = train_val_pipeline(train_set, val_set, selected_config, metric, diff_type)
+
+        # Update best config if this one is better according to the selected metric
+        if metric_value < best_metric_value:
+            best_metric_value = metric_value
+            best_config = config
+
+
+    return best_config, best_metric_value, num_evaluations
+
+
+
+
+def train_calib_pred_test(train_set: pd.DataFrame, test_set: pd.DataFrame, 
+                     config: Dict,
+                     model_type: Literal['xgb','mlp','tpot'] = 'xgb', number_cv_calib = 5, diff_type: Literal['perc','abs'] = 'perc',
+                     covariates: list[str] = None, exclude_bool:bool = False) -> float:
+    '''
+    Aim of this question is to train a model on the train set, calibrate it using the calibration method provided, and predict it on the test set using the metric provided.
+    '''
+
+    config = get_config(config)
+    
+    # Step 1: Validate and preprocess the input data
+    train_set = validate_and_clean_input(train_set, covariates=covariates)
+    test_set = validate_and_clean_input(test_set, covariates=covariates)
+
+    train_set_preprocessed, scaler_train = preprocess_data(train_set, diff_type=diff_type)
+    test_set_preprocessed = preprocess_data_val(df=test_set, df_train=train_set, diff_type=diff_type, scaler=scaler_train)
+
+    # Step 2: Fuzzy Partition for train, validation, and test sets
+    fp = FuzzyPartition(fuzzy_function=config['fuzzy_part_func'], 
+                        n_clusters=config['n_clusters'], 
+                        sigma=config['sigma'], 
+                        scaler=scaler_train, 
+                        verbosity=config['verbosity'])
+
+    # Prepare train, validation, and test fuzzy partitions
+    X_training = train_set_preprocessed['diff_scaled'].values
+    X_test = test_set_preprocessed['diff_scaled'].values
+
+    train_fuzzy_partition, _, _ = fp.fuzzy_partition(X_training)
+    test_fuzzy_partition, _, center_points_unscaled_test = fp.fuzzy_partition(X_test)
+
+    if exclude_bool:
+        ## Remove column left from train_fuzzy_partition
+        train_fuzzy_partition = train_fuzzy_partition.drop(columns=['left'])
+        test_fuzzy_partition = test_fuzzy_partition.drop(columns=['left'])
+
+    train_fuzzy_partition.to_csv('train_fuzzy_partition.csv')
+    test_fuzzy_partition.to_csv('test_fuzzy_partition.csv')
+
+    print('center_points_unscaled_test:', center_points_unscaled_test)
+
+    # Prepare data for model training, validation, and testing
+    X_train, y_train = prepare_for_model(train_fuzzy_partition.copy(), config['number_of_lags'])
+    X_test_final, _ = prepare_for_model_val_set(df_val_fp=test_fuzzy_partition.copy(),
+                                                           df_train_fp=train_fuzzy_partition.copy(),
+                                                           n_lags=config['number_of_lags'])
+    
+    if covariates:
+        train_covariates = train_set[covariates].copy()
+        test_covariates = test_set[covariates].copy() 
+
+        X_train = pd.concat([X_train, train_covariates], axis=1)
+        X_test_final = pd.concat([X_test_final, test_covariates], axis=1)
+    
+
+    # Step 3: Train the model on the combined train and validation set
+    model = FuzzyPipelineModel(n_clusters=config['n_clusters'], 
+                               number_of_lags=config['number_of_lags'], 
+                               verbosity=config['verbosity'])
+ 
+    model.fit(X_train, y_train, model_type=model_type)
+
+    try:
+        # Step 4: Calibrate the model using CalibratedClassifierCV
+        model.calibrate(X_train, y_train, method='sigmoid', cv=number_cv_calib)
+    except:
+        pass
+
+    # Step 5: Make predictions and evaluate on the test set
+    y_test_pred_cluster = model.predict(X_test_final)
+
+    ## Convert prediction to crips number using center points of clusters
+    y_test_pred_center_point = [center_points_unscaled_test[i] for i in y_test_pred_cluster]
+
+
+
+
+    ## Recalculate percentage difference to actual values
+    y_test_pred= [None] * len(test_set)
+
+    # Set the first prediction using the last known value from the train set
+    last_train_value = train_set['Y'].iloc[-1]  # Assuming `df_train` holds the training data
+    y_test_pred[0] = last_train_value * (1 + y_test_pred_center_point[0])
+
+    if diff_type == 'perc':
+        # Loop to calculate each subsequent prediction based on the actual previous value in `df_test['Y']`
+        for i in range(1, len(test_set)):
+            prev_Y = test_set['Y'].iloc[i-1]  # Use the previous actual value from `df_test`
+            perc_change = y_test_pred_center_point[i]
+            y_test_pred[i] = prev_Y * (1 + perc_change)
+
+    elif diff_type == 'abs':
+        for i in range(1, len(test_set)):
+            prev_Y = test_set['Y'].iloc[i-1]
+            y_test_pred[i] = prev_Y + y_test_pred_center_point[i]
+
+    return y_test_pred_cluster, y_test_pred_center_point,y_test_pred
+
+
+

autofuzzts/preprocess/__init__.py

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

autofuzzts/preprocess/prep_for_model.py

@@ -0,0 +1,70 @@
+import pandas as pd
+import warnings
+from sklearn.preprocessing import LabelEncoder
+
+def prepare_for_model(df: pd.DataFrame, number_of_lags: int):
+    """
+    Prepare clustering data for modeling.
+    
+    Parameters:
+    - df (pd.DataFrame): The input DataFrame containing clustering data.
+    - number_of_lags (int): The number of lag features to create.
+
+    Returns:
+    - X_train (pd.DataFrame): Features for training the model.
+    - y_train (np.ndarray): Target variable for training the model.
+    """
+    
+    # Prepare the 'cluster' column
+    df.loc[:, "cluster"] = df["cluster"].str.replace("set_", "").astype(int).copy()
+
+    # Create lagged features
+    for i in range(1, number_of_lags + 1):
+        df.loc[:, "cluster_lag" + str(i)] = df["cluster"].shift(i).copy()
+        df.loc[:, "membership_value_lag" + str(i)] = df["membership_value"].shift(i).copy()
+        df.loc[:, "left_lag" + str(i)] = df["left"].shift(i).copy()
+
+    # Reset warning filter
+    warnings.filterwarnings("default", category=pd.errors.SettingWithCopyWarning)
+
+    # Prepare the model DataFrame
+    df_model = df.copy()
+    df_model.drop(columns=["membership_value", "left"], inplace=True)
+    df_model.rename(columns={"X_value": "Y"}, inplace=True)
+
+    numeric_cols = df_model.select_dtypes(include=['float64', 'int64']).columns
+    df_model[numeric_cols] = df_model[numeric_cols].fillna(0)
+
+
+    # Separate target and features
+    y_train = df_model["cluster"]
+    X_train = df_model.drop(columns=["Y", "cluster"])
+
+    # Encode categorical columns
+    label_encoder = LabelEncoder()
+    encoded_cols = []
+
+    # Loop through columns and encode if they start with 'cluster_'
+    for col in X_train.columns:
+        if col.startswith("cluster_"):
+            X_train[col] = label_encoder.fit_transform(X_train[col])
+            encoded_cols.append(col)
+
+    # Label encode y_train
+    y_train = label_encoder.fit_transform(y_train)
+
+    return X_train, y_train
+
+def prepare_for_model_val_set(df_val_fp: pd.DataFrame, df_train_fp: pd.DataFrame, n_lags: pd.DataFrame):
+    '''
+    Prepare validation set. Attach to the begginning of val set rows from the end of the train set (based on numbef of lags). In the end remove the attached rows.
+    '''
+    df_concat = pd.concat([df_train_fp.tail(n_lags), df_val_fp], axis=0).reset_index(drop=True)
+
+
+    X_val, y_val = prepare_for_model(df=df_concat, number_of_lags=n_lags)
+
+    X_val = X_val.iloc[n_lags:]
+    y_val = y_val[n_lags:]
+
+    return X_val, y_val

autofuzzts/preprocess/preprocess.py

@@ -0,0 +1,63 @@
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+from typing import Literal
+
+
+def preprocess_data(df: pd.DataFrame, diff_type: Literal['perc', 'abs'] = 'perc', scaler: MinMaxScaler = None) -> pd.DataFrame:
+    """
+    Prepares time series data by calculating differences, scaling, and selecting rows.
+    
+    Parameters:
+        df (pd.DataFrame): Input DataFrame with a single column named 'Y' containing the time series data.
+        diff_type (str): Type of difference to calculate ('perc' for percentage, 'abs' for absolute). Default is 'perc'.
+        n_rows (int): Number of rows to retain from the end. If -1, use all rows.
+    
+    Returns:
+        np.ndarray: The preprocessed data, scaled and ready for further processing.
+        MinMaxScaler: The scaler used for scaling, useful for inverse transformation.
+    """
+    
+    # Step 1: Calculate the difference based on user choice
+    if diff_type == 'perc':
+        df['diff'] = df['Y'].pct_change()  # Percentage difference
+    elif diff_type == 'abs':
+        df['diff'] = df['Y'].diff()  # Absolute difference
+    else:
+        raise ValueError("Invalid diff_type. Choose 'perc' for percentage or 'abs' for absolute.")
+    
+
+    ## Replace infinite values with 1 or -1
+    df['diff'] = np.where(df['diff'] == np.inf, 1, df['diff'])
+    df['diff'] = np.where(df['diff'] == -np.inf, -1, df['diff'])
+
+    ## If diff is bellow 0.01 quantile or 0.99 quantile, replace with 0.01 or 0.99 quantile
+    df['diff'] = np.where(df['diff'] < df['diff'].quantile(0.01), df['diff'].quantile(0.01), df['diff'])
+    df['diff'] = np.where(df['diff'] > df['diff'].quantile(0.99), df['diff'].quantile(0.99), df['diff'])
+
+
+    ## Relace NaNs with 0
+    df['diff'] = df['diff'].fillna(0)  # Replace NaNs with 0, or adjust as needed
+
+    # Step 2: Scale only the 'diff' column
+    if scaler is None:  # If no scaler is provided, create a new one (otherwise use the existing one)
+        scaler = MinMaxScaler()
+
+    df_scaled = df.copy()
+    df_scaled['diff_scaled'] = scaler.fit_transform(df[['diff']])  # Scale 'diff' column only
+ 
+
+
+
+    return df_scaled, scaler  # Return scaled data and scaler for possible inverse transform
+
+def preprocess_data_val(df: pd.DataFrame,df_train: pd.DataFrame, diff_type: Literal['perc', 'abs'] = 'perc', scaler: MinMaxScaler = None):
+    '''
+    Attach last row of train set to the beginnig of the val set and preprocess the data. In the end remove the attached row.
+    '''
+    df_concat = pd.concat([df_train.tail(1), df], axis=0)
+    df_preprocessed, scaler = preprocess_data(df=df_concat, diff_type=diff_type, scaler=scaler)
+    df_preprocessed = df_preprocessed.iloc[1:]
+    return df_preprocessed
+
+    

autofuzzts/utils.py

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

autofuzzts-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,25 @@
+autofuzzts/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/config.py,sha256=rzwULHfKKtf5Rdpm8pk-zwuXrkKc0dckF-xIfz1UVcY,392
+autofuzzts/pipeline.py,sha256=3rre8nzxEtSQI2_G4STt-AqIACEDLczP0t4YMr0IMW8,15782
+autofuzzts/utils.py,sha256=lywC_KhHuYgjUmXjj-ay9vZYTKUSxFgWXY2q6EdWf9s,10
+autofuzzts/data/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/data/data_loader.py,sha256=VO8V9O3WgXffyktUMSmbGTiXWBJ2kgN5wLqgFgvkE6w,266
+autofuzzts/data_validation/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/data_validation/validate.py,sha256=ttK3nnvfTfxFF_GKyfxuU168oqmA6MEemB1dP06mL7g,1453
+autofuzzts/evaluation/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/models/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/models/fuzzy_classifier.py,sha256=mU0t91n-8mTJQs-_XDYbrix9oa6EQP_3UvGDCw-GmJY,3363
+autofuzzts/models/mlp_nas.py,sha256=OCFtrd47IhesAqtaHpBTOwKPdFly9yjl7O-25msXXGE,3048
+autofuzzts/partition/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/partition/fuzzy_clust_fun.py,sha256=NlpkI8s7N4ebdHWbGECsQZqk1Xf8v0c15cA27JEMJ-A,3097
+autofuzzts/partition/fuzzy_clust_fun_orig.py,sha256=JlXYw-MxiNAcIasYTyWiQHaHhJuY8h_BRy3jLo2efOA,3653
+autofuzzts/partition/partition.py,sha256=f5nTHjrJJYKjtzMFxsdfPL_CGBb12HOR0hkGi4L_WLY,4410
+autofuzzts/partition/visualize_partition.py,sha256=F31yovGfosqa-EmtuQdIIuF61XejHEGGdALfHHAtDu0,909
+autofuzzts/preprocess/__init__.py,sha256=2k_ZeqU7FvqZMFqGm-EYRiV98uxUxmiy5wXygvIobPU,13
+autofuzzts/preprocess/prep_for_model.py,sha256=mp19PGo_p8YWezSny__qKnuTREhAldSlxCzIutrisGk,2565
+autofuzzts/preprocess/preprocess.py,sha256=QZ0h4bZslwOrjTUyvPQaXDT_lBlnL8nKdp545Qy3xdk,2786
+autofuzzts-0.1.0.dist-info/licenses/LICENSE,sha256=bjnZy7iTBVYeRcAPI9NVlXeQGx62R13_t8xwoLq44Ms,1087
+autofuzzts-0.1.0.dist-info/METADATA,sha256=8Kg6RDBTKZBNKA8y3Lwp74Rw8lL9H1Hl1VU43Dm_9n0,1222
+autofuzzts-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+autofuzzts-0.1.0.dist-info/top_level.txt,sha256=YHgbVRUPg-x2WX7FKyJMUAeI9o46c8XFiR_eYKtXIxc,11
+autofuzzts-0.1.0.dist-info/RECORD,,

autofuzzts-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

autofuzzts-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+autofuzzts