likelihood 1.2.22__py3-none-any.whl → 1.2.24__py3-none-any.whl

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/graph/nn.py

@@ -1,6 +1,8 @@
 import os
 
 os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
+# Suppress TensorFlow INFO logs
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
 import logging
 import warnings
 from typing import List, Tuple
@@ -9,7 +11,6 @@ import numpy as np
 import pandas as pd
 import tensorflow as tf
 from IPython.display import clear_output
-from numpy import ndarray
 from pandas.core.frame import DataFrame
 from sklearn.metrics import f1_score
 from sklearn.model_selection import train_test_split
@@ -21,7 +22,7 @@ logging.getLogger("tensorflow").setLevel(logging.ERROR)
 tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
 
 
-def compare_similarity(arr1: ndarray, arr2: ndarray) -> int:
+def compare_similarity(arr1: np.ndarray, arr2: np.ndarray) -> int:
     """Compares the similarity between two arrays of categories.
 
     Parameters
@@ -44,9 +45,9 @@ def compare_similarity(arr1: ndarray, arr2: ndarray) -> int:
     return count
 
 
-def cal_adjency_matrix(
+def cal_adjacency_matrix(
     df: DataFrame, exclude_subset: List[str] = [], sparse: bool = True, **kwargs
-) -> Tuple[dict, ndarray]:
+) -> Tuple[dict, np.ndarray]:
     """Calculates the adjacency matrix for a given DataFrame.
     The adjacency matrix is a matrix that represents the similarity between each pair of categories.
     The similarity is calculated using the `compare_similarity` function.
@@ -133,7 +134,7 @@ class Data:
         target: str | None = None,
         exclude_subset: List[str] = [],
     ):
-        _, adjacency = cal_adjency_matrix(df, exclude_subset=exclude_subset, sparse=True)
+        _, adjacency = cal_adjacency_matrix(df, exclude_subset=exclude_subset, sparse=True)
         if target is not None:
             X = df.drop(columns=[target] + exclude_subset)
         else:

likelihood/models/hmm.py

@@ -0,0 +1,163 @@
+import logging
+import os
+import pickle
+from typing import List, Tuple
+
+import numpy as np
+from IPython.display import clear_output
+
+
+class HMM:
+    def __init__(self, n_states: int, n_observations: int):
+        self.n_states = n_states
+        self.n_observations = n_observations
+
+        # Initialize parameters with random values
+        self.pi = np.random.dirichlet(np.ones(n_states), size=1)[0]
+        self.A = np.random.dirichlet(np.ones(n_states), size=n_states)
+        self.B = np.random.dirichlet(np.ones(n_observations), size=n_states)
+
+    def save_model(self, filename: str = "./hmm") -> None:
+        filename = filename if filename.endswith(".pkl") else filename + ".pkl"
+        with open(filename, "wb") as f:
+            pickle.dump(self, f)
+
+    @staticmethod
+    def load_model(filename: str = "./hmm") -> "HMM":
+        filename = filename + ".pkl" if not filename.endswith(".pkl") else filename
+        with open(filename, "rb") as f:
+            return pickle.load(f)
+
+    def forward(self, sequence: List[int]) -> np.ndarray:
+        T = len(sequence)
+        alpha = np.zeros((T, self.n_states))
+
+        # Add a small constant (smoothing) to avoid log(0)
+        epsilon = 1e-10  # Small value to avoid taking log(0)
+
+        # Initialization (log-space)
+        alpha[0] = np.log(self.pi + epsilon) + np.log(self.B[:, sequence[0]] + epsilon)
+        alpha[0] -= np.log(np.sum(np.exp(alpha[0])))  # Normalization (log-space)
+
+        # Recursion (log-space)
+        for t in range(1, T):
+            for i in range(self.n_states):
+                alpha[t, i] = np.log(
+                    np.sum(np.exp(alpha[t - 1] + np.log(self.A[:, i] + epsilon)))
+                ) + np.log(self.B[i, sequence[t]] + epsilon)
+            alpha[t] -= np.log(np.sum(np.exp(alpha[t])))  # Normalization
+
+        return alpha
+
+    def backward(self, sequence: List[int]) -> np.ndarray:
+        T = len(sequence)
+        beta = np.ones((T, self.n_states))
+
+        # Backward recursion
+        for t in range(T - 2, -1, -1):
+            for i in range(self.n_states):
+                beta[t, i] = np.sum(self.A[i] * self.B[:, sequence[t + 1]] * beta[t + 1])
+
+        return beta
+
+    def viterbi(self, sequence: List[int]) -> np.ndarray:
+        T = len(sequence)
+        delta = np.zeros((T, self.n_states))
+        psi = np.zeros((T, self.n_states), dtype=int)
+
+        # Initialization
+        delta[0] = self.pi * self.B[:, sequence[0]]
+
+        # Recursion
+        for t in range(1, T):
+            for i in range(self.n_states):
+                delta[t, i] = np.max(delta[t - 1] * self.A[:, i]) * self.B[i, sequence[t]]
+                psi[t, i] = np.argmax(delta[t - 1] * self.A[:, i])
+
+        # Reconstruct the most probable path
+        state_sequence = np.zeros(T, dtype=int)
+        state_sequence[T - 1] = np.argmax(delta[T - 1])
+        for t in range(T - 2, -1, -1):
+            state_sequence[t] = psi[t + 1, state_sequence[t + 1]]
+
+        return state_sequence
+
+    def baum_welch(
+        self, sequences: List[List[int]], n_iterations: int, verbose: bool = False
+    ) -> None:
+        for iteration in range(n_iterations):
+            # Initialize accumulators
+            A_num = np.zeros((self.n_states, self.n_states))
+            B_num = np.zeros((self.n_states, self.n_observations))
+            pi_num = np.zeros(self.n_states)
+
+            for sequence in sequences:
+                T = len(sequence)
+                alpha = self.forward(sequence)
+                beta = self.backward(sequence)
+
+                # Update pi
+                gamma = (alpha * beta) / np.sum(alpha * beta, axis=1, keepdims=True)
+                pi_num += gamma[0]
+
+                # Update A and B
+                for t in range(T - 1):
+                    xi = np.zeros((self.n_states, self.n_states))
+                    denom = np.sum(alpha[t] * self.A * self.B[:, sequence[t + 1]] * beta[t + 1])
+
+                    for i in range(self.n_states):
+                        for j in range(self.n_states):
+                            xi[i, j] = (
+                                alpha[t, i]
+                                * self.A[i, j]
+                                * self.B[j, sequence[t + 1]]
+                                * beta[t + 1, j]
+                            ) / denom
+                        A_num[i] += xi[i]
+
+                    B_num[:, sequence[t]] += gamma[t]
+
+                # For the last step of the sequence
+                B_num[:, sequence[-1]] += gamma[-1]
+
+            # Normalize and update parameters
+            self.pi = pi_num / len(sequences)
+            self.A = A_num / np.sum(A_num, axis=1, keepdims=True)
+            self.B = B_num / np.sum(B_num, axis=1, keepdims=True)
+
+            # Logging parameters every 10 iterations
+            if iteration % 10 == 0 and verbose:
+                os.system("cls" if os.name == "nt" else "clear")
+                clear_output(wait=True)
+                logging.info(f"Iteration {iteration}:")
+                logging.info("Pi: %s", self.pi)
+                logging.info("A:\n%s", self.A)
+                logging.info("B:\n%s", self.B)
+
+    def decoding_accuracy(self, sequences: List[List[int]], true_states: List[List[int]]) -> float:
+        correct_predictions = 0
+        total_predictions = 0
+
+        for sequence, true_state in zip(sequences, true_states):
+            predicted_states = self.viterbi(sequence)
+            correct_predictions += np.sum(predicted_states == true_state)
+            total_predictions += len(sequence)
+
+        accuracy = (correct_predictions / total_predictions) * 100
+        return accuracy
+
+    def state_probabilities(self, sequence: List[int]) -> np.ndarray:
+        """
+        Returns the smoothed probabilities of the hidden states at each time step.
+        This is done by using both forward and backward probabilities.
+        """
+        alpha = self.forward(sequence)
+        beta = self.backward(sequence)
+
+        # Compute smoothed probabilities (gamma)
+        smoothed_probs = (alpha * beta) / np.sum(alpha * beta, axis=1, keepdims=True)
+
+        return smoothed_probs
+
+    def sequence_probability(self, sequence: List[int]) -> np.ndarray:
+        return self.state_probabilities(sequence)[-1]

likelihood/models/simulation.py

@@ -1,12 +1,36 @@
+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, check_nan_inf
+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):
@@ -32,20 +56,21 @@ class SimulationEngine(FeatureSelection):
     for both numerical and categorical outcomes efficiently.
     """
 
-    def __init__(self, df: DataFrame, n_importances: int, use_scaler: bool = False, **kwargs):
+    def __init__(self, use_scaler: bool = False, **kwargs):
 
-        self.df = df
-        self.n_importances = n_importances
+        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:
+    def predict(self, df: DataFrame, column: str) -> np.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
+        # Change the scale of the DataFrame
         dataset = self.df.copy()
         dataset.drop(columns=column, inplace=True)
         numeric_df = dataset.select_dtypes(include="number")
@@ -59,7 +84,7 @@ class SimulationEngine(FeatureSelection):
             for col in numeric_df.columns:
                 df[col] = numeric_df[col].values
 
-        # Encoding the datadrame
+        # Encoding the DataFrame
         for num, colname in enumerate(dfe._encode_columns):
             if df[colname].dtype == "object":
                 encode_dict = dfe.encoding_list[num]
@@ -67,7 +92,7 @@ class SimulationEngine(FeatureSelection):
                     dfe._code_transformation_to, dictionary_list=encode_dict
                 )
 
-        # PREDICTION
+        # Prediction
         y = df.to_numpy() @ w
 
         # Categorical column
@@ -87,10 +112,78 @@ class SimulationEngine(FeatureSelection):
 
         return y[:]
 
-    def fit(self, **kwargs) -> None:
-
+    def _encode(self, df: DataFrame) -> np.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:
 
@@ -101,3 +194,29 @@ class SimulationEngine(FeatureSelection):
         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/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.dist-info → likelihood-1.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: likelihood
-Version: 1.2.22
+Version: 1.2.24
 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.dist-info → likelihood-1.2.24.dist-info}/RECORD

@@ -1,19 +1,20 @@
 likelihood/__init__.py,sha256=5C0hapdsk85XZhN_rssRAEFpkRRuKNtj6cyRbqD2_gM,994
 likelihood/main.py,sha256=fcCkGOOWKjfvw2tLVqjuKPV8t0rVCIT9FlbYcOv4EYo,7974
 likelihood/graph/__init__.py,sha256=6TuFDfmXTwpLyHl7_KqBfdzW6zqHjGzIFvymjFPlvjI,21
-likelihood/graph/graph.py,sha256=wKJqgxXiSbnvzyW3SjhQVrqp00yKMHf3ph6CIDNVhNM,2891
-likelihood/graph/nn.py,sha256=jBgb2SMUwM5OBatkIxH2I-_hH1ok5aw2fwXq5a1VAEg,12306
+likelihood/graph/graph.py,sha256=hGWCznxaRQ8BfY2aLjrvwriZkAIsz5ydKXF4x_7b0EQ,3359
+likelihood/graph/nn.py,sha256=3HihXchK4FQcp0j-pzTO36RSNg7EjzhuXYY_8M3C2G0,12366
 likelihood/models/__init__.py,sha256=e6nB4w47w0Q9DrAFeP3OcUgcoHOtf7Il4mBhgf4AARg,52
+likelihood/models/hmm.py,sha256=0s0gFySH1u4NjRaZDxiZ8oeTaFhFrw1x0GJxwy3dFrA,6253
 likelihood/models/regression.py,sha256=9cakyGlJCEO6WfpoKLh3GxdXQeQp7cUvJIkQ5odT0TA,9404
-likelihood/models/simulation.py,sha256=mdgQPg_LEY5svPaF4TFv-DoQRE2oP2ig_uXnwINtewM,4039
+likelihood/models/simulation.py,sha256=L_9Mihcca7i_AnvWWrZilFV8VEhz_Z8fDLepmwBGSi8,8832
 likelihood/models/utils.py,sha256=VtEj07lV-GRoWraQgpfjU0jTt1Ntf9MXgYwe6XYQh20,1552
 likelihood/models/deep/__init__.py,sha256=-KIPippVaMqgG8mEgYjNxYQdqOUcFhUuKhbVe8TTCfo,28
 likelihood/models/deep/autoencoders.py,sha256=2P--nS96XwMi44q0OIxvIp6Mdbt-B4LqwCSXTn2jYrY,10070
 likelihood/tools/__init__.py,sha256=MCjsCWfBNKE2uMN0VizDN1uFzZ_md0X2WZeBdWhrCR8,50
 likelihood/tools/numeric_tools.py,sha256=FA44kbiAcxcquz1el_g3Pqsp5ii8XFkAIrsMs5bGkj0,11445
-likelihood/tools/tools.py,sha256=O39aPxTNsaBVSJFIkNsUESNSkfG4C7GG77wcR51a8IQ,42543
-likelihood-1.2.22.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
-likelihood-1.2.22.dist-info/METADATA,sha256=_7sP0uqn2Qt-HCsWwVtqVML8K9Mite9BDktrT1BX_6I,2504
-likelihood-1.2.22.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-likelihood-1.2.22.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
-likelihood-1.2.22.dist-info/RECORD,,
+likelihood/tools/tools.py,sha256=iZBC7IHTFpAyxooyel7ZFi-5-G0nCotNLLtxenPw9T8,44303
+likelihood-1.2.24.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
+likelihood-1.2.24.dist-info/METADATA,sha256=Z6fUcQ3cU1oL8_o6px8uidolXPhlnivmztoZQpvlx8o,2504
+likelihood-1.2.24.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+likelihood-1.2.24.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
+likelihood-1.2.24.dist-info/RECORD,,