likelihood 1.2.15__py3-none-any.whl → 1.2.17__py3-none-any.whl

likelihood/graph/nn.py

@@ -0,0 +1,344 @@
+import warnings
+from typing import List, Tuple
+
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from numpy import ndarray
+from pandas.core.frame import DataFrame
+from sklearn.metrics import f1_score
+from sklearn.model_selection import train_test_split
+
+from likelihood.tools import generate_feature_yaml
+
+
+def compare_similarity(arr1: ndarray, arr2: ndarray) -> int:
+    """Compares the similarity between two arrays of categories.
+
+    Parameters
+    ----------
+    arr1 : `ndarray`
+        The first array of categories.
+    arr2 : `ndarray`
+        The second array of categories.
+
+    Returns
+    -------
+    count: `int`
+        The number of categories that are the same in both arrays.
+    """
+
+    count = 0
+    for i in range(len(arr1)):
+        if arr1[i] == arr2[i]:
+            count += 1
+    return count
+
+
+def cal_adjency_matrix(
+    df: DataFrame, exclude_subset: List[str] = [], sparse: bool = True, **kwargs
+) -> Tuple[dict, 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.
+    The resulting matrix is a square matrix with the same number of rows and columns as the input DataFrame.
+
+    Parameters
+    ----------
+    df : `DataFrame`
+        The input DataFrame containing the categories.
+    exclude_subset : `List[str]`, optional
+        A list of categories to exclude from the calculation of the adjacency matrix.
+    sparse : `bool`, optional
+        Whether to return a sparse matrix or a dense matrix.
+    **kwargs : `dict`
+        Additional keyword arguments to pass to the `compare_similarity` function.
+
+    Keyword Arguments:
+    ----------
+    similarity: `int`
+        The minimum number of categories that must be the same in both arrays to be considered similar.
+
+    Returns
+    -------
+    adj_dict : `dict`
+        A dictionary containing the categories.
+    adjacency_matrix : `ndarray`
+        The adjacency matrix.
+    """
+
+    yaml_ = generate_feature_yaml(df)
+    categorical_columns = yaml_["categorical_features"]
+    if len(exclude_subset) > 0:
+        categorical_columns = [col for col in categorical_columns if col not in exclude_subset]
+
+    if len(categorical_columns) > 1:
+        df_categorical = df[categorical_columns].copy()
+    else:
+        categorical_columns = [
+            col
+            for col in df.columns
+            if (
+                col not in exclude_subset
+                and pd.api.types.is_integer_dtype(df[col])
+                and len(df[col].unique()) > 2
+            )
+        ]
+        df_categorical = df[categorical_columns].copy()
+
+    assert len(df_categorical) > 0
+
+    similarity = kwargs["similarity"] if "similarity" in kwargs else len(df_categorical.columns) - 1
+    assert similarity <= df_categorical.shape[1]
+
+    adj_dict = {}
+    for index, row in df_categorical.iterrows():
+        adj_dict[index] = row.to_list()
+
+    adjacency_matrix = np.zeros((len(df_categorical), len(df_categorical)))
+
+    for i in range(len(df_categorical)):
+        for j in range(len(df_categorical)):
+            if compare_similarity(adj_dict[i], adj_dict[j]) >= similarity:
+                adjacency_matrix[i][j] = 1
+
+    if sparse:
+        num_nodes = adjacency_matrix.shape[0]
+
+        indices = np.argwhere(adjacency_matrix != 0.0)
+        indices = tf.constant(indices, dtype=tf.int64)
+        values = tf.constant(adjacency_matrix[indices[:, 0], indices[:, 1]], dtype=tf.float32)
+        adjacency_matrix = tf.sparse.SparseTensor(
+            indices=indices, values=values, dense_shape=(num_nodes, num_nodes)
+        )
+
+        return adj_dict, adjacency_matrix
+    else:
+        return adj_dict, adjacency_matrix
+
+
+class Data:
+    def __init__(
+        self,
+        df: DataFrame,
+        target: str | None = None,
+        exclude_subset: List[str] = [],
+    ):
+        _, adjacency = cal_adjency_matrix(df, exclude_subset=exclude_subset, sparse=True)
+        if target is not None:
+            X = df.drop(columns=[target] + exclude_subset)
+        else:
+            X = df.drop(columns=exclude_subset)
+        self.columns = X.columns
+        X = X.to_numpy()
+        self.x = np.asarray(X).astype(np.float32)
+        self.adjacency = adjacency
+        if target is not None:
+            self.y = np.asarray(df[target].values).astype(np.int32)
+
+
+@tf.keras.utils.register_keras_serializable(package="Custom", name="VanillaGNNLayer")
+class VanillaGNNLayer(tf.keras.layers.Layer):
+    def __init__(self, dim_in, dim_out, kernel_initializer="glorot_uniform", **kwargs):
+        super(VanillaGNNLayer, self).__init__(**kwargs)
+        self.dim_out = dim_out
+        self.kernel_initializer = kernel_initializer
+        self.linear = None
+
+    def build(self, input_shape):
+        self.linear = tf.keras.layers.Dense(
+            self.dim_out, use_bias=False, kernel_initializer=self.kernel_initializer
+        )
+        super(VanillaGNNLayer, self).build(input_shape)
+
+    def call(self, x, adjacency):
+        x = self.linear(x)
+        x = tf.sparse.sparse_dense_matmul(adjacency, x)
+        return x
+
+    def get_config(self):
+        config = super(VanillaGNNLayer, self).get_config()
+        config.update(
+            {
+                "dim_out": self.dim_out,
+                "kernel_initializer": tf.keras.initializers.serialize(
+                    self.linear.kernel_initializer
+                ),
+            }
+        )
+        return config
+
+
+@tf.keras.utils.register_keras_serializable(package="Custom", name="VanillaGNN")
+class VanillaGNN(tf.keras.Model):
+    def __init__(self, dim_in, dim_h, dim_out, **kwargs):
+        super(VanillaGNN, self).__init__(**kwargs)
+        self.dim_in = dim_in
+        self.dim_h = dim_h
+        self.dim_out = dim_out
+        self.gnn1 = VanillaGNNLayer(self.dim_in, self.dim_h)
+        self.gnn2 = VanillaGNNLayer(self.dim_h, self.dim_h)
+        self.gnn3 = VanillaGNNLayer(self.dim_h, self.dim_out)
+
+    def build(self, input_shape):
+        super(VanillaGNN, self).build(input_shape)
+        dummy_input = tf.keras.Input(shape=input_shape[1:])
+        dummy_adjacency = tf.sparse.SparseTensor(
+            indices=[[0, 0]], values=[1.0], dense_shape=[input_shape[0], input_shape[0]]
+        )
+        _ = self(dummy_input, dummy_adjacency)
+
+    def call(self, x, adjacency):
+        h = self.gnn1(x, adjacency)
+        h = tf.nn.tanh(h)
+        h = self.gnn2(h, adjacency)
+        h = self.gnn3(h, adjacency)
+        return tf.nn.softmax(h, axis=1)
+
+    def f1_macro(self, y_true, y_pred):
+        return f1_score(y_true, y_pred, average="macro")
+
+    def compute_f1_score(self, logits, labels):
+        predictions = tf.argmax(logits, axis=1, output_type=tf.int32)
+        true_labels = tf.cast(labels, tf.int32)
+        return self.f1_macro(true_labels.numpy(), predictions.numpy())
+
+    def evaluate(self, x, adjacency, y):
+        y = tf.cast(y, tf.int32)
+        out = self(x, adjacency)
+        loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=out)
+        loss = tf.reduce_mean(loss)
+        f1 = self.compute_f1_score(out, y)
+        return loss.numpy(), f1
+
+    def test(self, data):
+        out = self(data.x, data.adjacency)
+        test_f1 = self.compute_f1_score(out, data.y)
+        return test_f1
+
+    def predict(self, data):
+        out = self(data.x, data.adjacency)
+        return tf.argmax(out, axis=1, output_type=tf.int32).numpy()
+
+    def get_config(self):
+        config = {
+            "dim_in": self.dim_in,
+            "dim_h": self.dim_h,
+            "dim_out": self.dim_out,
+        }
+        base_config = super(VanillaGNN, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))
+
+    @classmethod
+    def from_config(cls, config):
+        return cls(
+            dim_in=config["dim_in"],
+            dim_h=config["dim_h"],
+            dim_out=config["dim_out"],
+        )
+
+    @tf.function
+    def train_step(self, batch_x, batch_adjacency, batch_y, optimizer):
+        with tf.GradientTape() as tape:
+            out = self(batch_x, batch_adjacency)
+            loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=batch_y, logits=out)
+            loss = tf.reduce_mean(loss)
+        gradients = tape.gradient(loss, self.trainable_variables)
+        optimizer.apply_gradients(zip(gradients, self.trainable_variables))
+        return loss
+
+    def fit(self, data, epochs, batch_size, test_size=0.2, optimizer="adam"):
+        warnings.warn(
+            "It is normal for validation metrics to underperform. Use the test method to validate after training.",
+            UserWarning,
+        )
+        optimizers = {
+            "sgd": tf.keras.optimizers.SGD(),
+            "adam": tf.keras.optimizers.Adam(),
+            "adamw": tf.keras.optimizers.AdamW(),
+            "adadelta": tf.keras.optimizers.Adadelta(),
+            "rmsprop": tf.keras.optimizers.RMSprop(),
+        }
+        optimizer = optimizers[optimizer]
+        train_losses = []
+        train_f1_scores = []
+        val_losses = []
+        val_f1_scores = []
+
+        X_train, X_test, y_train, y_test = train_test_split(
+            data.x, data.y, test_size=test_size, shuffle=False
+        )
+        adjacency_train = tf.sparse.slice(data.adjacency, [0, 0], [len(X_train), len(X_train)])
+        adjacency_test = tf.sparse.slice(
+            data.adjacency, [len(X_train), 0], [len(X_test), len(X_test)]
+        )
+
+        batch_starts = np.arange(0, len(X_train), batch_size)
+        for epoch in range(epochs):
+            np.random.shuffle(batch_starts)
+            for start in batch_starts:
+                end = start + batch_size
+                batch_x = X_train[start:end, :]
+                batch_adjacency = tf.sparse.slice(
+                    adjacency_train, [start, start], [batch_size, batch_size]
+                )
+                batch_y = y_train[start:end]
+                train_loss = self.train_step(batch_x, batch_adjacency, batch_y, optimizer)
+
+            train_loss, train_f1 = self.evaluate(X_train, adjacency_train, y_train)
+            train_losses.append(train_loss)
+            train_f1_scores.append(train_f1)
+
+            if epoch % 2 == 0:
+                val_loss, val_f1 = self.evaluate(X_test, adjacency_test, y_test)
+                val_losses.append(val_loss)
+                val_f1_scores.append(val_f1)
+                print(
+                    f"Epoch {epoch:>3} | Train Loss: {train_loss:.3f} | Train F1: {train_f1:.3f} | Val Loss: {val_loss:.3f} | Val F1: {val_f1:.3f}"
+                )
+
+        return train_losses, train_f1_scores, val_losses, val_f1_scores
+
+
+if __name__ == "__main__":
+    # Example usage
+    import pandas as pd
+    from sklearn.datasets import load_iris
+
+    # Load the dataset
+    iris = load_iris()
+
+    # Convert to a DataFrame for easy exploration
+    iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
+    iris_df["species"] = iris.target
+
+    iris_df["sepal length (cm)"] = iris_df["sepal length (cm)"].astype("category")
+    iris_df["sepal width (cm)"] = iris_df["sepal width (cm)"].astype("category")
+    iris_df["petal length (cm)"] = iris_df["petal length (cm)"].astype("category")
+    iris_df["petal width (cm)"] = iris_df["petal width (cm)"].astype("category")
+
+    # Display the first few rows of the dataset
+    print(iris_df.head())
+
+    iris_df = iris_df.sample(frac=1, replace=False).reset_index(drop=True)
+
+    data = Data(iris_df, "species")
+
+    model = VanillaGNN(dim_in=data.x.shape[1], dim_h=8, dim_out=len(iris_df["species"].unique()))
+    print("Before training F1:", model.test(data))
+    model.fit(data, epochs=200, batch_size=32, test_size=0.5)
+    model.save("./best_model.keras")
+    print("After training F1:", model.test(data))
+    best_model = tf.keras.models.load_model("./best_model.keras")
+
+    print("After loading F1:", best_model.test(data))
+    df_results = pd.DataFrame()
+
+    # Suppose we have a new dataset without the target variable
+    iris_df = iris_df.drop(columns=["species"])
+    data_new = Data(iris_df)
+    print("Predictions:", best_model.predict(data_new))
+    df_results["predicted"] = list(model.predict(data))
+    df_results["actual"] = list(data.y)
+    # df_results.to_csv("results.csv", index=False)
+    breakpoint()

likelihood/models/deep/autoencoders.py

@@ -6,12 +6,11 @@ import numpy as np
 import pandas as pd
 import tensorflow as tf
 from pandas.core.frame import DataFrame
-from tensorflow.keras.models import Model
 
 from likelihood.tools import OneHotEncoder
 
 
-class AutoClassifier(Model):
+class AutoClassifier(tf.keras.Model):
     """
     An auto-classifier model that automatically determines the best classification strategy based on the input data.
 
@@ -23,6 +22,10 @@ class AutoClassifier(Model):
 
     Methods:
         __init__(self, input_shape, num_classes, units, activation): Initializes an AutoClassifier instance with the given parameters.
+        build(self, input_shape): Builds the model architecture based on input_shape.
+        call(self, x): Defines the forward pass of the model.
+        get_config(self): Returns the configuration of the model.
+        from_config(cls, config): Recreates an instance of AutoClassifier from its configuration.
     """
 
     def __init__(self, input_shape, num_classes, units, activation):
@@ -41,33 +44,59 @@ class AutoClassifier(Model):
             The type of activation function to use for the neural network layers.
         """
         super(AutoClassifier, self).__init__()
+        self.input_shape = input_shape
+        self.num_classes = num_classes
         self.units = units
-        self.shape = input_shape
+        self.activation = activation
 
+        self.encoder = None
+        self.decoder = None
+        self.classifier = None
+
+    def build(self, input_shape):
         self.encoder = tf.keras.Sequential(
             [
-                tf.keras.layers.Dense(units=units, activation=activation),
-                tf.keras.layers.Dense(units=int(units / 2), activation=activation),
+                tf.keras.layers.Dense(units=self.units, activation=self.activation),
+                tf.keras.layers.Dense(units=int(self.units / 2), activation=self.activation),
             ]
         )
 
         self.decoder = tf.keras.Sequential(
             [
-                tf.keras.layers.Dense(units=units, activation=activation),
-                tf.keras.layers.Dense(units=input_shape, activation=activation),
+                tf.keras.layers.Dense(units=self.units, activation=self.activation),
+                tf.keras.layers.Dense(units=self.input_shape, activation=self.activation),
             ]
         )
 
         self.classifier = tf.keras.Sequential(
-            [tf.keras.layers.Dense(num_classes, activation="softmax")]
+            [tf.keras.layers.Dense(self.num_classes, activation="softmax")]
         )
 
     def call(self, x):
         encoded = self.encoder(x)
         decoded = self.decoder(encoded)
         combined = tf.concat([decoded, encoded], axis=1)
-        classifier = self.classifier(combined)
-        return classifier
+        classification = self.classifier(combined)
+        return classification
+
+    def get_config(self):
+        config = {
+            "input_shape": self.input_shape,
+            "num_classes": self.num_classes,
+            "units": self.units,
+            "activation": self.activation,
+        }
+        base_config = super(AutoClassifier, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))
+
+    @classmethod
+    def from_config(cls, config):
+        return cls(
+            input_shape=config["input_shape"],
+            num_classes=config["num_classes"],
+            units=config["units"],
+            activation=config["activation"],
+        )
 
 
 def call_existing_code(
@@ -146,7 +175,13 @@ def build_model(hp, input_shape: None | int, num_classes: None | int) -> AutoCla
 
 
 def setup_model(
-    data: DataFrame, target: str, epochs: int, train_size: float = 0.7, seed=None, **kwargs
+    data: DataFrame,
+    target: str,
+    epochs: int,
+    train_size: float = 0.7,
+    seed=None,
+    filepath: str = "./my_dir/best_model.keras",
+    **kwargs
 ) -> AutoClassifier:
     """Setup model for training and tuning.
 
@@ -162,6 +197,8 @@ def setup_model(
         The proportion of the dataset to use for training.
     seed : `Any` | `int`
         The random seed to use for reproducibility.
+    filepath : `str`
+        The path to save the best model to.
 
     Keyword Arguments:
     ----------
@@ -228,13 +265,13 @@ def setup_model(
         best_model = models[0]
 
         # save model
-        best_model.save("./my_dir/best_model.keras")
+        best_model.save(filepath)
 
         if verbose:
             tuner.results_summary()
     else:
         # Load the best model from the directory
-        best_model = tf.keras.models.load_model("./my_dir/best_model.keras")
+        best_model = tf.keras.models.load_model(filepath)
 
     return best_model
 

likelihood/tools/tools.py

@@ -815,7 +815,10 @@ class DataFrameEncoder:
                 self._df[i] = self._df[i].apply(
                     self._code_transformation_to, dictionary_list=encode_dict
                 )
-                median_value = len(self._df[i].unique()) // 2
+                if len(self._df[i].unique()) > 1:
+                    median_value = len(self._df[i].unique()) // 2
+                else:
+                    median_value = 1.0
                 if norm_method == "median":
                     self._df[i] = self._df[i].astype("float64")
                     self._df[i] = self._df[i] / median_value
@@ -842,6 +845,8 @@ class DataFrameEncoder:
             print("Configuration detected")
             if len(self.median_list) == len(self._encode_columns):
                 median_mode = True
+            else:
+                median_mode = False
             for num, colname in enumerate(self._encode_columns):
                 if self._df[colname].dtype == "object":
                     encode_dict = self.encoding_list[num]
@@ -859,6 +864,8 @@ class DataFrameEncoder:
         df_decoded = self._df.copy()
         if len(self.median_list) == len(self._encode_columns):
             median_mode = True
+        else:
+            median_mode = False
         try:
             number_of_columns = len(self.decoding_list[j])
             for i in self._encode_columns:

{likelihood-1.2.15.dist-info → likelihood-1.2.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: likelihood
-Version: 1.2.15
+Version: 1.2.17
 Summary: A package that performs the maximum likelihood algorithm.
 Home-page: https://github.com/jzsmoreno/likelihood/
 Author: J. A. Moreno-Guerra
@@ -30,6 +30,7 @@ Requires-Dist: networkx ; extra == 'full'
 Requires-Dist: pyvis ; extra == 'full'
 Requires-Dist: tensorflow ; extra == 'full'
 Requires-Dist: keras-tuner ; extra == 'full'
+Requires-Dist: scikit-learn ; extra == 'full'
 
 ![likelihood](https://raw.githubusercontent.com/RodolfoFerro/likelihood/main/likelihood.png)
 

{likelihood-1.2.15.dist-info → likelihood-1.2.17.dist-info}/RECORD

@@ -2,17 +2,18 @@ likelihood/__init__.py,sha256=5C0hapdsk85XZhN_rssRAEFpkRRuKNtj6cyRbqD2_gM,994
 likelihood/main.py,sha256=prqT9egu3B2rcbsVMqYxuosNbe7NhDBCmmZtQ21aSlQ,8591
 likelihood/graph/__init__.py,sha256=6TuFDfmXTwpLyHl7_KqBfdzW6zqHjGzIFvymjFPlvjI,21
 likelihood/graph/graph.py,sha256=wKJqgxXiSbnvzyW3SjhQVrqp00yKMHf3ph6CIDNVhNM,2891
+likelihood/graph/nn.py,sha256=XqTnAHzXP0jSdLd0IOFjVZUZTcQU-XppsZLmJrG2GMo,12372
 likelihood/models/__init__.py,sha256=e6nB4w47w0Q9DrAFeP3OcUgcoHOtf7Il4mBhgf4AARg,52
 likelihood/models/regression.py,sha256=9cakyGlJCEO6WfpoKLh3GxdXQeQp7cUvJIkQ5odT0TA,9404
 likelihood/models/simulation.py,sha256=KYdVjt2PaLo04g8kBsRGQJ5AKMBaQVUH3orZE_TXTy8,2960
 likelihood/models/utils.py,sha256=VtEj07lV-GRoWraQgpfjU0jTt1Ntf9MXgYwe6XYQh20,1552
 likelihood/models/deep/__init__.py,sha256=-KIPippVaMqgG8mEgYjNxYQdqOUcFhUuKhbVe8TTCfo,28
-likelihood/models/deep/autoencoders.py,sha256=12kPN0UlXyDcqZuysf9KwALsH-Oi1HqPDVR1a8EJsLA,7710
+likelihood/models/deep/autoencoders.py,sha256=kyqyH_GZuImvCAdvKeQqxGUhfs2-xdt2MzDX4jfDHDY,8953
 likelihood/tools/__init__.py,sha256=MCjsCWfBNKE2uMN0VizDN1uFzZ_md0X2WZeBdWhrCR8,50
 likelihood/tools/numeric_tools.py,sha256=EQD959b56aovi4PI_og0BITgyUONgDUU9LG9YqNgX70,7554
-likelihood/tools/tools.py,sha256=zfrGKgRjz9G_hmJkpf8VYuJ6PsfwWvWTxqao_b2vydw,41412
-likelihood-1.2.15.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
-likelihood-1.2.15.dist-info/METADATA,sha256=Z-iU581E4E9kSuwr3coAkS_T6Z9N5cr_CMzr_us2dds,2463
-likelihood-1.2.15.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-likelihood-1.2.15.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
-likelihood-1.2.15.dist-info/RECORD,,
+likelihood/tools/tools.py,sha256=B1_xRZeO2fUSCVUvdkhlB6zO9dGzIglSknydLv7VCEc,41627
+likelihood-1.2.17.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
+likelihood-1.2.17.dist-info/METADATA,sha256=h2BYri6oepaP2iCwAyln149xMS5NZ5pHVhsPChTOyNo,2509
+likelihood-1.2.17.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+likelihood-1.2.17.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
+likelihood-1.2.17.dist-info/RECORD,,

{likelihood-1.2.15.dist-info → likelihood-1.2.17.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any