API updates

Author: pockerman

src/algorithms/trainer.py

@@ -2,8 +2,9 @@
 Trainer
 """
 
-from src.utils import INFO
+import numpy as np
 from typing import TypeVar
+from src.utils import INFO
 
 Env = TypeVar("Env")
 Agent = TypeVar("Agent")
@@ -15,22 +16,44 @@ def __init__(self, env: Env,  agent: Agent, configuration: dir) -> None:
         self.env = env
         self.agent = agent
         self.configuration = configuration
+        # monitor performance
+        self.total_rewards: np.array = None
+        self.iterations_per_episode = []
+
+    def actions_before_training(self):
+        self.total_rewards: np.array = np.zeros(self.configuration['n_episodes'])
+        self.iterations_per_episode = []
+
+        self.agent.actions_before_training(self.env)
+
+    def actions_after_episode_ends(self, **options):
+        self.agent.actions_after_episode_ends(**options)
 
     def train(self):
 
         print("{0} Training agent {1}".format(INFO, self.agent.name))
+        self.actions_before_training()
 
-        for episode in range(1, self.configuration["max_n_episodes"] + 1):
-            print("INFO: Episode {0}/{1}".format(episode, self.configuration["max_n_episodes"]))
+        for episode in range(0, self.configuration["n_episodes"]):
+            print("INFO: Episode {0}/{1}".format(episode, self.configuration["n_episodes"]))
 
             # reset the environment
             ignore = self.env.reset()
 
             # train for a number of iterations
-            self.agent.train(self.env)
+            episode_score, n_itrs = self.agent.train(self.env)
+
+            if episode % self.configuration['output_msg_frequency'] == 0:
+                print("{0}: On episode {1} training finished with  "
+                      "{2} iterations. Total reward={3}".format(INFO, episode, n_itrs, episode_score))
+
+            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/datasets/dataset_wrapper.py

@@ -80,7 +80,20 @@ def read(self, filename: Path,  **options) -> None:
         # try to cast to the data types
         self.ds = change_column_types(ds=self.ds, column_types=self.columns)
 
+    def sample_column_name(self) -> str:
+        """
+        Samples a name from the columns
+        :return: a column name
+        """
+        names = self.get_columns_names()
+        return np.random.choice(names)
+
     def set_columns_to_type(self, col_name_types) -> None:
+        """
+        Set the types of the columns
+        :param col_name_types:
+        :return:
+        """
         self.ds.astype(dtype=col_name_types)
 
     def attach_column_hierarchy(self, col_name: str, hierarchy: HierarchyBase):

src/exceptions/exceptions.py

@@ -15,3 +15,13 @@ def __str__(self):
         return self.message
 
 
+class InvalidParamValue(Exception):
+    def __init__(self, param_name: str, param_value: str):
+        self.message = "Parameter {0} has invalid value {1}".format(param_name, param_value)
+
+    def __str__(self):
+        return self.message
+
+
+
+

src/spaces/action_space.py

@@ -3,6 +3,7 @@
 actions in the actions.py module
 """
 
+import numpy as np
 from gym.spaces.discrete import Discrete
 from src.spaces.actions import ActionBase
 
@@ -66,3 +67,37 @@ def sample_and_get(self) -> ActionBase:
         """
         action_idx = self.sample()
         return self.actions[action_idx]
+
+    def get_non_exhausted_actions(self) -> list:
+
+        actions_ = []
+
+        for action in self.actions:
+            if not action.is_exhausted():
+                actions_.append(action)
+
+        return actions_
+
+    def sample_and_get_non_exhausted(self) -> ActionBase:
+
+        actions = self.get_non_exhausted_actions()
+        return np.random.choice(actions)
+
+    def is_exhausted(self):
+
+        finished = True
+
+        for action in self.actions:
+            if not action.is_exhausted():
+                return False
+
+        return finished
+
+    def reset(self) -> None:
+        """
+        Reset every action in the action space
+        :return:
+        """
+        for action in self.actions:
+            action.reinit()
+

src/spaces/actions.py

@@ -3,6 +3,18 @@
 from typing import List
 
 from src.utils.hierarchy_base import HierarchyBase
+from src.utils.mixins import WithHierarchyTable
+
+
+def move_next(iterators: List) -> None:
+    """
+    Loop over the iterators and move them
+    to the next item
+    :param iterators: The list of iterators to propagate
+    :return: None
+    """
+    for item in iterators:
+        next(item)
 
 
 class ActionType(enum.IntEnum):
@@ -47,39 +59,27 @@ def act(self, **ops) -> None:
         """
 
     @abc.abstractmethod
-    def get_maximum_number_of_transforms(self):
+    def get_maximum_number_of_transforms(self) -> int:
         """
         Returns the maximum number of transforms that the action applies
         :return:
         """
 
+    @abc.abstractmethod
+    def is_exhausted(self) -> bool:
+        """
+        Returns true if the action has exhausted all its
+        transforms
+        :return:
+        """
 
-def move_next(iterators: List) -> None:
-    """
-    Loop over the iterators and move them
-    to the next item
-    :param iterators: The list of iterators to propagate
-    :return: None
-    """
-    for item in iterators:
-        next(item)
-
-
-class _WithTable(object):
-
-    def __init__(self) -> None:
-        super(_WithTable, self).__init__()
-        self.table = {}
-        self.iterators = []
-
-    def add_hierarchy(self, key: str, hierarchy: HierarchyBase) -> None:
+    @abc.abstractmethod
+    def reinit(self) -> None:
         """
-        Add a hierarchy for the given key
-        :param key: The key to attach the Hierarchy
-        :param hierarchy: The hierarchy to attach
-        :return: None
+        Reinitialize the action to the state when the
+        constructor is called
+        :return:
         """
-        self.table[key] = hierarchy
 
 
 class ActionIdentity(ActionBase):
@@ -89,13 +89,14 @@ class ActionIdentity(ActionBase):
 
     def __init__(self, column_name: str) -> None:
         super(ActionIdentity, self).__init__(column_name=column_name, action_type=ActionType.IDENTITY)
+        self.called = False
 
-    def act(self, **ops):
+    def act(self, **ops) -> None:
         """
         Perform the action
         :return:
         """
-        pass
+        self.called = True
 
     def get_maximum_number_of_transforms(self):
         """
@@ -104,6 +105,22 @@ def get_maximum_number_of_transforms(self):
         """
         return 1
 
+    def is_exhausted(self) -> bool:
+        """
+        Returns true if the action has exhausted all its
+        transforms
+        :return:
+        """
+        return self.called
+
+    def reinit(self) -> None:
+        """
+        Reinitialize the action to the state when the
+        constructor is called
+        :return:
+        """
+        self.called = False
+
 
 class ActionTransform(ActionBase):
 
@@ -127,17 +144,32 @@ def get_maximum_number_of_transforms(self):
         """
         raise NotImplementedError("Method not implemented")
 
+    def is_exhausted(self) -> bool:
+        """
+        Returns true if the action has exhausted all its
+        transforms
+        :return:
+        """
+        raise NotImplementedError("Method not implemented")
+
+    def reinit(self) -> None:
+        """
+        Reinitialize the action to the state when the
+        constructor is called
+        :return:
+        """
+        raise NotImplementedError("Method not implemented")
+
 
-class ActionSuppress(ActionBase, _WithTable):
+class ActionSuppress(ActionBase, WithHierarchyTable):
 
     """
     Implements the suppress action
     """
     def __init__(self, column_name: str, suppress_table=None):
         super(ActionSuppress, self).__init__(column_name=column_name, action_type=ActionType.SUPPRESS)
 
-        if suppress_table is not None:
-            self.table = suppress_table
+        self.table = suppress_table
 
         # fill in the iterators
         self.iterators = [iter(self.table[item]) for item in self.table]
@@ -148,16 +180,21 @@ def act(self, **ops) -> None:
         :return: None
         """
 
+        # get the values of the column
+        col_vals = ops['data'].values
+
         # generalize the data given
         for i, item in enumerate(ops["data"]):
+            value = self.table[item].value
+            col_vals[i] = value
 
-            if item in self.table:
-                value = self.table[item].value
-                item = value
-                ops["data"][i] = value
+        ops["data"] = col_vals
 
-        # update the generalization
+        # update the generalization iterators
+        # so next time we visit we update according to
+        # the new values
         move_next(iterators=self.iterators)
+        return ops['data']
 
     def get_maximum_number_of_transforms(self):
         """
@@ -174,17 +211,32 @@ def get_maximum_number_of_transforms(self):
 
         return max_transform
 
+    def is_exhausted(self) -> bool:
+        """
+        Returns true if the action has exhausted all its
+        transforms
+        :return:
+        """
+        return self.finished()
+
+    def reinit(self) -> None:
+        """
+        Reinitialize the action to the state when the
+        constructor is called
+        :return:
+        """
+        self.reset_iterators()
 
-class ActionGeneralize(ActionBase, _WithTable):
+
+class ActionGeneralize(ActionBase, WithHierarchyTable):
     """
     Implements the generalization action
     """
 
     def __init__(self, column_name: str, generalization_table: dict = None):
         super(ActionGeneralize, self).__init__(column_name=column_name, action_type=ActionType.GENERALIZE)
 
-        if generalization_table is not None:
-            self.table = generalization_table
+        self.table = generalization_table
 
         # fill in the iterators
         self.iterators = [iter(self.table[item]) for item in self.table]
@@ -201,7 +253,6 @@ def act(self, **ops):
         # generalize the data given
         for i, item in enumerate(col_vals):
 
-            #print(item)
             # How do we update the generalizations?
             value = self.table[item].value
             col_vals[i] = value
@@ -232,6 +283,22 @@ def get_maximum_number_of_transforms(self):
 
         return max_transform
 
+    def is_exhausted(self) -> bool:
+        """
+        Returns true if the action has exhausted all its
+        transforms
+        :return:
+        """
+        return self.finished()
+
+    def reinit(self) -> None:
+        """
+        Reinitialize the action to the state when the
+        constructor is called
+        :return:
+        """
+        self.reset_iterators()
+