gr-libs 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

gr_libs/environment/__init__.py

@@ -0,0 +1,22 @@
+import importlib.metadata
+import warnings
+
+def is_extra_installed(package: str, extra: str) -> bool:
+    """Check if an extra was installed for a given package."""
+    try:
+        # Get metadata for the installed package
+        dist = importlib.metadata.metadata(package)
+        requires = dist.get_all("Requires-Dist", [])  # Dependencies listed in the package metadata
+        return any(extra in req for req in requires)
+    except importlib.metadata.PackageNotFoundError:
+        return False  # The package is not installed
+
+# Check if `gr_libs[minigrid]` was installed
+for env in ["minigrid", "panda", "parking", "point_maze"]:
+	if is_extra_installed("gr_libs", f"gr_envs[{env}]"):
+		try:
+			importlib.import_module(f"gr_envs.{env}_scripts.envs")
+		except ImportError:
+			raise ImportError(f"gr_libs[{env}] was not installed, but gr_libs[{env}] requires it! if you messed with gr_libs installation, you can reinstall gr_libs.")
+	else:
+		warnings.warn(f"gr_libs[{env}] was not installed, skipping {env} imports.", RuntimeWarning)

gr_libs/environment/environment.py

@@ -168,8 +168,6 @@ class PandaProperty(GCEnvProperty):
 
         
 class ParkingProperty(GCEnvProperty):
-    # def str_to_goal(self): # TODO not use it, goal is not a part of the env property anymore.
-    #     return self.name.split("-")[-2]
 
     def __init__(self, name):
         super().__init__(name)

gr_libs/ml/neural/deep_rl_learner.py

@@ -13,11 +13,6 @@ if __name__ != "__main__":
 	from gr_libs.ml.utils.format import random_subset_with_order
 from stable_baselines3 import SAC, PPO
 from stable_baselines3.common.vec_env import DummyVecEnv
-from gr_envs.custom_env_wrappers.flat_obs_wrapper import CombineAchievedGoalAndObservationWrapper
-
-# important for registration of envs! do not remove lad
-import gr_envs.maze_scripts.envs.maze
-import gr_envs.highway_env_scripts.envs.parking_env
 from gr_libs.ml.utils import device
 
 # built-in python modules
@@ -32,13 +27,15 @@ def create_vec_env(kwargs):
 	return DummyVecEnv([lambda: env])
 
 def change_goal_to_specific_desired(obs, desired):
-	try:
-		if desired!=None: obs['desired_goal'] = desired
-	except Exception as e:
-		try:
-			if all(desired!=None): obs['desired_goal'] = desired
-		except Exception as e:
-			if all([desiredy!=None for desiredish in desired for desiredy in desiredish]): obs['desired_goal'] = desired
+	if desired is not None:
+		obs['desired_goal'] = desired
+	# try:
+	# 	if desired!=None: obs['desired_goal'] = desired
+	# except Exception as e:
+	# 	try:
+	# 		if all(desired!=None): obs['desired_goal'] = desired
+	# 	except Exception as e:
+	# 		if all([desiredy!=None for desiredish in desired for desiredy in desiredish]): obs['desired_goal'] = desired
 
 
 NETWORK_SETUP = {
@@ -265,6 +262,7 @@ class DeepRLAgent():
 			assert fig_path == None, "You can't specify a vid path when you don't even save the figure."
 		else:
 			assert fig_path != None, "You need to specify a vid path when you save the figure."
+		# The try-except is a bug fix for the env not being reset properly in panda. If someone wants to check why and provide a robust solution they're welcome.
 		try:
 			obs = self.env.reset()
 			change_goal_to_specific_desired(obs, desired)

gr_libs/recognizer/graml/graml_recognizer.py

@@ -103,7 +103,6 @@ class Graml(LearningRecognizer):
 		self.plans_dict[f"{true_goal}_true"] = true_sequence
 
 		with open(embeddings_path + f'/{true_goal}_{percentage}_plans_dict.pkl', 'wb') as plans_file:
-			# TODO erase AGENT_BASED macros
 			to_dump = {}
 			for goal, obss in self.plans_dict.items():
 				if goal == f"{true_goal}_true":
@@ -243,7 +242,7 @@ class GCGraml(Graml, GaAdaptingRecognizer):
 		if num_timesteps != None: kwargs["num_timesteps"] = num_timesteps
 		gc_agent = self.rl_agent_type(**kwargs)
 		gc_agent.learn()
-		self.agents.append(ContextualAgent(problem_name=self.env_prop.name, problem_goal="general", agent=gc_agent)) # TODO change
+		self.agents.append(ContextualAgent(problem_name=self.env_prop.name, problem_goal="general", agent=gc_agent))
 
 	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		problem_name = self.env_prop.goal_to_problem_str(goal)

gr_libs/recognizer/recognizer.py

@@ -18,7 +18,7 @@ class Recognizer(ABC):
 	def inference_phase(self, inf_sequence, true_goal, percentage) -> str:
 		pass
 
-class LearningRecognizer(Recognizer): # TODO add a class diagram with the inheritance of all calsses
+class LearningRecognizer(Recognizer):
 	def __init__(self, *args, **kwargs):
 		super().__init__(*args, **kwargs)
 
@@ -26,7 +26,7 @@ class LearningRecognizer(Recognizer): # TODO add a class diagram with the inheri
 		self.original_train_configs = train_configs
 
 # a recognizer that needs to train agents for every new goal as part of the goal adaptation phase (that's why it needs dynamic train configs)
-class GaAgentTrainerRecognizer(Recognizer): # TODO add a class diagram with the inheritance of all calsses
+class GaAgentTrainerRecognizer(Recognizer):
 	def __init__(self, *args, **kwargs):
 		super().__init__(*args, **kwargs)
 
@@ -37,7 +37,7 @@ class GaAgentTrainerRecognizer(Recognizer): # TODO add a class diagram with the
 	def domain_learning_phase(self, base_goals: List[str], train_configs: List):
 		super().domain_learning_phase(base_goals, train_configs)
 
-class GaAdaptingRecognizer(Recognizer): # TODO add a class diagram with the inheritance of all calsses
+class GaAdaptingRecognizer(Recognizer):
 	def __init__(self, *args, **kwargs):
 		super().__init__(*args, **kwargs)
 

gr_libs/recognizer/recognizer_doc.md

@@ -0,0 +1,61 @@
+# Recognizer Module Documentation
+
+This document provides an overview of the recognizer module, including its class hierarchy and instructions for adding a new class of recognizer.
+
+## Class Hierarchy
+
+The recognizer module consists of an abstract base class `Recognizer` and several derived classes, each implementing specific behaviors. The main classes are:
+
+1. **Recognizer (Abstract Base Class)**
+   - `inference_phase()` (abstract method)
+
+2. **LearningRecognizer (Extends Recognizer)**
+   - `domain_learning_phase()`
+
+3. **GaAgentTrainerRecognizer (Extends Recognizer)**
+   - `goals_adaptation_phase()` (abstract method)
+   - `domain_learning_phase()`
+
+4. **GaAdaptingRecognizer (Extends Recognizer)**
+   - `goals_adaptation_phase()` (abstract method)
+
+5. **GRAsRL (Extends Recognizer)**
+   - Implements `goals_adaptation_phase()`
+   - Implements `inference_phase()`
+
+6. **Specific Implementations:**
+   - `Graql (Extends GRAsRL, GaAgentTrainerRecognizer)`
+   - `Draco (Extends GRAsRL, GaAgentTrainerRecognizer)`
+   - `GCDraco (Extends GRAsRL, LearningRecognizer, GaAdaptingRecognizer)`
+   - `Graml (Extends LearningRecognizer)`
+
+## How to Add a New Recognizer Class
+
+To add a new class of recognizer, follow these steps:
+
+1. **Determine the Type of Recognizer:**
+   - Will it require learning? Extend `LearningRecognizer`.
+   - Will it adapt goals dynamically? Extend `GaAdaptingRecognizer`.
+   - Will it train agents for new goals? Extend `GaAgentTrainerRecognizer`.
+   - Will it involve RL-based recognition? Extend `GRAsRL`.
+
+2. **Define the Class:**
+   - Create a new class that extends the appropriate base class(es).
+   - Implement the required abstract methods (`inference_phase()`, `goals_adaptation_phase()`, etc.).
+
+3. **Initialize the Recognizer:**
+   - Ensure proper initialization by calling `super().__init__(*args, **kwargs)`.
+   - Set up any necessary agent storage or evaluation functions.
+
+4. **Implement Core Methods:**
+   - Define how the recognizer processes inference sequences.
+   - Implement learning or goal adaptation logic if applicable.
+
+5. **Register the Recognizer:**
+   - Ensure it integrates properly with the existing system by using the correct `domain_to_env_property()`.
+
+6. **Test the New Recognizer:**
+   - Run experiments to validate its behavior.
+   - Compare results against existing recognizers to ensure correctness.
+
+By following these steps, you can seamlessly integrate a new recognizer into the framework while maintaining compatibility with the existing structure.

gr_libs-0.1.5.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: gr_libs
+Version: 0.1.5
+Summary: Package with goal recognition frameworks baselines
+Author: Ben Nageris
+Author-email: Matan Shamir <matan.shamir@live.biu.ac.il>, Osher Elhadad <osher.elhadad@live.biu.ac.il>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: gr_envs
+Requires-Dist: dill
+Requires-Dist: opencv-python
+Requires-Dist: tensorboardX
+Requires-Dist: torchvision
+Requires-Dist: rl_zoo3
+Requires-Dist: stable_baselines3[extra]
+Requires-Dist: sb3_contrib
+Provides-Extra: minigrid
+Requires-Dist: gr_envs[minigrid]; extra == "minigrid"
+Provides-Extra: highway
+Requires-Dist: gr_envs[highway]; extra == "highway"
+Provides-Extra: maze
+Requires-Dist: gr_envs[maze]; extra == "maze"
+Provides-Extra: panda
+Requires-Dist: gr_envs[panda]; extra == "panda"
+
+# GRLib
+GRLib is a Python package that implements Goal Recognition (GR) algorithms using Markov Decision Processes (MDPs) to model decision-making processes. These implementations adhere to the Gymnasium API. All agents in these algorithms interact with environments registered to the Gym API as part of the initialization process of the `gr_envs` package, on which GRLib depends. More details on `gr_envs` can be found at: [GR Envs Repository](https://github.com/MatanShamir1/GREnvs).
+
+## Setup
+
+**Note:** If you are using Windows, use Git Bash for the following commands. Otherwise, any terminal or shell will work.
+
+`gr_libs` depends on `gr_envs`, which registers a set of Gym environments. Ensure your Python environment is set up with Python >= 3.11.
+
+### Setting Up a Python Environment (if needed)
+#### Using Pip
+1. **Find Your Python Installation:**  
+   To locate your Python 3.12 executable, run:
+   ```sh
+   py -3.12 -c "import sys; print(sys.executable)"
+   ```
+2. **Create a New Virtual Environment:**  
+   Using the path found above, create a new empty venv:
+   ```sh
+   C:/Users/path/to/Programs/Python/Python312/python.exe -m venv test_env
+   ```
+3. **Activate the Virtual Environment:**
+   ```sh
+   source test_env/Scripts/activate
+   ```
+4. **Verify the Active Environment:**  
+   Since there is no direct equivalent to `conda env list`, you can check your active environment via:
+   ```sh
+   echo $VIRTUAL_ENV
+   ```
+
+#### Using Conda
+If you prefer using Conda, follow these steps:
+
+1. **Create a New Conda Environment:**  
+   Replace `3.12` with your desired Python version if necessary.
+   ```sh
+   conda create -n new_env python=3.12
+   ```
+2. **Activate the Environment:**
+   ```sh
+   conda activate new_env
+   ```
+  
+  
+### Upgrade Basic Package Management Modules:
+   Run the following command (replace `/path/to/python.exe` with the actual path):
+   ```sh
+   /path/to/python.exe -m pip install --upgrade pip setuptools wheel versioneer
+   ```
+### Install the `GoalRecognitionLibs` Package:
+  The extras install the custom environments defined in `gr_envs`.
+  (For editable installation, add the `-e` flag by cloning the repo and cd'ing to it https://github.com/MatanShamir1/GRLib.git)
+  - **Minigrid Environment:**  
+    ```sh
+    pip install gr_libs[minigrid]
+    ```
+  - **Highway Environment (Parking):**  
+    ```sh
+    pip install gr_libs[highway]
+    ```
+  - **Maze Environment (Point-Maze):**  
+    ```sh
+    pip install gr_libs[maze]
+    ```
+  - **Panda Environment:**  
+    ```sh
+    pip install gr_libs[panda]
+    ```
+   (For editable installation, add the `-e` flag.)
+   ```sh
+   cd /path/to/clone/of/GoalRecognitionLibs
+   pip install -e .
+   ```
+
+## Issues & Troubleshooting
+
+For any issues or troubleshooting, please refer to the repository's issue tracker.
+
+## Usage Guide
+
+After installing GRLib, you will have access to custom Gym environments, allowing you to set up and execute an Online Dynamic Goal Recognition (ODGR) scenario with the algorithm of your choice.
+
+Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tutorials`. These tutorials walk through the initialization and deployment process, showcasing how different GR algorithms adapt to emerging goals in various Gym environments.
+
+### Method 1: Writing a Custom Script
+
+1. **Create a recognizer**
+   
+   Specify the domain name and specific environment for the recognizer, effectively telling it the domain theory - the collection of states and actions in the environment.
+
+   ```python
+   recognizer = Graql(
+       domain_name="minigrid",
+       env_name="MiniGrid-SimpleCrossingS13N4"
+   )
+   ```
+
+2. **Domain Learning Phase** (For GRAQL)
+   
+   GRAQL does not accumulate information about the domain or engage in learning activities during this phase.
+   Other algorithms don't require any data for the phase and simply use what's provided in their intialization: the domain and environment specifics, excluding the possible goals.
+
+3. **Goal Adaptation Phase**
+   
+   The recognizer receives new goals and corresponding training configurations. GRAQL trains goal-directed agents and stores their policies for inference.
+   
+   ```python
+   recognizer.goals_adaptation_phase(
+       dynamic_goals=[(11,1), (11,11), (1,11)],
+       dynamic_train_configs=[(QLEARNING, 100000) for _ in range(3)]  # For expert sequence generation
+   )
+   ```
+
+4. **Inference Phase**
+   
+   This phase generates a partial sequence from a trained agent, simulating suboptimal behavior with Gaussian noise.
+   
+   ```python
+   actor = TabularQLearner(
+       domain_name="minigrid",
+       problem_name="MiniGrid-SimpleCrossingS13N4-DynamicGoal-11x1-v0",
+       algorithm=QLEARNING,
+       num_timesteps=100000
+   )
+   actor.learn()
+   full_sequence = actor.generate_observation(
+       action_selection_method=stochastic_amplified_selection,
+       random_optimalism=True  # Adds noise to action values
+   )
+   partial_sequence = random_subset_with_order(full_sequence, int(0.5 * len(full_sequence)), is_consecutive=False)
+   closest_goal = recognizer.inference_phase(partial_sequence, (11,1), 0.5)
+   ```
+
+5. **Evaluate the result**
+   
+   ```python
+   print(f"Closest goal returned by Graql: {closest_goal}\nActual goal actor aimed towards: (11, 1)")
+   ```
+
+### Method 2: Using a Configuration File
+
+The `consts.py` file contains predefined ODGR problem configurations. You can use existing configurations or define new ones.
+
+To execute a single task using the configuration file:
+```sh
+python odgr_executor.py --recognizer MCTSBasedGraml --domain minigrid --task L1 --minigrid_env MinigridSimple
+```
+
+## Supported Algorithms
+
+Successors of algorithms that don't differ in their specifics are added in parentheses after the algorithm name. For example, since GC-DRACO and DRACO share the same column values, they're written on one line as DRACO (GC).
+
+| **Algorithm** | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** |
+|--------------|--------------|------------------------|------------------|------------------|--------------|--------------|--------------|--------------|--------------|
+| GRAQL       | ❌           | ✅                     | ✅                | ❌                | ✅                | ❌                | ❌           | ✅           | ❌           |
+| DRACO (GC)  | ❌           | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ❌           |
+| GRAML (GC, BG) | ✅        | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ✅           |
+
+## Supported Domains
+
+| **Domain**  | **Action Space** | **State Space** |
+|------------|----------------|----------------|
+| Minigrid   | Discrete       | Discrete       |
+| PointMaze  | Continuous     | Continuous     |
+| Parking    | Continuous     | Continuous     |
+| Panda      | Continuous     | Continuous     |
+
+## Running Experiments
+
+The repository provides benchmark domains and scripts for analyzing experimental results. The `scripts` directory contains tools for processing and visualizing results.
+
+1. **`analyze_results_cross_alg_cross_domain.py`**
+   - Runs without arguments.
+   - Reads data from `get_experiment_results_path` (e.g., `dataset/graml/minigrid/continuing/.../experiment_results.pkl`).
+   - Generates plots comparing algorithm performance across domains.
+
+2. **`generate_task_specific_statistics_plots.py`**
+   - Produces task-specific accuracy and confidence plots.
+   - Generates a confusion matrix displaying confidence levels.
+   - Example output paths:
+     - `figures/point_maze/obstacles/graql_point_maze_obstacles_fragmented_stats.png`
+     - `figures/point_maze/obstacles/graml_point_maze_obstacles_conf_mat.png`

{gr_libs-0.1.3.dist-info → gr_libs-0.1.5.dist-info}/RECORD

@@ -8,8 +8,8 @@ evaluation/generate_task_specific_statistics_plots.py,sha256=rBsqaMe2irP_Cfo-icw
 evaluation/get_plans_images.py,sha256=BT-bGWuOPUAYpZVDwk7YMRBLdgKaDbNOBjMrtcl1Vjk,2346
 evaluation/increasing_and_decreasing_.py,sha256=fu1hkEjhOQC3jEsjiS7emW_UPRpVFCaae0d0E2MGZqI,2991
 gr_libs/__init__.py,sha256=-uKsQiHIL7yojbDwlTR-I8sj1WX9XT52PoFbPjtUTKo,145
-gr_libs/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/environment/environment.py,sha256=0-3kZJCmLMF9o0NignZaMEwQb94NZQ2gmsOyfjPXKDI,6919
+gr_libs/environment/__init__.py,sha256=oxEKmdvzQLKbbMxedqEf3bGsSJvp2XL9Bxr5JEO6a5o,1038
+gr_libs/environment/environment.py,sha256=Ca9m6W8KEt4le0HFSAUvSHW5lSHg_wwJaBqFSq1KlUg,6781
 gr_libs/environment/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gr_libs/environment/utils/utils.py,sha256=4yM3s30KjyuEmWR8UuICE5rR03zsLi3tzqNDvBkdPcU,537
 gr_libs/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,7 +20,7 @@ gr_libs/ml/consts.py,sha256=mrbZk8n6QoGzLGaKmaxq4QlAsBbk4fhkCgXLuO9jXKw,365
 gr_libs/ml/base/__init__.py,sha256=MfIYhl_UqH8H7YoTCih8wBFA_gpTOUFq8Ph0_Nq0XQk,68
 gr_libs/ml/base/rl_agent.py,sha256=u9rnb-ma9iDM5b_BlwjcTJGSFezIGrxXINw6b-Dbl8s,1598
 gr_libs/ml/neural/__init__.py,sha256=g-0D5oFX8W52To4OR8vO8kDoBLSxAupVqwcQw8XjT5E,180
-gr_libs/ml/neural/deep_rl_learner.py,sha256=_d6LdbMPqN4qJlOI_UqSD7o0yzIa7EjRONdFSVYO_Ag,20677
+gr_libs/ml/neural/deep_rl_learner.py,sha256=b41_b4GVlYqxhjrr1_YMcGdU9iwcMXsf3zH8D2kEucs,20659
 gr_libs/ml/neural/utils/__init__.py,sha256=bJgPfRnmfDQxdnb0OyRGwzgebEc1PnlO7-GpqszPBcc,106
 gr_libs/ml/neural/utils/dictlist.py,sha256=WpHfdWpVZ_T3PcSnOQUC--ro_tsS0dvam2WG3LcsHDw,1039
 gr_libs/ml/neural/utils/penv.py,sha256=R1uW8sePQqvTlJjpAuMx16eDU6TuGAjQF3hTR1QasMo,1862
@@ -43,20 +43,21 @@ gr_libs/ml/utils/math.py,sha256=n62zssVOLHnUb4dPofAoFhoLOKl5n_xBzaKQOUQBoNc,440
 gr_libs/ml/utils/other.py,sha256=HKUfeLBbd4DgJxSTs3ya9KQ85Acx4TjycRrtGD9WQ3s,505
 gr_libs/ml/utils/storage.py,sha256=oCdvL_ypCglnSJsyyXzNyV_UJASTfioa3yJhFlFso64,4277
 gr_libs/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/recognizer/recognizer.py,sha256=ysJYOGe5OlERMAeMwclKpwqw2tQvbSvGnLZrq4qP0xk,1895
+gr_libs/recognizer/recognizer.py,sha256=2lMlJNE7X13Y3FMpNfql-WAYw23NImIiomnVmCI75bM,1706
+gr_libs/recognizer/recognizer_doc.md,sha256=RnTvbZhl2opvU7-QT4pULCV5HCdJTw2dsu8WQOOiR3E,2521
 gr_libs/recognizer/gr_as_rl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gr_libs/recognizer/gr_as_rl/gr_as_rl_recognizer.py,sha256=84GdfohC2dZoNH_QEo7GpSt8nZWdfqSRKCTY99X_iME,5215
 gr_libs/recognizer/graml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gr_libs/recognizer/graml/gr_dataset.py,sha256=lG6m3ulxFELpH1oURnlcmNDWOrxyuzvlAR28ZTqB7L8,7224
-gr_libs/recognizer/graml/graml_recognizer.py,sha256=OblODjvWSi8KZ5ByvGyL5Mm1GY3IZb8yspfk81Dbebg,15721
+gr_libs/recognizer/graml/graml_recognizer.py,sha256=SGs7rtkA73lbCv9HISa6dfjVUJUhlH54QriVsoGVRss,15672
 gr_libs/recognizer/utils/__init__.py,sha256=ewSroxL7aATvvm-Xzc1_-61mP2LU2U28YaOEqvVVDB0,41
 gr_libs/recognizer/utils/format.py,sha256=e0AnqtPeYoJsV9Z7cEBpgbzTM0hLNxFIjn07fQ3YbQw,492
-tutorials/graml_minigrid_tutorial.py,sha256=iLs7mOYNAZ5wtxtSwiE8tvbLMIueQ5VmVmDnBBjWG_4,1589
-tutorials/graml_panda_tutorial.py,sha256=DuHVDLe49qwgWouLxwalqdT1P4dlNOOMdgDc3ocNX5Y,1820
-tutorials/graml_parking_tutorial.py,sha256=sQ496DNuAo9GZ_0iUZ_6Hqe5zFxIYZ_pBIHQscQvR4o,2501
-tutorials/graml_point_maze_tutorial.py,sha256=TnLT9FdDj6AF8lm0lDIZum4ouPE5rye4RBH8z4Exj2Y,2713
+tutorials/graml_minigrid_tutorial.py,sha256=0jSlsKd0H3DXA7rPSnw09y56pTSXvtXCFOKSuUvfDjs,1597
+tutorials/graml_panda_tutorial.py,sha256=LwNQPb7Kdg7X8jY7Zk13-8uBfDP8LMNzwgH-u3KOcjw,1861
+tutorials/graml_parking_tutorial.py,sha256=fsLbASIESUGnZe09eEhMcqxpU0NP8k1IQyGgJq_AFVs,1549
+tutorials/graml_point_maze_tutorial.py,sha256=gY8GCHnq32xyY7gSw3i3DL98TlfwgMkhO17csyV2QBA,1631
 tutorials/graql_minigrid_tutorial.py,sha256=VoXbEgL_hjQLfau6WohXxPK8rrv1VLA874F8PZ7ZtPk,1421
-gr_libs-0.1.3.dist-info/METADATA,sha256=Jgcr7b3qVESwqOa_odcgVjqMQK4OF0doW2if37Uwe3g,10484
-gr_libs-0.1.3.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-gr_libs-0.1.3.dist-info/top_level.txt,sha256=k7_l789QSJEr9JrtvsRMxNoTIDwNduq8mhIN-YoPJUM,29
-gr_libs-0.1.3.dist-info/RECORD,,
+gr_libs-0.1.5.dist-info/METADATA,sha256=h4QUMjuxouD3o1iKg2F3doJbKLbezkV1FaGKm1oBL0o,8905
+gr_libs-0.1.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+gr_libs-0.1.5.dist-info/top_level.txt,sha256=k7_l789QSJEr9JrtvsRMxNoTIDwNduq8mhIN-YoPJUM,29
+gr_libs-0.1.5.dist-info/RECORD,,

{gr_libs-0.1.3.dist-info → gr_libs-0.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tutorials/graml_minigrid_tutorial.py

@@ -1,11 +1,11 @@
-from gr_libs.environment.environment import QLEARNING
+from gr_libs.environment.environment import MINIGRID, QLEARNING
 from gr_libs.metrics.metrics import stochastic_amplified_selection
 from gr_libs.ml.tabular.tabular_q_learner import TabularQLearner
 from gr_libs.ml.utils.format import random_subset_with_order
 from gr_libs import ExpertBasedGraml
 
 recognizer = ExpertBasedGraml(
-	domain_name="minigrid",
+	domain_name=MINIGRID,
 	env_name="MiniGrid-SimpleCrossingS13N4"
 )
 

tutorials/graml_panda_tutorial.py

@@ -1,7 +1,8 @@
 
 import numpy as np
 from stable_baselines3 import PPO, SAC
-from gr_libs.environment.environment import PANDA, GCEnvProperty, PandaProperty
+import gr_libs.environment.environment
+from gr_libs.environment.environment import PANDA, EnvProperty, GCEnvProperty, PandaProperty
 from gr_libs.environment.utils.utils import domain_to_env_property
 from gr_libs.metrics.metrics import stochastic_amplified_selection
 from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent, GCDeepRLAgent
@@ -12,9 +13,13 @@ recognizer = GCGraml( # TODO make these tutorials into pytests
     domain_name=PANDA,
 	env_name="PandaMyReachDense"
 )
-recognizer.domain_learning_phase(base_goals=[np.array([PandaProperty.sample_goal()]) for _ in range(1,30)],
-					             train_configs=[(SAC, 800000)])
-recognizer.goals_adaptation_phase(dynamic_goals=[np.array([[-0.1, -0.1, 0.1]]), np.array([[-0.1, 0.1, 0.1]]), np.array([[0.2, 0.2, 0.1]])])
+recognizer.domain_learning_phase(
+	base_goals=[np.array([PandaProperty.sample_goal()]) for _ in range(1,30)],
+	train_configs=[(SAC, 800000)]
+)
+recognizer.goals_adaptation_phase(
+	dynamic_goals=[np.array([[-0.1, -0.1, 0.1]]), np.array([[-0.1, 0.1, 0.1]]), np.array([[0.2, 0.2, 0.1]])]
+)
 # TD3 is different from recognizer and expert algorithms, which are SAC #
 property_type = domain_to_env_property(PANDA)
 env_property = property_type("PandaMyReachDense")

tutorials/graml_parking_tutorial.py

@@ -1,31 +1,27 @@
 
 from stable_baselines3 import PPO, SAC, TD3
-from gr_libs.environment.environment import EnvProperty, GCEnvProperty, ParkingProperty
+from gr_libs.environment.environment import PARKING, EnvProperty, GCEnvProperty, ParkingProperty
 from gr_libs.metrics.metrics import stochastic_amplified_selection
 from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent, GCDeepRLAgent
 from gr_libs.ml.utils.format import random_subset_with_order
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
 
-# Consider extracting all these to "default point_maze (or every other domain) variables" module which would simplify things like the problem_list_to_str_tuple function, sizes of inputs, etc.
 recognizer = GCGraml(
-    env_name="parking", # TODO change to macros which are importable from some info or env module of enums.
-    problems=[ParkingProperty("parking-v0")],
-    train_configs=[(PPO, 400000)],
-	gc_goal_set=[f"Parking-S-14-PC--GI-{i}-v0" for i in range(1,21)]
+	domain_name=PARKING,
+	env_name="Parking-S-14-PC-"
+)
+					
+recognizer.domain_learning_phase(
+	[i for i in range(1,21)],
+	[(PPO, 200000)]
 )
-recognizer.domain_learning_phase()
 recognizer.goals_adaptation_phase(
-    dynamic_goals_problems = [ParkingProperty(p) for p in ["Parking-S-14-PC--GI-1-v0",
-                              "Parking-S-14-PC--GI-4-v0",
-                              "Parking-S-14-PC--GI-8-v0",
-                              "Parking-S-14-PC--GI-11-v0",
-                              "Parking-S-14-PC--GI-14-v0",
-                              "Parking-S-14-PC--GI-18-v0",
-                              "Parking-S-14-PC--GI-21-v0"]] # TODO detach the goal from the environment instance in every gym env, add the ability to alter it from outside.
-    #dynamic_train_configs=[(SAC, 400000) for _ in range(7)] # for expert sequence generation. TODO change to require this only if sequence generation method is EXPERT.
+    dynamic_goals = ["1", "11", "21"]
+	# no need for expert sequence generation since GCRL is used
 )
+
 # TD3 is different from recognizer and expert algorithms, which are SAC #
-actor = DeepRLAgent(env_name="parking", problem_name="Parking-S-14-PC--GI-8-v0", algorithm=TD3, num_timesteps=400000)
+actor = DeepRLAgent(domain_name="parking", problem_name="Parking-S-14-PC--GI-11-v0", algorithm=TD3, num_timesteps=400000)
 actor.learn()
 # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
 full_sequence = actor.generate_observation(
@@ -34,5 +30,5 @@ full_sequence = actor.generate_observation(
 )
 
 partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
-closest_goal = recognizer.inference_phase(partial_sequence, ParkingProperty("Parking-S-14-PC--GI-8-v0").str_to_goal(), 0.5)
-print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: 8")
+closest_goal = recognizer.inference_phase(partial_sequence, ParkingProperty("Parking-S-14-PC--GI-11-v0").str_to_goal(), 0.5)
+print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: 11")

tutorials/graml_point_maze_tutorial.py

@@ -1,36 +1,28 @@
 
 from stable_baselines3 import SAC, TD3
-from gr_libs.environment.utils.format import maze_str_to_goal
+from gr_libs.environment.environment import POINT_MAZE, PointMazeProperty
 from gr_libs.metrics.metrics import stochastic_amplified_selection
 from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
 from gr_libs.ml.utils.format import random_subset_with_order
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml
 
-# Consider extracting all these to "default point_maze (or every other domain) variables" module which would simplify things like the problem_list_to_str_tuple function, sizes of inputs, etc.
 recognizer = ExpertBasedGraml(
-    env_name="point_maze", # TODO change to macros which are importable from some info or env module of enums.
-    problems=[("PointMaze-FourRoomsEnvDense-11x11-Goal-9x1"),
-              ("PointMaze-FourRoomsEnv-11x11-Goal-9x9"), # this one doesn't work with dense rewards because of encountering local minima
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-1x9"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x3"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x4"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-8x2"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x7"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-2x8")],
-    task_str_to_goal=maze_str_to_goal,
-    method=DeepRLAgent,
-    collect_statistics=False,
-    train_configs=[(SAC, 200000) for _ in range(8)],
+	domain_name=POINT_MAZE,
+	env_name="PointMaze-FourRoomsEnvDense-11x11"
 )
-recognizer.domain_learning_phase()
+
+recognizer.domain_learning_phase(
+	[(9,1), (9,9), (1,9), (3,3), (3,4), (8,2), (3,7), (2,8)],
+	[(SAC, 200000) for _ in range(8)]
+)
+
 recognizer.goals_adaptation_phase(
-    dynamic_goals_problems = ["PointMaze-FourRoomsEnvDense-11x11-Goal-4x4",
-                              "PointMaze-FourRoomsEnvDense-11x11-Goal-7x3",
-                              "PointMaze-FourRoomsEnvDense-11x11-Goal-3x7"],
-    dynamic_train_configs=[(SAC, 200000) for _ in range(3)] # for expert sequence generation. TODO change to require this only if sequence generation method is EXPERT.
+    dynamic_goals = [(4,4), (7,3), (3,7)],
+    dynamic_train_configs=[(SAC, 200000) for _ in range(3)] # for expert sequence generation.
 )
+
 # TD3 is different from recognizer and expert algorithms, which are SAC #
-actor = DeepRLAgent(env_name="point_maze", problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4", algorithm=TD3, num_timesteps=200000)
+actor = DeepRLAgent(domain_name="point_maze", problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4", algorithm=TD3, num_timesteps=200000)
 actor.learn()
 # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
 full_sequence = actor.generate_observation(
@@ -39,5 +31,5 @@ full_sequence = actor.generate_observation(
 )
 
 partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)))
-closest_goal = recognizer.inference_phase(partial_sequence, maze_str_to_goal("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4"), 0.5)
+closest_goal = recognizer.inference_phase(partial_sequence, PointMazeProperty("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4").str_to_goal(), 0.5)
 print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (4, 4)")

gr_libs-0.1.3.dist-info/METADATA

@@ -1,197 +0,0 @@
-Metadata-Version: 2.4
-Name: gr_libs
-Version: 0.1.3
-Summary: Package with goal recognition frameworks baselines
-Author: Osher Elhadad, Ben Nageris
-Author-email: Matan Shamir <matan.shamir@live.biu.ac.il>
-License-Expression: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: gr_envs
-Requires-Dist: dill
-Requires-Dist: opencv-python
-
-# GRLib
-GRLib is a python package containing implementations of Goal Recognition (GR) algorithms which use MDPs to represent the decision making process. All agents in those algorithms interact with an environment that's registered in gym API.
-## Setup:
-If you're on linux, great, If on windows, use git bash for the next commands to work.
-1. Find where your python is installed. If you want to find where's your python3.12, you can run:
-```sh
-py -3.12 -c "import sys; print(sys.executable)"
-```
-2. Create a new empty venv from that python venv module:
-```sh
-C:/Users/path/to/Programs/Python/Python312/python.exe -m venv test_env
-```
-3. Activate the environment:
-```sh
-source test_env/Scripts/activate
-```
-4. There's no equivalent to conda env list to check the global virtual environments status, so you can verify the active one via:
-```sh
-echo $VIRTUAL_ENV
-```
-5. Install and upgrade basic package management modules:
-```sh
-/path/to/python.exe -m pip install --upgrade pip setuptools wheel versioneer
-```
-6. Install the gr_libss package (can add -e for editable mode):
-```sh
-cd /path/to/clone/of/GoalRecognitionLibs
-pip install -e .
-```
-7. Install gr_libs package (can add -e for editable mode):
-```sh
-cd /path/to/clone/of/Grlib
-pip install -e .
-```
-
-
-<!-- 1. Ensure you have python 3.11 installed.
-If you have root permissions, simply use:
-```sh
-mkdir -p ~/.local/python3.11
-dnf install python3.11 --prefix ~/.local/python3.11
-echo 'export PATH=$HOME/.local/python3.11/bin:$PATH' >> ~/.bashrc
-source ~/.bashrc
-```
-Else, use pyenv:
-```sh
-pyenv install 3.11.0
-```
-2. Create a new venv or use an existing 3.11 venv, and activate it. To create a new venv:
-```sh
-~/.pyenv/versions/3.11.0/bin/python -m venv graml_env
-./Python-3.11.0/graml_env/bin/activate
-```
-If you're not a sudo, and you have problems with building python getting such warnings:
-```sh
-WARNING: The Python ctypes extension was not compiled. Missing the libffi lib?
-```
-That means you don't have the necesarry libraries for building python, and you probably can't change that since you're not a sudoer.
-An alternative solution can be using a conda env:
-```sh
-conda create -n graml_env python=3.11
-conda activate graml_env
-```
-3. Install GoalRecognitionLibs to get all needed dependencies:
-```sh
-git clone [GoalRecognitionLibs address]
-cd GoalRecognitionLibs
-pip install -e . # using the conda's pip of course
-``` -->
-
-### Issues & Problems ###
-If you're not a sudo, and you have problems with building python getting such warnings:
-```sh
-WARNING: The Python ctypes extension was not compiled. Missing the libffi lib?
-```
-That means you don't have the necesarry libraries for building python.
-
-### How to use Grlib ###
-Now that you've installed the package, you have additional custom gym environments and you can start creating an ODGR scenario with the algorithm you wish to test.
-The tutorial at tutorials/tutorial.py follows a simple ODGR scnenario. We guide through the initialization and deployment process following an example where GRAML is expected to adapt to new emerging goals in the point_maze gym environment.
-
-#### Method 1: write your own script
-1. create the recognizer: we need to state the base problems on which the recognizer train.
-we also need the env_name for the sake of storing the trained models.
-Other notable parameters include the parameters for the training of the model: For example, Graml's LSTM needs to accept input sizes the size of the concatenation of the state space with the action space.
-
-```python
-recognizer = Graml(
-    env_name="point_maze", # TODO change to macros which are importable from some info or env module of enums.
-    problems=[("PointMaze-FourRoomsEnvDense-11x11-Goal-9x1"),
-              ("PointMaze-FourRoomsEnv-11x11-Goal-9x9"), # this one doesn't work with dense rewards because of encountering local minima
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-1x9"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x3"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x4"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-8x2"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x7"),
-              ("PointMaze-FourRoomsEnvDense-11x11-Goal-2x8")],
-    task_str_to_goal=maze_str_to_goal,
-    method=DeepRLAgent,
-    collect_statistics=False,
-    train_configs=[(SAC, 200000) for i in range(8)],
-    partial_obs_type="fragmented",
-    batch_size=32,
-    input_size=6,
-    hidden_size=8,
-    num_samples=20000,
-    problem_list_to_str_tuple=lambda problems: "_".join([f"[{s.split('-')[-1]}]" for s in problems]),
-    is_learn_same_length_sequences=False,
-    goals_adaptation_sequence_generation_method=AGENT_BASED # take expert samples in goals adaptation phase
-)
-```
-
-2. The domain learning phase: In GRAML's case, the recognizer generates a dataset by training agents towards the base goals and trains an metric model combined of an LSTM on traces generated by those agents.
-
-```python
-recognizer.domain_learning_phase()
-```
-3. The goals adaptation phase: The recognizer receives new goals, along with configurations to the training of those agents - since the sequence generation method in this case is from an expert.
-```python
-recognizer.goals_adaptation_phase(
-    dynamic_goals_problems = ["PointMaze-FourRoomsEnvDense-11x11-Goal-4x4",
-                              "PointMaze-FourRoomsEnvDense-11x11-Goal-7x3",
-                              "PointMaze-FourRoomsEnvDense-11x11-Goal-3x7"],
-    dynamic_train_configs=[(SAC, 200000) for i in range(3)] # for expert sequence generation
-)
-```
-4. Inference phase - this snippet generates a partial sequence by an agent trained towards one of the goals of the inference phase. Note how the trace is generated using a different agent from the recognizer's inner agents or expert (TD3 rather than SAC), and with noise added to every action to simulate suboptimal behavior.
-```python
-actor = DeepRLAgent(env_name="point_maze", problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4", algorithm=TD3, num_timesteps=200000)
-actor.learn()
-full_sequence = actor.generate_observation(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
-partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_fragmented="fragmented")
-closest_goal = recognizer.inference_phase(partial_sequence, maze_str_to_goal("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4"), 0.5)
-```
-5. check the result returned by GRAML and print whether it was right or not.
-```python
-print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (4, 4)")
-```
-
-#### Method 2: use a configuration file
-The configuraiton file consts.py holds configurations of ODGR problems.
-You can either use existing ones or add new ones.
-Note that using the config file, despite being easier on a large scale, some inputs to the ODGR problem are not as flexible as they would be using method 1.
-For example, the sequence generation will be performed by trained agents and is non configurable. The sequences will either be completely consecutive or randomly sampled from the trace.
-Example for a problem:
-
-You can use odgr_executor.py to execute a single task:
-```sh
-python odgr_executor.py --recognizer MCTSBasedGraml --domain minigrid --task L1 --minigrid_env MinigridSimple
-```
-
-
-## Supported Algorithms
-
-| **Name**         | **Supervised**      | **RL**          | **Discrete**     | **Continuous** | **Model-Based**  | **Model-Free** | **Actions Only** |
-| ------------------- | ------------------ | ------------------ | ------------------ | ------------------- | ------------------ | --------------------------------- |
-| GRAQL   | :x: | :heavy_check_mark: | :heavy_check_mark: | :x: | :x: | :heavy_check_mark: | :x: |
-| DRACO   | :x: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x: | :heavy_check_mark: | :x: |
-| GRAML   | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x: | :heavy_check_mark: | :heavy_check_mark: |
-
-## Supported Domains
-
-| **Name**         | **Action**      | **State**          |
-| ------------------- | ------------------ | ------------------ |
-| Minigrid   | Discrete | Discrete |
-|  PointMaze  | Continuous | Continuous |
-| Parking   | Continuous | Continuous |
-| Panda   | Continuous | Continuous |
-
-### Experiments
-Given here is a guide for executing the experiments. There are benchmark domains suggested in the repository, and the 'scripts' directory suggests a series of tools to analyze them. They are defaultly set on the domains used for GRAML and GRAQL analysis during the writing of GRAML paper, but can easily be adjusted for new domains and algorithms.
-1. analyze_results_cross_alg_cross_domain.py: this script runs with no arguments. it injects information from get_experiment_results_path (for example: dataset\graml\minigrid\continuing\inference_same_seq_len\learn_diff_seq_len\experiment_results\obstacles\L111\experiment_results.pkl), and produces a plot with 4 figures showing the accuracy trend of algorithms on the domains checked one against the other. Currently GRAML is checked against GRAQL or DRACO but it can easily be adjusted from within the script.
-2. generate_task_specific_statistics_plots.py - this script produces, for a specific task execution (results of execution of experiments.py), a summary combined of a figure with sticks with the accuracies and confidence levels of an algorithm on the task on the varying percentages. figures\point_maze\obstacles\graql_point_maze_obstacles_fragmented_stats.png is an example of a path at which the output is dumped. Another product of this script is a confusion matrix with the confidence levels - visualizing the same data, and the output file resides in this path: figures\point_maze\obstacles\graml_point_maze_obstacles_fragmented_inference_same_seq_len_learn_diff_seq_len_goals_conf_mat.png.
-
-### How to add a new environment
-1. bla
-2. blalba
-
-### How to add a new Learner