gym-csle-stopping-game 0.6.4__tar.gz → 0.6.5__tar.gz

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym_csle_stopping_game
-Version: 0.6.4
+Version: 0.6.5
 Summary: OpenAI gym reinforcement learning environment of a Dynkin (Optimal stopping) game in CSLE
 Author: Kim Hammar
 Author-email: hammar.kim@gmail.com

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/setup.cfg

@@ -20,11 +20,11 @@ classifiers =
 [options]
 install_requires = 
 	gymnasium>=0.27.1
-	csle-base>=0.6.4
-	csle-common>=0.6.4
-	csle-attacker>=0.6.4
-	csle-defender>=0.6.4
-	csle-collector>=0.6.4
+	csle-base>=0.6.5
+	csle-common>=0.6.5
+	csle-attacker>=0.6.5
+	csle-defender>=0.6.5
+	csle-collector>=0.6.5
 python_requires = >=3.8
 package_dir = 
 	=src

gym_csle_stopping_game-0.6.5/src/gym_csle_stopping_game/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.6.5'

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/src/gym_csle_stopping_game/dao/stopping_game_config.py

@@ -14,7 +14,7 @@ class StoppingGameConfig(SimulationEnvInputConfig):
                  T: npt.NDArray[Any], O: npt.NDArray[np.int_], Z: npt.NDArray[Any],
                  R: npt.NDArray[Any], S: npt.NDArray[np.int_], A1: npt.NDArray[np.int_],
                  A2: npt.NDArray[np.int_], L: int, R_INT: int, R_COST: int, R_SLA: int, R_ST: int,
-                 b1: npt.NDArray[np.float_],
+                 b1: npt.NDArray[np.float64],
                  save_dir: str, checkpoint_traces_freq: int, gamma: float = 1, compute_beliefs: bool = True,
                  save_trace: bool = True) -> None:
         """

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/src/gym_csle_stopping_game/dao/stopping_game_state.py

@@ -10,7 +10,7 @@ class StoppingGameState(JSONSerializable):
     Represents the state of the optimal stopping game
     """
 
-    def __init__(self, b1: npt.NDArray[np.float_], L: int) -> None:
+    def __init__(self, b1: npt.NDArray[np.float64], L: int) -> None:
         """
         Intializes the state
 

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/src/gym_csle_stopping_game/envs/stopping_game_mdp_attacker_env.py

@@ -48,7 +48,7 @@ class StoppingGameMdpAttackerEnv(BaseEnv):
         self.reset()
         super().__init__()
 
-    def step(self, pi2: Union[npt.NDArray[Any], int, float, np.int_, np.float_]) \
+    def step(self, pi2: Union[npt.NDArray[Any], int, float, np.int_, np.float64]) \
             -> Tuple[npt.NDArray[Any], int, bool, bool, Dict[str, Any]]:
         """
         Takes a step in the environment by executing the given action

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/src/gym_csle_stopping_game/util/stopping_game_util.py

@@ -11,7 +11,7 @@ class StoppingGameUtil:
     """
 
     @staticmethod
-    def b1() -> npt.NDArray[np.float_]:
+    def b1() -> npt.NDArray[np.float64]:
         """
         Gets the initial belief
 
@@ -233,7 +233,7 @@ class StoppingGameUtil:
         return int(np.random.choice(np.arange(0, len(S)), p=state_probs))
 
     @staticmethod
-    def sample_initial_state(b1: npt.NDArray[np.float_]) -> int:
+    def sample_initial_state(b1: npt.NDArray[np.float64]) -> int:
         """
         Samples the initial state
 
@@ -264,7 +264,7 @@ class StoppingGameUtil:
         return int(o)
 
     @staticmethod
-    def bayes_filter(s_prime: int, o: int, a1: int, b: npt.NDArray[np.float_], pi2: npt.NDArray[Any], l: int,
+    def bayes_filter(s_prime: int, o: int, a1: int, b: npt.NDArray[np.float64], pi2: npt.NDArray[Any], l: int,
                      config: StoppingGameConfig) -> float:
         """
         A Bayesian filter to compute the belief of player 1
@@ -302,8 +302,8 @@ class StoppingGameUtil:
         return float(b_prime_s_prime)
 
     @staticmethod
-    def next_belief(o: int, a1: int, b: npt.NDArray[np.float_], pi2: npt.NDArray[Any],
-                    config: StoppingGameConfig, l: int, a2: int = 0, s: int = 0) -> npt.NDArray[np.float_]:
+    def next_belief(o: int, a1: int, b: npt.NDArray[np.float64], pi2: npt.NDArray[Any],
+                    config: StoppingGameConfig, l: int, a2: int = 0, s: int = 0) -> npt.NDArray[np.float64]:
         """
         Computes the next belief using a Bayesian filter
 
@@ -337,3 +337,52 @@ class StoppingGameUtil:
         :return: a2 is the attacker action
         """
         return int(np.random.choice(np.arange(0, len(pi2[s])), p=pi2[s]))
+
+    @staticmethod
+    def pomdp_solver_file(config: StoppingGameConfig, discount_factor: float, pi2: npt.NDArray[Any]) -> str:
+        """
+        Gets the POMDP environment specification based on the format at http://www.pomdp.org/code/index.html,
+        for the defender's local problem against a static attacker
+
+        :param config: the POMDP config
+        :param discount_factor: the discount factor
+        :param pi2: the attacker strategy
+        :return: the file content as a string
+        """
+        file_str = ""
+        file_str = file_str + f"discount: {discount_factor}\n\n"
+        file_str = file_str + "values: reward\n\n"
+        file_str = file_str + f"states: {len(config.S)}\n\n"
+        file_str = file_str + f"actions: {len(config.A1)}\n\n"
+        file_str = file_str + f"observations: {len(config.O)}\n\n"
+        initial_belief_str = " ".join(list(map(lambda x: str(x), config.b1)))
+        file_str = file_str + f"start: {initial_belief_str}\n\n\n"
+        num_transitions = 0
+        for s in config.S:
+            for a1 in config.A1:
+                probs = []
+                for s_prime in range(len(config.S)):
+                    num_transitions += 1
+                    prob = 0
+                    for a2 in config.A2:
+                        prob += config.T[0][a1][a2][s][s_prime] * pi2[s][a2]
+                    file_str = file_str + f"T: {a1} : {s} : {s_prime} {prob:.80f}\n"
+                    probs.append(prob)
+                assert round(sum(probs), 3) == 1
+        file_str = file_str + "\n\n"
+        for a1 in config.A1:
+            for s_prime in config.S:
+                probs = []
+                for o in range(len(config.O)):
+                    prob = config.Z[0][0][s_prime][o]
+                    file_str = file_str + f"O : {a1} : {s_prime} : {o} {prob:.80f}\n"
+                    probs.append(prob)
+                assert round(sum(probs), 3) == 1
+        file_str = file_str + "\n\n"
+        for s in config.S:
+            for a1 in config.A1:
+                for s_prime in config.S:
+                    for o in config.O:
+                        r = config.R[0][a1][0][s]
+                        file_str = file_str + f"R: {a1} : {s} : {s_prime} : {o} {r:.80f}\n"
+        return file_str

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/src/gym_csle_stopping_game.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gym-csle-stopping-game
-Version: 0.6.4
+Version: 0.6.5
 Summary: OpenAI gym reinforcement learning environment of a Dynkin (Optimal stopping) game in CSLE
 Author: Kim Hammar
 Author-email: hammar.kim@gmail.com

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/src/gym_csle_stopping_game.egg-info/requires.txt

@@ -1,9 +1,9 @@
 gymnasium>=0.27.1
-csle-base>=0.6.4
-csle-common>=0.6.4
-csle-attacker>=0.6.4
-csle-defender>=0.6.4
-csle-collector>=0.6.4
+csle-base>=0.6.5
+csle-common>=0.6.5
+csle-attacker>=0.6.5
+csle-defender>=0.6.5
+csle-collector>=0.6.5
 
 [testing]
 pytest>=6.0

{gym_csle_stopping_game-0.6.4 → gym_csle_stopping_game-0.6.5}/tests/test_stopping_game_env.py

@@ -357,7 +357,7 @@ class TestStoppingGameEnvSuite:
                         1,
                         (
                             np.array(
-                                [[0.2, 0.8], [0.6, 0.4], [0.5, 0.5], [0.5, 0.5]]
+                                [[0.2, 0.8], [0.6, 0.4], [0.5, 0.5]]
                             ),
                             2,
                         ),

gym_csle_stopping_game-0.6.4/src/gym_csle_stopping_game/__version__.py

@@ -1 +0,0 @@
-__version__ = '0.6.4'