likelihood 1.4.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

likelihood/tools/figures.py

@@ -0,0 +1,348 @@
+import os
+import warnings
+from typing import Optional
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.ticker import AutoMinorLocator
+from scipy import stats
+
+plt.rcParams.update({"font.size": 14})
+
+
+def act_pred(
+    y_act: np.ndarray,
+    y_pred: np.ndarray,
+    name: str = "example",
+    x_hist: bool = True,
+    y_hist: bool = True,
+    reg_line: bool = True,
+    save_dir: Optional[str] = None,
+) -> None:
+    """
+    Creates a scatter plot of actual vs predicted values along with histograms and a regression line.
+
+    Parameters
+    ----------
+    y_act : `np.ndarray`
+        The actual values (ground truth) as a 1D numpy array.
+    y_pred : `np.ndarray`
+        The predicted values as a 1D numpy array.
+    name : `str`, optional
+        The name for saving the plot. Default is "example".
+    x_hist : `bool`, optional
+        Whether to display the histogram for the actual values (y_act). Default is True.
+    y_hist : `bool`, optional
+        Whether to display the histogram for the predicted values (y_pred). Default is True.
+    reg_line : `bool`, optional
+        Whether to plot a regression line (best-fit line) in the scatter plot. Default is True.
+    save_dir : `Optional[str]`, optional
+        The directory to save the figure. If None, the figure will not be saved. Default is None.
+
+    Returns
+    -------
+    `None` : The function doesn't return anything. It generates and optionally saves a plot.
+    """
+
+    y_pred, y_act = y_pred.flatten(), y_act.flatten()
+
+    if not isinstance(y_act, np.ndarray) or not isinstance(y_pred, np.ndarray):
+        raise ValueError("y_act and y_pred must be numpy arrays.")
+    if y_act.shape != y_pred.shape:
+        raise ValueError("y_act and y_pred must have the same shape.")
+
+    mec = "#2F4F4F"
+    mfc = "#C0C0C0"
+
+    fig = plt.figure(figsize=(6, 6))
+
+    left, width = 0.1, 0.65
+    bottom, height = 0.1, 0.65
+    bottom_h = left + width
+    left_h = left + width + 0.05
+
+    ax2 = fig.add_axes([left, bottom, width, height])
+    ax2.tick_params(direction="in", length=7, top=True, right=True)
+    ax2.xaxis.set_minor_locator(AutoMinorLocator(2))
+    ax2.yaxis.set_minor_locator(AutoMinorLocator(2))
+
+    ax2.scatter(y_act, y_pred, color=mfc, edgecolor=mec, alpha=0.5, s=35, lw=1.2)
+    ax2.plot(
+        [y_act.min(), y_act.max()], [y_act.min(), y_act.max()], "k--", alpha=0.8, label="Ideal"
+    )
+
+    ax2.set_xlabel("Actual value")
+    ax2.set_ylabel("Predicted value")
+    ax2.set_xlim([y_act.min() * 1.05, y_act.max() * 1.05])
+    ax2.set_ylim([y_act.min() * 1.05, y_act.max() * 1.05])
+
+    ax1 = fig.add_axes([left, bottom_h, width, 0.15])
+    ax1.hist(y_act, bins=31, density=True, color=mfc, edgecolor=mec, alpha=0.6)
+    ax1.set_xticks([])
+    ax1.set_yticks([])
+    ax1.set_xlim(ax2.get_xlim())
+
+    if x_hist:
+        ax1.set_alpha(1.0)
+
+    ax3 = fig.add_axes([left_h, bottom, 0.15, height])
+    ax3.hist(
+        y_pred, bins=31, density=True, color=mfc, edgecolor=mec, orientation="horizontal", alpha=0.6
+    )
+    ax3.set_xticks([])
+    ax3.set_yticks([])
+    ax3.set_ylim(ax2.get_ylim())
+
+    if y_hist:
+        ax3.set_alpha(1.0)
+
+    if reg_line:
+        polyfit = np.polyfit(y_act, y_pred, deg=1)
+        reg_line_vals = np.poly1d(polyfit)(np.unique(y_act))
+        ax2.plot(np.unique(y_act), reg_line_vals, "r-", label="Regression Line", alpha=0.8)
+
+    ax2.legend(loc="upper left", framealpha=0.35, handlelength=1.5)
+
+    plt.tight_layout()
+
+    if save_dir is not None:
+        os.makedirs(save_dir, exist_ok=True)
+        fig_name = os.path.join(save_dir, f"{name}_act_pred.png")
+        plt.savefig(fig_name, bbox_inches="tight", dpi=300)
+
+    plt.show()
+    plt.close(fig)
+
+
+def residual(
+    y_act: np.ndarray, y_pred: np.ndarray, name: str = "example", save_dir: str = None
+) -> None:
+    """
+    Plots the residual errors between the actual and predicted values.
+
+    This function generates a residual plot by calculating the difference between the
+    actual values (y_act) and predicted values (y_pred). The plot shows the residuals
+    (y_pred - y_act) against the actual values. Optionally, the plot can be saved to a file.
+
+    Parameters
+    ----------
+    y_act : `np.ndarray`
+        The actual values, typically the ground truth values.
+    y_pred : `np.ndarray`
+        The predicted values that are compared against the actual values.
+    name : `str`, optional
+        The name of the plot file (without extension) used when saving the plot. Default is "example".
+    save_dir : `str`, optional
+        The directory where the plot will be saved. If None, the plot is not saved. Default is None.
+
+    Returns
+    -------
+    `None` : This function does not return any value. It generates and optionally saves a plot.
+
+    Notes
+    -----
+    - The plot is shown with the residuals (y_pred - y_act) on the y-axis and the actual values (y_act)
+      on the x-axis. The plot includes a horizontal line representing the ideal case where the residual
+      is zero (i.e., perfect predictions).
+    - The plot will be saved as a PNG image if a valid `save_dir` is provided.
+    """
+
+    mec = "#2F4F4F"
+    mfc = "#C0C0C0"
+
+    y_act = np.array(y_act)
+    y_pred = np.array(y_pred)
+
+    xmin = np.min([y_act]) * 0.9
+    xmax = np.max([y_act]) / 0.9
+    y_err = y_pred - y_act
+    ymin = np.min([y_err]) * 0.9
+    ymax = np.max([y_err]) / 0.9
+
+    fig, ax = plt.subplots(figsize=(4, 4))
+
+    ax.plot(y_act, y_err, "o", mec=mec, mfc=mfc, alpha=0.5, label=None, mew=1.2, ms=5.2)
+    ax.plot([xmin, xmax], [0, 0], "k--", alpha=0.8, label="ideal")
+
+    ax.set_ylabel("Residual error")
+    ax.set_xlabel("Actual value")
+    ax.legend(loc="lower right")
+
+    minor_locator_x = AutoMinorLocator(2)
+    minor_locator_y = AutoMinorLocator(2)
+    ax.get_xaxis().set_minor_locator(minor_locator_x)
+    ax.get_yaxis().set_minor_locator(minor_locator_y)
+
+    ax.tick_params(right=True, top=True, direction="in", length=7)
+    ax.tick_params(which="minor", right=True, top=True, direction="in", length=4)
+
+    ax.set_xlim(xmin, xmax)
+    ax.set_ylim(ymin, ymax)
+
+    if save_dir is not None:
+        fig_name = f"{save_dir}/{name}_residual.png"
+        os.makedirs(save_dir, exist_ok=True)
+        plt.savefig(fig_name, bbox_inches="tight", dpi=300)
+
+    plt.draw()
+    plt.pause(0.001)
+
+    plt.close()
+
+
+def residual_hist(
+    y_act: np.ndarray, y_pred: np.ndarray, name: str = "example", save_dir: Optional[str] = None
+) -> None:
+    """
+    Generates a residual error histogram with kernel density estimate (KDE) for the given true and predicted values.
+    Optionally saves the plot to a specified directory.
+
+    Parameters
+    ----------
+    y_act : `np.ndarray`
+        Array of true (actual) values.
+
+    y_pred : `np.ndarray`
+        Array of predicted values.
+
+    name : `str`, optional, default="example"
+        The name used for the saved plot filename.
+
+    save_dir : `str`, optional, default=None
+        Directory path to save the generated plot. If None, the plot is not saved.
+
+    Returns
+    --------
+    `None` : This function generates and optionally saves a plot but does not return any value.
+
+    Raises
+    -------
+    `UserWarning` : If the data has high correlation among variables, suggesting dimensionality reduction.
+    """
+    mec = "#2F4F4F"
+    mfc = "#C0C0C0"
+    y_pred, y_act = y_pred.flatten(), y_act.flatten()
+
+    fig, ax = plt.subplots(figsize=(4, 4))
+    y_err = y_pred - y_act
+    x_range = np.linspace(min(y_err), max(y_err), 1000)
+
+    try:
+        kde_act = stats.gaussian_kde(y_err)
+        ax.plot(x_range, kde_act(x_range), "-", lw=1.2, color="k", label="kde")
+    except np.linalg.LinAlgError as e:
+        warnings.warn(
+            "The data has very high correlation among variables. Consider dimensionality reduction.",
+            UserWarning,
+        )
+
+    ax.hist(y_err, color=mfc, bins=35, alpha=1, edgecolor=mec, density=True)
+
+    ax.set_xlabel("Residual error")
+    ax.set_ylabel("Relative frequency")
+    plt.legend(loc=2, framealpha=0.35, handlelength=1.5)
+
+    ax.tick_params(direction="in", length=7, top=True, right=True)
+
+    minor_locator_x = AutoMinorLocator(2)
+    minor_locator_y = AutoMinorLocator(2)
+    ax.get_xaxis().set_minor_locator(minor_locator_x)
+    ax.get_yaxis().set_minor_locator(minor_locator_y)
+    plt.tick_params(which="minor", direction="in", length=4, right=True, top=True)
+
+    if save_dir is not None:
+        fig_name = f"{save_dir}/{name}_residual_hist.png"
+        os.makedirs(save_dir, exist_ok=True)
+        plt.savefig(fig_name, bbox_inches="tight", dpi=300)
+
+    plt.draw()
+    plt.pause(0.001)
+    plt.close()
+
+
+def loss_curve(
+    x_data: np.ndarray,
+    train_err: np.ndarray,
+    val_err: np.ndarray,
+    name: str = "example",
+    save_dir: Optional[str] = None,
+) -> None:
+    """
+    Plots the loss curve for both training and validation errors over epochs,
+    and optionally saves the plot as an image.
+
+    Parameters
+    ----------
+    x_data : `np.ndarray`
+        Array of x-values (usually epochs) for the plot.
+    train_err : `np.ndarray`
+        Array of training error values.
+    val_err : `np.ndarray`
+        Array of validation error values.
+    name : `str`, optional
+        The name to use when saving the plot. Default is "example".
+    save_dir : `Optional[str]`, optional
+        Directory where the plot should be saved. If None, the plot is not saved. Default is None.
+
+    Returns
+    -------
+    `None` : This function does not return any value. It generates and optionally saves a plot.
+    """
+    mec1 = "#2F4F4F"
+    mfc1 = "#C0C0C0"
+    mec2 = "maroon"
+    mfc2 = "pink"
+
+    fig, ax = plt.subplots(figsize=(4, 4))
+
+    ax.plot(
+        x_data,
+        train_err,
+        "-",
+        color=mec1,
+        marker="o",
+        mec=mec1,
+        mfc=mfc1,
+        ms=4,
+        alpha=0.5,
+        label="train",
+    )
+
+    ax.plot(
+        x_data,
+        val_err,
+        "--",
+        color=mec2,
+        marker="s",
+        mec=mec2,
+        mfc=mfc2,
+        ms=4,
+        alpha=0.5,
+        label="validation",
+    )
+
+    max_val_err = max(val_err)
+    ax.axhline(max_val_err, color="b", linestyle="--", alpha=0.3)
+
+    ax.set_xlabel("Number of training epochs")
+    ax.set_ylabel("Loss (Units)")
+    ax.set_ylim(0, 2 * np.mean(val_err))
+
+    ax.legend(loc=1, framealpha=0.35, handlelength=1.5)
+
+    minor_locator_x = AutoMinorLocator(2)
+    minor_locator_y = AutoMinorLocator(2)
+    ax.get_xaxis().set_minor_locator(minor_locator_x)
+    ax.get_yaxis().set_minor_locator(minor_locator_y)
+
+    ax.tick_params(right=True, top=True, direction="in", length=7)
+    ax.tick_params(which="minor", right=True, top=True, direction="in", length=4)
+
+    if save_dir is not None:
+        fig_name = f"{save_dir}/{name}_loss_curve.png"
+        os.makedirs(save_dir, exist_ok=True)
+        plt.savefig(fig_name, bbox_inches="tight", dpi=300)
+
+    plt.draw()
+    plt.pause(0.001)
+    plt.close()

likelihood/tools/impute.py

@@ -0,0 +1,279 @@
+import pickle
+import warnings
+from typing import Union
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+
+from likelihood.models import SimulationEngine
+from likelihood.tools.numeric_tools import find_multiples
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+
+
+class SimpleImputer:
+    """Multiple imputation using simulation engine."""
+
+    def __init__(self, n_features: int | None = None, use_scaler: bool = False):
+        """
+        Initialize the imputer.
+
+        Parameters
+        ----------
+        n_features: int | None
+            Number of features to be used in the imputer. Default is None.
+        use_scaler: bool
+            Whether to use a scaler. Default is False.
+        """
+        self.n_features = n_features
+        self.sim = SimulationEngine(use_scaler=use_scaler)
+        self.params = {}
+        self.cols_transf = pd.Series([])
+
+    def fit(self, X: pd.DataFrame) -> None:
+        """
+        Fit the imputer to the data.
+
+        Parameters
+        ----------
+        X: pd.DataFrame
+            Dataframe to fit the imputer to.
+        """
+        X_impute = X.copy()
+        self.params = self._get_dict_params(X_impute)
+        X_impute = self.sim._clean_data(X_impute)
+
+        if X_impute.empty:
+            raise ValueError(
+                "The dataframe is empty after cleaning, it is not possible to train the imputer."
+            )
+        self.n_features = self.n_features or X_impute.shape[1] - 1
+        self.sim.fit(X_impute, self.n_features)
+
+    def transform(
+        self, X: pd.DataFrame, boundary: bool = True, inplace: bool = True
+    ) -> pd.DataFrame:
+        """
+        Impute missing values in the data.
+
+        Parameters
+        -----------
+        X: pd.DataFrame
+            Dataframe to impute missing values.
+        boundary: bool
+            Whether to use the boundaries of the data to impute missing values. Default is True.
+        inplace: bool
+            Whether to modify the columns of the original dataframe or return new ones. Default is True.
+        """
+        X_impute = X.copy()
+        self.cols_transf = X_impute.columns
+        for column in X_impute.columns:
+            if X_impute[column].isnull().sum() > 0:
+
+                if not X_impute[column].dtype == "object":
+                    min_value = self.params[column]["min"]
+                    max_value = self.params[column]["max"]
+                    to_compare = self.params[column]["to_compare"]
+                for row in X_impute.index:
+                    if pd.isnull(X_impute.loc[row, column]):
+                        value_impute = self._check_dtype_convert(
+                            self.sim.predict(
+                                self._set_zero(X_impute.loc[row, :], column),
+                                column,
+                            )[0],
+                            to_compare,
+                        )
+                        if not X_impute[column].dtype == "object" and boundary:
+                            if value_impute < min_value:
+                                value_impute = min_value
+                            if value_impute > max_value:
+                                value_impute = max_value
+                        X_impute.loc[row, column] = value_impute
+            else:
+                self.cols_transf = self.cols_transf.drop(column)
+        if not inplace:
+            X_impute = X_impute[self.cols_transf].copy()
+            X_impute = X_impute.rename(
+                columns={column: column + "_imputed" for column in self.cols_transf}
+            )
+            X_impute = X.join(X_impute, rsuffix="_imputed")
+            order_cols = []
+            for column in X.columns:
+                if column + "_imputed" in X_impute.columns:
+                    order_cols.append(column)
+                    order_cols.append(column + "_imputed")
+                else:
+                    order_cols.append(column)
+            X_impute = X_impute[order_cols]
+        return X_impute
+
+    def fit_transform(
+        self, X: pd.DataFrame, boundary: bool = True, inplace: bool = True
+    ) -> pd.DataFrame:
+        """
+        Fit and transform the data.
+
+        Parameters
+        -----------
+        X: pd.DataFrame
+            Dataframe to fit and transform.
+        boundary: bool
+            Whether to use the boundaries of the data to impute missing values. Default is True.
+        inplace: bool
+            Whether to modify the columns of the original dataframe or return new ones. Default is True.
+        """
+        X_train = X.copy()
+        self.fit(X_train)
+        return self.transform(X, boundary, inplace)
+
+    def _set_zero(self, X: pd.Series, column_exception) -> pd.DataFrame:
+        """
+        Set missing values to zero, except for `column_exception`.
+
+        Parameters
+        -----------
+        X: pd.Series
+            Series to set missing values to zero.
+        """
+        X = X.copy()
+        for column in X.index:
+            if pd.isnull(X[column]) and column != column_exception:
+                X[column] = 0
+        data = X.to_frame().T
+        return data
+
+    def _check_dtype_convert(self, value: Union[int, float], to_compare: Union[int, float]) -> None:
+        """
+        Check if the value is an integer and convert it to float if it is.
+
+        Parameters
+        -----------
+        value: Union[int, float]
+            Value to check and convert.
+        to_compare: Union[int, float]
+            Value to compare to.
+        """
+        if isinstance(to_compare, int) and isinstance(value, float):
+            value = int(round(value, 0))
+
+        if isinstance(to_compare, float) and isinstance(value, float):
+            value = round(value, len(str(to_compare).split(".")[1]))
+        return value
+
+    def _get_dict_params(self, df: pd.DataFrame) -> dict:
+        """
+        Get the parameters for the imputer.
+
+        Parameters
+        -----------
+        df: pd.DataFrame
+            Dataframe to get the parameters from.
+        """
+        params = {}
+        for column in df.columns:
+            if df[column].isnull().sum() > 0:
+                if not df[column].dtype == "object":
+                    to_compare = df[column].dropna().sample().values[0]
+                    params[column] = {
+                        "min": df[column].min(),
+                        "to_compare": to_compare,
+                        "max": df[column].max(),
+                    }
+        return params
+
+    def eval(self, X: pd.DataFrame) -> None:
+        """
+        Create a histogram of the imputed values.
+
+        Parameters
+        -----------
+        X: pd.DataFrame
+            Dataframe to create the histogram from.
+        """
+
+        if not isinstance(X, pd.DataFrame):
+            raise ValueError("Input X must be a pandas DataFrame.")
+
+        df = X.copy()
+
+        imputed_cols = [col for col in df.columns if col.endswith("_imputed")]
+        num_impute = len(imputed_cols)
+
+        if num_impute == 0:
+            print("No imputed columns found in the DataFrame.")
+            return
+
+        try:
+            ncols, nrows = find_multiples(num_impute)
+        except ValueError as e:
+            print(f"Error finding multiples for {num_impute}: {e}")
+            ncols = 1
+            nrows = num_impute
+
+        _, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=(12, 5 * nrows))
+        axes = axes.flatten() if isinstance(axes, np.ndarray) else [axes]
+
+        for i, col in enumerate(imputed_cols):
+            original_col = col.replace("_imputed", "")
+
+            if original_col in df.columns:
+                original_col_data = df[original_col].dropna()
+                ax = axes[i]
+
+                # Plot the original data
+                sns.histplot(
+                    original_col_data,
+                    kde=True,
+                    color="blue",
+                    label=f"Original",
+                    bins=10,
+                    ax=ax,
+                )
+
+                # Plot the imputed data
+                sns.histplot(
+                    df[col],
+                    kde=True,
+                    color="red",
+                    label=f"Imputed",
+                    bins=10,
+                    ax=ax,
+                )
+
+                ax.set_xlabel(original_col)
+                ax.set_ylabel("Frequency" if i % ncols == 0 else "")
+                ax.legend(loc="upper right")
+
+        plt.suptitle("Histogram Comparison", fontsize=16, fontweight="bold")
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.9)
+        plt.show()
+
+    def save(self, filename: str = "./imputer") -> None:
+        """
+        Save the state of the SimpleImputer to a file.
+
+        Parameters
+        -----------
+        filename: str
+            Name of the file to save the imputer to. Default is "./imputer".
+        """
+        filename = filename if filename.endswith(".pkl") else filename + ".pkl"
+        with open(filename, "wb") as f:
+            pickle.dump(self, f)
+
+    @staticmethod
+    def load(filename: str = "./imputer"):
+        """
+        Load the state of a SimpleImputer from a file.
+
+        Parameters
+        -----------
+        filename: str
+            Name of the file to load the imputer from. Default is "./imputer".
+        """
+        filename = filename + ".pkl" if not filename.endswith(".pkl") else filename
+        with open(filename, "rb") as f:
+            return pickle.load(f)