gr-libs 0.1.8__py3-none-any.whl → 0.2.5__py3-none-any.whl

gr_libs/environment/environment.py

@@ -1,14 +1,18 @@
+""" environment.py """
+
+import os
+import sys
 from abc import abstractmethod
 from collections import namedtuple
-import os
+from contextlib import contextmanager
 
 import gymnasium as gym
-from stable_baselines3.common.vec_env import DummyVecEnv
-from PIL import Image
 import numpy as np
 from gymnasium.envs.registration import register
-from minigrid.core.world_object import Wall, Lava
-from minigrid.wrappers import RGBImgPartialObsWrapper, ImgObsWrapper
+from minigrid.core.world_object import Lava, Wall
+from minigrid.wrappers import ImgObsWrapper, RGBImgPartialObsWrapper
+from PIL import Image
+from stable_baselines3.common.vec_env import DummyVecEnv
 
 MINIGRID, PANDA, PARKING, POINT_MAZE = "minigrid", "panda", "parking", "point_maze"
 
@@ -21,112 +25,226 @@ LSTMProperties = namedtuple(
 )
 
 
+@contextmanager
+def suppress_output():
+    """
+    Context manager to suppress stdout and stderr (including C/C++ prints).
+    """
+    with open(os.devnull, "w") as devnull:
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        sys.stdout = devnull
+        sys.stderr = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+
 class EnvProperty:
+    """
+    Base class for environment properties.
+    """
+
     def __init__(self, name):
+        """
+        Initializes a new instance of the Environment class.
+
+        Args:
+            name (str): The name of the environment.
+        """
         self.name = name
 
     def __str__(self):
+        """
+        Returns a string representation of the object.
+        """
         return f"{self.name}"
 
     def __repr__(self):
+        """
+        Returns a string representation of the object.
+        """
         return f"{self.name}"
 
     def __eq__(self, other):
+        """
+        Check if this object is equal to another object.
+
+        Args:
+            other: The other object to compare with.
+
+        Returns:
+            True if the objects are equal, False otherwise.
+        """
         return self.name == other.name
 
     def __ne__(self, other):
+        """
+        Check if the current object is not equal to the other object.
+
+        Args:
+            other: The object to compare with.
+
+        Returns:
+            bool: True if the objects are not equal, False otherwise.
+        """
         return not self.__eq__(other)
 
     @abstractmethod
     def str_to_goal(self):
-        pass
+        """
+        Convert a problem name to a goal.
+        """
 
     @abstractmethod
     def gc_adaptable(self):
-        pass
+        """
+        Check if the environment is goal-conditioned adaptable.
+        """
 
     @abstractmethod
     def problem_list_to_str_tuple(self, problems):
-        pass
+        """
+        Convert a list of problems to a string tuple.
+        """
 
     @abstractmethod
     def goal_to_problem_str(self, goal):
-        pass
+        """
+        Convert a goal to a problem string.
+        """
 
     @abstractmethod
     def is_action_discrete(self):
-        pass
+        """
+        Check if the action space is discrete.
+        """
 
     @abstractmethod
     def is_state_discrete(self):
-        pass
+        """
+        Check if the state space is discrete.
+        """
 
     @abstractmethod
     def get_lstm_props(self):
-        pass
+        """
+        Get the LSTM properties for the environment.
+        """
 
     @abstractmethod
     def change_done_by_specific_desired(self, obs, desired, old_success_done):
-        pass
+        """
+        Change the 'done' flag based on a specific desired goal.
+        """
 
     @abstractmethod
     def is_done(self, done):
-        pass
+        """
+        Check if the episode is done.
+        """
 
     @abstractmethod
     def is_success(self, info):
-        pass
+        """
+        Check if the episode is successful.
+        """
 
     def create_vec_env(self, kwargs):
-        env = gym.make(**kwargs)
+        """
+        Create a vectorized environment, suppressing prints from gym/pybullet/panda-gym.
+        """
+        with suppress_output():
+            env = gym.make(**kwargs)
         return DummyVecEnv([lambda: env])
 
     @abstractmethod
     def change_goal_to_specific_desired(self, obs, desired):
-        pass
+        """
+        Change the goal to a specific desired goal.
+        """
 
 
 class GCEnvProperty(EnvProperty):
+    """
+    Base class for goal-conditioned environment properties.
+    """
+
     @abstractmethod
     def use_goal_directed_problem(self):
-        pass
+        """
+        Check if the environment uses a goal-directed problem.
+        """
 
     def problem_list_to_str_tuple(self, problems):
+        """
+        Convert a list of problems to a string tuple.
+        """
         return "goal_conditioned"
 
 
 class MinigridProperty(EnvProperty):
+    """
+    Environment properties for the Minigrid domain.
+    """
+
     def __init__(self, name):
         super().__init__(name)
         self.domain_name = "minigrid"
 
     def goal_to_problem_str(self, goal):
+        """
+        Convert a goal to a problem string.
+        """
         return self.name + f"-DynamicGoal-{goal[0]}x{goal[1]}-v0"
 
     def str_to_goal(self, problem_name):
+        """
+        Convert a problem name to a goal.
+        """
         parts = problem_name.split("-")
         goal_part = [part for part in parts if "x" in part]
         width, height = goal_part[0].split("x")
         return (int(width), int(height))
 
     def gc_adaptable(self):
+        """
+        Check if the environment is goal-conditioned adaptable.
+        """
         return False
 
     def problem_list_to_str_tuple(self, problems):
+        """
+        Convert a list of problems to a string tuple.
+        """
         return "_".join([f"[{s.split('-')[-2]}]" for s in problems])
 
     def is_action_discrete(self):
+        """
+        Check if the action space is discrete.
+        """
         return True
 
     def is_state_discrete(self):
+        """
+        Check if the state space is discrete.
+        """
         return True
 
     def get_lstm_props(self):
+        """
+        Get the LSTM properties for the environment.
+        """
         return LSTMProperties(
             batch_size=16, input_size=4, hidden_size=8, num_samples=40000
         )
 
     def create_sequence_image(self, sequence, img_path, problem_name):
+        """
+        Create a sequence image for the environment.
+        """
         if not os.path.exists(os.path.dirname(img_path)):
             os.makedirs(os.path.dirname(img_path))
         env_id = (
@@ -134,7 +252,7 @@ class MinigridProperty(EnvProperty):
             + "-DynamicGoal-"
             + problem_name.split("-DynamicGoal-")[1]
         )
-        result = register(
+        register(
             id=env_id,
             entry_point="gr_envs.minigrid_scripts.envs:CustomColorEnv",
             kwargs={
@@ -146,7 +264,6 @@ class MinigridProperty(EnvProperty):
                 "plan": sequence,
             },
         )
-        # print(result)
         env = gym.make(id=env_id)
         env = RGBImgPartialObsWrapper(env)  # Get pixel observations
         env = ImgObsWrapper(env)  # Get rid of the 'mission' field
@@ -156,34 +273,62 @@ class MinigridProperty(EnvProperty):
 
         ####### save image to file
         image_pil = Image.fromarray(np.uint8(img)).convert("RGB")
-        image_pil.save(r"{}.png".format(img_path))
+        image_pil.save(r"{}.png".format(os.path.join(img_path, "plan_image")))
 
     def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        """
+        Change the 'done' flag based on a specific desired goal.
+        """
         assert (
             desired is None
         ), "In MinigridProperty, giving a specific 'desired' is not supported."
         return old_success_done
 
     def is_done(self, done):
+        """
+        Check if the episode is done.
+        """
         assert isinstance(done, np.ndarray)
         return done[0]
 
-    # Not used currently since TabularQLearner doesn't need is_success from the environment
     def is_success(self, info):
+        """
+        Check if the episode is successful.
+        """
         raise NotImplementedError("no other option for any of the environments.")
 
     def change_goal_to_specific_desired(self, obs, desired):
+        """
+        Change the goal to a specific desired goal.
+        """
         assert (
             desired is None
         ), "In MinigridProperty, giving a specific 'desired' is not supported."
 
 
 class PandaProperty(GCEnvProperty):
+    """
+    Environment properties for the Panda domain.
+    """
+
     def __init__(self, name):
+        """
+        Initialize a new instance of the Environment class.
+
+        Args:
+            name (str): The name of the environment.
+
+        Attributes:
+            domain_name (str): The domain name of the environment.
+
+        """
         super().__init__(name)
         self.domain_name = "panda"
 
     def str_to_goal(self, problem_name):
+        """
+        Convert a problem name to a goal.
+        """
         try:
             numeric_part = problem_name.split("PandaMyReachDenseX")[1]
             components = [
@@ -194,38 +339,62 @@ class PandaProperty(GCEnvProperty):
             for component in components:
                 floats.append(float(component))
             return np.array([floats], dtype=np.float32)
-        except Exception as e:
+        except Exception:
             return "general"
 
     def goal_to_problem_str(self, goal):
+        """
+        Convert a goal to a problem string.
+        """
         goal_str = "X".join(
             [str(float(g)).replace(".", "y").replace("-", "M") for g in goal[0]]
         )
         return f"PandaMyReachDenseX{goal_str}-v3"
 
     def gc_adaptable(self):
+        """
+        Check if the environment is goal-conditioned adaptable.
+        """
         return True
 
     def use_goal_directed_problem(self):
+        """
+        Check if the environment uses a goal-directed problem.
+        """
         return False
 
     def is_action_discrete(self):
+        """
+        Check if the action space is discrete.
+        """
         return False
 
     def is_state_discrete(self):
+        """
+        Check if the state space is discrete.
+        """
         return False
 
     def get_lstm_props(self):
+        """
+        Get the LSTM properties for the environment.
+        """
         return LSTMProperties(
             batch_size=32, input_size=9, hidden_size=8, num_samples=20000
         )
 
     def sample_goal():
+        """
+        Sample a random goal.
+        """
         goal_range_low = np.array([-0.40, -0.40, 0.10])
         goal_range_high = np.array([0.2, 0.2, 0.10])
         return np.random.uniform(goal_range_low, goal_range_high)
 
     def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        """
+        Change the 'done' flag based on a specific desired goal.
+        """
         if desired is None:
             return old_success_done
         assert isinstance(
@@ -241,70 +410,134 @@ class PandaProperty(GCEnvProperty):
             return old_success_done
 
     def is_done(self, done):
+        """
+        Check if the episode is done.
+        """
         assert isinstance(done, np.ndarray)
         return done[0]
 
     def is_success(self, info):
+        """
+        Check if the episode is successful.
+        """
         assert "is_success" in info[0].keys()
         return info[0]["is_success"]
 
     def change_goal_to_specific_desired(self, obs, desired):
+        """
+        Change the goal to a specific desired goal.
+        """
         if desired is not None:
             obs["desired_goal"] = desired
 
 
 class ParkingProperty(GCEnvProperty):
+    """
+    Environment properties for the Parking domain.
+    """
 
     def __init__(self, name):
+        """
+        Initialize a new environment object.
+
+        Args:
+            name (str): The name of the environment.
+
+        Attributes:
+            domain_name (str): The domain name of the environment.
+
+        """
         super().__init__(name)
         self.domain_name = "parking"
 
     def goal_to_problem_str(self, goal):
+        """
+        Convert a goal to a problem string.
+        """
         return self.name.split("-v0")[0] + f"-GI-{goal}-v0"
 
     def gc_adaptable(self):
+        """
+        Check if the environment is goal-conditioned adaptable.
+        """
         return True
 
     def is_action_discrete(self):
+        """
+        Check if the action space is discrete.
+        """
         return False
 
     def is_state_discrete(self):
+        """
+        Check if the state space is discrete.
+        """
         return False
 
     def use_goal_directed_problem(self):
+        """
+        Check if the environment uses a goal-directed problem.
+        """
         return True
 
     def get_lstm_props(self):
+        """
+        Get the LSTM properties for the environment.
+        """
         return LSTMProperties(
             batch_size=32, input_size=8, hidden_size=8, num_samples=20000
         )
 
     def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        """
+        Change the 'done' flag based on a specific desired goal.
+        """
         assert (
             desired is None
         ), "In ParkingProperty, giving a specific 'desired' is not supported."
         return old_success_done
 
     def is_done(self, done):
+        """
+        Check if the episode is done.
+        """
         assert isinstance(done, np.ndarray)
         return done[0]
 
     def is_success(self, info):
+        """
+        Check if the episode is successful.
+        """
         assert "is_success" in info[0].keys()
         return info[0]["is_success"]
 
     def change_goal_to_specific_desired(self, obs, desired):
+        """
+        Change the goal to a specific desired goal.
+        """
         assert (
             desired is None
         ), "In ParkingProperty, giving a specific 'desired' is not supported."
 
 
 class PointMazeProperty(EnvProperty):
+    """Environment properties for the Point Maze domain."""
+
     def __init__(self, name):
+        """
+        Initializes a new instance of the Environment class.
+
+        Args:
+            name (str): The name of the environment.
+
+        Attributes:
+            domain_name (str): The domain name of the environment.
+        """
         super().__init__(name)
         self.domain_name = "point_maze"
 
     def str_to_goal(self):
+        """Convert a problem name to a goal."""
         parts = self.name.split("-")
         # Find the part containing the goal size (usually after "DynamicGoal")
         sizes_parts = [part for part in parts if "x" in part]
@@ -314,40 +547,62 @@ class PointMazeProperty(EnvProperty):
         return (int(width), int(height))
 
     def gc_adaptable(self):
+        """Check if the environment is goal-conditioned adaptable."""
         return False
 
     def problem_list_to_str_tuple(self, problems):
+        """Convert a list of problems to a string tuple."""
         return "_".join([f"[{s.split('-')[-1]}]" for s in problems])
 
     def is_action_discrete(self):
+        """Check if the action space is discrete."""
         return False
 
     def is_state_discrete(self):
+        """Check if the state space is discrete."""
         return False
 
     def get_lstm_props(self):
+        """
+        Get the LSTM properties for the environment.
+        """
         return LSTMProperties(
             batch_size=32, input_size=6, hidden_size=8, num_samples=20000
         )
 
     def goal_to_problem_str(self, goal):
+        """
+        Convert a goal to a problem string.
+        """
         return self.name + f"-Goal-{goal[0]}x{goal[1]}"
 
     def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        """
+        Change the 'done' flag based on a specific desired goal.
+        """
         assert (
             desired is None
         ), "In PointMazeProperty, giving a specific 'desired' is not supported."
         return old_success_done
 
     def is_done(self, done):
+        """
+        Check if the episode is done.
+        """
         assert isinstance(done, np.ndarray)
         return done[0]
 
     def is_success(self, info):
+        """
+        Check if the episode is successful.
+        """
         assert "success" in info[0].keys()
         return info[0]["success"]
 
     def change_goal_to_specific_desired(self, obs, desired):
+        """
+        Change the goal to a specific desired goal.
+        """
         assert (
             desired is None
         ), "In ParkingProperty, giving a specific 'desired' is not supported."

gr_libs/evaluation/__init__.py

@@ -0,0 +1 @@
+""" This is a directory that includes scripts for analysis of GR results. """

gr_libs/evaluation/generate_experiments_results.py

@@ -0,0 +1,100 @@
+import argparse
+import os
+
+import dill
+import matplotlib.pyplot as plt
+import numpy as np
+
+from gr_libs.ml.utils.storage import get_experiment_results_path
+
+
+def load_results(domain, env, task, recognizer, n_runs, percentage, cons_type):
+    # Collect accuracy for a single task and recognizer
+    accs = []
+    res_dir = get_experiment_results_path(domain, env, task, recognizer)
+    if not os.path.exists(res_dir):
+        return accs
+    for i in range(n_runs):
+        res_file = os.path.join(res_dir, f"res_{i}.pkl")
+        if not os.path.exists(res_file):
+            continue
+        with open(res_file, "rb") as f:
+            results = dill.load(f)
+        if percentage in results and cons_type in results[percentage]:
+            acc = results[percentage][cons_type].get("accuracy")
+            if acc is not None:
+                accs.append(acc)
+    return accs
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--domain", required=True)
+    parser.add_argument("--env", required=True)
+    parser.add_argument("--tasks", nargs="+", required=True)
+    parser.add_argument("--recognizers", nargs="+", required=True)
+    parser.add_argument("--n_runs", type=int, default=5)
+    parser.add_argument("--percentage", required=True)
+    parser.add_argument(
+        "--cons_type", choices=["consecutive", "non_consecutive"], required=True
+    )
+    parser.add_argument("--graph_name", type=str, default="experiment_results")
+    args = parser.parse_args()
+
+    plt.figure(figsize=(7, 5))
+    has_data = False
+    missing_recognizers = []
+
+    for recognizer in args.recognizers:
+        x_vals = []
+        y_means = []
+        y_sems = []
+        for task in args.tasks:
+            accs = load_results(
+                args.domain,
+                args.env,
+                task,
+                recognizer,
+                args.n_runs,
+                args.percentage,
+                args.cons_type,
+            )
+            if accs:
+                x_vals.append(task)
+                y_means.append(np.mean(accs))
+                y_sems.append(np.std(accs) / np.sqrt(len(accs)))
+        if x_vals:
+            has_data = True
+            x_ticks = np.arange(len(x_vals))
+            plt.plot(x_ticks, y_means, marker="o", label=recognizer)
+            plt.fill_between(
+                x_ticks,
+                np.array(y_means) - np.array(y_sems),
+                np.array(y_means) + np.array(y_sems),
+                alpha=0.2,
+            )
+            plt.xticks(x_ticks, x_vals)
+        else:
+            print(
+                f"Warning: No data found for recognizer '{recognizer}' in {args.domain} / {args.env} / {args.percentage} / {args.cons_type}"
+            )
+            missing_recognizers.append(recognizer)
+
+    if not has_data:
+        raise RuntimeError(
+            f"No data found for any recognizer in {args.domain} / {args.env} / {args.percentage} / {args.cons_type}. "
+            f"Missing recognizers: {', '.join(missing_recognizers)}"
+        )
+
+    plt.xlabel("Task")
+    plt.ylabel("Accuracy")
+    plt.title(f"{args.domain} - {args.env} ({args.percentage}, {args.cons_type})")
+    plt.legend()
+    plt.grid(True)
+    fig_path = f"{args.graph_name}_{'_'.join(args.recognizers)}_{args.domain}_{args.env}_{args.percentage}_{args.cons_type}.png"
+    plt.savefig(fig_path)
+    print(f"Figure saved at: {fig_path}")
+
+
+if __name__ == "__main__":
+    main()