likelihood 1.5.8__py3-none-any.whl → 2.0.0__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/tools.py

@@ -8,10 +8,15 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import yaml
+from packaging import version
 from pandas.core.frame import DataFrame
 
-# Suppress RankWarning
-warnings.simplefilter("ignore", np.RankWarning)
+if version.parse(np.__version__) < version.parse("2.0.0"):
+    filter = np.RankWarning
+else:
+    filter = np.exceptions.RankWarning
+
+warnings.simplefilter("ignore", filter)
 
 # -------------------------------------------------------------------------
 

{likelihood-1.5.8.dist-info → likelihood-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: likelihood
-Version: 1.5.8
+Version: 2.0.0
 Summary: A package that performs the maximum likelihood algorithm.
 Home-page: https://github.com/jzsmoreno/likelihood/
 Author: J. A. Moreno-Guerra
@@ -20,9 +20,10 @@ 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: numpy<3.0.0,>=1.26.4
 Requires-Dist: pydot==2.0.0
 Requires-Dist: matplotlib
+Requires-Dist: packaging
 Requires-Dist: graphviz
 Requires-Dist: seaborn
 Requires-Dist: pyyaml
@@ -32,7 +33,7 @@ Requires-Dist: tqdm
 Provides-Extra: full
 Requires-Dist: networkx; extra == "full"
 Requires-Dist: pyvis; extra == "full"
-Requires-Dist: tensorflow==2.15.0; extra == "full"
+Requires-Dist: tensorflow>=2.15.0; extra == "full"
 Requires-Dist: keras-tuner; extra == "full"
 Requires-Dist: scikit-learn; extra == "full"
 Dynamic: author

likelihood-2.0.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+likelihood/__init__.py,sha256=5C0hapdsk85XZhN_rssRAEFpkRRuKNtj6cyRbqD2_gM,994
+likelihood/main.py,sha256=fcCkGOOWKjfvw2tLVqjuKPV8t0rVCIT9FlbYcOv4EYo,7974
+likelihood/graph/__init__.py,sha256=vUY4pKlnm3eSVTXd2d-5JDPawhqGNRIKRhaHIobsNws,188
+likelihood/graph/_nn.py,sha256=Sh7dRz8QSI08Ydfw9e--uCxc4KMtHUsCz_-C-loXklQ,13883
+likelihood/graph/graph.py,sha256=bLrNMvIh7GOTdPTwnNss8oPZ7cbSHQScAsH_ttmVUK0,3294
+likelihood/graph/nn.py,sha256=uxCxGt1suKmThmEjFope2ew93-WlgvGhgr6RVCHwzhM,11420
+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=xsl4mJ2qFCuZR_B9LfQcLjV6OtONU1zyESX3CCUfOiw,8619
+likelihood/models/utils.py,sha256=dvigPi_hxcs5ntfHr7Y1JvP5ULtMW3kkN0nJpS4orE8,1319
+likelihood/models/deep/__init__.py,sha256=I55FciI0BfljYdhW2OGNqcpYV57FhPZETZX7Y1y9GVQ,303
+likelihood/models/deep/_autoencoders.py,sha256=CeD79YzU7DdPd92wUNG_EtPVQOBgsgYoC4uS2JF3b6o,30939
+likelihood/models/deep/_predictor.py,sha256=XI4QfVM7PS_60zYtmi-V8UzNDrASFiDMVPmV17BB8lM,27984
+likelihood/models/deep/autoencoders.py,sha256=muUBH9BclOK8ViI7PijyMOBBLVox6uwuIabyJvpU5qw,30729
+likelihood/models/deep/gan.py,sha256=rTnaLmIPjsKg6_0B8JZOVwPxdx59rHmqvzDitdJMCQ4,10924
+likelihood/models/deep/predictor.py,sha256=q5tPaAbF7s5XIcxVr6fyHTQdZa9tlixO9vb9a9Cw0wM,27831
+likelihood/models/deep/rl.py,sha256=9dhhnVTIETi9zvVeyOXYo1hl-LQJezmv0rgsUq11Qwc,11611
+likelihood/tools/__init__.py,sha256=N1IhMDzacsGQT2MIYBMBC0zTxes78vC_0gGrwkuPgmg,78
+likelihood/tools/cat_embed.py,sha256=SJ7o1vbrNYp21fLLcjRnWpUDcz1nVSe8TmMvsLIz5CI,7346
+likelihood/tools/figures.py,sha256=waF0NHIMrctCmaLhcuz5DMcXyRKynmn6aG0XITYCTLc,10940
+likelihood/tools/impute.py,sha256=n87Tv-xLUAdPl7BQLFcLWSsXBZbXksahyCayJWMydXc,9485
+likelihood/tools/models_tools.py,sha256=c3-vac-1MYSarYDtfR6XfVC7X_WY9auS7y2_3Z973IQ,8875
+likelihood/tools/numeric_tools.py,sha256=Hwf-lbqROqPPZ9N7eVzKIDyZxFGQdP53isWxPqpG0eo,12254
+likelihood/tools/tools.py,sha256=GKZsqjyO5tGXWGSfn3jlQBTjRlmBv2byfvpu-QclUx0,42188
+likelihood-2.0.0.dist-info/licenses/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
+likelihood-2.0.0.dist-info/METADATA,sha256=Ziysy1MQuW77OHHd1UzMtlfeUT9wsdgCl6rxW3uLBEE,2917
+likelihood-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+likelihood-2.0.0.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
+likelihood-2.0.0.dist-info/RECORD,,

likelihood-1.5.8.dist-info/RECORD

@@ -1,26 +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=bLrNMvIh7GOTdPTwnNss8oPZ7cbSHQScAsH_ttmVUK0,3294
-likelihood/graph/nn.py,sha256=uxCxGt1suKmThmEjFope2ew93-WlgvGhgr6RVCHwzhM,11420
-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=6OD2IXAnbctxtOzUJ2b9vKW7_tdGs4dQYmQQShqsioA,8443
-likelihood/models/utils.py,sha256=dvigPi_hxcs5ntfHr7Y1JvP5ULtMW3kkN0nJpS4orE8,1319
-likelihood/models/deep/__init__.py,sha256=UV_VYhySvrNnB4a0VXYM4wK3KKF7ytjLFFfwvnaZWaA,82
-likelihood/models/deep/autoencoders.py,sha256=02sgVTB-78DNUndyrzFGoiNZAY87KF953C-bdB2Dj3I,30731
-likelihood/models/deep/gan.py,sha256=prLgKEoJu6NdvT_ICfn7rBdjppga2LlvDRsTjVA8Ug0,10922
-likelihood/models/deep/predictor.py,sha256=Q9-PsgcViTDXm52h67Qdjd3HbjpLlXyAPxSqioUvgiA,27778
-likelihood/tools/__init__.py,sha256=N1IhMDzacsGQT2MIYBMBC0zTxes78vC_0gGrwkuPgmg,78
-likelihood/tools/cat_embed.py,sha256=SJ7o1vbrNYp21fLLcjRnWpUDcz1nVSe8TmMvsLIz5CI,7346
-likelihood/tools/figures.py,sha256=waF0NHIMrctCmaLhcuz5DMcXyRKynmn6aG0XITYCTLc,10940
-likelihood/tools/impute.py,sha256=n87Tv-xLUAdPl7BQLFcLWSsXBZbXksahyCayJWMydXc,9485
-likelihood/tools/models_tools.py,sha256=c3-vac-1MYSarYDtfR6XfVC7X_WY9auS7y2_3Z973IQ,8875
-likelihood/tools/numeric_tools.py,sha256=Hwf-lbqROqPPZ9N7eVzKIDyZxFGQdP53isWxPqpG0eo,12254
-likelihood/tools/tools.py,sha256=lk9BIskjUKYQ1XVwARm9jAjHuLQ4UO68aZY8oxkzk5c,42056
-likelihood-1.5.8.dist-info/licenses/LICENSE,sha256=XWHWt9egYEUHGPTnlcZfJKLPmysacOwdiLj_-J7Z9ew,1066
-likelihood-1.5.8.dist-info/METADATA,sha256=RmHunm_vrHb6AbiVasPO4J3GogK7U2lEpmwqVr8QU0E,2883
-likelihood-1.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-likelihood-1.5.8.dist-info/top_level.txt,sha256=KDiBLr870YTxqLFqObTOSrTK10uw8dFsITSNLlte3PA,11
-likelihood-1.5.8.dist-info/RECORD,,