#13 Update API

Author: pockerman

README.md

@@ -16,5 +16,9 @@ to use the reinforcement learning paradigm in order to train agents to perform t
 places this into a persepctive 
 
 
-![RL anonymity paradigm](images/general_concept.png "Reinforcement learning anonymity schematics") 
+![RL anonymity paradigm](images/general_concept.png "Reinforcement learning anonymity schematics")
+
+## Dependencies 
+
+## Documentation
 

src/algorithms/trainer.py

@@ -50,10 +50,6 @@ def train(self):
             self.iterations_per_episode.append(n_itrs)
             self.total_rewards[episode] = episode_score
 
-            # is it time to update the model?
-            if self.configuration["update_frequency"] % episode == 0:
-                self.agent.update()
-
             self.actions_after_episode_ends(**{"episode_idx": episode})
 
         print("{0} Training finished for agent {1}".format(INFO, self.agent.name))

src/apps/qlearning_on_mock.py

@@ -65,9 +65,9 @@
 
     agent = QLearning(algo_config=algo_config)
 
-    configuration = {"n_episodes": 10, "update_frequency": 100}
+    configuration = {"n_episodes": 10, "output_msg_frequency": 100}
 
     # create a trainer to train the A2C agent
     trainer = Trainer(env=env, agent=agent, configuration=configuration)
 
-    trainer.train()
+    trainer.train()

src/datasets/dataset_information_leakage.py

@@ -1,4 +1,46 @@
 """
 Utilities for calculating the information leakage
 for a dataset
-"""
+"""
+import numpy as np
+from typing import TypeVar
+from src.exceptions.exceptions import InvalidSchemaException
+from src.datasets.dataset_distances import lp_distance
+
+DataSet = TypeVar("DataSet")
+
+
+def info_leakage(ds1: DataSet, ds2: DataSet, column_distances: dict = None, p=None) -> tuple:
+    """
+    Returns the information leakage between the two data sets
+    :param ds1:
+    :param ds2:
+    :param column_dists: A dictionary that holds numeric distances to use if a column
+    is of type string
+    :return:
+    """
+
+    if ds1.schema != ds2.schema:
+        raise InvalidSchemaException(message="Invalid schema for datasets")
+
+    if column_distances is None:
+        return lp_distance(ds1=ds1, ds2=ds2, p=p)
+
+    distances = {}
+    cols = ds1.get_columns_names()
+    for col in cols:
+
+        if col in column_distances:
+            # get the total distortion of the column
+            distances[col] = column_distances[col]
+        else:
+
+            val1 = ds1.get_column(col_name=col)
+            val2 = ds2.get_column(col_name=col)
+            distances[col] = np.linalg.norm(val1 - val2, ord=p)
+
+    sum_distances = sum(distances.values())
+    return distances, sum_distances
+
+
+

src/exceptions/exceptions.py

@@ -23,5 +23,15 @@ def __str__(self):
         return self.message
 
 
+class InvalidSchemaException(Exception):
+    def __init__(self, message: str) -> None:
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+
+
+
 
 

src/policies/deterministic_policy.py

@@ -1,12 +1,10 @@
 import numpy as np
 from typing import TypeVar
 
-from src.policies.policy_adaptor_base import PolicyAdaptorBase
-
 PolicyBase = TypeVar('PolicyBase')
 
 
-class DeterministicAdaptorPolicy(PolicyAdaptorBase):
+class DeterministicAdaptorPolicy(object):
 
     """
     Update a policy by choosing the best action

src/policies/epsilon_greedy_policy.py

@@ -11,6 +11,7 @@
 
 UserDefinedDecreaseMethod = TypeVar('UserDefinedDecreaseMethod')
 Env = TypeVar("Env")
+QTable = TypeVar("QTable")
 
 
 class EpsilonDecreaseOption(Enum):
@@ -41,7 +42,13 @@ def __init__(self, env: Env, eps: float,
         self._epsilon_decay_factor = epsilon_decay_factor
         self.user_defined_decrease_method: UserDefinedDecreaseMethod = user_defined_decrease_method
 
-    def __call__(self, q_func: Any, state: Any) -> int:
+    def __call__(self, q_func: QTable, state: Any) -> int:
+        """
+        Execute the policy
+        :param q_func:
+        :param state:
+        :return:
+        """
 
         # select greedy action with probability epsilon
         if random.random() > self._eps:

src/spaces/action_space.py

@@ -37,13 +37,28 @@ def __setitem__(self, key: int, value: ActionBase) -> None:
         """
         self.actions[key] = value
 
-    def add(self, action: ActionBase) -> None:
+    def get_action_by_column_name(self, column_name: str) -> ActionBase:
         """
-        Add a new action in the space
-        :param action:
-        :return:
+        Get the action that corresponds to the column with
+        the given name. Raises ValueError if such an action does not
+        exist
+        :param column_name: The column name to look for
+        :return: The action that corresponds to this name
         """
 
+        for action in self.actions:
+            if action.column_name == column_name:
+                return action
+
+        raise ValueError("No action exists for column={0}".format(column_name))
+
+    def add(self, action: ActionBase) -> None:
+        """
+        Add a new action in the space. Throws ValueError if the action space
+        is full
+        :param action: the action to add
+        :return: None
+        """
         if len(self.actions) >= self.n:
             raise ValueError("Action space is saturated. You cannot add a new action")
 
@@ -69,24 +84,32 @@ def sample_and_get(self) -> ActionBase:
         return self.actions[action_idx]
 
     def get_non_exhausted_actions(self) -> list:
-
+        """
+        Returns a list of actions that have not exhausted the
+        transformations that apply on a column.
+        :return: list of actions. List may be empty. Client code should handle this
+        """
         actions_ = []
-
         for action in self.actions:
             if not action.is_exhausted():
                 actions_.append(action)
 
         return actions_
 
     def sample_and_get_non_exhausted(self) -> ActionBase:
-
+        """
+        Sample an action from the non exhausted actions
+        :return: A non-exhausted action
+        """
         actions = self.get_non_exhausted_actions()
         return np.random.choice(actions)
 
-    def is_exhausted(self):
-
+    def is_exhausted(self) -> bool:
+        """
+        Returns true if all the actions in the space are exhausted
+        :return:
+        """
         finished = True
-
         for action in self.actions:
             if not action.is_exhausted():
                 return False
@@ -99,5 +122,5 @@ def reset(self) -> None:
         :return:
         """
         for action in self.actions:
-            action.reinit()
+            action.reinitialize()
 

src/spaces/actions.py

@@ -74,7 +74,7 @@ def is_exhausted(self) -> bool:
         """
 
     @abc.abstractmethod
-    def reinit(self) -> None:
+    def reinitialize(self) -> None:
         """
         Reinitialize the action to the state when the
         constructor is called
@@ -113,7 +113,7 @@ def is_exhausted(self) -> bool:
         """
         return self.called
 
-    def reinit(self) -> None:
+    def reinitialize(self) -> None:
         """
         Reinitialize the action to the state when the
         constructor is called
@@ -123,7 +123,6 @@ def reinit(self) -> None:
 
 
 class ActionTransform(ActionBase):
-
     """
     Implements the transform action
     """
@@ -152,7 +151,7 @@ def is_exhausted(self) -> bool:
         """
         raise NotImplementedError("Method not implemented")
 
-    def reinit(self) -> None:
+    def reinitialize(self) -> None:
         """
         Reinitialize the action to the state when the
         constructor is called
@@ -162,7 +161,6 @@ def reinit(self) -> None:
 
 
 class ActionSuppress(ActionBase, WithHierarchyTable):
-
     """
     Implements the suppress action
     """
@@ -219,7 +217,7 @@ def is_exhausted(self) -> bool:
         """
         return self.finished()
 
-    def reinit(self) -> None:
+    def reinitialize(self) -> None:
         """
         Reinitialize the action to the state when the
         constructor is called
@@ -291,7 +289,7 @@ def is_exhausted(self) -> bool:
         """
         return self.finished()
 
-    def reinit(self) -> None:
+    def reinitialize(self) -> None:
         """
         Reinitialize the action to the state when the
         constructor is called