data/Webapp/Code/mlr_modeling.py

from collections import defaultdict
from itertools import combinations
from pathlib import Path
from tqdm import tqdm

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import RepeatedKFold
from sklearn.preprocessing import StandardScaler

from .utils import SHAP_analysis


def regression_modeling(filename, objective, 
                        further_objectives = None, n_feat = 3,
                        repeats_outer = 5, k_outer = 4, 
                        repeats_inner = 10, k_inner = 5, 
                        fname_shap = "df_shap.csv",
                        feature_cutoff = 20, corr_cutoff = 0.7,
                        fname_pred = "mlr_predictions.csv",
                        print_pred = True,
                        directory = "."):
    """
    Generate a linear regression model to predict the performance of unseen substrates
    using a nested, repeated cross-validation (CV) approach.
    --------------------
    filename: str
        name of the searchspace .csv file with experimental results
    objective: str
        name of the reaction objective to be modelled
        NOTE: Only one objective can be modelled!
    further_objectives: list or None
        list of all other objectives of the reaction
        Default is None --> no further objectives
    n_feat: int 
        (Default = 3)
        maximum number of features in the generated model
    repeats_outer: int 
        (Default = 5)
        repeats of the outer CV loop
    k_outer: int 
        (Default = 4)
        number of folds in the outer CV loop
    repeats_inner: int 
        (Default = 10)
        repeats of the outer CV loop
    k_inner: int 
        (Default = 10)
        number of folds in the outer CV loop
    fname_shap: str 
        (Default = "df_shap.csv")
        name for the file generated for the shap analyis in the feature reduction
    feature_cutoff: int 
        (Default = 20)
        maximum number of features to consider in the inner CV loop
        if there are more features after preprocessing, the top-[value] features in a SHAP 
        analysis of the ScopeBO surrogate model will be kept
    corr_cutoff: float 
        (Default = 0.7)
        cutoff value for the Pearson correlation analysis in the feature preprocessing
        features with correlations to other features higher than the value will be removed
    fname_pred: str
        (Default = "performance_prediction.csv")
        name of the generated file with the model predictions
    print_pred: Boolean
        (Default = True)
        print the file with the predictions
    directory: str (Default = current directory)
        working directory
    --------------------
    Prints the best model and its statistics.
    Returns the predictions and the model settings.

    """

    print("This might take a moment. Please wait!")

    # read in the search space
    wdir = Path(directory)
    df_exp = pd.read_csv(wdir / filename,index_col=0,header=0, float_precision = "round_trip")

    # drop the priority column if present
    if "priority" in df_exp.columns:
        df_exp = df_exp.drop(labels = "priority", axis = 1)

    # prune to the samples with experimental data
    df = df_exp.loc[df_exp[objective] != "PENDING"].copy()

    # drop the data for other objectives if they exist
    all_obj = [objective]
    if further_objectives is not None:
        df = df.drop(labels = further_objectives, axis = 1)
        all_obj += further_objectives

    # separate the features and labels
    X = df[[col for col in df.columns if col != objective]].copy()
    y = df[objective].copy()
    y = y.astype(float)

    # instantiate object for outer CV
    outer_cv = RepeatedKFold(n_splits = k_outer,
                            n_repeats = repeats_outer,
                            random_state = 42)

    # progress bar for overall CV manifold progress
    pbar  =tqdm (total = outer_cv.get_n_splits() * k_inner * repeats_inner,
                desc = "Model optimization progress")

    # variable to save outer CV results
    out_cv_models = defaultdict(list)

    # loop through the outer folds
    for (train_idx_out, test_idx) in outer_cv.split(X, y):
        # split the data for the outer CV
        X_train_out = X.iloc[train_idx_out].copy()
        X_test = X.iloc[test_idx].copy()
        y_train_out = y.iloc[train_idx_out].copy()
        y_test = y.iloc[test_idx].copy()

        # instantiate object for inner CV
        inner_cv = RepeatedKFold(n_splits = k_inner,
                            n_repeats = repeats_inner,
                            random_state = 42)
        
        # variable to save the inner CV results
        inn_cv_models = defaultdict(list)


        # loop through the inner CV
        for (train_idx_inn, val_idx) in inner_cv.split(X_train_out, y_train_out):

            # split the data for the inner CV
            X_train_inn = X_train_out.iloc[train_idx_inn].copy()
            X_val = X_train_out.iloc[val_idx].copy()
            y_train_inn= y_train_out.iloc[train_idx_inn].copy()
            y_val = y_train_out.iloc[val_idx].copy()

            # removely correlated features by correlation analysis of inner train
            corr_mat = X_train_inn.corr().abs()
            upper = corr_mat.where(np.triu(np.ones(corr_mat.shape), k = 1).astype(bool))
            to_drop = [column for column in upper.columns if any(upper[column] > corr_cutoff)]
            X_train_inn = X_train_inn.drop(to_drop, axis = 1)
            features = X_train_inn.columns.to_list()

            # if there are more features left than the feature_cutoff, 
            # prune to the top [feature_cutoff] most important feature in a SHAP analysis
            # note that the SHAP analysis is done on the inner train data only
            if len(features) > feature_cutoff:
                features = _SHAP_pruning(X=X_train_inn, df_exp=df_exp, curr_feat=features,
                                        all_obj=all_obj, fname_shap=fname_shap, 
                                        feat_cutoff=feature_cutoff, wdir=wdir)

            # prune inner train and val to the preprocessed features
            X_train_inn = X_train_inn[features]
            X_val = X_val[features]

            # scale the features for inner train
            scaler = StandardScaler()
            X_train_inn_sc = pd.DataFrame(scaler.fit_transform(X_train_inn), columns = features)

            # apply the same scaling to inner val
            X_val_sc = pd.DataFrame(scaler.transform(X_val), columns = features)

            # test all feature combinations (up to 3 features) on the inner train
            # keep the best feature combinations (returns tuples of comb and RSS)
            inn_train_models = _feature_search(X_train_inn_sc, y_train_inn, features, n_feat)

            # evaluate the top models on the inner validation data
            for comb, _ in inn_train_models:
                model = LinearRegression().fit(X_train_inn_sc[comb], y_train_inn)
                y_val_pred = model.predict(X_val_sc[comb])
                rmse = np.sqrt(mean_squared_error(y_val, y_val_pred))
                # record the features and rmse
                inn_cv_models[tuple(comb)].append(rmse)

            # current inner fold finished - update tqdm
            pbar.update(1)

        # average rmse for each feature comb selected by the inner cv models
        best_inn_models = {k: np.mean(v) for k, v in inn_cv_models.items()}

        # get the features with lowest mean rmse (inner CV champion)
        best_inn_model_feat = list(min(best_inn_models, key=best_inn_models.get))

        # fit a scaler on the outer train and scale it
        scaler = StandardScaler()
        X_train_out_sc = pd.DataFrame(scaler.fit_transform(X_train_out), 
                                    columns = X_train_out.columns)

        # apply the same scaling to outer test
        X_test_sc = pd.DataFrame(scaler.transform(X_test), 
                                columns = X_test.columns)

        # refit model using best feature subset on outer train
        model = LinearRegression().fit(X_train_out_sc[best_inn_model_feat], y_train_out)

        # evaluate on outer train
        y_train_out_pred = model.predict(X_train_out_sc[best_inn_model_feat])
        train_rmse = np.sqrt(mean_squared_error(y_train_out, y_train_out_pred))
        r2_train = _calculate_r2(y_train_out, y_train_out_pred)
        adj_r2_train = _calculate_adjusted_r2(r2_train,
                                            len(y_train_out),
                                            len(best_inn_model_feat))

        # evaluate on outer test
        y_test_pred = model.predict(X_test_sc[best_inn_model_feat])
        test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred))
        r2_test = _calculate_r2(y_test, y_test_pred)
        adj_r2_test = _calculate_adjusted_r2(r2_test,
                                            len(y_test),
                                            len(best_inn_model_feat))

        out_cv_models[tuple(best_inn_model_feat)].append((train_rmse, r2_train, adj_r2_train,
                                                        test_rmse, r2_test, adj_r2_test))

    # average the performance for all outer CV models
    best_out_models = {k: tuple(np.mean(score) for score in zip(*v)) for 
                       k,v in out_cv_models.items()}

    # pick the model features that were picked most often
    highest_counter = max(len(v) for v in out_cv_models.values())
    most_freq = [k for k,v in out_cv_models.items() if len(v) == highest_counter]
    champion_feat = None
    if len(most_freq) == 1:  # clear winner
        champion_feat = most_freq[0]
    else:  # test_rmse tie-breaker
        rmse_vals = [best_out_models[mod][3] for mod in most_freq]  # test_rmse is 4th tuple entry (0-indexed)
        top_idx = rmse_vals.index(min(rmse_vals))
        champion_feat = most_freq[top_idx]
    champion_feat = list(champion_feat)

    # train model on the full dataset using the champion features
    scaler = StandardScaler()
    X_sc = pd.DataFrame(scaler.fit_transform(X), 
                                columns = X.columns)
    model = LinearRegression().fit(X_sc[champion_feat], y)

    model_settings = {f: c for f, c in zip(champion_feat, model.coef_)}
    model_settings["Intercept"] = model.intercept_

    print("Model training completed.\n\nHere are the model parameters using scaled features:")

    for k, v in model_settings.items():
        print(f"{k}: {v}")

    print("\nModel statistics (on outer CV splits):")
    print("Mean RMSE:", best_out_models[tuple(champion_feat)][3])
    print("Mean R2 value:", best_out_models[tuple(champion_feat)][4])

    # use the champion model to predict on the full search space

    # drop all objectives, but save the data for the obj to be predicted
    exp_labels = df_exp[objective].to_list()
    df_exp = df_exp.drop(labels = all_obj, axis = 1)

    # apply the scaler
    df_exp_sc = pd.DataFrame(scaler.transform(df_exp), columns = df_exp.columns)

    # predict
    pred_vals = model.predict(df_exp_sc[champion_feat])

    # report the predictions
    df_pred = pd.DataFrame(np.nan, index = df_exp.index, columns = [objective, f"{objective}_pred"])
    df_pred[f"{objective}_pred"] = pred_vals
    df_pred[objective] = exp_labels

    if print_pred:
        # save the predictions
        df_pred.to_csv(wdir / fname_pred, index = True, header = True)
        print(f"\nPredictions have been saved in the file '{fname_pred}' in the folder '{directory}'.")

    else:
        print("Predictions obtained!")

    return df_pred, model_settings


def _SHAP_pruning(X, df_exp, curr_feat, all_obj, fname_shap, feat_cutoff, wdir):
    """
    Prune the number for feature to the most important features in a SHAP
    analysis of the ScopeBO surrogate model (using only the inner train samples)
    """

    # limit the experimental data to the inner train data 
    # and the downselected features + objectives
    df_shap = df_exp.loc[X.index, curr_feat + all_obj]

    # the SHAP analysis requires a csv file as input - generate it
    df_shap.to_csv(wdir / fname_shap, index = True, header = True)

    # do the SHAP analysis and prune the features to the top most important SHAP features
    _, mean_abs_shap = SHAP_analysis(objectives = all_obj, 
                                        filename = fname_shap, plot_type = [])
    features = mean_abs_shap.index.to_list()[:feat_cutoff]

    return features


def _eval_feat_comb(X, y, feat):
    """
    Evaluate a feature combination by building a MLR and 
    returning the residual sum of squares (RSS).

    X, y: features and labels
    feat: list of feature names
    """

    # limit to the selected features
    X_feat = X.loc[:,feat]
    y = np.array(y)

    # build the model
    model = LinearRegression()
    model.fit(X_feat, y)
    y_pred = model.predict(X_feat)

    # return RSS
    return np.sum((y_pred - y)**2)


def _feature_search(X, y, feat, n_feat = 3, top_n = 5):
    """
    Exhaustive search for best feature combinations for a MLR 
    model with up to n_features. Returns the features and RSS
    for the top_n models.
    """

    # Initiate list of combinations with all single features
    combs = [[f] for f in feat]

    # add combinations of up to n_features length (starting from 2 feat)
    for i in range(2, n_feat +1):
        combs += [list(c) for c in combinations(feat, i)]

    search_results = []
    for i,comb in enumerate(combs):
        rss = _eval_feat_comb(X, y, comb)
        search_results.append((comb,rss))

    # sort by rss and keep the top_n models
    search_results.sort(key = lambda x: x[1])
    top_models = search_results[:top_n]

    return top_models


def _calculate_r2(y_true, y_pred):
    """Calculate R² using the squared Pearson correlation coefficient."""
    correlation_matrix = np.corrcoef(y_true, y_pred)
    r = correlation_matrix[0, 1]
    return r**2


def _calculate_adjusted_r2(r_squared, n_samples, n_features):
    """Adust R2 value for number of samples and features."""
    return 1 - (1 - r_squared) * ((n_samples - 1) / (n_samples - n_features - 1))