autofuzzts 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

autofuzzts/pipeline.py

@@ -8,8 +8,11 @@ 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.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
@@ -17,7 +20,11 @@ from sklearn.calibration import CalibratedClassifierCV
 
 
 ## Import RMSE and MAE
-from sklearn.metrics import root_mean_squared_error, mean_absolute_error,mean_squared_error
+from sklearn.metrics import (
+    root_mean_squared_error,
+    mean_absolute_error,
+    mean_squared_error,
+)
 
 # Example custom configuration
 custom_config = {
@@ -29,100 +36,126 @@ custom_config = {
 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("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:
+
+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))
+    print("train set length:", len(train_set))
 
-    if covariates :
+    if covariates:
         train_covariates = train_set[covariates].copy()
-        val_covariates = val_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'])
+    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
-
+    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'])
+    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 = 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')
+    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)
+    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
+    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':
+    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`
+            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':
+    elif diff_type == "abs":
         for i in range(1, len(val_set)):
-            prev_Y = val_set['Y'].iloc[i-1]
+            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)
+
+    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'")
-  
+        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'):
-    '''
+
+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:
@@ -132,52 +165,81 @@ def train_model(dataset: pd.DataFrame, config: Dict, model_type: Literal['xgb','
         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'])
+    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
+    X_training = df_preprocessed["diff_scaled"].values
 
-    train_fuzzy_partition,_,_  = fp.fuzzy_partition(X_training)
+    train_fuzzy_partition, _, _ = fp.fuzzy_partition(X_training)
 
-    X_train, y_train = prepare_for_model(train_fuzzy_partition.copy(), config['number_of_lags'])
+    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 = 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 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
+            "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)
+        if config["fuzzy_part_func"] == "Gaussian":
+            config["sigma"] = trial.suggest_float("sigma", 0.1, 4, log=True)
         else:
-            config['sigma'] = None
+            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)
+        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)
@@ -191,26 +253,37 @@ def tune_hyperparameters_bayes(train_set: pd.DataFrame, val_set: pd.DataFrame, n
     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 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']),
+            "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)
+        if config["fuzzy_part_func"] == "Gaussian":
+            config["sigma"] = trial.suggest_float("sigma", 0.1, 4, log=True)
         else:
-            config['sigma'] = None
-        
+            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)
+        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)
@@ -224,25 +297,27 @@ def tune_hyperparameters_bayes_Henon(train_set: pd.DataFrame, val_set: pd.DataFr
     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'):
-    
+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']
+        "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']
+        "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
@@ -268,84 +343,95 @@ def tune_hyperparameters_grid(train_set: pd.DataFrame, val_set: pd.DataFrame,n_t
             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)
+        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:
-    '''
+def fit_calibrate_predict(
+    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)
+    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'])
+    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
+    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)
+        train_fuzzy_partition = train_fuzzy_partition.drop(columns=["left"])
+        test_fuzzy_partition = test_fuzzy_partition.drop(columns=["left"])
 
     # 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'])
-    
+    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() 
+        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 = 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)
+        model.calibrate(X_train, y_train, method="sigmoid", cv=number_cv_calib)
     except:
         pass
 
@@ -353,31 +439,31 @@ def train_calib_pred_test(train_set: pd.DataFrame, test_set: pd.DataFrame,
     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]
-
-
-
+    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)
+    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
+    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':
+    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`
+            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':
+    elif diff_type == "abs":
         for i in range(1, len(test_set)):
-            prev_Y = test_set['Y'].iloc[i-1]
+            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
-
-
-
+    return y_test_pred_cluster, y_test_pred_center_point, y_test_pred

autofuzzts-0.1.2.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: autofuzzts
+Version: 0.1.2
+Summary: 'Time series forecasting using fuzzy logic and AutoML'
+Author-email: Jan Timko <jantimko16@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jtimko16/AutoFuzzTS
+Project-URL: Repository, https://github.com/jtimko16/AutoFuzzTS
+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: license-file
+
+# AutoFuzzTS
+
+Time series forecasting library using fuzzy logic and automated machine learning.  
+Build and evaluate time series models automatically using fuzzy logic and AutoML techniques.
+
+## Installation
+
+```bash
+pip install autofuzzts
+```
+
+## 🚀 Quick Start
+
+### Load and prepare your time series data
+```python
+import pandas as pd
+
+# Load dataset into a pandas DataFrame
+data = pd.read_csv("../clean_data/ADBE_yf_hourly_cleaned.csv").head(240)
+
+# Select the target column to forecast
+data_column_name = "close_price"
+df = data[[data_column_name]].copy()
+
+# Split into train, validation, and test sets
+test_len = len(df) // 5
+val_len = len(df) // 5
+train_len = len(df) - test_len - val_len
+
+df_train = df[:train_len]
+df_val = df[train_len:(train_len + val_len)]
+df_test = df[(train_len + val_len):]
+```
+
+---
+
+### Tune hyperparameters using Bayesian search
+```python
+from autofuzzts import pipeline
+
+# Run Bayesian optimization for fuzzy pipeline configuration
+best_config, best_rmse = pipeline.tune_hyperparameters_bayes(
+    train_set=df_train,
+    val_set=df_val,
+    n_trials=20,
+    metric="rmse"
+)
+
+print(f"Best configuration: {best_config}")
+```
+
+**Example output:**
+```
+Best configuration: {'n_clusters': 19, 'number_of_lags': 2, 'fuzzy_part_func': 'Triangle'}
+```
+
+---
+
+### Train, calibrate, and predict
+```python
+from autofuzzts import fit_calibrate_predict
+
+# Train model, calibrate, and make one-step-ahead predictions
+pred_set, pred_center_points, pred_test = fit_calibrate_predict(
+    train_set=df_train,
+    test_set=df_test,
+    config=best_config,
+    model_type="xgb"
+)
+```
+
+This returns:
+- `pred_set`: predicted fuzzy sets  
+- `pred_center_points`: corresponding fuzzy center values  
+- `pred_test`: crisp numeric predictions (one-step-ahead forecast)
+
+---
+
+##  Function Overview
+
+### `fit_calibrate_predict()`
+
+```python
+fit_calibrate_predict(
+    train_set: pd.DataFrame,
+    test_set: pd.DataFrame,
+    config: dict,
+    model_type: Literal['xgb', 'mlp', 'tpot'] = 'xgb',
+    number_cv_calib: int = 5,
+    diff_type: Literal['perc', 'abs'] = 'perc',
+    covariates: list[str] | None = None,
+    exclude_bool: bool = False
+) -> float
+```
+
+Trains and calibrates a fuzzy time series model on the training set using
+cross-validation, then predicts on the test set and returns performance metrics.
+
+---
+
+## Description
+
+AutoFuzzTS automates the process of fuzzy time series modeling by:
+- building and testing multiple fuzzy pipelines,  
+- tuning hyperparameters using Bayesian optimization, and  
+- integrating tuned classification models -  **XGBoost**, **MLP**, or **TPOT**.
+
+This allows for rapid experimentation and selection of optimal configurations 
+for forecasting tasks.
+
+---
+
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License.
+

{autofuzzts-0.1.0.dist-info → autofuzzts-0.1.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 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/pipeline.py,sha256=wwaVXBvnoAvd3MDvEaj4xKqPlBWMSyOHSR5TOTP2jTo,16189
 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
@@ -18,8 +18,8 @@ autofuzzts/partition/visualize_partition.py,sha256=F31yovGfosqa-EmtuQdIIuF61XejH
 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.2.dist-info/licenses/LICENSE,sha256=bjnZy7iTBVYeRcAPI9NVlXeQGx62R13_t8xwoLq44Ms,1087
+autofuzzts-0.1.2.dist-info/METADATA,sha256=XuLUJuUcurF9DZE0YLGwFzkdJbIEZMXdJ3MI2KFztNk,3764
+autofuzzts-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+autofuzzts-0.1.2.dist-info/top_level.txt,sha256=YHgbVRUPg-x2WX7FKyJMUAeI9o46c8XFiR_eYKtXIxc,11
+autofuzzts-0.1.2.dist-info/RECORD,,

autofuzzts-0.1.0.dist-info/METADATA

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