likelihood 1.2.25__py3-none-any.whl → 1.3.1__py3-none-any.whl

likelihood/graph/graph.py

@@ -45,8 +45,8 @@ class DynamicGraph(FeatureSelection):
 
     def draw(self, name="graph.html", **kwargs) -> None:
         """Display the network using HTML format"""
-        spring_length = kwargs["spring_length"] if "spring_length" in kwargs else 500
-        node_distance = kwargs["node_distance"] if "node_distance" in kwargs else 100
+        spring_length = kwargs.get("spring_length", 500)
+        node_distance = kwargs.get("node_distance", 100)
         self.G.repulsion(node_distance=node_distance, spring_length=spring_length)
         self.G.show_buttons(filter_=["physics"])
         self.G.show(name)
@@ -89,5 +89,5 @@ if __name__ == "__main__":
     df["y"] = y
     # Instantiate DynamicGraph
     fs = DynamicGraph(df, n_importances=2)
-    print(fs.fit())
+    fs.fit()
     fs.draw()

likelihood/graph/nn.py

@@ -96,7 +96,7 @@ def cal_adjacency_matrix(
 
     assert len(df_categorical) > 0
 
-    similarity = kwargs["similarity"] if "similarity" in kwargs else len(df_categorical.columns) - 1
+    similarity = kwargs.get("similarity", len(df_categorical.columns) - 1)
     assert similarity <= df_categorical.shape[1]
 
     adj_dict = {}

likelihood/models/deep/autoencoders.py

@@ -19,8 +19,10 @@ from functools import wraps
 
 import keras_tuner
 import tensorflow as tf
+from keras.src.engine.input_layer import InputLayer
 from pandas.core.frame import DataFrame
 from sklearn.manifold import TSNE
+from tensorflow.keras.regularizers import l2
 
 from likelihood.tools import OneHotEncoder
 
@@ -79,6 +81,10 @@ class AutoClassifier(tf.keras.Model):
             The activation function to use for the classifier layer. Default is "softmax". If the activation function is not a classification function, the model can be used in regression problems.
         num_layers : `int`
             The number of hidden layers in the classifier. Default is 1.
+        dropout : `float`
+            The dropout rate to use in the classifier. Default is None.
+        l2_reg : `float`
+            The L2 regularization parameter. Default is 0.0.
         """
         super(AutoClassifier, self).__init__()
         self.input_shape_parm = input_shape_parm
@@ -91,30 +97,69 @@ class AutoClassifier(tf.keras.Model):
         self.classifier = None
         self.classifier_activation = kwargs.get("classifier_activation", "softmax")
         self.num_layers = kwargs.get("num_layers", 1)
+        self.dropout = kwargs.get("dropout", None)
+        self.l2_reg = kwargs.get("l2_reg", 0.0)
 
     def build(self, input_shape):
-        self.encoder = tf.keras.Sequential(
-            [
-                tf.keras.layers.Dense(units=self.units, activation=self.activation),
-                tf.keras.layers.Dense(units=int(self.units / 2), activation=self.activation),
-            ]
+        # Encoder with L2 regularization
+        self.encoder = (
+            tf.keras.Sequential(
+                [
+                    tf.keras.layers.Dense(
+                        units=self.units,
+                        activation=self.activation,
+                        kernel_regularizer=l2(self.l2_reg),
+                    ),
+                    tf.keras.layers.Dense(
+                        units=int(self.units / 2),
+                        activation=self.activation,
+                        kernel_regularizer=l2(self.l2_reg),
+                    ),
+                ]
+            )
+            if not self.encoder
+            else self.encoder
         )
 
-        self.decoder = tf.keras.Sequential(
-            [
-                tf.keras.layers.Dense(units=self.units, activation=self.activation),
-                tf.keras.layers.Dense(units=self.input_shape_parm, activation=self.activation),
-            ]
+        # Decoder with L2 regularization
+        self.decoder = (
+            tf.keras.Sequential(
+                [
+                    tf.keras.layers.Dense(
+                        units=self.units,
+                        activation=self.activation,
+                        kernel_regularizer=l2(self.l2_reg),
+                    ),
+                    tf.keras.layers.Dense(
+                        units=self.input_shape_parm,
+                        activation=self.activation,
+                        kernel_regularizer=l2(self.l2_reg),
+                    ),
+                ]
+            )
+            if not self.decoder
+            else self.decoder
         )
 
+        # Classifier with L2 regularization
         self.classifier = tf.keras.Sequential()
         if self.num_layers > 1:
             for _ in range(self.num_layers - 1):
                 self.classifier.add(
-                    tf.keras.layers.Dense(units=self.units, activation=self.activation)
+                    tf.keras.layers.Dense(
+                        units=self.units,
+                        activation=self.activation,
+                        kernel_regularizer=l2(self.l2_reg),
+                    )
                 )
+                if self.dropout:
+                    self.classifier.add(tf.keras.layers.Dropout(self.dropout))
         self.classifier.add(
-            tf.keras.layers.Dense(units=self.num_classes, activation=self.classifier_activation)
+            tf.keras.layers.Dense(
+                units=self.num_classes,
+                activation=self.classifier_activation,
+                kernel_regularizer=l2(self.l2_reg),
+            )
         )
 
     def call(self, x):
@@ -124,6 +169,84 @@ class AutoClassifier(tf.keras.Model):
         classification = self.classifier(combined)
         return classification
 
+    def freeze_encoder_decoder(self):
+        """
+        Freezes the encoder and decoder layers to prevent them from being updated during training.
+        """
+        for layer in self.encoder.layers:
+            layer.trainable = False
+        for layer in self.decoder.layers:
+            layer.trainable = False
+
+    def unfreeze_encoder_decoder(self):
+        """
+        Unfreezes the encoder and decoder layers allowing them to be updated during training.
+        """
+        for layer in self.encoder.layers:
+            layer.trainable = True
+        for layer in self.decoder.layers:
+            layer.trainable = True
+
+    def set_encoder_decoder(self, source_model):
+        """
+        Sets the encoder and decoder layers from another AutoClassifier instance,
+        ensuring compatibility in dimensions.
+
+        Parameters:
+        -----------
+        source_model : AutoClassifier
+            The source model to copy the encoder and decoder layers from.
+
+        Raises:
+        -------
+        ValueError
+            If the input shape or units of the source model do not match.
+        """
+        if not isinstance(source_model, AutoClassifier):
+            raise ValueError("Source model must be an instance of AutoClassifier.")
+
+        # Check compatibility in input shape and units
+        if self.input_shape_parm != source_model.input_shape_parm:
+            raise ValueError(
+                f"Incompatible input shape. Expected {self.input_shape_parm}, got {source_model.input_shape_parm}."
+            )
+        if self.units != source_model.units:
+            raise ValueError(
+                f"Incompatible number of units. Expected {self.units}, got {source_model.units}."
+            )
+        self.encoder, self.decoder = tf.keras.Sequential(), tf.keras.Sequential()
+        # Copy the encoder layers
+        for i, layer in enumerate(source_model.encoder.layers):
+            if isinstance(layer, tf.keras.layers.Dense):  # Make sure it's a Dense layer
+                dummy_input = tf.convert_to_tensor(tf.random.normal([1, layer.input_shape[1]]))
+                dense_layer = tf.keras.layers.Dense(
+                    units=layer.units,
+                    activation=self.activation,
+                    kernel_regularizer=l2(self.l2_reg),
+                )
+                dense_layer.build(dummy_input.shape)
+                self.encoder.add(dense_layer)
+                # Set the weights correctly
+                self.encoder.layers[i].set_weights(layer.get_weights())
+            elif not isinstance(layer, InputLayer):
+                raise ValueError(f"Layer type {type(layer)} not supported for copying.")
+
+        # Copy the decoder layers
+        for i, layer in enumerate(source_model.decoder.layers):
+            if isinstance(layer, tf.keras.layers.Dense):  # Ensure it's a Dense layer
+                dummy_input = tf.convert_to_tensor(tf.random.normal([1, layer.input_shape[1]]))
+                dense_layer = tf.keras.layers.Dense(
+                    units=layer.units,
+                    activation=self.activation,
+                    kernel_regularizer=l2(self.l2_reg),
+                )
+                dense_layer.build(dummy_input.shape)
+                self.decoder.add(dense_layer)
+                # Set the weights correctly
+                self.decoder.layers[i].set_weights(layer.get_weights())
+            elif not isinstance(layer, InputLayer):
+                raise ValueError(f"Layer type {type(layer)} not supported for copying.")
+
     def get_config(self):
         config = {
             "input_shape_parm": self.input_shape_parm,
@@ -132,6 +255,8 @@ class AutoClassifier(tf.keras.Model):
             "activation": self.activation,
             "classifier_activation": self.classifier_activation,
             "num_layers": self.num_layers,
+            "dropout": self.dropout,
+            "l2_reg": self.l2_reg,
         }
         base_config = super(AutoClassifier, self).get_config()
         return dict(list(base_config.items()) + list(config.items()))
@@ -145,6 +270,8 @@ class AutoClassifier(tf.keras.Model):
             activation=config["activation"],
             classifier_activation=config["classifier_activation"],
             num_layers=config["num_layers"],
+            dropout=config["dropout"],
+            l2_reg=config["l2_reg"],
         )
 
 
@@ -156,6 +283,7 @@ def call_existing_code(
     input_shape_parm: None | int = None,
     num_classes: None | int = None,
     num_layers: int = 1,
+    **kwargs,
 ) -> AutoClassifier:
     """
     Calls an existing AutoClassifier instance.
@@ -180,12 +308,16 @@ def call_existing_code(
     `AutoClassifier`
         The AutoClassifier instance.
     """
+    dropout = kwargs.get("dropout", None)
+    l2_reg = kwargs.get("l2_reg", 0.0)
     model = AutoClassifier(
         input_shape_parm=input_shape_parm,
         num_classes=num_classes,
         units=units,
         activation=activation,
         num_layers=num_layers,
+        dropout=dropout,
+        l2_reg=l2_reg,
     )
     model.compile(
         optimizer=optimizer,
@@ -232,27 +364,65 @@ def build_model(
             step=2,
         )
         if "units" not in hyperparameters_keys
-        else hyperparameters["units"]
+        else (
+            hp.Choice("units", hyperparameters["units"])
+            if isinstance(hyperparameters["units"], list)
+            else hyperparameters["units"]
+        )
     )
     activation = (
         hp.Choice("activation", ["sigmoid", "relu", "tanh", "selu", "softplus", "softsign"])
         if "activation" not in hyperparameters_keys
-        else hyperparameters["activation"]
+        else (
+            hp.Choice("activation", hyperparameters["activation"])
+            if isinstance(hyperparameters["activation"], list)
+            else hyperparameters["activation"]
+        )
     )
     optimizer = (
         hp.Choice("optimizer", ["sgd", "adam", "adadelta", "rmsprop", "adamax", "adagrad"])
         if "optimizer" not in hyperparameters_keys
-        else hyperparameters["optimizer"]
+        else (
+            hp.Choice("optimizer", hyperparameters["optimizer"])
+            if isinstance(hyperparameters["optimizer"], list)
+            else hyperparameters["optimizer"]
+        )
     )
     threshold = (
         hp.Float("threshold", min_value=0.1, max_value=0.9, sampling="log")
         if "threshold" not in hyperparameters_keys
-        else hyperparameters["threshold"]
+        else (
+            hp.Choice("threshold", hyperparameters["threshold"])
+            if isinstance(hyperparameters["threshold"], list)
+            else hyperparameters["threshold"]
+        )
     )
     num_layers = (
         hp.Int("num_layers", min_value=1, max_value=10, step=1)
         if "num_layers" not in hyperparameters_keys
-        else hyperparameters["num_layers"]
+        else (
+            hp.Choice("num_layers", hyperparameters["num_layers"])
+            if isinstance(hyperparameters["num_layers"], list)
+            else hyperparameters["num_layers"]
+        )
+    )
+    dropout = (
+        hp.Float("dropout", min_value=0.1, max_value=0.9, sampling="log")
+        if "dropout" not in hyperparameters_keys
+        else (
+            hp.Choice("dropout", hyperparameters["dropout"])
+            if isinstance(hyperparameters["dropout"], list)
+            else hyperparameters["dropout"]
+        )
+    )
+    l2_reg = (
+        hp.Float("l2_reg", min_value=1e-6, max_value=0.1, sampling="log")
+        if "l2_reg" not in hyperparameters_keys
+        else (
+            hp.Choice("l2_reg", hyperparameters["l2_reg"])
+            if isinstance(hyperparameters["l2_reg"], list)
+            else hyperparameters["l2_reg"]
+        )
     )
 
     model = call_existing_code(
@@ -263,6 +433,8 @@ def build_model(
         input_shape_parm=input_shape_parm,
         num_classes=num_classes,
         num_layers=num_layers,
+        dropout=dropout,
+        l2_reg=l2_reg,
     )
     return model
 
@@ -408,10 +580,8 @@ class GetInsights:
         self.model = model
         self.encoder_layer = self.model.encoder.layers[0]
         self.decoder_layer = self.model.decoder.layers[0]
-        self.classifier_layer = self.model.classifier.layers[-2]
         self.encoder_weights = self.encoder_layer.get_weights()[0]
         self.decoder_weights = self.decoder_layer.get_weights()[0]
-        self.classifier_weights = self.classifier_layer.get_weights()[0]
         colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS)
 
         by_hsv = sorted(
@@ -463,11 +633,31 @@ class GetInsights:
         )
         self.data["class"] = self.classification
         self.data_input["class"] = self.classification
-        radviz(self.data, "class", color=self.colors)
+
+        self.data_normalized = self.data.copy(deep=True)
+        self.data_normalized.iloc[:, :-1] = (
+            2.0
+            * (self.data_normalized.iloc[:, :-1] - self.data_normalized.iloc[:, :-1].min())
+            / (self.data_normalized.iloc[:, :-1].max() - self.data_normalized.iloc[:, :-1].min())
+            - 1
+        )
+        radviz(self.data_normalized, "class", color=self.colors)
         plt.title("Radviz Visualization of Latent Space")
         plt.show()
-
-        radviz(self.data_input, "class", color=self.colors)
+        self.data_input_normalized = self.data_input.copy(deep=True)
+        self.data_input_normalized.iloc[:, :-1] = (
+            2.0
+            * (
+                self.data_input_normalized.iloc[:, :-1]
+                - self.data_input_normalized.iloc[:, :-1].min()
+            )
+            / (
+                self.data_input_normalized.iloc[:, :-1].max()
+                - self.data_input_normalized.iloc[:, :-1].min()
+            )
+            - 1
+        )
+        radviz(self.data_input_normalized, "class", color=self.colors)
         plt.title("Radviz Visualization of Input Data")
         plt.show()
         return self._statistics(self.data_input)
@@ -580,7 +770,12 @@ if __name__ == "__main__":
     y = np.asarray(y).astype(np.float32)
 
     model = AutoClassifier(
-        input_shape_parm=X.shape[1], num_classes=3, units=27, activation="selu", num_layers=2
+        input_shape_parm=X.shape[1],
+        num_classes=3,
+        units=27,
+        activation="tanh",
+        num_layers=2,
+        dropout=0.2,
     )
     model.compile(
         optimizer="adam",

likelihood/models/simulation.py

@@ -2,31 +2,25 @@ import pickle
 import warnings
 from typing import List, Tuple, Union
 
-import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 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
 

likelihood/models/utils.py

@@ -1,12 +1,10 @@
-import matplotlib.pyplot as plt
 import numpy as np
-from numpy import ndarray
 
 from likelihood.tools import cal_average
 
 
 class FeaturesArima:
-    def forward(self, y_sum: ndarray, theta: list, mode: bool, noise: float):
+    def forward(self, y_sum: np.ndarray, theta: list, mode: bool, noise: float):
         if mode:
             y_vec = []
 
@@ -31,20 +29,14 @@ class FeaturesArima:
 
         return np.array(y_vec)
 
-    def integrated(self, datapoints: ndarray):
+    def integrated(self, datapoints: np.ndarray):
         datapoints = self.datapoints
-        # n = datapoints.shape[0]
-
-        # y_sum = [
-        #    ((1.0 - datapoints[i - 1] / datapoints[i]) ** self.d) * datapoints[i]
-        #    for i in range(1, n)
-        # ]
         y_sum = list(np.diff(datapoints, self.d))
         y_sum.insert(0, datapoints[0])
 
         return np.array(y_sum)
 
-    def average(self, datapoints: ndarray):
+    def average(self, datapoints: np.ndarray):
         y_sum_average = cal_average(datapoints)
         y_sum_eps = datapoints - y_sum_average
 

likelihood/tools/tools.py

@@ -979,6 +979,7 @@ class PerformanceMeasures:
     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)
+        mean_f_measure = np.around(mean_f_measure, decimals=4)
 
         for label, f_measure in zip(labels, F_vec):
             print(f"F-measure of label {label} -> {f_measure}")
@@ -1005,9 +1006,9 @@ class PerformanceMeasures:
 
     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))
+        print(" " * 6, " | ".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))]
+            row = [f" {int(count_mat[i, j]):5d} " for j in range(len(labels))]
             print(f"--{label_i}--|", " | ".join(row))
 
     def _f1_score(self, y_true: np.ndarray, y_pred: np.ndarray, labels: List[int]) -> np.ndarray:
@@ -1023,6 +1024,7 @@ class PerformanceMeasures:
             count_mat.diagonal(), sum_rows, out=np.zeros_like(sum_rows), where=sum_rows != 0
         )
         f1_vec = 2 * ((precision * recall) / (precision + recall))
+        f1_vec = np.around(f1_vec, decimals=4)
 
         return f1_vec
 

{likelihood-1.2.25.dist-info → likelihood-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: likelihood
-Version: 1.2.25
+Version: 1.3.1
 Summary: A package that performs the maximum likelihood algorithm.
 Home-page: https://github.com/jzsmoreno/likelihood/
 Author: J. A. Moreno-Guerra
@@ -14,14 +14,16 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: black[jupyter]>=24.3.0
-Requires-Dist: mypy-extensions==1.0.0
-Requires-Dist: types-openpyxl==3.1.0.15
-Requires-Dist: pydocstyle==6.3.0
-Requires-Dist: flake8==6.0.0
-Requires-Dist: isort==5.12.0
-Requires-Dist: mypy==1.4.1
+Requires-Dist: mypy-extensions>=1.0.0
+Requires-Dist: types-openpyxl>=3.1.0.15
+Requires-Dist: pydocstyle>=6.3.0
+Requires-Dist: flake8>=6.0.0
+Requires-Dist: isort>=5.12.0
+Requires-Dist: mypy>=1.4.1
 Requires-Dist: numpy<2.0.0
+Requires-Dist: pydot==2.0.0
 Requires-Dist: matplotlib
+Requires-Dist: graphviz
 Requires-Dist: pyyaml
 Requires-Dist: pandas
 Requires-Dist: corner

likelihood-1.3.1.dist-info/RECORD

@@ -0,0 +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=bLrNMvIh7GOTdPTwnNss8oPZ7cbSHQScAsH_ttmVUK0,3294
+likelihood/graph/nn.py,sha256=-OvHAeB3l2nd0ZeAk03cVDGBgaTn-WyGIsj5Rq7XeCY,12237
+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=LFyE_szo7sDukviMLeg_6RoyAaI7yMXUy8f4mDOrGoc,8460
+likelihood/models/utils.py,sha256=dvigPi_hxcs5ntfHr7Y1JvP5ULtMW3kkN0nJpS4orE8,1319
+likelihood/models/deep/__init__.py,sha256=-KIPippVaMqgG8mEgYjNxYQdqOUcFhUuKhbVe8TTCfo,28
+likelihood/models/deep/autoencoders.py,sha256=S11ARmoROTNFC4AZLuTcB-ymbm14NUH-a0Dg861fsYM,28203
+likelihood/tools/__init__.py,sha256=MCjsCWfBNKE2uMN0VizDN1uFzZ_md0X2WZeBdWhrCR8,50
+likelihood/tools/numeric_tools.py,sha256=FA44kbiAcxcquz1el_g3Pqsp5ii8XFkAIrsMs5bGkj0,11445
+likelihood/tools/tools.py,sha256=6JLZBHxc4f1lJfw4aBwdS2s16EpydFNqLZF73I7wddQ,44412
+likelihood-1.3.1.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
+likelihood-1.3.1.dist-info/METADATA,sha256=CuHvFiy8Pr1ToXw2oCvqoEsnImRtcifH2Mn7HQnFEkc,2822
+likelihood-1.3.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+likelihood-1.3.1.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
+likelihood-1.3.1.dist-info/RECORD,,

likelihood-1.2.25.dist-info/RECORD

@@ -1,20 +0,0 @@
-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=hGWCznxaRQ8BfY2aLjrvwriZkAIsz5ydKXF4x_7b0EQ,3359
-likelihood/graph/nn.py,sha256=WuK66hRTN5hdVIArgfSweqtE098tb6QFd2ZMFaHvnZA,12263
-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=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=seE1rb1t1gbbKRyEzfi01BqMsV4MU6yakVTLcukAMkg,20591
-likelihood/tools/__init__.py,sha256=MCjsCWfBNKE2uMN0VizDN1uFzZ_md0X2WZeBdWhrCR8,50
-likelihood/tools/numeric_tools.py,sha256=FA44kbiAcxcquz1el_g3Pqsp5ii8XFkAIrsMs5bGkj0,11445
-likelihood/tools/tools.py,sha256=iZBC7IHTFpAyxooyel7ZFi-5-G0nCotNLLtxenPw9T8,44303
-likelihood-1.2.25.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
-likelihood-1.2.25.dist-info/METADATA,sha256=hUsmkghXP8m4z3FtWcM64gwBEW74HIOTNJifK26OOkw,2771
-likelihood-1.2.25.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-likelihood-1.2.25.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
-likelihood-1.2.25.dist-info/RECORD,,