#13 Update API

Author: pockerman

src/apps/qlearning_on_mock.py

@@ -2,12 +2,13 @@
 from src.algorithms.trainer import Trainer
 from src.utils.string_distance_calculator import DistanceType
 from src.spaces.actions import ActionSuppress, ActionIdentity, ActionGeneralize, ActionTransform
-from src.spaces.environment import Environment
+from src.spaces.environment import Environment, EnvConfig
 from src.spaces.action_space import ActionSpace
 from src.datasets.datasets_loaders import MockSubjectsLoader
 from src.utils.reward_manager import RewardManager
 from src.policies.epsilon_greedy_policy import EpsilonGreedyPolicy, EpsilonDecreaseOption
 from src.utils.serial_hierarchy import SerialHierarchy
+from src.utils.numeric_distance_type import NumericDistanceType
 
 
 if __name__ == '__main__':
@@ -47,12 +48,23 @@
                           ActionIdentity(column_name="salary"), ActionIdentity(column_name="education"),
                           ActionGeneralize(column_name="ethnicity", generalization_table=generalization_table))
 
+    average_distortion_constraint = {"salary": [0.0, 0.0, 0.0], "education": [0.0, 0.0, 0.0],
+                                     "ethnicity": [3.0, 1.0, -1.0], "gender": [4.0, 1.0, -1.0]}
+
     # specify the reward manager to use
-    reward_manager = RewardManager()
+    reward_manager = RewardManager(average_distortion_constraint=average_distortion_constraint)
+
+    env_config = EnvConfig()
+    env_config.start_column = "gender"
+    env_config.action_space = action_space
+    env_config.reward_manager = reward_manager
+    env_config.data_set = ds
+    env_config.gamma = 0.99
+    env_config.numeric_column_distortion_metric_type = NumericDistanceType.L2
 
     # create the environment
-    env = Environment(data_set=ds, action_space=action_space,
-                      gamma=0.99, start_column="gender", reward_manager=reward_manager)
+    env = Environment(env_config=env_config)
+
     # initialize text distances
     env.initialize_text_distances(distance_type=DistanceType.COSINE)
 

src/datasets/dataset_information_leakage.py

@@ -4,10 +4,22 @@
 """
 import numpy as np
 from typing import TypeVar
-from src.exceptions.exceptions import InvalidSchemaException
+from src.exceptions.exceptions import InvalidSchemaException, Error
 from src.datasets.dataset_distances import lp_distance
+from src.utils import numeric_distance_type
 
 DataSet = TypeVar("DataSet")
+State = TypeVar("State")
+
+
+def state_leakage(state1: State, state2: State, dist_type: numeric_distance_type.NumericDistanceType) -> float:
+
+    if dist_type == numeric_distance_type.NumericDistanceType.L2:
+        return _l2_state_leakage(state1=state1, state2=state2)
+    elif dist_type == numeric_distance_type.NumericDistanceType.L1:
+        return _l1_state_leakage(state1=state1, state2=state2)
+
+    raise Error("Invalid distance type {0}".format(dist_type.name))
 
 
 def info_leakage(ds1: DataSet, ds2: DataSet, column_distances: dict = None, p=None) -> tuple:
@@ -43,4 +55,14 @@ def info_leakage(ds1: DataSet, ds2: DataSet, column_distances: dict = None, p=No
     return distances, sum_distances
 
 
+def _l2_state_leakage(state1: State, state2: State) -> float:
+    return np.linalg.norm(state1 - state2, ord=None)
+
+def _l1_state_leakage(state1: State, state2: State) -> float:
+    return np.linalg.norm(state1 - state2, ord=1)
+
+
+
+
+
 

src/spaces/environment.py

@@ -15,6 +15,8 @@
 from src.spaces.actions import ActionBase, ActionType
 from src.spaces.state_space import StateSpace, State
 from src.utils.string_distance_calculator import DistanceType, TextDistanceCalculator
+from src.utils.numeric_distance_type import NumericDistanceType
+from src.datasets.dataset_information_leakage import state_leakage
 
 DataSet = TypeVar("DataSet")
 RewardManager = TypeVar("RewardManager")
@@ -77,6 +79,7 @@ def __init__(self):
         self.average_distortion_constraint: float = 0
         self.start_column: str = "None_Column"
         self.gamma: float = 0.99
+        self.numeric_column_distortion_metric_type: NumericDistanceType = NumericDistanceType.INVALID
 
 
 class Environment(object):
@@ -99,6 +102,7 @@ def __init__(self, env_config: EnvConfig):
         self.state_space = StateSpace()
         self.distance_calculator = None
         self.reward_manager: RewardManager = env_config.reward_manager
+        self.numeric_column_distortion_metric_type = env_config.numeric_column_distortion_metric_type
 
         # initialize the state space
         self.state_space.init_from_environment(env=self)
@@ -219,15 +223,26 @@ def prepare_column_state(self, column_name):
             start_column = self.start_ds.get_column(col_name=column_name)
 
             row_count = 0
-            print("Distance {0} ".format(self.distance_calculator.calculate(txt1="".join(current_column.values),
-                                                                            txt2="".join(start_column.values))))
 
+            # join the column to calculate the distance
             self.column_distances[column_name] = self.distance_calculator.calculate(txt1="".join(current_column.values),
                                                                                     txt2="".join(start_column.values))
-            #for item1, item2 in zip(current_column.values, start_column.values):
-            #    #self.column_distances[column_name][row_count] = self.distance_calculator.calculate(txt1=item1, txt2=item2)
 
-            #    row_count += 1
+    def get_state_distortion(self, state_name) -> float:
+        """
+        Returns the distortion for the state with the given name
+        :param state_name:
+        :return:
+        """
+        if self.start_ds.columns[state_name] == str:
+            return self.column_distances[state_name]
+        else:
+
+            current_column = self.data_set.get_column(col_name=state_name)
+            start_column = self.start_ds.get_column(col_name=state_name)
+
+            return state_leakage(state1=current_column,
+                                 state2=start_column, dist_type=self.numeric_column_distortion_metric_type)
 
     def prepare_columns_state(self):
         """
@@ -299,6 +314,7 @@ def apply_action(self, action: ActionBase):
         :return:
         """
 
+        # nothing to act on identity
         if action.action_type == ActionType.IDENTITY:
             return
 
@@ -333,14 +349,17 @@ def step(self, action: ActionBase) -> TimeStep:
         # update the state space
         self.state_space.update_state(state_name=action.column_name, status=action.action_type)
 
+        # prepare the column state. We only do work
+        # if the column is a string
         self.prepare_column_state(column_name=action.column_name)
 
         # perform the action on the data set
         #self.prepare_columns_state()
 
         # calculate the information leakage and establish the reward
         # to return to the agent
-        reward = self.reward_manager.get_state_reward(self.state_space, action)
+        state_distortion = self.get_state_distortion(state_name=action.column_name)
+        reward = self.reward_manager.get_state_reward(action.column_name, action, state_distortion)
 
         # what is the next state? maybe do it randomly?
         # or select the next column in the dataset

src/utils/reward_manager.py

@@ -2,13 +2,34 @@
 Various utilities to handle reward assignment
 """
 
+from typing import TypeVar
+
+
+State = TypeVar("State")
+Action = TypeVar("Action")
+
 
 class RewardManager(object):
     """
     Helper class to assign rewards
     """
-    def __init__(self) -> None:
-        pass
+    def __init__(self, average_distortion_constraint: dict) -> None:
+        self.average_distortion_constraint: dict = average_distortion_constraint
+
+    def get_state_reward(self, state_name: str, action: Action, state_distortion: float) -> float:
+        """
+        Returns the reward associated with the action
+        applied
+        :param options:
+        :return:
+        """
+
+        if state_name not in self.average_distortion_constraint:
+            raise KeyError("state {0} does not exist".format(state_name))
+
+        state_rewards = self.average_distortion_constraint[state_name]
+
+        if state_distortion < state_rewards[0]:
+            return state_rewards[1]
 
-    def get_state_reward(self, *options) -> float:
-        return 0.0
+        return state_rewards[2]