likelihood 1.5.7__tar.gz → 1.5.8__tar.gz

{likelihood-1.5.7 → likelihood-1.5.8}/PKG-INFO

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

{likelihood-1.5.7 → likelihood-1.5.8}/likelihood/models/deep/autoencoders.py

@@ -277,7 +277,8 @@ class AutoClassifier(tf.keras.Model):
                         activation=self.activation,
                         kernel_regularizer=l2(self.l2_reg),
                     ),
-                ]
+                ],
+                name="encoder",
             )
             if not self.encoder
             else self.encoder
@@ -296,7 +297,8 @@ class AutoClassifier(tf.keras.Model):
                         activation=self.activation,
                         kernel_regularizer=l2(self.l2_reg),
                     ),
-                ]
+                ],
+                name="decoder",
             )
             if not self.decoder
             else self.decoder
@@ -326,7 +328,7 @@ class AutoClassifier(tf.keras.Model):
             log_var = tf.keras.layers.Lambda(lambda x: x + 1e-7)(log_var)
 
             self.encoder = (
-                tf.keras.Model(inputs, [mean, log_var], name="encoder")
+                tf.keras.Model(inputs, [mean, log_var], name="vae_encoder")
                 if not self.encoder
                 else self.encoder
             )
@@ -345,7 +347,8 @@ class AutoClassifier(tf.keras.Model):
                         ),
                         tf.keras.layers.BatchNormalization(),
                         tf.keras.layers.Activation(self.activation),
-                    ]
+                    ],
+                    name="vae_decoder",
                 )
                 if not self.decoder
                 else self.decoder
@@ -366,13 +369,7 @@ class AutoClassifier(tf.keras.Model):
                 )
                 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,
-                    kernel_regularizer=l2(self.l2_reg),
-                )
-            )
+
         elif self.lora_mode:
             for _ in range(self.num_layers - 1):
                 self.classifier.add(
@@ -381,21 +378,14 @@ class AutoClassifier(tf.keras.Model):
                 self.classifier.add(tf.keras.layers.Activation(self.activation))
                 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,
-                    kernel_regularizer=l2(self.l2_reg),
-                )
-            )
-        else:
-            self.classifier.add(
-                tf.keras.layers.Dense(
-                    units=self.num_classes,
-                    activation=self.classifier_activation,
-                    kernel_regularizer=l2(self.l2_reg),
-                )
+
+        self.classifier.add(
+            tf.keras.layers.Dense(
+                units=self.num_classes,
+                activation=self.classifier_activation,
+                kernel_regularizer=l2(self.l2_reg),
             )
+        )
 
     def train_encoder_decoder(
         self, data, epochs, batch_size, validation_split=0.2, patience=10, **kwargs
@@ -610,6 +600,13 @@ def call_existing_code(
     num_layers : `int`
         The number of hidden layers in the classifier. Default is 1.
 
+    Keyword Arguments:
+    ----------
+    vae_mode : `bool`
+        Whether to use variational autoencoder mode. Default is False.
+    vae_units : `int`
+        The number of units in the variational autoencoder. Default is 2.
+
     Returns
     -------
     `AutoClassifier`
@@ -617,6 +614,8 @@ def call_existing_code(
     """
     dropout = kwargs.get("dropout", None)
     l2_reg = kwargs.get("l2_reg", 0.0)
+    vae_mode = kwargs.get("vae_mode", False)
+    vae_units = kwargs.get("vae_units", 2)
     model = AutoClassifier(
         input_shape_parm=input_shape_parm,
         num_classes=num_classes,
@@ -625,6 +624,8 @@ def call_existing_code(
         num_layers=num_layers,
         dropout=dropout,
         l2_reg=l2_reg,
+        vae_mode=vae_mode,
+        vae_units=vae_units,
     )
     model.compile(
         optimizer=optimizer,
@@ -731,6 +732,24 @@ def build_model(
             else hyperparameters["l2_reg"]
         )
     )
+    vae_mode = (
+        hp.Choice("vae_mode", [True, False])
+        if "vae_mode" not in hyperparameters_keys
+        else hyperparameters["vae_mode"]
+    )
+
+    try:
+        vae_units = (
+            hp.Int("vae_units", min_value=2, max_value=10, step=1)
+            if ("vae_units" not in hyperparameters_keys) and vae_mode
+            else (
+                hp.Choice("vae_units", hyperparameters["vae_units"])
+                if isinstance(hyperparameters["vae_units"], list)
+                else hyperparameters["vae_units"]
+            )
+        )
+    except KeyError:
+        vae_units = None
 
     model = call_existing_code(
         units=units,
@@ -742,6 +761,8 @@ def build_model(
         num_layers=num_layers,
         dropout=dropout,
         l2_reg=l2_reg,
+        vae_mode=vae_mode,
+        vae_units=vae_units,
     )
     return model
 
@@ -876,6 +897,8 @@ def setup_model(
             tuner.results_summary()
     else:
         best_model = tf.keras.models.load_model(filepath)
-
     best_hps = tuner.get_best_hyperparameters(1)[0].values
-    return best_model, pd.DataFrame(best_hps, index=["Value"])
+    vae_mode = best_hps.get("vae_mode", hyperparameters.get("vae_mode", False))
+    best_hps["vae_units"] = None if not vae_mode else best_hps["vae_units"]
+
+    return best_model, pd.DataFrame(best_hps, index=["Value"]).dropna(axis=1)

{likelihood-1.5.7 → likelihood-1.5.8}/likelihood/models/deep/gan.py

@@ -41,7 +41,7 @@ class GANRegressor(tf.keras.Model):
         self.build(dummy_input.shape)
 
     def build(self, input_shape):
-        self.gan = tf.keras.models.Sequential([self.generator, self.discriminator])
+        self.gan = tf.keras.models.Sequential([self.generator, self.discriminator], name="gan")
 
         self.generator.compile(
             optimizer=self.optimizer,
@@ -57,7 +57,7 @@ class GANRegressor(tf.keras.Model):
         super(GANRegressor, self).build(input_shape)
 
     def _build_generator(self):
-        generator = tf.keras.Sequential()
+        generator = tf.keras.Sequential(name="generator")
         generator.add(
             tf.keras.layers.Dense(
                 self.num_neurons,
@@ -78,7 +78,7 @@ class GANRegressor(tf.keras.Model):
         return generator
 
     def _build_discriminator(self):
-        discriminator = tf.keras.Sequential()
+        discriminator = tf.keras.Sequential(name="discriminator")
         for _ in range(self.depth):
             discriminator.add(
                 tf.keras.layers.Dense(

{likelihood-1.5.7 → likelihood-1.5.8}/likelihood/models/deep/predictor.py

@@ -109,15 +109,16 @@ class GetInsights:
                 "in the model's transformation.</p>"
             )
         )
-        self.viz_encoder_decoder_graphs(threshold_factor=threshold_factor, top_k=top_k)
-
-        display(HTML("<h2 style='margin-top:30px;'>🧠 Classifier Layer Graphs</h2>"))
-        display(
-            HTML(
-                "<p>This visualization shows how features propagate through each dense layer in the classifier. "
-                "Only the strongest weighted connections are shown to highlight influential paths through the network.</p>"
+        if not self.model.encoder.name.startswith("vae"):
+            self.viz_encoder_decoder_graphs(threshold_factor=threshold_factor, top_k=top_k)
+
+            display(HTML("<h2 style='margin-top:30px;'>🧠 Classifier Layer Graphs</h2>"))
+            display(
+                HTML(
+                    "<p>This visualization shows how features propagate through each dense layer in the classifier. "
+                    "Only the strongest weighted connections are shown to highlight influential paths through the network.</p>"
+                )
             )
-        )
         self.viz_classifier_graphs(threshold_factor=threshold_factor, top_k=top_k)
 
         display(HTML("<h2 style='margin-top:30px;'>📈 Statistical Summary</h2>"))

likelihood-1.5.8/likelihood/tools/cat_embed.py

@@ -0,0 +1,213 @@
+import logging
+import os
+from typing import List
+
+import numpy as np
+import pandas as pd
+
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+logging.getLogger("tensorflow").setLevel(logging.ERROR)
+import tensorflow as tf
+from pandas.core.frame import DataFrame
+from sklearn.preprocessing import LabelEncoder
+
+tf.get_logger().setLevel("ERROR")
+
+
+class CategoricalEmbedder:
+    def __init__(self, embedding_dim=32):
+        self.embedding_dim = embedding_dim
+        self.label_encoders = {}
+        self.embeddings = {}
+
+    def fit(self, df: DataFrame, categorical_cols: List):
+        """
+        Fit the embeddings on the given data.
+
+        Parameters
+        ----------
+        df : `DataFrame`
+            Pandas DataFrame containing the tabular data.
+        categorical_cols : `List`
+            List of column names representing categorical features.
+
+        Returns
+        -------
+        `None`
+        """
+        df_processed = df.copy()
+        for col in categorical_cols:
+            if col not in df_processed.columns:
+                raise ValueError(f"Column {col} not found in DataFrame")
+
+        for col in categorical_cols:
+            mode_val = df_processed[col].mode()
+            if not mode_val.empty:
+                df_processed[col] = df_processed[col].fillna(mode_val[0])
+
+        for col in categorical_cols:
+            le = LabelEncoder()
+            df_processed[col] = le.fit_transform(df_processed[col])
+            self.label_encoders[col] = le
+
+            vocab_size = len(le.classes_)
+            embedding_matrix = np.random.rand(vocab_size, self.embedding_dim)
+            self.embeddings[col] = tf.Variable(embedding_matrix, dtype=tf.float32)
+
+    def transform(self, df: DataFrame, categorical_cols: List[str]):
+        """
+        Transform the data using the fitted embeddings.
+
+        Parameters
+        ----------
+        df : `DataFrame`
+            Pandas DataFrame containing the tabular data.
+        categorical_cols : `List[str]`
+            List of column names representing categorical features.
+
+        Returns
+        -------
+        Transformed Pandas DataFrame with original columns except `categorical_cols` replaced by their embedding representations.
+        """
+
+        df_processed = df.copy()
+
+        for col in categorical_cols:
+            if col not in self.label_encoders:
+                raise ValueError(
+                    f"Column {col} has not been fitted. Please call fit() on this column first."
+                )
+            mode_val = df_processed[col].mode()
+            if not mode_val.empty:
+                df_processed[col] = df_processed[col].fillna(mode_val[0])
+            le = self.label_encoders[col]
+            df_processed[col] = le.transform(df_processed[col])
+
+        for col in categorical_cols:
+            indices_tensor = tf.constant(df_processed[col], dtype=tf.int32)
+            embedding_layer = tf.nn.embedding_lookup(
+                params=self.embeddings[col], ids=indices_tensor
+            )
+            if len(embedding_layer.shape) == 1:
+                embedding_layer = tf.expand_dims(embedding_layer, axis=0)
+
+            for i in range(self.embedding_dim):
+                df_processed[f"{col}_embed_{i}"] = embedding_layer[:, i]
+            df_processed.drop(columns=[col], inplace=True)
+
+        return df_processed
+
+    def inverse_transform(self, df: pd.DataFrame, categorical_cols: List[str]):
+        """
+        Inverse transform the data using the fitted embeddings.
+
+        Parameters
+        ----------
+        df : `DataFrame`
+            Pandas DataFrame containing the tabular data with embedded representations.
+        categorical_cols : `List[str]`
+            List of column names representing categorical features.
+
+        Returns
+        -------
+        Transformed Pandas DataFrame with original columns replaced by their categorical labels.
+        """
+
+        df_processed = df.copy()
+
+        for col in categorical_cols:
+            if col not in self.label_encoders:
+                raise ValueError(
+                    f"Column {col} has not been fitted. Please call fit() on this column first."
+                )
+
+            embedding_matrix = self.embeddings[col].numpy()
+            label_encoder = self.label_encoders[col]
+
+            embedded_columns = [f"{col}_embed_{i}" for i in range(self.embedding_dim)]
+            embeddings = df_processed[embedded_columns].values
+
+            distances = np.linalg.norm(embedding_matrix - embeddings[:, np.newaxis], axis=2)
+            original_indices = np.argmin(distances, axis=1)
+            original_labels = label_encoder.inverse_transform(original_indices)
+
+            df_processed[col] = original_labels
+            df_processed.drop(columns=embedded_columns, inplace=True)
+
+        return df_processed
+
+    def save_embeddings(self, path: str):
+        """
+        Save the embeddings to a directory.
+
+        Parameters
+        ----------
+        path : `str`
+            Path to the directory where embeddings will be saved.
+        """
+
+        os.makedirs(path, exist_ok=True)
+        for col, embedding in self.embeddings.items():
+            np.save(os.path.join(path, f"{col}_embedding.npy"), embedding.numpy())
+
+    def load_embeddings(self, path: str):
+        """
+        Load the embeddings from a directory.
+
+        Parameters
+        ----------
+        path : `str`
+            Path to the directory where embeddings are saved.
+        """
+
+        for col in self.label_encoders.keys():
+            embedding_path = os.path.join(path, f"{col}_embedding.npy")
+            if not os.path.exists(embedding_path):
+                raise FileNotFoundError(f"Embedding file {embedding_path} not found.")
+            embedding_matrix = np.load(embedding_path)
+            self.embeddings[col] = tf.Variable(embedding_matrix, dtype=tf.float32)
+
+
+if __name__ == "__main__":
+    data = {
+        "color": ["red", "blue", None, "green", "blue"],
+        "size": ["S", "M", "XL", "XS", None],
+        "price": [10.99, 25.50, 30.00, 8.75, 12.25],
+    }
+    df = pd.DataFrame(data)
+
+    # Initialize the embedder
+    embedder = CategoricalEmbedder(embedding_dim=3)
+
+    # Fit the embeddings on the data
+    embedder.fit(df, categorical_cols=["color", "size"])
+
+    # Transform the data using the fitted embeddings
+    processed_df = embedder.transform(df, categorical_cols=["color", "size"])
+
+    print("Processed DataFrame:")
+    print(processed_df.head())
+
+    # Save the embeddings to disk
+    embedder.save_embeddings("./embeddings")
+
+    # Load the embeddings from disk
+    new_embedder = CategoricalEmbedder(embedding_dim=3)
+    new_embedder.label_encoders = (
+        embedder.label_encoders
+    )  # Assuming label encodings are consistent across runs
+    new_embedder.load_embeddings("./embeddings")
+
+    # Transform the data using the loaded embeddings
+    processed_df_loaded = new_embedder.transform(df, categorical_cols=["color", "size"])
+    print("\nProcessed DataFrame with Loaded Embeddings:")
+    print(processed_df_loaded.head())
+
+    # Inverse transform the data
+    df_loaded = new_embedder.inverse_transform(
+        processed_df_loaded, categorical_cols=["color", "size"]
+    )
+    print("\nOriginal DataFrame:")
+    print(df.head())
+    print("\nProcessed DataFrame with Inverse Transform:")
+    print(df_loaded.head())

{likelihood-1.5.7 → likelihood-1.5.8}/likelihood.egg-info/PKG-INFO

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

{likelihood-1.5.7 → likelihood-1.5.8}/likelihood.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ likelihood/models/deep/autoencoders.py
 likelihood/models/deep/gan.py
 likelihood/models/deep/predictor.py
 likelihood/tools/__init__.py
+likelihood/tools/cat_embed.py
 likelihood/tools/figures.py
 likelihood/tools/impute.py
 likelihood/tools/models_tools.py