likelihood 1.5.8__py3-none-any.whl → 2.0.1__py3-none-any.whl

likelihood/models/deep/autoencoders.py

@@ -484,12 +484,12 @@ class AutoClassifier(tf.keras.Model):
         Sets the encoder and decoder layers from another AutoClassifier instance,
         ensuring compatibility in dimensions. Only works if vae_mode is False.
 
-        Parameters:
+        Parameters
         -----------
         source_model : AutoClassifier
             The source model to copy the encoder and decoder layers from.
 
-        Raises:
+        Raises
         -------
         ValueError
             If the input shape or units of the source model do not match.

likelihood/models/deep/gan.py

@@ -102,7 +102,7 @@ class GANRegressor(tf.keras.Model):
         Train the GAN model.
 
         Parameters
-        --------
+        ----------
         X : array-like
             Input data.
         y : array-like
@@ -117,7 +117,7 @@ class GANRegressor(tf.keras.Model):
             Verbosity level. Default is 1.
 
         Returns
-        --------
+        -------
         history : pd.DataFrame
             Training history.
         """
@@ -234,7 +234,7 @@ class GANRegressor(tf.keras.Model):
         Train the generator model.
 
         Parameters
-        --------
+        ----------
         X_train : array-like
             Training data.
         y_train : array-like
@@ -249,7 +249,7 @@ class GANRegressor(tf.keras.Model):
             Number of epochs to wait before early stopping. Default is 3.
 
         Returns
-        --------
+        -------
         history : pd.DataFrame
             Training history.
         """

likelihood/models/deep/predictor.py

@@ -674,6 +674,7 @@ class GetInsights:
             / (data_normalized.iloc[:, :-1].max() - data_normalized.iloc[:, :-1].min())
             - 1
         )
+        data_normalized.dropna(axis=1, inplace=True)
         radviz(data_normalized, color_column, color=self.colors)
         plt.title(title)
         plt.show()

likelihood/models/deep/rl.py

@@ -0,0 +1,350 @@
+import random
+from collections import deque
+
+import numpy as np
+import tensorflow as tf
+from packaging import version
+
+if version.parse(tf.__version__) > version.parse("2.15.0"):
+    from ._autoencoders import AutoClassifier
+else:
+    from .autoencoders import AutoClassifier
+
+
+def print_progress_bar(iteration, total, length=30):
+    percent = f"{100 * (iteration / float(total)):.1f}"
+    filled_length = int(length * iteration // total)
+    bar = "█" * filled_length + "-" * (length - filled_length)
+    print(f"\rProgress: |{bar}| {percent}% Complete", end="\r")
+    if iteration == total:
+        print()
+
+
+class Env:
+    def __init__(self, model, maxlen=100, name="likenasium"):
+        """
+        Initialize the environment with a model.
+
+        Parameters
+        ----------
+        model : Any
+            Model with `.predict()` method (e.g., Keras model).
+        maxlen : int
+            Maximum length of deque. By default it is set to `100`.
+        name : str
+            The name of the environment. By default it is set to `likenasium`.
+        """
+        self.model = model
+        self.maxlen = maxlen
+        self.transitions = deque(
+            maxlen=self.maxlen
+        )  # Stores (state, action, reward, next_action, done)
+        self.current_state = None
+        self.current_step = 0
+        self.done = False
+
+    def step(self, state, action, verbose=0):
+        """
+        Perform an environment step with the given action.
+
+        Parameters
+        ----------
+        state : `np.ndarray`
+            Current state to process (input to the model).
+        action : `int`
+            Expected action to process.
+
+        Returns
+        -------
+            `tuple` : (current_state, action_pred, reward, next_action, done)
+        """
+        if self.done:
+            return None, None, 0, None, True
+
+        # Process action through model
+        model_output = self.model.predict(state.reshape((1, -1)), verbose=verbose)
+        action_pred = np.argmax(model_output, axis=1)[0]
+        model_output[:, action_pred] = 0.0
+        next_action = np.max(model_output, axis=1)[0]  # Second most probable action
+
+        # Calculate reward (1 if correct prediction, 0 otherwise)
+        reward = 1 if action_pred == action else 0
+
+        # Update current state
+        self.current_state = state
+        self.current_step += 1
+
+        # Add transition to history
+        if self.current_step <= self.maxlen:
+            self.transitions.append(
+                (
+                    self.current_state,  # Previous state
+                    action_pred,  # Current action
+                    reward,  # Reward
+                    next_action,  # Next action
+                    self.done,  # Done flag
+                )
+            )
+        return self.current_state, action_pred, reward, next_action, self.done
+
+    def reset(self):
+        """Reset the environment to initial state."""
+        self.current_state = None
+        self.current_step = 0
+        self.done = False
+        self.transitions = deque(maxlen=self.maxlen)
+        return self.current_state
+
+    def get_transitions(self):
+        """Get all stored transitions."""
+        return self.transitions
+
+
+class AutoQL:
+    """
+    AutoQL: A reinforcement learning agent using Q-learning with Epsilon-greedy policy.
+
+    This class implements a Q-learning agent with:
+    - Epsilon-greedy policy for exploration
+    - Replay buffer for experience replay
+    - Automatic model version handling for TensorFlow
+    """
+
+    def __init__(
+        self,
+        env,
+        model,
+        maxlen=2000,
+    ):
+        """Initialize AutoQL agent
+
+        Parameters
+        ----------
+        env : `Any`
+            The environment to interact with
+        model : `tf.keras.Model`
+            The Q-network model
+        """
+
+        self.env = env
+        self.model = model
+        self.maxlen = maxlen
+        self.replay_buffer = deque(maxlen=self.maxlen)
+
+    def epsilon_greedy_policy(self, state, action, epsilon=0):
+        """
+        Epsilon-greedy policy for action selection
+
+        Parameters
+        ----------
+        state : `np.ndarray`
+            Current state.
+        action : `int`
+            Expected action to process.
+        epsilon : `float`
+            Exploration probability. By default it is set to `0`
+
+        Returns
+        -------
+            `tuple` : (state, action, reward, next_action, done)
+        """
+        current_state, value, reward, next_action, done = self.env.step(state, action)
+
+        if np.random.rand() > epsilon:
+            state = np.asarray(state).astype(np.float32)
+            return current_state, value, reward, next_action, done
+        step_ = random.sample(self.env.get_transitions(), 1)
+        _state, greedy_action, _reward, _next_action, _done = zip(*step_)
+
+        return _state[0], greedy_action[0], _reward[0], _next_action[0], _done[0]
+
+    def play_one_step(self, state, action, epsilon):
+        """
+        Perform one step in the environment and add experience to buffer
+
+        Parameters
+        ----------
+        state : `np.ndarray`
+            Current state
+        action : `int`
+            Expected action to process.
+
+        epsilon : `float`
+            Exploration probability.
+
+        Returns
+        -------
+            `tuple` : (state, action, reward, next_action, done)
+        """
+        current_state, greedy_action, reward, next_action, done = self.epsilon_greedy_policy(
+            state, action, epsilon
+        )
+
+        done = 1 if done else 0
+
+        # Add experience to replay buffer
+        self.replay_buffer.append(
+            (
+                current_state,  # Previous state
+                greedy_action,  # Current action
+                reward,  # Reward
+                next_action,  # Next action
+                done,  # Done flag
+            )
+        )
+
+        return current_state, greedy_action, reward, next_action, done
+
+    @tf.function
+    def _training_step(self):
+        """
+        Perform one training step using experience replay
+
+        Returns
+        -------
+            `float` : Training loss
+        """
+
+        batch_ = random.sample(self.replay_buffer, self.batch_size)
+        states, actions, rewards, next_actions, dones = zip(*batch_)
+        states = np.array(states).reshape(self.batch_size, -1)
+        actions = np.array(actions).reshape(
+            self.batch_size,
+        )
+        rewards = np.array(rewards).reshape(
+            self.batch_size,
+        )
+        max_next_Q_values = np.array(next_actions).reshape(self.batch_size, -1)
+        dones = np.array(dones).reshape(
+            self.batch_size,
+        )
+        target_Q_values = rewards + (1 - dones) * self.gamma * max_next_Q_values
+
+        actions = tf.convert_to_tensor(actions, dtype=tf.int32)
+        states = tf.convert_to_tensor(states, dtype=tf.float32)
+        target_Q_values = tf.convert_to_tensor(target_Q_values, dtype=tf.float32)
+
+        with tf.GradientTape() as tape:
+            all_Q_values = self.model(states)
+            indices = tf.stack([tf.range(tf.shape(actions)[0]), actions], axis=1)
+            Q_values = tf.gather_nd(all_Q_values, indices)
+            loss = tf.reduce_mean(self.loss_fn(target_Q_values, Q_values))
+        grads = tape.gradient(loss, self.model.trainable_variables)
+        self.optimizer.apply_gradients(zip(grads, self.model.trainable_variables))
+        return loss
+
+    def train(
+        self,
+        x_data,
+        y_data,
+        optimizer="adam",
+        loss_fn="mse",
+        num_episodes=50,
+        num_steps=100,
+        gamma=0.7,
+        batch_size=32,
+        patience=10,
+        alpha=0.01,
+    ):
+        """Train the agent for a fixed number of episodes
+
+        Parameters
+        ----------
+        optimizer : `str`
+            The optimizer for training (e.g., `sgd`). By default it is set to `adam`.
+        loss_fn : `str`
+            The loss function. By default it is set to `mse`.
+        num_episodes : `int`
+            Total number of episodes to train. By default it is set to `50`.
+        num_steps : `int`
+            Steps per episode. By default it is set to `100`. If `num_steps` is less than `self.env.maxlen`, then the second will be chosen.
+        gamma : `float`
+            Discount factor. By default it is set to `0.7`.
+        batch_size : `int`
+            Size of training batches. By default it is set to `32`.
+        patience : `int`
+            How many episodes to wait for improvement.
+        alpha : `float`
+            Trade-off factor between loss and reward.
+        """
+        rewards = []
+        self.best_weights = None
+        self.best_loss = float("inf")
+
+        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(),
+        }
+        self.optimizer = optimizers[optimizer]
+        losses = {
+            "mse": tf.keras.losses.MeanSquaredError(),
+            "mae": tf.keras.losses.MeanAbsoluteError(),
+            "mape": tf.keras.losses.MeanAbsolutePercentageError(),
+        }
+        self.loss_fn = losses[loss_fn]
+        self.num_episodes = num_episodes
+        self.num_steps = num_steps if num_steps >= self.env.maxlen else self.env.maxlen
+        self.gamma = gamma
+        self.batch_size = batch_size
+        loss = float("inf")
+        no_improve_count = 0
+        best_combined_metric = float("inf")
+
+        for episode in range(self.num_episodes):
+            print_progress_bar(episode + 1, self.num_episodes)
+            self.env.reset()
+            sum_rewards = 0
+            epsilon = max(1 - episode / (self.num_episodes * 0.8), 0.01)
+
+            for step in range(self.num_steps):
+                state, action, reward, next_action, done = self.play_one_step(
+                    x_data[step], y_data[step], epsilon
+                )
+                sum_rewards += reward if isinstance(reward, int) else reward[0]
+
+                # Train if buffer has enough samples
+                if len(self.replay_buffer) > self.batch_size:
+                    loss = self._training_step()
+
+                if done:
+                    break
+
+            combined_metric = loss - alpha * sum_rewards
+
+            if combined_metric < best_combined_metric:
+                best_combined_metric = combined_metric
+                self.best_weights = self.model.get_weights()
+                self.best_loss = loss
+                no_improve_count = 0  # Reset counter on improvement
+            else:
+                no_improve_count += 1
+
+            rewards.append(sum_rewards)
+
+            # Logging
+            if episode % (self.num_episodes // 10) == 0:
+                print(
+                    f"Episode: {episode}, Steps: {step+1}, Epsilon: {epsilon:.3f}, Loss: {loss:.2e}, Reward: {sum_rewards}, No Improve Count: {no_improve_count}"
+                )
+
+            # Early stopping condition
+            if no_improve_count >= patience:
+                print(
+                    f"Early stopping at episode {episode} due to no improvement in {patience} episodes."
+                )
+                break
+
+        # Save best model
+        self.model.set_weights(self.best_weights)
+
+    def __str__(self):
+        return (
+            f"AutoQL (Env: {self.env.name}, Episodes: {self.num_episodes}, Steps: {self.num_steps})"
+        )
+
+
+if __name__ == "__main__":
+    pass

likelihood/models/simulation.py

@@ -4,11 +4,15 @@ from typing import Dict, List, Tuple, Union
 
 import numpy as np
 import pandas as pd
+from packaging import version
 from pandas.core.frame import DataFrame
 
 from likelihood.tools import DataScaler, FeatureSelection, OneHotEncoder, cdf, check_nan_inf
 
-warnings.simplefilter("ignore", np.RankWarning)
+if version.parse(np.__version__) < version.parse("2.0.0"):
+    filter = np.RankWarning
+else:
+    filter = np.exceptions.RankWarning
 
 
 # --------------------------------------------------------------------------------------------------------------------------------------
@@ -128,14 +132,15 @@ class SimulationEngine(FeatureSelection):
             )
             poly = kwargs.get("poly", 9)
             plot = kwargs.get("plot", False)
+            bandwidth = kwargs.get("bandwidth", 1.5)
             if not x[1]:
                 media = self.df[key].mean()
                 standard_deviation = self.df[key].std()
-                lower_limit = media - 1.5 * standard_deviation
-                upper_limit = media + 1.5 * standard_deviation
+                lower_limit = media - bandwidth * standard_deviation
+                upper_limit = media + bandwidth * standard_deviation
                 if plot:
                     print(f"Cumulative Distribution Function ({key})")
-                f, cdf_, ox = cdf(x[0].flatten(), poly=poly, plot=plot)
+                f, _, ox = cdf(x[0].flatten(), poly=poly, plot=plot)
             else:
                 f, ox = None, None
                 least_frequent_category, most_frequent_category = categories_by_quartile(

likelihood/tools/models_tools.py

@@ -11,7 +11,7 @@ logging.getLogger("tensorflow").setLevel(logging.ERROR)
 import sys
 import warnings
 from functools import wraps
-from typing import Dict
+from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import tensorflow as tf
@@ -40,6 +40,189 @@ def suppress_warnings(func):
     return wrapper
 
 
+class TransformRange:
+    """
+    Generates a new DataFrame with ranges represented as strings.
+
+    Transforms numerical columns into categorical range bins with descriptive labels.
+    """
+
+    def __init__(self, df: pd.DataFrame) -> None:
+        """Initializes the class with the original DataFrame.
+
+        Parameters
+        ----------
+        df : `pd.DataFrame`
+            The original DataFrame to transform.
+
+        Raises
+        ------
+        TypeError
+            If df is not a pandas DataFrame.
+        """
+        if not isinstance(df, pd.DataFrame):
+            raise TypeError("df must be a pandas DataFrame")
+        self.df = df.copy()  # Create a copy to avoid modifying the original
+
+    def _create_bins_and_labels(
+        self, min_val: Union[int, float], max_val: Union[int, float], bin_size: int
+    ) -> Tuple[np.ndarray, List[str]]:
+        """
+        Creates the bin edges and their labels.
+
+        Parameters
+        ----------
+        min_val : `int` or `float`
+            The minimum value for the range.
+        max_val : `int` or `float`
+            The maximum value for the range.
+        bin_size : `int`
+            The size of each bin.
+
+        Returns
+        -------
+        bins : `np.ndarray`
+            The bin edges.
+        labels : `list`
+            The labels for the bins.
+
+        Raises
+        ------
+        ValueError
+            If bin_size is not positive or if min_val >= max_val.
+        """
+        if bin_size <= 0:
+            raise ValueError("bin_size must be positive")
+        if min_val >= max_val:
+            raise ValueError("min_val must be less than max_val")
+
+        start = int(min_val)
+        end = int(max_val) + bin_size
+
+        bins = np.arange(start, end + 1, bin_size)
+
+        if bins[-1] <= max_val:
+            bins = np.append(bins, max_val + 1)
+
+        labels = [f"{int(bins[i])}-{int(bins[i+1] - 1)}" for i in range(len(bins) - 1)]
+        return bins, labels
+
+    def _transform_column_to_ranges(self, column: str, bin_size: int) -> pd.Series:
+        """
+        Transforms a column in the DataFrame into range bins.
+
+        Parameters
+        ----------
+        column : `str`
+            The name of the column to transform.
+        bin_size : `int`
+            The size of each bin.
+
+        Returns
+        -------
+        `pd.Series`
+            A Series with the range labels.
+
+        Raises
+        ------
+        KeyError
+            If column is not found in the DataFrame.
+        ValueError
+            If bin_size is not positive or if column contains non-numeric data.
+        """
+        if column not in self.df.columns:
+            raise KeyError(f"Column '{column}' not found in DataFrame")
+
+        if bin_size <= 0:
+            raise ValueError("bin_size must be positive")
+
+        numeric_series = pd.to_numeric(self.df[column], errors="coerce")
+        if numeric_series.isna().all():
+            raise ValueError(f"Column '{column}' contains no valid numeric data")
+
+        min_val = numeric_series.min()
+        max_val = numeric_series.max()
+
+        if min_val == max_val:
+            return pd.Series(
+                [f"{int(min_val)}-{int(max_val)}"] * len(self.df), name=f"{column}_range"
+            )
+
+        bins, labels = self._create_bins_and_labels(min_val, max_val, bin_size)
+
+        return pd.cut(numeric_series, bins=bins, labels=labels, right=False, include_lowest=True)
+
+    def transform_dataframe(
+        self, columns_bin_sizes: Dict[str, int], drop_original: bool = False
+    ) -> pd.DataFrame:
+        """
+        Creates a new DataFrame with range columns.
+
+        Parameters
+        ----------
+        columns_bin_sizes : `dict`
+            A dictionary where the keys are column names and the values are the bin sizes.
+        drop_original : `bool`, optional
+            If True, drops original columns from the result, by default False
+
+        Returns
+        -------
+        `pd.DataFrame`
+            A DataFrame with the transformed range columns.
+
+        Raises
+        ------
+        TypeError
+            If columns_bin_sizes is not a dictionary.
+        """
+        if not isinstance(columns_bin_sizes, dict):
+            raise TypeError("columns_bin_sizes must be a dictionary")
+
+        if not columns_bin_sizes:
+            return pd.DataFrame()
+
+        range_columns = {}
+        for column, bin_size in columns_bin_sizes.items():
+            range_columns[f"{column}_range"] = self._transform_column_to_ranges(column, bin_size)
+
+        result_df = pd.DataFrame(range_columns)
+
+        if not drop_original:
+            original_cols = [col for col in self.df.columns if col not in columns_bin_sizes]
+            if original_cols:
+                result_df = pd.concat([self.df[original_cols], result_df], axis=1)
+
+        return result_df
+
+    def get_range_info(self, column: str) -> Dict[str, Union[int, float, List[str]]]:
+        """
+        Get information about the range transformation for a specific column.
+
+        Parameters
+        ----------
+        column : `str`
+            The name of the column to analyze.
+
+        Returns
+        -------
+        `dict`
+            Dictionary containing min_val, max_val, bin_size, and labels.
+        """
+        if column not in self.df.columns:
+            raise KeyError(f"Column '{column}' not found in DataFrame")
+
+        numeric_series = pd.to_numeric(self.df[column], errors="coerce")
+        min_val = numeric_series.min()
+        max_val = numeric_series.max()
+
+        return {
+            "min_value": min_val,
+            "max_value": max_val,
+            "range": max_val - min_val,
+            "column": column,
+        }
+
+
 def remove_collinearity(df: DataFrame, threshold: float = 0.9):
     """
     Removes highly collinear features from the DataFrame based on a correlation threshold.
@@ -56,8 +239,8 @@ def remove_collinearity(df: DataFrame, threshold: float = 0.9):
         The correlation threshold above which features will be removed. Default is `0.9`.
 
     Returns
-    ----------
-        DataFrame: A DataFrame with highly collinear features removed.
+    -------
+        DataFrame : A DataFrame with highly collinear features removed.
     """
     corr_matrix = df.corr().abs()
     upper_triangle = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
@@ -97,11 +280,11 @@ def train_and_insights(
         Fraction of data to use (default is 1.0).
 
     Keyword Arguments:
-    ----------
+    ------------------
     Additional keyword arguments passed to the `model.fit` function, such as validation split and callbacks.
 
     Returns
-    ----------
+    -------
     `tf.keras.Model`
         The trained model after fitting.
     """
@@ -207,7 +390,7 @@ def graph_metrics(adj_matrix: np.ndarray, eigenvector_threshold: float = 1e-6) -
         A threshold for the eigenvector centrality calculation, used to determine the cutoff for small eigenvalues. Default is `1e-6`.
 
     Returns
-    ----------
+    -------
     DataFrame : A DataFrame containing the following graph metrics as columns.
         - `Degree Centrality`: Degree centrality values for each node, indicating the number of direct connections each node has.
         - `Clustering Coefficient`: Clustering coefficient values for each node, representing the degree to which nodes cluster together.
@@ -218,7 +401,7 @@ def graph_metrics(adj_matrix: np.ndarray, eigenvector_threshold: float = 1e-6) -
         - `Assortativity`: The assortativity coefficient of the graph, measuring the tendency of nodes to connect to similar nodes.
 
     Notes
-    ----------
+    -----
     The returned DataFrame will have one row for each node and one column for each of the computed metrics.
     """
     adj_matrix = adj_matrix.astype(int)
@@ -251,3 +434,7 @@ def graph_metrics(adj_matrix: np.ndarray, eigenvector_threshold: float = 1e-6) -
     metrics_df["Assortativity"] = assortativity
 
     return metrics_df
+
+
+if __name__ == "__main__":
+    pass