likelihood 1.2.14__py3-none-any.whl → 1.2.16__py3-none-any.whl

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):
@@ -39,39 +42,61 @@ class AutoClassifier(Model):
             The number of neurons in each hidden layer.
         activation : `str`
             The type of activation function to use for the neural network layers.
-
-        Returns
-        -------
-            None
         """
         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(
@@ -210,8 +235,6 @@ def setup_model(
         X = X.to_numpy()
         X = np.asarray(X).astype(np.float32)
 
-        y = pd.DataFrame(y, columns=["class_0", "class_1"])
-        y = y.to_numpy()
         y = np.asarray(y).astype(np.float32)
 
         input_shape = X.shape[1]

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.14.dist-info → likelihood-1.2.16.dist-info}/METADATA

@@ -1,10 +1,12 @@
 Metadata-Version: 2.1
 Name: likelihood
-Version: 1.2.14
+Version: 1.2.16
 Summary: A package that performs the maximum likelihood algorithm.
 Home-page: https://github.com/jzsmoreno/likelihood/
 Author: J. A. Moreno-Guerra
 Author-email: jzs.gm27@gmail.com
+Maintainer: Jafet Castañeda
+Maintainer-email: jafetcc17@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{likelihood-1.2.14.dist-info → likelihood-1.2.16.dist-info}/RECORD

@@ -7,12 +7,12 @@ likelihood/models/regression.py,sha256=9cakyGlJCEO6WfpoKLh3GxdXQeQp7cUvJIkQ5odT0
 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=oMQ_sjCsR0WISM10MDI4IbBHpn5sbT5_L6AtqbsTZcg,7845
+likelihood/models/deep/autoencoders.py,sha256=wgra29Wjyh4KOMdOVEhWLtfqTFvjKeOVf1GthomB7PE,8857
 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.14.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
-likelihood-1.2.14.dist-info/METADATA,sha256=j-JksVP8DVWR6Px7DxoI_3eHbzxzKX-YVAeLrptDkTQ,2396
-likelihood-1.2.14.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-likelihood-1.2.14.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
-likelihood-1.2.14.dist-info/RECORD,,
+likelihood/tools/tools.py,sha256=B1_xRZeO2fUSCVUvdkhlB6zO9dGzIglSknydLv7VCEc,41627
+likelihood-1.2.16.dist-info/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
+likelihood-1.2.16.dist-info/METADATA,sha256=5htpwpnzwy5Y0sU103sm_K8Yt5xhMjjmLf1a3rx_40s,2463
+likelihood-1.2.16.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+likelihood-1.2.16.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
+likelihood-1.2.16.dist-info/RECORD,,