likelihood 1.2.22__tar.gz → 1.2.23__tar.gz

{likelihood-1.2.22 → likelihood-1.2.23}/PKG-INFO

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

{likelihood-1.2.22 → likelihood-1.2.23}/likelihood/graph/graph.py

@@ -74,3 +74,20 @@ class DynamicGraph(FeatureSelection):
             nx_graph.add_edges_from([(source, target, edge)])
 
         return nx_graph
+
+
+# -------------------------------------------------------------------------
+if __name__ == "__main__":
+    import numpy as np
+    import pandas as pd
+
+    # Generate data
+    x = np.random.rand(3, 100)
+    y = 0.1 * x[0, :] + 0.4 * x[1, :] + 0.5 * x[2, :] + 0.1
+    # Create a DataFrame
+    df = pd.DataFrame(x.T, columns=["x1", "x2", "x3"])
+    df["y"] = y
+    # Instantiate DynamicGraph
+    fs = DynamicGraph(df, n_importances=2)
+    print(fs.fit())
+    fs.draw()

likelihood-1.2.23/likelihood/models/simulation.py

@@ -0,0 +1,223 @@
+import pickle
+import warnings
+from typing import List, Tuple, Union
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from numpy import ndarray
+from pandas.core.frame import DataFrame
+
+from likelihood.tools import DataScaler, FeatureSelection, OneHotEncoder, cdf, check_nan_inf
+
+# Suppress RankWarning
+warnings.simplefilter("ignore", np.RankWarning)
+
+
+# --------------------------------------------------------------------------------------------------------------------------------------
+def categories_by_quartile(df: DataFrame, column: str) -> Tuple[str, str]:
+    # Count the frequency of each category in the column
+    freq = df[column].value_counts()
+
+    # Calculate the 25th percentile (Q1) and 75th percentile (Q3)
+    q1 = freq.quantile(0.25)
+    q3 = freq.quantile(0.75)
+
+    # Filter categories that are below the 25th percentile and above the 75th percentile
+    least_frequent = freq[freq <= q1]
+    most_frequent = freq[freq >= q3]
+
+    # Get the least frequent category (25th percentile) and the most frequent category (75th percentile)
+    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) -> ndarray | list:
+        # Let us assign the dictionary entries corresponding to the column
+        w, quick_encoder, names_cols, dfe, numeric_dict = self.w_dict[column]
+
+        df = df[names_cols].copy()
+        # Change the scale of the dataframe
+        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
+
+        # Encoding the datadrame
+        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
+                )
+
+        # PREDICTION
+        y = df.to_numpy() @ w
+
+        # Categorical column
+        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]
+        # Numeric column
+        else:
+            if self.use_scaler:
+                # scale output
+                y += 1
+                y /= 2
+                y = y * (self.df[column].max() - self.df[column].min())
+
+        return y[:]
+
+    def _encode(self, df: DataFrame) -> ndarray | list:
+        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
+        # We run the feature selection algorithm
+        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)
+            if not x[1]:
+                media = self.df[key].mean()
+                desviacion_estandar = self.df[key].std()
+                cota_inferior = media - 1.5 * desviacion_estandar
+                cota_superior = media + 1.5 * desviacion_estandar
+                if plot:
+                    print(f"Cumulative Distribution Function ({key})")
+                f, cdf_, ox = cdf(x[0].flatten(), poly=poly, plot=plot)
+            else:
+                f, ox = None, None
+                least_frequent_category, most_frequent_category = categories_by_quartile(
+                    self.df[[key]], key
+                )
+                cota_inferior = x[1].get(least_frequent_category, 0)
+                cota_superior = 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(cota_inferior) if f else cota_inferior,
+                f(cota_superior) if f else cota_superior,
+            )
+
+    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: 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-1.2.22 → likelihood-1.2.23}/likelihood/tools/tools.py

@@ -1,15 +1,18 @@
 import math
 import os
 import pickle
-from typing import Callable, Dict, List, Tuple
+import warnings
+from typing import Callable, Dict, List, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import yaml
-from numpy import ndarray
 from pandas.core.frame import DataFrame
 
+# Suppress RankWarning
+warnings.simplefilter("ignore", np.RankWarning)
+
 # -------------------------------------------------------------------------
 
 """
@@ -68,7 +71,7 @@ def difference_quotient(f: Callable, x: float, h: float) -> Callable:
     return (f(x + h) - f(x)) / h
 
 
-def partial_difference_quotient(f: Callable, v: ndarray, i: int, h: float) -> ndarray:
+def partial_difference_quotient(f: Callable, v: np.ndarray, i: int, h: float) -> np.ndarray:
     """Calculates the partial difference quotient of `f`
 
     Parameters
@@ -93,7 +96,7 @@ def partial_difference_quotient(f: Callable, v: ndarray, i: int, h: float) -> nd
     return (f(w) - f(v)) / h
 
 
-def estimate_gradient(f: Callable, v: ndarray, h: float = 1e-4) -> List[ndarray]:
+def estimate_gradient(f: Callable, v: np.ndarray, h: float = 1e-4) -> List[np.ndarray]:
     """Calculates the gradient of `f` at `v`
 
     Parameters
@@ -138,35 +141,32 @@ def generate_feature_yaml(
         A dictionary with four keys ('ordinal_features', 'numeric_features', 'categorical_features', 'ignore_features')
         mapping to lists of feature names. Or a YAML formatted string if `yaml_string` is `True`.
     """
+    ignore_features = ignore_features or []
     feature_info = {
         "ordinal_features": [],
         "numeric_features": [],
         "categorical_features": [],
-        "ignore_features": [],
+        "ignore_features": ignore_features,
     }
 
     for col in df.columns:
-        if ignore_features and col in ignore_features:
+        if col in ignore_features:
             continue
 
         if pd.api.types.is_numeric_dtype(df[col]):
-            feature_info["numeric_features"].append(col)
+            if pd.api.types.is_integer_dtype(df[col]) or pd.api.types.is_float_dtype(df[col]):
+                feature_info["numeric_features"].append(col)
+            elif pd.api.types.is_bool_dtype(df[col]):
+                feature_info["ordinal_features"].append(col)  # Assuming bool can be ordinal
         elif pd.api.types.is_object_dtype(df[col]) or pd.api.types.is_categorical_dtype(df[col]):
             feature_info["categorical_features"].append(col)
-        elif pd.api.types.is_integer_dtype(df[col]):
-            feature_info["ordinal_features"].append(col)
-        elif pd.api.types.is_float_dtype(df[col]):
-            feature_info["ordinal_features"].append(col)
-        elif pd.api.types.is_bool_dtype(df[col]):
-            feature_info["ordinal_features"].append(col)
         else:
             print(f"Unknown type for feature {col}")
-        feature_info["ignore_features"] = ignore_features
 
     if yaml_string:
         return yaml.dump(feature_info, default_flow_style=False)
-    else:
-        return feature_info
+
+    return feature_info
 
 
 # a function that calculates the percentage of missing values per column is defined
@@ -192,61 +192,9 @@ def cal_missing_values(df: DataFrame) -> None:
         )
 
 
-def calculate_probability(x: ndarray, points: int = 1, cond: bool = True) -> ndarray:
-    """Calculates the probability of the data.
-
-    Parameters
-    ----------
-    x : `np.array`
-        An array containing the data.
-    points : `int`
-        An integer value. By default it is set to `1`.
-    cond : `bool`
-        A boolean value. By default it is set to `True`.
-
-    Returns
-    -------
-    p : `np.array`
-        An array containing the probability of the data.
-
-    """
-
-    p = []
-
-    f = cdf(x)[0]
-    for i in range(len(x)):
-        p.append(f(x[i]))
-    p = np.array(p)
-    if cond:
-        if np.prod(p[-points]) > 1:
-            print("\nThe probability of the data cannot be calculated.\n")
-        else:
-            if np.prod(p[-points]) < 0:
-                print("\nThe probability of the data cannot be calculated.\n")
-            else:
-                print(
-                    "The model has a probability of {:.2f}% of being correct".format(
-                        np.prod(p[-points]) * 100
-                    )
-                )
-    else:
-        if np.sum(p[-points]) < 0:
-            print("\nThe probability of the data cannot be calculated.\n")
-        else:
-            if np.sum(p[-points]) > 1:
-                print("\nThe probability of the data cannot be calculated.\n")
-            else:
-                print(
-                    "The model has a probability of {:.2f}% of being correct".format(
-                        np.sum(p[-points]) * 100
-                    )
-                )
-    return p
-
-
 def cdf(
-    x: ndarray, poly: int = 9, inv: bool = False, plot: bool = False, savename: str = None
-) -> ndarray:
+    x: np.ndarray, poly: int = 9, inv: bool = False, plot: bool = False, savename: str = None
+) -> tuple:
     """Calculates the cumulative distribution function of the data.
 
     Parameters
@@ -254,165 +202,229 @@ def cdf(
     x : `np.array`
         An array containing the data.
     poly : `int`
-        An integer value. By default it is set to `9`.
+        Degree of the polynomial fit. By default it is set to `9`.
     inv : `bool`
-        A boolean value. By default it is set to `False`.
+        If True, calculate the inverse CDF (quantile function).
+    plot : `bool`
+        If True, plot the results.
+    savename : `str`, optional
+        Filename to save the plot.
 
     Returns
     -------
-    cdf_ : `np.array`
-        An array containing the cumulative distribution function.
-
+    fit : `np.poly1d`
+        Polynomial fit of the CDF or quantile function.
+    cdf_values : `np.array`
+        Cumulative distribution values.
+    sorted_x : `np.array`
+        Sorted input data.
     """
 
-    cdf_ = np.cumsum(x) / np.sum(x)
+    if len(x) == 0:
+        raise ValueError("Input array 'x' must not be empty.")
+
+    cdf_values = np.cumsum(x) / np.sum(x)
+    sorted_x = np.sort(x)
 
-    ox = np.sort(x)
-    I = np.ones(len(ox))
-    M = np.triu(I)
-    df = np.dot(ox, M)
-    df_ = df / np.max(df)
+    # Calculate the CDF or inverse CDF (quantile function)
+    probabilities = np.linspace(0, 1, len(sorted_x))
 
     if inv:
-        fit = np.polyfit(df_, ox, poly)
+        fit = np.polyfit(probabilities, sorted_x, poly)
         f = np.poly1d(fit)
+        plot_label = "Quantile Function"
+        x_values = probabilities
+        y_values = sorted_x
     else:
-        fit = np.polyfit(ox, df_, poly)
+        fit = np.polyfit(sorted_x, probabilities, poly)
         f = np.poly1d(fit)
+        plot_label = "Cumulative Distribution Function"
+        x_values = sorted_x
+        y_values = cdf_values
 
     if plot:
-        if inv:
-            plt.plot(df_, ox, "o", label="inv cdf")
-            plt.plot(df_, f(df_), "r--", label="fit")
-            plt.title("Quantile Function")
-            plt.xlabel("Probability")
-            plt.ylabel("Value")
-            plt.legend()
-            if savename != None:
-                plt.savefig(savename, dpi=300)
-            plt.show()
-        else:
-            plt.plot(ox, cdf_, "o", label="cdf")
-            plt.plot(ox, f(ox), "r--", label="fit")
-            plt.title("Cumulative Distribution Function")
-            plt.xlabel("Value")
-            plt.ylabel("Probability")
-            plt.legend()
-            if savename != None:
-                plt.savefig(savename, dpi=300)
-            plt.show()
+        plt.figure()
+        plt.plot(x_values, y_values, "o", label="data")
+        plt.plot(x_values, f(x_values), "r--", label="fit")
+        plt.title(plot_label)
+        plt.xlabel("Probability" if inv else "Value")
+        plt.ylabel("Value" if inv else "Probability")
+        plt.legend()
+        if savename:
+            plt.savefig(savename, dpi=300)
+        plt.show()
 
-    return f, cdf_, ox
+    return f, cdf_values, sorted_x
 
 
-class corr:
-    """Calculates the correlation of the data.
+def calculate_probability(x: np.ndarray, points: int = 1, cond: bool = True) -> np.ndarray:
+    """Calculates the probability of the data based on the CDF fit.
 
     Parameters
     ----------
     x : `np.array`
         An array containing the data.
-    y : `np.array`
-        An array containing the data.
+    points : `int`
+        Number of points to consider for the final probability calculation.
+    cond : `bool`
+        Condition to use product (True) or sum (False) for the final probability check.
 
     Returns
     -------
-    z : `np.array`
-        An array containing the correlation of `x` and `y`.
-
+    p : `np.array`
+        Array containing the probabilities of the data.
     """
 
+    if len(x) == 0:
+        raise ValueError("Input array 'x' must not be empty.")
+
+    fit, _, sorted_x = cdf(x)
+    p = fit(x)
+
+    # Validate probability values
+    if cond:
+        prob_value = np.prod(p[-points])
+        message = "product"
+    else:
+        prob_value = np.sum(p[-points])
+        message = "sum"
+
+    if 0 <= prob_value <= 1:
+        print(f"The model has a probability of {prob_value * 100:.2f}% based on the {message}.")
+    else:
+        print("\nThe probability of the data cannot be calculated.\n")
+
+    return p
+
+
+class CorrelationBase:
+    """Base class for correlation calculations."""
+
     __slots__ = ["x", "y", "result", "z"]
 
-    def __init__(self, x: ndarray, y: ndarray):
+    def __init__(self, x: np.ndarray, y: Union[np.ndarray, None] = None):
         self.x = x
-        self.y = y
-        self.result = np.correlate(x, y, mode="full")
+        self.y = y if y is not None else x  # Default to autocorrelation if y is not provided
+        self._compute_correlation()
         self.z = self.result[self.result.size // 2 :]
-        self.z = self.z / float(np.abs(self.z).max())
+        self.z /= np.abs(self.z).max()
+
+    def _compute_correlation(self):
+        """Compute the correlation between x and y (or x with itself for autocorrelation)."""
+        self.result = np.correlate(self.x, self.y, mode="full")
 
     def plot(self):
-        plt.plot(range(len(self.z)), self.z, label="Correlation")
+        """Plot the correlation or autocorrelation."""
+        plt.plot(range(len(self.z)), self.z, label=self._get_label())
         plt.legend()
         plt.show()
 
+    def _get_label(self) -> str:
+        return "Autocorrelation" if np.array_equal(self.x, self.y) else "Correlation"
+
     def __call__(self):
+        """Return the computed correlation or autocorrelation."""
         return self.z
 
 
-class autocorr:
-    """Calculates the autocorrelation of the data.
+class Correlation(CorrelationBase):
+    """Calculates the cross-correlation of two datasets.
 
     Parameters
     ----------
-    x : `np.array`
-        An array containing the data.
+    x : `np.ndarray`
+        An array containing the first dataset.
+    y : `np.ndarray`
+        An array containing the second dataset.
 
     Returns
     -------
-    z : `np.array`
-        An array containing the autocorrelation of the data.
+    z : `np.ndarray`
+        An array containing the correlation of `x` and `y`.
 
     """
 
-    __slots__ = ["x", "result", "z"]
+    def __init__(self, x: np.ndarray, y: np.ndarray):
+        super().__init__(x, y)
 
-    def __init__(self, x: ndarray):
-        self.x = x
-        self.result = np.correlate(x, x, mode="full")
-        self.z = self.result[self.result.size // 2 :]
-        self.z = self.z / float(np.abs(self.z).max())
 
-    def plot(self):
-        plt.plot(range(len(self.z)), self.z, label="Autocorrelation")
-        plt.legend()
-        plt.show()
+class AutoCorrelation(CorrelationBase):
+    """Calculates the autocorrelation of a dataset.
 
-    def __call__(self):
-        return self.z
+    Parameters
+    ----------
+    x : `np.ndarray`
+        An array containing the data.
 
+    Returns
+    -------
+    z : `np.ndarray`
+        An array containing the autocorrelation of the data.
+    """
+
+    def __init__(self, x: np.ndarray):
+        super().__init__(x)
 
-def fft_denoise(dataset: ndarray, sigma: float = 0, mode: bool = True) -> Tuple[ndarray, float]:
-    """Performs the noise removal using the Fast Fourier Transform.
+
+def fft_denoise(
+    dataset: np.ndarray, sigma: float = 0, mode: bool = True
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Performs noise removal using the Fast Fourier Transform.
 
     Parameters
     ----------
-    dataset : `np.array`
-        An array containing the noised data.
-    sigma : `float`
-        A `float` between `0` and `1`. By default it is set to `0`.
-    mode : `bool`
-        A boolean value. By default it is set to `True`.
+    dataset : `np.ndarray`
+        An array containing the noised data. Expected shape (num_samples, num_points).
+    sigma : `float`, default=0
+        A float between 0 and 1 representing the threshold for noise filtering.
+    mode : `bool`, default=True
+        If True, print progress messages.
 
     Returns
     -------
-    dataset : `np.array`
-        An array containing the denoised data.
-    period : `float`
-        period of the function described by the dataset
-
+    denoised_dataset : `np.ndarray`
+        An array containing the denoised data with the same shape as `dataset`.
+    periods : `np.ndarray`
+        Array of estimated periods for each sample in `dataset`.
     """
-    dataset_ = dataset.copy()
-    for i in range(dataset.shape[0]):
-        n = dataset.shape[1]
-        fhat = np.fft.fft(dataset[i, :], n)
-        freq = (1 / n) * np.arange(n)
-        L = np.arange(1, np.floor(n / 2), dtype="int")
-        PSD = fhat * np.conj(fhat) / n
-        indices = PSD > np.mean(PSD) + sigma * np.std(PSD)
-        PSDclean = PSD * indices  # Zero out all others
-        fhat = indices * fhat
-        ffilt = np.fft.ifft(fhat)  # Inverse FFT for filtered time signal
-        dataset_[i, :] = ffilt.real
+
+    if not (0 <= sigma <= 1):
+        raise ValueError("sigma must be between 0 and 1")
+
+    num_samples, n_points = dataset.shape
+    denoised_dataset = np.zeros_like(dataset)
+    periods = np.zeros(num_samples)
+
+    # Precompute values that do not change within the loop
+    freq = (1 / n_points) * np.arange(n_points)
+    L = np.arange(1, np.floor(n_points / 2), dtype=int)
+
+    for i in range(num_samples):
+        fhat = np.fft.fft(dataset[i, :], n_points)
+        PSD = fhat * np.conj(fhat) / n_points
+        threshold = np.mean(PSD) + sigma * np.std(PSD)
+        indices = PSD > threshold
+
+        # Zero out all others in frequency domain
+        PSDclean = PSD * indices
+        fhat_cleaned = fhat * indices
+
+        # Inverse FFT for filtered time signal
+        denoised_signal = np.fft.ifft(fhat_cleaned).real
+        denoised_dataset[i, :] = denoised_signal
+
         # Calculate the period of the signal
-        period = 1 / (2 * freq[L][np.argmax(fhat[L])])
+        peak_index = L[np.argmax(np.abs(fhat[L]))]
+        periods[i] = 1 / (2 * freq[peak_index])
+
         if mode:
             print(f"The {i+1}-th row of the dataset has been denoised.")
-            print(f"The period is {round(period, 4)}")
-    return dataset_, period
+            print(f"The estimated period is {round(periods[i], 4)}")
+
+    return denoised_dataset, periods
 
 
-def get_period(dataset: ndarray) -> float:
+def get_period(dataset: np.ndarray) -> float:
     """Calculates the periodicity of a `dataset`.
 
     Parameters
@@ -426,13 +438,31 @@ def get_period(dataset: ndarray) -> float:
         period of the function described by the `dataset`
     """
     n = dataset.size
-    fhat = np.fft.fft(dataset, n)
-    freq = (1 / n) * np.arange(n)
-    L = np.arange(1, np.floor(n / 2), dtype="int")
-    PSD = fhat * np.conj(fhat) / n
-    indices = PSD > np.mean(PSD) + np.std(PSD)
-    fhat = indices * fhat
-    period = 1 / (2 * freq[L][np.argmax(fhat[L])])
+
+    # Ensure there are enough points for FFT analysis
+    if n < 2:
+        raise ValueError("Dataset must contain at least two points.")
+
+    # Compute the FFT and PSD
+    fhat = np.fft.rfft(dataset)  # Use rfft for real-valued input to save computation
+    freqs = np.fft.rfftfreq(n)  # Get only positive frequencies
+
+    # Calculate the Power Spectral Density (PSD)
+    PSD = np.abs(fhat) ** 2 / n
+
+    # Remove the first frequency component (DC component)
+    PSD[0] = 0
+
+    # Find the index of the maximum PSD value, excluding the DC component
+    max_psd_index = np.argmax(PSD)
+
+    # Calculate the period based on the corresponding frequency
+    dominant_freq = freqs[max_psd_index]
+    if dominant_freq == 0:
+        raise ValueError("No significant periodic component found in the dataset.")
+
+    period = 1 / dominant_freq
+
     return period
 
 
@@ -468,7 +498,7 @@ class LogisticRegression:
 
         self.importance = []
 
-    def fit(self, dataset: ndarray, values: ndarray) -> None:
+    def fit(self, dataset: np.ndarray, values: np.ndarray) -> None:
         """Performs linear multiple model training
 
         Parameters
@@ -501,7 +531,7 @@ class LogisticRegression:
                 a = np.around(self.w[i], decimals=8)
                 self.importance.append(a)
 
-    def predict(self, datapoints: ndarray) -> ndarray:
+    def predict(self, datapoints: np.ndarray) -> np.ndarray:
         """
         Performs predictions for a set of points
 
@@ -515,7 +545,7 @@ class LogisticRegression:
 
         return sig(np.array(self.importance) @ datapoints)
 
-    def get_importances(self, print_important_features: bool = False) -> ndarray:
+    def get_importances(self, print_important_features: bool = False) -> np.ndarray:
         """
         Returns the important features
 
@@ -547,7 +577,7 @@ class LinearRegression:
 
         self.importance = []
 
-    def fit(self, dataset: ndarray, values: ndarray, verbose: bool = False) -> None:
+    def fit(self, dataset: np.ndarray, values: np.ndarray, verbose: bool = False) -> None:
         """Performs linear multiple model training
 
         Parameters
@@ -580,7 +610,7 @@ class LinearRegression:
             print("\nParameters:", np.array(self.importance).shape)
             print("RMSE: {:.4f}".format(mean_square_error(self.y, self.predict(self.X))))
 
-    def predict(self, datapoints: ndarray) -> ndarray:
+    def predict(self, datapoints: np.ndarray) -> np.ndarray:
         """
         Performs predictions for a set of points
 
@@ -592,7 +622,7 @@ class LinearRegression:
         """
         return np.array(self.importance) @ datapoints
 
-    def get_importances(self, print_important_features: bool = False) -> ndarray:
+    def get_importances(self, print_important_features: bool = False) -> np.ndarray:
         """
         Returns the important features
 
@@ -614,7 +644,7 @@ class LinearRegression:
         return np.array(self.importance)
 
 
-def cal_average(y: ndarray, alpha: float = 1):
+def cal_average(y: np.ndarray, alpha: float = 1):
     """Calculates the moving average of the data
 
     Parameters
@@ -642,12 +672,12 @@ class DataScaler:
 
     __slots__ = ["dataset_", "_n", "data_scaled", "values", "transpose", "inv_fitting"]
 
-    def __init__(self, dataset: ndarray, n: int = 1) -> None:
+    def __init__(self, dataset: np.ndarray, n: int = 1) -> None:
         """Initializes the parameters required for scaling the data"""
         self.dataset_ = dataset.copy()
         self._n = n
 
-    def rescale(self, dataset_: ndarray | None = None) -> ndarray:
+    def rescale(self, dataset_: np.ndarray | None = None) -> np.ndarray:
         """Perform a standard rescaling of the data
 
         Returns
@@ -655,7 +685,7 @@ class DataScaler:
         data_scaled : `np.array`
             An array containing the scaled data.
         """
-        if isinstance(dataset_, ndarray):
+        if isinstance(dataset_, np.ndarray):
             data_scaled = np.copy(dataset_)
             mu = self.values[0]
             sigma = self.values[1]
@@ -711,7 +741,7 @@ class DataScaler:
 
         return self.data_scaled
 
-    def scale(self, dataset_: ndarray) -> ndarray:
+    def scale(self, dataset_: np.ndarray) -> np.ndarray:
         """Performs the inverse operation to the rescale function
 
         Parameters
@@ -755,7 +785,7 @@ def generate_series(n: int, n_steps: int, incline: bool = True):
     return series.astype(np.float32)
 
 
-def mean_square_error(y_true: ndarray, y_pred: ndarray, print_error: bool = False):
+def mean_square_error(y_true: np.ndarray, y_pred: np.ndarray, print_error: bool = False):
     """Calculates the Root Mean Squared Error
 
     Parameters
@@ -946,88 +976,65 @@ class PerformanceMeasures:
         pass
 
     # Performance measure Res_T
-    def f_mean(self, y_true: ndarray, y_pred: ndarray, labels: list) -> None:
-        n = len(labels)
+    def f_mean(self, y_true: np.ndarray, y_pred: np.ndarray, labels: List[int]) -> float:
+        F_vec = self._f1_score(y_true, y_pred, labels)
+        mean_f_measure = np.mean(F_vec)
 
-        F_vec = self._f1_score(y_true, y_pred, labels=labels)
-        a = np.sum(F_vec)
+        for label, f_measure in zip(labels, F_vec):
+            print(f"F-measure of label {label} -> {f_measure}")
 
-        for i in range(len(F_vec)):
-            print("F-measure of label ", labels[i], " -> ", F_vec[i])
+        print(f"Mean of F-measure -> {mean_f_measure}")
 
-        print("Mean of F-measure -> ", a / n)
+        return mean_f_measure
 
     # Performance measure Res_P
-    def resp(self, y_true: ndarray, y_pred: ndarray, labels: list) -> None:
-        # We initialize sum counters
-        sum1 = 0
-        sum2 = 0
-
-        # Calculamos T_C
+    def resp(self, y_true: np.ndarray, y_pred: np.ndarray, labels: List[int]) -> float:
         T_C = len(y_true)
-        for i in range(len(labels)):
-            # We calculate instances of the classes and their F-measures
-            sum1 += (1 - ((y_true == labels[i]).sum() / T_C)) * self._fi_measure(
-                y_true, y_pred, labels, i
-            )
-            sum2 += 1 - ((y_true == labels[i]).sum()) / T_C
+        sum1, sum2 = 0.0, 0.0
+        F_vec = self._f1_score(y_true, y_pred, labels)
 
-        # Print the metric corresponding to the prediction vector
-        print("Metric Res_p ->", sum1 / sum2)
+        for label_idx, label in enumerate(labels):
+            class_instances = np.sum(y_true == label) / T_C
+            sum1 += (1 - class_instances) * F_vec[label_idx]
+            sum2 += 1 - class_instances
 
-    def _fi_measure(self, y_true: ndarray, y_pred: ndarray, labels: list, i: int) -> int:
-        F_vec = self._f1_score(y_true, y_pred, labels=labels)
+        res_p = sum1 / sum2 if sum2 != 0 else 0.0  # Avoid division by zero
+        print(f"Metric Res_p -> {res_p}")
 
-        return F_vec[i]  # We return the position of the f1-score corresponding to the label
+        return res_p
 
-    # Summary of the labels predicted
-    def _summary_pred(self, y_true: ndarray, y_pred: ndarray, labels: list) -> None:
-        count_mat = self._confu_mat(y_true, y_pred, labels)
-        print("        ", end="")
-        for i in range(len(labels)):
-            print("|--", labels[i], "--", end="")
-            if i + 1 == len(labels):
-                print("|", end="")
-        for i in range(len(labels)):
-            print("")
-            print("|--", labels[i], "--|", end="")
-            for j in range(len(labels)):
-                if j != 0:
-                    print(" ", end="")
-                print("  ", int(count_mat[i, j]), "  ", end="")
-
-    def _f1_score(self, y_true: ndarray, y_pred: ndarray, labels: list) -> ndarray:
-        f1_vec = np.zeros(len(labels))
-
-        # Calculate confusion mat
+    def _summary_pred(self, y_true: np.ndarray, y_pred: np.ndarray, labels: List[int]) -> None:
         count_mat = self._confu_mat(y_true, y_pred, labels)
+        print("       ", " | ".join(f"--{label}--" for label in labels))
+        for i, label_i in enumerate(labels):
+            row = [f"  {int(count_mat[i, j])}  " for j in range(len(labels))]
+            print(f"--{label_i}--|", " | ".join(row))
 
-        # sums over columns
-        sum1 = np.sum(count_mat, axis=0)
-        # sums over rows
-        sum2 = np.sum(count_mat, axis=1)
-        # Iterate over labels to calculate f1 scores of each one
-        for i in range(len(labels)):
-            precision = count_mat[i, i] / (sum1[i])
-            recall = count_mat[i, i] / (sum2[i])
+    def _f1_score(self, y_true: np.ndarray, y_pred: np.ndarray, labels: List[int]) -> np.ndarray:
+        count_mat = self._confu_mat(y_true, y_pred, labels)
+        sum_cols = np.sum(count_mat, axis=0)
+        sum_rows = np.sum(count_mat, axis=1)
 
-            f1_vec[i] = 2 * ((precision * recall) / (precision + recall))
+        # Avoid division by zero
+        precision = np.divide(
+            count_mat.diagonal(), sum_cols, out=np.zeros_like(sum_cols), where=sum_cols != 0
+        )
+        recall = np.divide(
+            count_mat.diagonal(), sum_rows, out=np.zeros_like(sum_rows), where=sum_rows != 0
+        )
+        f1_vec = 2 * ((precision * recall) / (precision + recall))
 
         return f1_vec
 
     # Returns confusion matrix of predictions
-    def _confu_mat(self, y_true: ndarray, y_pred: ndarray, labels: list) -> ndarray:
-        labels = np.array(labels)
-        count_mat = np.zeros((len(labels), len(labels)))
-
-        for i in range(len(labels)):
-            for j in range(len(y_pred)):
-                if y_pred[j] == labels[i]:
-                    if y_pred[j] == y_true[j]:
-                        count_mat[i, i] += 1
-                    else:
-                        x = np.where(labels == y_true[j])
-                        count_mat[i, x[0]] += 1
+    def _confu_mat(self, y_true: np.ndarray, y_pred: np.ndarray, labels: List[int]) -> np.ndarray:
+        num_classes = len(labels)
+        label_mapping = {label: idx for idx, label in enumerate(labels)}
+        count_mat = np.zeros((num_classes, num_classes))
+
+        for pred_label, true_label in zip(y_pred, y_true):
+            if pred_label in label_mapping and true_label in label_mapping:
+                count_mat[label_mapping[pred_label], label_mapping[true_label]] += 1
 
         return count_mat
 
@@ -1043,10 +1050,10 @@ class OneHotEncoder:
     def __init__(self) -> None:
         pass
 
-    def encode(self, x: ndarray | list):
+    def encode(self, x: np.ndarray | list):
         self.x = x
 
-        if not isinstance(self.x, ndarray):
+        if not isinstance(self.x, np.ndarray):
             self.x = np.array(self.x)  # If not numpy array then convert it
 
         y = np.zeros(
@@ -1057,8 +1064,8 @@ class OneHotEncoder:
 
         return y
 
-    def decode(self, x: ndarray | list) -> ndarray:
-        if not isinstance(x, ndarray):
+    def decode(self, x: np.ndarray | list) -> np.ndarray:
+        if not isinstance(x, np.ndarray):
             x = np.array(x)  # If not numpy array then convert it
 
         # We return the max values of each row
@@ -1220,17 +1227,33 @@ class FeatureSelection:
 
 
 def check_nan_inf(df: DataFrame) -> DataFrame:
-    """Checks for `NaN` and `Inf` values in the `DataFrame`. If any are found they will be removed."""
+    """
+    Checks for NaN and Inf values in the DataFrame. If any are found, they will be removed.
+
+    Parameters:
+        df (DataFrame): The input DataFrame to be checked.
+
+    Returns:
+        DataFrame: A new DataFrame with NaN and Inf values removed.
+    """
+
     nan_values = df.isnull().values.any()
-    count = np.isinf(df.select_dtypes(include="number")).values.sum()
-    print("There are null values : ", nan_values)
-    print("It contains " + str(count) + " infinite values")
+    inf_values = np.isinf(df.select_dtypes(include="number")).values.any()
+
     if nan_values:
-        warning_type = "UserWarning"
-        msg = "Some rows may have been deleted due to the existence of nan values."
-        print(f"{warning_type}: {msg}")
-        print("Missing values correctly removed : ", "{:,}".format(df.isnull().values.sum()))
-        df = df.dropna()
+        print("UserWarning: Some rows may have been deleted due to the existence of NaN values.")
+        df.dropna(inplace=True)
+
+    if inf_values:
+        print("UserWarning: Some rows may have been deleted due to the existence of Inf values.")
+        df.replace([np.inf, -np.inf], np.nan, inplace=True)
+        df.dropna(inplace=True)
+
+    nan_count = df.isnull().values.sum()
+    inf_count = np.isinf(df.select_dtypes(include="number")).values.sum()
+
+    print(f"NaN values removed: {nan_count}")
+    print(f"Infinite values removed: {inf_count}")
 
     return df
 
@@ -1244,6 +1267,7 @@ if __name__ == "__main__":
     helper = PerformanceMeasures()
     helper._summary_pred(y_true, y_pred, labels)
     print(helper._f1_score(y_true, y_pred, labels))
+    print(helper.f_mean(y_true, y_pred, labels))
 
     # Use DataFrameEncoder
     # Create a DataFrame
@@ -1273,6 +1297,13 @@ if __name__ == "__main__":
     # Generate data
     x = np.random.rand(3, 100)
     y = 0.1 * x[0, :] + 0.4 * x[1, :] + 0.5 * x[2, :] + 0.1
+    # Create a DataFrame
+    df = pd.DataFrame(x.T, columns=["x1", "x2", "x3"])
+    df["y"] = y
+    # Instantiate FeatureSelection
+    fs = FeatureSelection()
+    print(fs.get_digraph(df, n_importances=1))
+
     linear_model = LinearRegression()
     linear_model.fit(x, y)
     importance = linear_model.get_importances()
@@ -1303,7 +1334,7 @@ if __name__ == "__main__":
     plt.show()
 
     # Calculate the autocorrelation of the data
-    z = autocorr(a[0, :])
+    z = AutoCorrelation(a[0, :])
     z.plot()
     # print(z())
 
@@ -1313,3 +1344,18 @@ if __name__ == "__main__":
     x = np.random.normal(mu, sigma, N)
     f, cdf_, ox = cdf(x, plot=True)
     invf, cdf_, ox = cdf(x, plot=True, inv=True)
+
+    encoder = OneHotEncoder()
+    encoding = encoder.encode([1, 2, 3, 4, 5])
+    assert np.array_equal(
+        encoding,
+        np.array(
+            [
+                [0, 1, 0, 0, 0, 0],
+                [0, 0, 1, 0, 0, 0],
+                [0, 0, 0, 1, 0, 0],
+                [0, 0, 0, 0, 1, 0],
+                [0, 0, 0, 0, 0, 1],
+            ]
+        ),
+    )

{likelihood-1.2.22 → likelihood-1.2.23}/likelihood.egg-info/PKG-INFO

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

likelihood-1.2.22/likelihood/models/simulation.py

@@ -1,103 +0,0 @@
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-from numpy import ndarray
-from pandas.core.frame import DataFrame
-
-from likelihood.tools import DataScaler, FeatureSelection, OneHotEncoder, check_nan_inf
-
-# --------------------------------------------------------------------------------------------------------------------------------------
-
-
-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, df: DataFrame, n_importances: int, use_scaler: bool = False, **kwargs):
-
-        self.df = df
-        self.n_importances = n_importances
-        self.use_scaler = use_scaler
-
-        super().__init__(**kwargs)
-
-    def predict(self, df: DataFrame, column: str) -> ndarray | list:
-        # Let us assign the dictionary entries corresponding to the column
-        w, quick_encoder, names_cols, dfe, numeric_dict = self.w_dict[column]
-
-        df = df[names_cols].copy()
-        # Change the scale of the dataframe
-        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
-
-        # Encoding the datadrame
-        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
-                )
-
-        # PREDICTION
-        y = df.to_numpy() @ w
-
-        # Categorical column
-        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]
-        # Numeric column
-        else:
-            if self.use_scaler:
-                # scale output
-                y += 1
-                y /= 2
-                y = y * (self.df[column].max() - self.df[column].min())
-
-        return y[:]
-
-    def fit(self, **kwargs) -> None:
-
-        # We run the feature selection algorithm
-        self.get_digraph(self.df, self.n_importances, self.use_scaler)
-
-    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