likelihood 2.0.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

likelihood/__init__.py

@@ -16,4 +16,5 @@ To get started with Likelihood, simply import the desired modules and start expl
 
 from likelihood.main import *
 from likelihood.models import *
+from likelihood.pipes import Pipeline
 from likelihood.tools import *

likelihood/models/deep/_autoencoders.py

@@ -7,8 +7,10 @@ from .autoencoders import (
     keras_tuner,
     l2,
     np,
+    os,
     partial,
     pd,
+    rmtree,
     sampling,
     suppress_warnings,
     tf,

likelihood/models/deep/rl.py

@@ -56,7 +56,7 @@ class Env:
 
         Returns
         -------
-            `tuple` : (current_state, action_pred, reward, next_action, done)
+        tuple : (current_state, action_pred, reward, next_action, done)
         """
         if self.done:
             return None, None, 0, None, True
@@ -146,7 +146,7 @@ class AutoQL:
 
         Returns
         -------
-            `tuple` : (state, action, reward, next_action, done)
+        tuple : (state, action, reward, next_action, done)
         """
         current_state, value, reward, next_action, done = self.env.step(state, action)
 
@@ -174,7 +174,7 @@ class AutoQL:
 
         Returns
         -------
-            `tuple` : (state, action, reward, next_action, done)
+        tuple : (state, action, reward, next_action, done)
         """
         current_state, greedy_action, reward, next_action, done = self.epsilon_greedy_policy(
             state, action, epsilon
@@ -202,7 +202,7 @@ class AutoQL:
 
         Returns
         -------
-            `float` : Training loss
+        float : Training loss
         """
 
         batch_ = random.sample(self.replay_buffer, self.batch_size)

likelihood/pipes.py

@@ -0,0 +1,355 @@
+import json
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+from likelihood.tools import generate_html_pipeline
+from likelihood.tools.impute import SimpleImputer
+from likelihood.tools.models_tools import TransformRange, remove_collinearity
+from likelihood.tools.tools import DataFrameEncoder, DataScaler, LinearRegression, OneHotEncoder
+
+
+class Pipeline:
+    def __init__(self, config_path: str):
+        """
+        Initialize the pipeline with a JSON configuration file.
+
+        Parameters
+        ----------
+        config_path : str
+            Path to the JSON config defining target column and preprocessing steps.
+        """
+        self.config = self._load_config(config_path)
+        self.target_col = self.config["target_column"]
+        self.steps = self.config["preprocessing_steps"]
+        self.compute_importance = self.config.get("compute_feature_importance", False)
+        self.fitted_components: Dict[str, object] = {}
+        self.columns_bin_sizes: Dict[str, int] | None = None
+
+    def _load_config(self, config_path: str) -> Dict:
+        """Load and validate the JSON configuration."""
+        with open(config_path, "r") as f:
+            config = json.load(f)
+
+        assert "target_column" in config, "Config must specify 'target_column'"
+        assert "preprocessing_steps" in config, "Config must specify 'preprocessing_steps'"
+        return config
+
+    def fit(self, df: pd.DataFrame) -> Tuple[pd.DataFrame, np.ndarray, Optional[np.ndarray]]:
+        """
+        Fit preprocessing components on the input DataFrame and return cleaned X/y.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            Input data with features + target column.
+
+        Returns
+        -------
+        X : pd.DataFrame
+            Cleaned feature matrix.
+        y : np.ndarray
+            Target vector (from self.target_col).
+        importances : Optional[np.ndarray]
+            Feature importance scores (if compute_feature_importance=True).
+        """
+        y = df[self.target_col].values
+        X = df.drop(columns=[self.target_col]).copy()
+
+        initial_info = {
+            "shape": X.shape,
+            "columns": list(X.columns),
+            "dtypes": X.dtypes.apply(lambda x: x.name).to_dict(),
+            "missing_values": X.isnull().sum().to_dict(),
+        }
+
+        steps_info = []
+        for step in self.steps:
+            step_name = step["name"]
+            params = step.get("params", {})
+            step_info = {
+                "step_name": step_name,
+                "parameters": params,
+                "description": self._get_step_description(step_name),
+            }
+            step_info["input_columns"] = list(X.columns)
+
+            X = self._apply_step(step_name, X, fit=True, **params)
+
+            step_info["output_shape"] = X.shape
+            step_info["output_columns"] = list(X.columns)
+            step_info["output_dtypes"] = X.dtypes.apply(lambda x: x.name).to_dict()
+
+            steps_info.append(step_info)
+
+        final_info = {
+            "shape": X.shape,
+            "columns": list(X.columns),
+            "dtypes": X.dtypes.apply(lambda x: x.name).to_dict(),
+            "missing_values": X.isnull().sum().to_dict(),
+        }
+
+        self.documentation = {
+            "initial_dataset": initial_info,
+            "processing_steps": steps_info,
+            "final_dataset": final_info,
+        }
+
+        importances = None
+        if self.compute_importance:
+            numeric_X = X.select_dtypes(include=["float"])
+            numeric_columns = numeric_X.columns.tolist()
+            model = LinearRegression()
+            model.fit(numeric_X.T.values, y)
+            importances = model.get_importances()
+            df_scores = pd.DataFrame([importances], columns=numeric_columns)
+            df_scores_abs = df_scores.abs()
+        df_scores_norm = (
+            df_scores_abs / df_scores_abs.to_numpy().sum()
+            if isinstance(importances, np.ndarray)
+            else pd.DataFrame()
+        )
+        return X, y, df_scores_norm
+
+    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Apply fitted preprocessing steps to new data (no target column needed).
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            New data to transform.
+
+        Returns
+        -------
+        X_transformed : pd.DataFrame
+            Cleaned feature matrix.
+        """
+        X = df.copy()
+        for step_name, _ in self.fitted_components.items():
+            X = self._apply_step(step_name, X, fit=False)
+
+        return X
+
+    def get_doc(
+        self, save_to_file: bool = True, file_name: str = "data_processing_report.html"
+    ) -> None:
+        """
+        Generate an HTML report from `self.documentation` for pipeline documentation.
+
+        Parameters
+        ----------
+        save_to_file : bool, optional
+            Whether to save generated HTML content to a file. Default is True.
+        file_name : str, optional
+            Filename for output when `save_to_file` is True. Default is "data_processing_report.html".
+        """
+
+        generate_html_pipeline(self.documentation, save_to_file=save_to_file, file_name=file_name)
+
+    def _apply_step(self, step_name: str, X: pd.DataFrame, fit: bool, **params) -> pd.DataFrame:
+        """Dispatch to the correct handler for a preprocessing step."""
+        handlers = {
+            "DataScaler": self._handle_datascaler,
+            "DataFrameEncoder": self._handle_dataframeencoder,
+            "remove_collinearity": self._handle_remove_collinearity,
+            "TransformRange": self._handle_transformrange,
+            "OneHotEncoder": self._handle_onehotencoder,
+            "SimpleImputer": self._handle_simpleimputer,
+        }
+
+        if step_name not in handlers:
+            raise ValueError(
+                f"Step '{step_name}' not supported. Supported steps: {list(handlers.keys())}"
+            )
+
+        return handlers[step_name](X, fit=fit, **params)
+
+    def _get_step_description(self, step_name: str) -> str:
+        """Return a description of what each preprocessing step does."""
+        descriptions = {
+            "DataScaler": "Scales numerical features using normalization",
+            "DataFrameEncoder": "Encodes categorical variables and normalizes to numerical features",
+            "remove_collinearity": "Removes highly correlated features to reduce multicollinearity",
+            "TransformRange": "Bins continuous features into discrete ranges",
+            "OneHotEncoder": "Converts categorical variables into binary variables",
+            "SimpleImputer": "Handles missing values by imputing with multiple linear regression strategies",
+        }
+
+        return descriptions.get(step_name, f"Unknown preprocessing step: {step_name}")
+
+    # ------------------------------ Step Handlers ------------------------------
+    def _handle_datascaler(self, X: pd.DataFrame, fit: bool, n: int = 1) -> pd.DataFrame:
+        """Handle DataScaler (fits on training data, applies to all)."""
+        numeric_X = X.select_dtypes(include=["float"])
+        numeric_columns = numeric_X.columns.tolist()
+        n = None if n == 0 else n
+        if fit:
+            scaler = DataScaler(numeric_X.values.T, n=n)
+            self.fitted_components["DataScaler"] = scaler
+            numeric_X = pd.DataFrame(scaler.rescale().T, columns=numeric_X.columns)
+        else:
+            scaler = self.fitted_components["DataScaler"]
+            numeric_X = pd.DataFrame(
+                scaler.rescale(numeric_X.values.T).T, columns=numeric_X.columns
+            )
+        for col in numeric_columns:
+            X[col] = numeric_X[col]
+        return X
+
+    def _handle_dataframeencoder(
+        self, X: pd.DataFrame, fit: bool, norm_method: str = "mean"
+    ) -> pd.DataFrame:
+        """Handle DataFrameEncoder (fits encoders/normalizers)."""
+        if fit:
+            encoder = DataFrameEncoder(X)
+            encoded_X = encoder.encode(norm_method=norm_method)
+            self.fitted_components["DataFrameEncoder"] = encoder
+            return encoded_X
+        else:
+            encoder = self.fitted_components["DataFrameEncoder"]
+            encoder._df = X
+            return encoder.encode()
+
+    def _handle_remove_collinearity(
+        self, X: pd.DataFrame, fit: bool, threshold: float = 0.9
+    ) -> pd.DataFrame:
+        """Handle collinearity removal (fits by selecting columns to drop)."""
+        numeric_X = X.select_dtypes(include=["float"])
+        numeric_columns = numeric_X.columns.tolist()
+        categorical_columns = set(X.columns) - set(numeric_columns)
+        if fit:
+            cleaned_X = remove_collinearity(numeric_X, threshold=threshold)
+            dropped_cols = set(X.columns) - set(cleaned_X.columns) - categorical_columns
+            self.fitted_components["remove_collinearity"] = dropped_cols
+            return X.drop(columns=dropped_cols)
+        else:
+            dropped_cols = self.fitted_components["remove_collinearity"]
+            return X.drop(columns=dropped_cols)
+
+    def _handle_transformrange(
+        self, X: pd.DataFrame, fit: bool, columns_bin_sizes: Dict[str, int] | None = None
+    ) -> pd.DataFrame:
+        """Handle TransformRange (bin numerical features into ranges)."""
+        if fit:
+            transformer = TransformRange(columns_bin_sizes)
+            cleaned_X = transformer.transform(X)
+            self.fitted_components["TransformRange"] = transformer
+            self.columns_bin_sizes = columns_bin_sizes
+            return cleaned_X
+        else:
+            transformer = self.fitted_components["TransformRange"]
+            return transformer.transform(X, fit=False)
+
+    def _handle_onehotencoder(
+        self, X: pd.DataFrame, fit: bool, columns: List[str] | None = None
+    ) -> pd.DataFrame:
+        """Handle OneHotEncoder (fits on categorical columns)."""
+        if fit:
+            tmp_df = X.drop(columns=columns)
+            encoder = OneHotEncoder()
+            category_to_indices = {}
+            for col in columns:
+                unique_values = X[col].unique()
+                category_to_indices[col] = {value: i for i, value in enumerate(unique_values)}
+                encoded_X = encoder.encode(
+                    X[col].values
+                    if isinstance(unique_values[0], int)
+                    else X[col].map(category_to_indices[col])
+                )
+                tmp_df = pd.concat([tmp_df, pd.DataFrame(encoded_X, columns=unique_values)], axis=1)
+            self.fitted_components["OneHotEncoder"] = (encoder, columns, category_to_indices)
+        else:
+            encoder, columns, category_to_indices = self.fitted_components["OneHotEncoder"]
+            tmp_df = X.drop(columns=columns)
+            for col in columns:
+                unique_values = list(category_to_indices[col].keys())
+                encoded_X = encoder.encode(
+                    (
+                        X[col].values
+                        if isinstance(unique_values[0], int)
+                        else X[col].map(category_to_indices[col])
+                    ),
+                    fit=False,
+                )
+                tmp_df = pd.concat([tmp_df, pd.DataFrame(encoded_X, columns=unique_values)], axis=1)
+        return tmp_df
+
+    def _handle_simpleimputer(
+        self,
+        X: pd.DataFrame,
+        fit: bool,
+        use_scaler: bool = False,
+        boundary: bool = True,
+    ) -> pd.DataFrame:
+        "Handle SimpleImputer (fit on numerical and categorical columns)."
+        if fit:
+            use_scaler = True if use_scaler == 1 else False
+            imputer = SimpleImputer(use_scaler=use_scaler)
+            tmp_df = imputer.fit_transform(X, boundary=boundary)
+            self.fitted_components["SimpleImputer"] = imputer
+            return tmp_df
+        else:
+            imputer = self.fitted_components["SimpleImputer"]
+            return imputer.transform(X, boundary=boundary)
+
+    def save(self, filepath: str) -> None:
+        """
+        Save the fitted pipeline state to a file using pickle.
+
+        Parameters
+        ----------
+        filepath : str
+            Path where the serialized pipeline will be saved.
+        """
+        import pickle
+
+        save_dict = {
+            "config": self.config,
+            "fitted_components": self.fitted_components,
+            "target_col": self.target_col,
+            "steps": self.steps,
+            "compute_importance": self.compute_importance,
+            "columns_bin_sizes": self.columns_bin_sizes,
+            "documentation": self.documentation,
+        }
+
+        filepath = filepath + ".pkl" if not filepath.endswith(".pkl") else filepath
+
+        with open(filepath, "wb") as f:
+            pickle.dump(save_dict, f)
+
+    @classmethod
+    def load(cls, filepath: str) -> "Pipeline":
+        """
+        Load a fitted pipeline from a file.
+
+        Parameters
+        ----------
+        filepath : str
+            Path to the serialized pipeline file.
+
+        Returns
+        -------
+        pipeline : Pipeline
+            Reconstructed pipeline instance with fitted components.
+        """
+        import pickle
+
+        filepath = filepath + ".pkl" if not filepath.endswith(".pkl") else filepath
+
+        with open(filepath, "rb") as f:
+            save_dict = pickle.load(f)
+
+        pipeline = cls.__new__(cls)
+
+        pipeline.config = save_dict["config"]
+        pipeline.fitted_components = save_dict["fitted_components"]
+        pipeline.target_col = save_dict["target_col"]
+        pipeline.steps = save_dict["steps"]
+        pipeline.compute_importance = save_dict["compute_importance"]
+        pipeline.columns_bin_sizes = save_dict["columns_bin_sizes"]
+        pipeline.documentation = save_dict["documentation"]
+
+        return pipeline

likelihood/tools/__init__.py

@@ -1,3 +1,4 @@
 from .models_tools import *
 from .numeric_tools import *
+from .reports import generate_html_pipeline
 from .tools import *

likelihood/tools/models_tools.py

@@ -47,22 +47,21 @@ class TransformRange:
     Transforms numerical columns into categorical range bins with descriptive labels.
     """
 
-    def __init__(self, df: pd.DataFrame) -> None:
+    def __init__(self, columns_bin_sizes: Dict[str, int]) -> None:
         """Initializes the class with the original DataFrame.
 
         Parameters
         ----------
-        df : `pd.DataFrame`
-            The original DataFrame to transform.
+        columns_bin_sizes : `dict`
+            A dictionary where the keys are column names and the values are the bin sizes.
 
         Raises
         ------
         TypeError
             If df is not a pandas DataFrame.
         """
-        if not isinstance(df, pd.DataFrame):
-            raise TypeError("df must be a pandas DataFrame")
-        self.df = df.copy()  # Create a copy to avoid modifying the original
+        self.info = {}
+        self.columns_bin_sizes = columns_bin_sizes
 
     def _create_bins_and_labels(
         self, min_val: Union[int, float], max_val: Union[int, float], bin_size: int
@@ -104,15 +103,28 @@ class TransformRange:
         if bins[-1] <= max_val:
             bins = np.append(bins, max_val + 1)
 
+        lower_bin_edge = -np.inf
+        upper_bin_edge = np.inf
+
         labels = [f"{int(bins[i])}-{int(bins[i+1] - 1)}" for i in range(len(bins) - 1)]
+        end = int(bins[-1] - 1)
+        bins = bins.tolist()
+        bins.insert(0, lower_bin_edge)
+        bins.append(upper_bin_edge)
+        labels.insert(0, f"< {start}")
+        labels.append(f"> {end}")
         return bins, labels
 
-    def _transform_column_to_ranges(self, column: str, bin_size: int) -> pd.Series:
+    def _transform_column_to_ranges(
+        self, df: pd.DataFrame, column: str, bin_size: int, fit: bool = True
+    ) -> pd.Series:
         """
         Transforms a column in the DataFrame into range bins.
 
         Parameters
         ----------
+        df : `pd.DataFrame`
+            The original DataFrame to transform.
         column : `str`
             The name of the column to transform.
         bin_size : `int`
@@ -130,40 +142,51 @@ class TransformRange:
         ValueError
             If bin_size is not positive or if column contains non-numeric data.
         """
-        if column not in self.df.columns:
-            raise KeyError(f"Column '{column}' not found in DataFrame")
-
-        if bin_size <= 0:
-            raise ValueError("bin_size must be positive")
-
-        numeric_series = pd.to_numeric(self.df[column], errors="coerce")
-        if numeric_series.isna().all():
-            raise ValueError(f"Column '{column}' contains no valid numeric data")
-
-        min_val = numeric_series.min()
-        max_val = numeric_series.max()
-
-        if min_val == max_val:
-            return pd.Series(
-                [f"{int(min_val)}-{int(max_val)}"] * len(self.df), name=f"{column}_range"
-            )
+        if not isinstance(df, pd.DataFrame):
+            raise TypeError("df must be a pandas DataFrame")
+        df_ = df.copy()  # Create a copy to avoid modifying the original
+        numeric_series = pd.to_numeric(df_[column], errors="coerce")
+        if fit:
+            self.df = df_.copy()
+            if column not in df_.columns:
+                raise KeyError(f"Column '{column}' not found in DataFrame")
+
+            if bin_size <= 0:
+                raise ValueError("bin_size must be positive")
+
+            if numeric_series.isna().all():
+                raise ValueError(f"Column '{column}' contains no valid numeric data")
+
+            min_val = numeric_series.min()
+            max_val = numeric_series.max()
+
+            if min_val == max_val:
+                return pd.Series(
+                    [f"{int(min_val)}-{int(max_val)}"] * len(df_), name=f"{column}_range"
+                )
+            self.info[column] = {"min_value": min_val, "max_value": max_val, "range": bin_size}
+        else:
+            min_val = self.info[column]["min_value"]
+            max_val = self.info[column]["max_value"]
+            bin_size = self.info[column]["range"]
 
         bins, labels = self._create_bins_and_labels(min_val, max_val, bin_size)
-
         return pd.cut(numeric_series, bins=bins, labels=labels, right=False, include_lowest=True)
 
-    def transform_dataframe(
-        self, columns_bin_sizes: Dict[str, int], drop_original: bool = False
+    def transform(
+        self, df: pd.DataFrame, drop_original: bool = False, fit: bool = True
     ) -> pd.DataFrame:
         """
         Creates a new DataFrame with range columns.
 
         Parameters
         ----------
-        columns_bin_sizes : `dict`
-            A dictionary where the keys are column names and the values are the bin sizes.
+        df : `pd.DataFrame`
+            The original DataFrame to transform.
         drop_original : `bool`, optional
             If True, drops original columns from the result, by default False
+        fit : `bool`, default=True
+            Whether to compute bin edges based on the data (True) or use predefined binning (False).
 
         Returns
         -------
@@ -175,22 +198,24 @@ class TransformRange:
         TypeError
             If columns_bin_sizes is not a dictionary.
         """
-        if not isinstance(columns_bin_sizes, dict):
+        if not isinstance(self.columns_bin_sizes, dict):
             raise TypeError("columns_bin_sizes must be a dictionary")
 
-        if not columns_bin_sizes:
+        if not self.columns_bin_sizes:
             return pd.DataFrame()
 
         range_columns = {}
-        for column, bin_size in columns_bin_sizes.items():
-            range_columns[f"{column}_range"] = self._transform_column_to_ranges(column, bin_size)
+        for column, bin_size in self.columns_bin_sizes.items():
+            range_columns[f"{column}_range"] = self._transform_column_to_ranges(
+                df, column, bin_size, fit
+            )
 
         result_df = pd.DataFrame(range_columns)
 
         if not drop_original:
-            original_cols = [col for col in self.df.columns if col not in columns_bin_sizes]
+            original_cols = [col for col in df.columns if col not in self.columns_bin_sizes]
             if original_cols:
-                result_df = pd.concat([self.df[original_cols], result_df], axis=1)
+                result_df = pd.concat([df[original_cols], result_df], axis=1)
 
         return result_df
 

likelihood/tools/reports.py

@@ -0,0 +1,195 @@
+from html import escape
+from IPython.display import HTML, display
+
+
+def generate_html_pipeline(data_dict, save_to_file=False, file_name="data_processing_report.html"):
+    css_js = """
+    <style>
+        :root {
+            --primary: #0d9488;
+            --primary-dark: #0f766e;
+            --success: #10b981;
+            --accent: #3b82f6;
+            --card-bg: #ffffff;
+            --shadow-sm: 0 2px 6px rgba(0, 0, 0, 0.03);
+            --border-radius-md: 6px;
+        }
+
+        * {
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+            background: #f8fafc;
+            color: #1e293b;
+            margin: 0;
+            padding: 1rem;
+            font-size: 14px;
+        }
+
+        h2 {
+            background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+            color: white;
+            text-align: center;
+            padding: 1rem;
+            border-radius: var(--border-radius-md);
+            font-weight: 600;
+            font-size: 1.5rem;
+            margin-bottom: 1.5rem;
+        }
+
+        section {
+            background: var(--card-bg);
+            border-radius: var(--border-radius-md);
+            padding: 1rem;
+            box-shadow: var(--shadow-sm);
+            margin-bottom: 1.2rem;
+        }
+
+        h3 {
+            color: var(--primary-dark);
+            font-weight: 600;
+            font-size: 1.2rem;
+            border-left: 4px solid var(--success);
+            padding-left: 0.8rem;
+            margin: 1rem 0 0.8rem;
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            font-size: 13px;
+            margin: 0.5rem 0 1rem;
+        }
+
+        th, td {
+            padding: 0.5rem 0.75rem;
+            text-align: left;
+            border-bottom: 1px solid #e2e8f0;
+            vertical-align: top;
+        }
+
+        thead {
+            background-color: #f0fdf4;
+        }
+
+        tbody tr:nth-child(odd) {
+            background-color: #f9fafb;
+        }
+
+        tbody tr:hover {
+            background-color: #e0f2fe;
+        }
+
+        .nested-table {
+            font-size: 12px;
+            margin-top: 0.5rem;
+        }
+
+        details {
+            margin-bottom: 0.8rem;
+            padding: 0.5rem 0.8rem;
+            background: #f9f9f9;
+            border-radius: var(--border-radius-md);
+        }
+
+        summary {
+            font-weight: 600;
+            font-size: 1rem;
+            color: var(--primary-dark);
+            cursor: pointer;
+        }
+
+        summary::before {
+            content: "▶";
+            margin-right: 6px;
+            color: var(--success);
+            font-size: 0.9rem;
+        }
+
+        @media (max-width: 768px) {
+            body {
+                font-size: 13px;
+            }
+
+            h2 {
+                font-size: 1.3rem;
+                padding: 0.8rem;
+            }
+
+            h3 {
+                font-size: 1.1rem;
+            }
+
+            table, .nested-table {
+                font-size: 12px;
+            }
+        }
+    </style>
+    """
+
+    def render_value(val):
+        if isinstance(val, dict):
+            return dict_to_table(val, nested=True)
+        elif isinstance(val, list):
+            if all(isinstance(item, (str, int, float)) for item in val):
+                return ", ".join(escape(str(x)) for x in val)
+            else:
+                return "<ul>" + "".join(f"<li>{render_value(v)}</li>" for v in val) + "</ul>"
+        else:
+            return escape(str(val))
+
+    def dict_to_table(d, title=None, nested=False):
+        html = ""
+        if title and not nested:
+            html += f"<h4>{escape(title)}</h4>"
+        table_class = "nested-table" if nested else "table"
+        html += f"<table class='{table_class}'>"
+        html += "<thead><tr><th>Key</th><th>Value</th></tr></thead><tbody>"
+        for key, val in d.items():
+            key_html = escape(str(key))
+            val_html = render_value(val)
+            html += f"<tr><td>{key_html}</td><td>{val_html}</td></tr>"
+        html += "</tbody></table>"
+        return html
+
+    html_content = css_js
+    html_content += "<h2>📈 Data Processing Report</h2>"
+
+    html_content += "<section>"
+    html_content += "<h3>📁 Initial Dataset</h3>"
+    html_content += dict_to_table(data_dict["initial_dataset"])
+    html_content += "</section>"
+
+    html_content += "<section>"
+    html_content += "<h3>🔧 Processing Steps</h3>"
+    for i, step in enumerate(data_dict["processing_steps"]):
+        html_content += "<details open>"
+        html_content += f"<summary>Step {i + 1}: {escape(step['step_name'])}</summary>"
+        html_content += f"<p><strong>Description:</strong> {escape(step['description'])}</p>"
+        html_content += dict_to_table(step["parameters"], title="Parameters", nested=True)
+        html_content += dict_to_table(
+            {
+                "Output Shape": step["output_shape"],
+                "Input Columns": step["input_columns"],
+                "Output Columns": step["output_columns"],
+                "Output Dtypes": step["output_dtypes"],
+            },
+            title="Output Info",
+            nested=True,
+        )
+        html_content += "</details>"
+    html_content += "</section>"
+
+    html_content += "<section>"
+    html_content += "<h3>✅ Final Dataset</h3>"
+    html_content += dict_to_table(data_dict["final_dataset"])
+    html_content += "</section>"
+
+    if save_to_file:
+        with open(file_name, "w", encoding="utf-8") as f:
+            f.write(html_content)
+        print(f"✅ Report saved to '{file_name}'")
+    else:
+        display(HTML(html_content))

likelihood/tools/tools.py

@@ -2,7 +2,7 @@ import math
 import os
 import pickle
 import warnings
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Dict, Generator, List, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -25,7 +25,7 @@ Data Science from Scratch, Second Edition, by Joel Grus (O'Reilly).Copyright 201
 """
 
 
-def minibatches(dataset: List, batch_size: int, shuffle: bool = True) -> List:
+def minibatches(dataset: List, batch_size: int, shuffle: bool = True) -> Generator:
     """Generates 'batch_size'-sized minibatches from the dataset
 
     Parameters
@@ -660,7 +660,7 @@ class DataScaler:
 
     __slots__ = ["dataset_", "_n", "data_scaled", "values", "inv_fitting"]
 
-    def __init__(self, dataset: np.ndarray, n: int = 1) -> None:
+    def __init__(self, dataset: np.ndarray, n: int | None = 1) -> None:
         """Initializes the parameters required for scaling the data"""
         self.dataset_ = dataset.copy()
         self._n = n
@@ -1024,20 +1024,21 @@ class OneHotEncoder:
     It receives an array of integers and returns a binary array using the one-hot encoding method.
     """
 
-    __slots__ = ["x"]
+    __slots__ = ["num_categories"]
 
     def __init__(self) -> None:
         pass
 
-    def encode(self, x: np.ndarray | list):
-        self.x = x
-
-        if not isinstance(self.x, np.ndarray):
-            self.x = np.array(self.x)
+    def encode(self, x: np.ndarray | list, fit: bool = True):
+        if not isinstance(x, np.ndarray):
+            x = np.array(x)
+        x = x.astype(int)
+        if fit:
+            self.num_categories = x.max() + 1
 
-        y = np.zeros((self.x.size, self.x.max() + 1))
+        y = np.zeros((x.size, self.num_categories))
 
-        y[np.arange(self.x.size), self.x] = 1
+        y[np.arange(x.size), x] = 1
 
         return y
 
@@ -1189,7 +1190,9 @@ def check_nan_inf(df: DataFrame, verbose: bool = False) -> DataFrame:
     if nan_values:
         (
             print(
-                "UserWarning: Some rows may have been deleted due to the existence of NaN values."
+                "UserWarning: Some rows may have been deleted due to the existence of NaN values.",
+                f"NaN values removed: ",
+                "{:,}".format(nan_count),
             )
             if verbose
             else None
@@ -1199,7 +1202,9 @@ def check_nan_inf(df: DataFrame, verbose: bool = False) -> DataFrame:
     if inf_values:
         (
             print(
-                "UserWarning: Some rows may have been deleted due to the existence of Inf values."
+                "UserWarning: Some rows may have been deleted due to the existence of Inf values.",
+                f"Infinite values removed: ",
+                "{:,}".format(inf_count),
             )
             if verbose
             else None
@@ -1207,9 +1212,6 @@ def check_nan_inf(df: DataFrame, verbose: bool = False) -> DataFrame:
         df.replace([np.inf, -np.inf], np.nan, inplace=True)
         df.dropna(inplace=True)
 
-    print(f"NaN values removed: ", "{:,}".format(nan_count))
-    print(f"Infinite values removed: ", "{:,}".format(inf_count))
-
     return df
 
 

{likelihood-2.0.1.dist-info → likelihood-2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: likelihood
-Version: 2.0.1
+Version: 2.0.2
 Summary: A package that performs the maximum likelihood algorithm.
 Home-page: https://github.com/jzsmoreno/likelihood/
 Author: J. A. Moreno-Guerra

{likelihood-2.0.1.dist-info → likelihood-2.0.2.dist-info}/RECORD

@@ -1,5 +1,6 @@
-likelihood/__init__.py,sha256=5C0hapdsk85XZhN_rssRAEFpkRRuKNtj6cyRbqD2_gM,994
+likelihood/__init__.py,sha256=e2AiFru2wEpWnK6frQlzEI-4r8UyU59ltxtkvOs-nEI,1032
 likelihood/main.py,sha256=fcCkGOOWKjfvw2tLVqjuKPV8t0rVCIT9FlbYcOv4EYo,7974
+likelihood/pipes.py,sha256=9M94YGppg-Q1yNpSIjAzy4MSNSCGobr10LrRRMpEmdA,13853
 likelihood/graph/__init__.py,sha256=vUY4pKlnm3eSVTXd2d-5JDPawhqGNRIKRhaHIobsNws,188
 likelihood/graph/_nn.py,sha256=Sh7dRz8QSI08Ydfw9e--uCxc4KMtHUsCz_-C-loXklQ,13883
 likelihood/graph/graph.py,sha256=bLrNMvIh7GOTdPTwnNss8oPZ7cbSHQScAsH_ttmVUK0,3294
@@ -10,21 +11,22 @@ likelihood/models/regression.py,sha256=9cakyGlJCEO6WfpoKLh3GxdXQeQp7cUvJIkQ5odT0
 likelihood/models/simulation.py,sha256=xsl4mJ2qFCuZR_B9LfQcLjV6OtONU1zyESX3CCUfOiw,8619
 likelihood/models/utils.py,sha256=dvigPi_hxcs5ntfHr7Y1JvP5ULtMW3kkN0nJpS4orE8,1319
 likelihood/models/deep/__init__.py,sha256=I55FciI0BfljYdhW2OGNqcpYV57FhPZETZX7Y1y9GVQ,303
-likelihood/models/deep/_autoencoders.py,sha256=CeD79YzU7DdPd92wUNG_EtPVQOBgsgYoC4uS2JF3b6o,30939
+likelihood/models/deep/_autoencoders.py,sha256=VG6nL5Zov1a31TnzbFNALiyBOAvup3s86ShD64JxmLA,30959
 likelihood/models/deep/_predictor.py,sha256=XI4QfVM7PS_60zYtmi-V8UzNDrASFiDMVPmV17BB8lM,27984
 likelihood/models/deep/autoencoders.py,sha256=muUBH9BclOK8ViI7PijyMOBBLVox6uwuIabyJvpU5qw,30729
 likelihood/models/deep/gan.py,sha256=rTnaLmIPjsKg6_0B8JZOVwPxdx59rHmqvzDitdJMCQ4,10924
 likelihood/models/deep/predictor.py,sha256=q5tPaAbF7s5XIcxVr6fyHTQdZa9tlixO9vb9a9Cw0wM,27831
-likelihood/models/deep/rl.py,sha256=VVuwHwK24d2fe3uNHliE1QJsKGZAPhx_pdgj3jqN5rQ,11565
-likelihood/tools/__init__.py,sha256=N1IhMDzacsGQT2MIYBMBC0zTxes78vC_0gGrwkuPgmg,78
+likelihood/models/deep/rl.py,sha256=WuRP_1RmTIkzbirjb7geUxFsqCAwt7CdtXWKHrmIgo4,11541
+likelihood/tools/__init__.py,sha256=C5r18DQdyBVePyxtlfdVLr9SMFnXeVuvgcZgmN5-3dY,122
 likelihood/tools/cat_embed.py,sha256=SJ7o1vbrNYp21fLLcjRnWpUDcz1nVSe8TmMvsLIz5CI,7346
 likelihood/tools/figures.py,sha256=waF0NHIMrctCmaLhcuz5DMcXyRKynmn6aG0XITYCTLc,10940
 likelihood/tools/impute.py,sha256=n87Tv-xLUAdPl7BQLFcLWSsXBZbXksahyCayJWMydXc,9485
-likelihood/tools/models_tools.py,sha256=-QAfvCy9mw-ZyeJHzJJ7O6eDfUXghtA7KfFtTc-Tp0A,14607
+likelihood/tools/models_tools.py,sha256=2e0uzpjgCMn5cB0McN6a_Vff_QHdMhjUbgLHzMferEA,15622
 likelihood/tools/numeric_tools.py,sha256=JeLECoVS3ayFH53kUYkAMs0fzALZV1M22-tBLM-Q34g,12264
-likelihood/tools/tools.py,sha256=5vPUHrm8D4ODsg-MP4uZ3NgXV9fNbs0Olx7RWtUdVDU,42196
-likelihood-2.0.1.dist-info/licenses/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
-likelihood-2.0.1.dist-info/METADATA,sha256=3mLJAcVO4jzu4IoCVVaSBPMxBWV-xnHs_f_DvvN9G0c,2917
-likelihood-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-likelihood-2.0.1.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
-likelihood-2.0.1.dist-info/RECORD,,
+likelihood/tools/reports.py,sha256=InhmpBQ014oCMLIwz_hkhkxj8LcVbMBy_dl8NPViSdI,5710
+likelihood/tools/tools.py,sha256=5teN35Dt6z4j6GgMiizf9txbD9uVirCJVLsGPTE7pZY,42336
+likelihood-2.0.2.dist-info/licenses/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
+likelihood-2.0.2.dist-info/METADATA,sha256=qdLRVowEQRvzD1UeTT2QYT-wrAtHtJEiM28y_Jv69iA,2917
+likelihood-2.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+likelihood-2.0.2.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
+likelihood-2.0.2.dist-info/RECORD,,