likelihood 2.2.0.dev1__cp310-cp310-musllinux_1_2_x86_64.whl

likelihood/models/simulation.py

@@ -0,0 +1,213 @@
+import pickle
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from packaging import version
+from pandas.core.frame import DataFrame
+
+from likelihood.tools import DataScaler, FeatureSelection, OneHotEncoder, cdf, check_nan_inf
+
+if version.parse(np.__version__) < version.parse("2.0.0"):
+    filter = np.RankWarning
+else:
+    filter = np.exceptions.RankWarning
+
+
+# --------------------------------------------------------------------------------------------------------------------------------------
+def categories_by_quartile(df: DataFrame, column: str) -> Tuple[str, str]:
+    freq = df[column].value_counts()
+
+    q1 = freq.quantile(0.25)
+    q3 = freq.quantile(0.75)
+
+    least_frequent = freq[freq <= q1]
+    most_frequent = freq[freq >= q3]
+
+    least_frequent_category = least_frequent.idxmin() if not least_frequent.empty else None
+    most_frequent_category = most_frequent.idxmax() if not most_frequent.empty else None
+
+    return least_frequent_category, most_frequent_category
+
+
+class SimulationEngine(FeatureSelection):
+    """
+    This class implements a predictive model that utilizes multiple linear regression for numerical target variables
+    and multiple logistic regression for categorical target variables.
+
+    The class provides methods for training the model on a given dataset, making predictions,
+    and evaluating the model's performance.
+
+    Key features:
+    - Supports both numerical and categorical target variables, automatically selecting the appropriate regression method.
+    - Includes methods for data preprocessing, model fitting, prediction, and evaluation metrics.
+    - Designed to be flexible and user-friendly, allowing for easy integration with various datasets.
+
+    Usage:
+    - Instantiate the class with the training data and target variable.
+    - Call the fit method to train the model.
+    - Use the predict method to generate predictions on new data.
+    - Evaluate the model using built-in metrics for accuracy and error.
+
+    This class is suitable for applications in data analysis and machine learning, enabling users to leverage regression techniques
+    for both numerical and categorical outcomes efficiently.
+    """
+
+    def __init__(self, use_scaler: bool = False, **kwargs):
+        self.df = pd.DataFrame()
+        self.n_importances = None
+        self.use_scaler = use_scaler
+        self.proba_dict = {}
+
+        super().__init__(**kwargs)
+
+    def predict(self, df: DataFrame, column: str) -> np.ndarray | list:
+        w, quick_encoder, names_cols, dfe, numeric_dict = self.w_dict[column]
+
+        df = df[names_cols].copy()
+        dataset = self.df.copy()
+        dataset.drop(columns=column, inplace=True)
+        numeric_df = dataset.select_dtypes(include="number")
+        if self.use_scaler:
+            scaler = DataScaler(numeric_df.copy().to_numpy().T, n=None)
+            _ = scaler.rescale()
+            dataset_ = df.copy()
+            numeric_df = dataset_.select_dtypes(include="number")
+            numeric_scaled = scaler.rescale(dataset_=numeric_df.to_numpy())
+            numeric_df = pd.DataFrame(numeric_scaled.T, columns=numeric_df.columns)
+            for col in numeric_df.columns:
+                df[col] = numeric_df[col].values
+
+        for num, colname in enumerate(dfe._encode_columns):
+            if df[colname].dtype == "object":
+                encode_dict = dfe.encoding_list[num]
+                df[colname] = df[colname].apply(
+                    dfe._code_transformation_to, dictionary_list=encode_dict
+                )
+
+        y = df.to_numpy() @ w
+
+        if quick_encoder != None:
+            one_hot = OneHotEncoder()
+            y = one_hot.decode(y)
+            encoding_dic = quick_encoder.decoding_list[0]
+            y = [encoding_dic[item] for item in y]
+        else:
+            if self.use_scaler:
+                y += 1
+                y /= 2
+                y = y * (self.df[column].max() - self.df[column].min())
+
+        return y[:]
+
+    def _encode(self, df: DataFrame) -> Dict[str, float]:
+        df = df.copy()
+        column = df.columns[0]
+        frec = df[column].value_counts() / len(df)
+        df.loc[:, "frec"] = df[column].map(frec)
+        df.sort_values("frec", inplace=True)
+        keys = df[column].to_list()
+        values = df["frec"].to_list()
+        return dict(zip(keys, values))
+
+    def fit(self, df: DataFrame, n_importances: int, **kwargs) -> None:
+        self.df = df
+        self.n_importances = n_importances
+        self.get_digraph(self.df, self.n_importances, self.use_scaler)
+        proba_dict_keys = list(self.w_dict.keys())
+        self.proba_dict = dict(zip(proba_dict_keys, [i for i in range(len(proba_dict_keys))]))
+        for key in proba_dict_keys:
+            x = (
+                self.df[key].values,
+                None if self.df[key].dtype != "object" else self._encode(self.df[[key]]),
+            )
+            poly = kwargs.get("poly", 9)
+            plot = kwargs.get("plot", False)
+            bandwidth = kwargs.get("bandwidth", 1.5)
+            if not x[1]:
+                media = self.df[key].mean()
+                standard_deviation = self.df[key].std()
+                lower_limit = media - bandwidth * standard_deviation
+                upper_limit = media + bandwidth * standard_deviation
+                f, _, ox = cdf(x[0].flatten(), poly=poly, plot=plot, key=key)
+            else:
+                f, ox = None, None
+                least_frequent_category, most_frequent_category = categories_by_quartile(
+                    self.df[[key]], key
+                )
+                lower_limit = x[1].get(least_frequent_category, 0)
+                upper_limit = x[1].get(most_frequent_category, 0)
+            self.proba_dict[key] = (
+                f if f else None,
+                x[1],
+                (np.mean(np.abs(np.diff(ox))) / 2.0 if isinstance(ox, np.ndarray) else None),
+                f(lower_limit) if f else lower_limit,
+                f(upper_limit) if f else upper_limit,
+            )
+
+    def get_proba(self, value: Union[Union[float, int], str] | list, colname: str) -> List[float]:
+        value = (
+            value
+            if isinstance(value, list)
+            else value.flatten().tolist() if isinstance(value, np.ndarray) else [value]
+        )
+        return [
+            (
+                self.proba_dict[colname][0](val)
+                - self.proba_dict[colname][0](val - self.proba_dict[colname][2])
+                if (isinstance(val, float) or isinstance(val, int))
+                else self.proba_dict[colname][1].get(val, 0)
+            )
+            for val in value
+        ]
+
+    def pred_outliers(self, value: Union[Union[float, int], str] | list, colname: str) -> List[str]:
+        return [
+            (
+                "inlier"
+                if (self.proba_dict[colname][3] < val < self.proba_dict[colname][4])
+                else "outlier"
+            )
+            for val in self.get_proba(value, colname)
+        ]
+
+    def _clean_data(self, df: DataFrame) -> DataFrame:
+        df.replace([np.inf, -np.inf], np.nan, inplace=True)
+        df.replace(" ", np.nan, inplace=True)
+        df = check_nan_inf(df)
+        df = df.reset_index()
+        df = df.drop(columns=["index"])
+
+        return df
+
+    def save(self, filename: str = "./simulation_model") -> None:
+        """
+        Save the state of the SimulationEngine to a file.
+
+        Parameters
+        ----------
+        filename : str
+            The name of the file where the object will be saved.
+        """
+        filename = filename if filename.endswith(".pkl") else filename + ".pkl"
+        with open(filename, "wb") as f:
+            pickle.dump(self, f)
+
+    @staticmethod
+    def load(filename: str = "./simulation_model"):
+        """
+        Load the state of a SimulationEngine from a file.
+
+        Parameters
+        ----------
+        filename : str
+            The name of the file containing the saved object.
+
+        Returns
+        -------
+        SimulationEngine : Any
+            A new instance of SimulationEngine with the loaded state.
+        """
+        filename = filename + ".pkl" if not filename.endswith(".pkl") else filename
+        with open(filename, "rb") as f:
+            return pickle.load(f)

likelihood/models/utils.py

@@ -0,0 +1,87 @@
+import numpy as np
+
+from likelihood.tools import cal_average
+
+
+class FeaturesArima:
+    """Base class for ARIMA feature computations."""
+
+    def forward(self, y_sum: np.ndarray, theta: list, mode: bool, noise: float) -> np.ndarray:
+        """Compute the forward pass of the model.
+
+        Parameters
+        ----------
+        y_sum : `np.ndarray`
+            Summed data points.
+        theta : `list`
+            Model parameters.
+        mode : `bool`
+            Forward pass mode.
+        noise : `float`
+            Noise level.
+
+        Returns
+        -------
+        `np.ndarray`
+            Computed values.
+        """
+        if mode:
+            y_vec = []
+
+            y_t = np.dot(theta, y_sum)
+
+            n = y_sum.shape[0]
+
+            for i in range(n):
+                try:
+                    n_int = np.where(y_sum != y_sum[i])[0]
+                    y_i = (y_t - np.dot(theta[n_int], y_sum[n_int])) / theta[i]
+                    y_i += np.random.rand() * noise
+                except:
+                    y_i = (y_t - np.dot(theta[0:i], y_sum[0:i])) / theta[i]
+                y_vec.append(y_i)
+        else:
+            y_t = np.dot(theta, y_sum) + y_sum[0]
+            n_int = np.where(y_sum != y_sum[0])[0]
+            y_i = (y_t - np.dot(theta[n_int], y_sum[n_int])) / theta[0]
+            y_i += np.random.rand() * noise
+            return y_i
+
+        return np.array(y_vec)
+
+    def integrated(self, datapoints: np.ndarray) -> np.ndarray:
+        """Compute integrated values.
+
+        Parameters
+        ----------
+        datapoints : `np.ndarray`
+            Input data points.
+
+        Returns
+        -------
+        `np.ndarray`
+            Integrated values.
+        """
+        datapoints = self.datapoints
+        y_sum = list(np.diff(datapoints, self.d))
+        y_sum.insert(0, datapoints[0])
+
+        return np.array(y_sum)
+
+    def average(self, datapoints: np.ndarray) -> np.ndarray:
+        """Compute average values.
+
+        Parameters
+        ----------
+        datapoints : `np.ndarray`
+            Input data points.
+
+        Returns
+        -------
+        `np.ndarray`
+            Average values.
+        """
+        y_sum_average = cal_average(datapoints)
+        y_sum_eps = datapoints - y_sum_average
+
+        return y_sum_eps

likelihood/pipes.py

@@ -0,0 +1,382 @@
+import json
+import pickle
+import re
+import uuid
+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.fitted_idx: List[str] = []
+        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", {})
+            uuid_idx = uuid.uuid4()
+            step_info = {
+                "step_name": step_name,
+                "parameters": params,
+                "description": self._get_step_description(step_name),
+                "id": uuid_idx,
+            }
+            step_info["input_columns"] = list(X.columns)
+            self.fitted_idx.append(uuid_idx)
+
+            X = self._apply_step(step_name, uuid_idx, 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()
+            categorical_columns = X.select_dtypes(include=["category"]).columns
+            unique_categories = {col: X[col].unique().tolist() for col in categorical_columns}
+            step_info["unique_categories"] = unique_categories
+
+            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 index, (step_name, _) in enumerate(self.fitted_components.items()):
+            step_name = re.sub(r"_[a-f0-9\-]{36}", "", step_name)
+            X = self._apply_step(step_name, self.fitted_idx[index], 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, idx: 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, idx=idx, 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, idx: str, 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[f"DataScaler_{idx}"] = scaler
+            numeric_X = pd.DataFrame(scaler.rescale().T, columns=numeric_X.columns)
+        else:
+            scaler = self.fitted_components[f"DataScaler_{idx}"]
+            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, idx: str, 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[f"DataFrameEncoder_{idx}"] = encoder
+            return encoded_X
+        else:
+            encoder = self.fitted_components[f"DataFrameEncoder_{idx}"]
+            encoder._df = X
+            return encoder.encode()
+
+    def _handle_remove_collinearity(
+        self, X: pd.DataFrame, idx: str, 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[f"remove_collinearity_{idx}"] = dropped_cols
+            return X.drop(columns=dropped_cols)
+        else:
+            dropped_cols = self.fitted_components[f"remove_collinearity_{idx}"]
+            return X.drop(columns=dropped_cols)
+
+    def _handle_transformrange(
+        self, X: pd.DataFrame, idx: str, 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[f"TransformRange_{idx}"] = transformer
+            self.columns_bin_sizes = columns_bin_sizes
+            return cleaned_X
+        else:
+            transformer = self.fitted_components[f"TransformRange_{idx}"]
+            return transformer.transform(X, fit=False)
+
+    def _handle_onehotencoder(
+        self, X: pd.DataFrame, idx: str, 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(
+                        X[col].cat.codes.unique()
+                        if pd.api.types.is_categorical_dtype(X[col])
+                        else X[col].unique()
+                    )
+                }
+                encoded_X = encoder.encode(
+                    X[col].values
+                    if isinstance(unique_values[0], int)
+                    else X[col].cat.codes.map(category_to_indices[col])
+                )
+                tmp_df = pd.concat([tmp_df, pd.DataFrame(encoded_X, columns=unique_values)], axis=1)
+            self.fitted_components[f"OneHotEncoder_{idx}"] = (
+                encoder,
+                columns,
+                category_to_indices,
+                unique_values,
+            )
+        else:
+            encoder, columns, category_to_indices, unique_values = self.fitted_components[
+                f"OneHotEncoder_{idx}"
+            ]
+            tmp_df = X.drop(columns=columns)
+            for col in columns:
+                encoded_X = encoder.encode(
+                    (
+                        X[col].values
+                        if isinstance(unique_values[0], int)
+                        else X[col].cat.codes.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,
+        idx: str,
+        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[f"SimpleImputer_{idx}"] = imputer
+            return tmp_df
+        else:
+            imputer = self.fitted_components[f"SimpleImputer_{idx}"]
+            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.
+        """
+
+        save_dict = {
+            "config": self.config,
+            "fitted_components": self.fitted_components,
+            "fitted_idx": self.fitted_idx,
+            "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.
+        """
+
+        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.fitted_idx = save_dict["fitted_idx"]
+        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

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