gr-libs 0.1.7.post0__py3-none-any.whl → 0.2.2__py3-none-any.whl

{gr_libs-0.1.7.post0.dist-info → gr_libs-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.7.post0
+Version: 0.2.2
 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>
@@ -106,6 +106,25 @@ If you prefer using Conda, follow these steps:
 
 For any issues or troubleshooting, please refer to the repository's issue tracker.
 
+## 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     |
+
 ## 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.
@@ -116,9 +135,10 @@ Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tu
 gr_libs also includes a library of trained agents for the various supported environments within the package.
 To get the dataset of trained agents, you can run:
 ```sh
+pip install gdown
 python download_dataset.py
 ```
-
+Alternatively, you can visit the google-drive links where download_dataset.py points to and manually download the zipped folders, and unzip them into the project directory.
 An alternative is to use our docker image, which includes the dataset in it.
 You can:
 1. pull the image:
@@ -191,42 +211,77 @@ docker run -it ghcr.io/MatanShamir1/gr_test_base:latest bash
 
 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:
+To execute an ODGR problem using the configuration file, you specify a recognizer, a domain, a gym environment within that domain and the task:
 ```sh
-python odgr_executor.py --recognizer MCTSBasedGraml --domain minigrid --task L1 --minigrid_env MinigridSimple
+python odgr_executor.py --recognizer ExpertBasedGraml --domain minigrid --task L1 --env_name MiniGrid-SimpleCrossingS13N4
 ```
 
-## Supported Algorithms
+If you also add the flag:
+```sh
+ --collect_stats
+```
+to the cmd, 3 kinds of outputs will be generated from the ODGR problem's execution:
+a. Into:
+```sh
+outputs\\minigrid\MiniGrid-SimpleCrossingS13N4\MiniGrid-SimpleCrossingS13N4\L1\experiment_results
+```
+a .pkl and a .txt summary in a dictionary format will be generated, including the summary of all ODGR executions, including runtime and overall accuracies for all lengths and types of input sequences.
 
-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).
+b. Into:
+```sh
+outputs\ExpertBasedGraml\minigrid\MiniGrid-SimpleCrossingS13N4\policy_sequences\MiniGrid-SimpleCrossingS13N4-DynamicGoal-1x11-v0_inference_seq/plan_image.png
+```
+a visulzation of the sequence the agent generated will be dumped, either in a png or an mp4 format, depending on the domain, for debugability.
 
-| **Algorithm** | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** |
-|--------------|--------------|------------------------|------------------|------------------|--------------|--------------|--------------|--------------|--------------|
-| GRAQL       | ❌           | ✅                     | ✅                | ❌                | ✅                | ❌                | ❌           | ✅           | ❌           |
-| DRACO (GC)  | ❌           | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ❌           |
-| GRAML (GC, BG) | ✅        | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ✅           |
+c. Into:
+either:
+```sh
+outputs\ExpertBasedGraml\minigrid\MiniGrid-SimpleCrossingS13N4\goal_embeddings
+```
+In Graml algorithms, or:
+```sh
+outputs\Graql\minigrid\MiniGrid-SimpleCrossingS13N4\confidence
+```
+In GRAsRL algorithms,
+pickled results from which confidence of the results can be obtained, for offline analysis.
 
-## Supported Domains
+For GRAsRL outputs, for every possible goal, the likelihood of it being the true goal from the input sequence, based on the policy distance metric.
 
-| **Domain**  | **Action Space** | **State Space** |
-|------------|----------------|----------------|
-| Minigrid   | Discrete       | Discrete       |
-| PointMaze  | Continuous     | Continuous     |
-| Parking    | Continuous     | Continuous     |
-| Panda      | Continuous     | Continuous     |
+For GRAML outputs, the embeddings of the sequences are pickled for every goal-directed sequence. Offline, since, since in the embdding space of GRAML's metric model- sequences towards the same sequences are close and vice versa, one could reproduce the most likely goal by measuring the elementwise vector distance of the embeddings, and retrieve a confidence of it.
 
 ## Running Experiments
 
-The repository provides benchmark domains and scripts for analyzing experimental results. The `scripts` directory contains tools for processing and visualizing results.
+In light of the previous section, the user should already know how to scale the experiments using odgr_executor, and they should also understand how to use the 3 types of outputs for offline analysis of the algorithms.
+gr_libs also provides another scaling method to run odgr_executor on multiple domains and environments, for many ODGR problems, as well as python scripts for analysis of these results, to create plots and statistics over the executions.
+
+### Scaling odgr_executor runs
+A part of the contribution of this package is standardizing the evaluations of MDP-based GR frameworks.
+consts.py provides a set of ODGR problems on which the framework can be evaluated.
+The 'evaluations' sub-package provides scripts to analyze the results of the all_experiments.py execution, done over the ODGR the problems defined at consts.py.
 
-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.
+In order to parallelize executions of odgr_executor.py, you can edit all_experiments.py with your combination of domains, environments and tasks.
+This script use multiprocessing to simultaniously execute many odgr_executor.py python executions as child processes.
 
-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`
+It logs failures and successful executions for debugability.
+
+After execution, another level of abstraction for the results is created. For example, when running for Graql in the minigrid domain:
+```sh
+outputs\summaries\detailed_summary_minigrid_Graql.txt
+```
+Will show the accuracies for every ODGR problem, for every percentage and type of input in a table-like .txt format, whike:
+```sh
+outputs\summaries\compiled_summary_minigrid_Graql.txt
+```
+Will show the same results in a more compact summary.
+
+### Using analysis scripts
+The repository provides benchmark domains and scripts for analyzing experimental results. The `evaluation` directory contains tools for processing and visualizing the results from odgr_executor.py and all_experiments.py.
+Please follow the README.md file in the 'evaluation' directory for more details.
+
+## For Developers
+Developers will need to work slightly different: instead of installing the packages, they need to clone the repos and either install them as editables or add their paths to PYTHONPATH so they will function as packages effectively.
+Additional packages to install as a developer:
+```sh
+pip install pre-commit
+pre-commit install
+```

gr_libs-0.2.2.dist-info/RECORD

@@ -0,0 +1,71 @@
+gr_libs/__init__.py,sha256=XGx0_nWGgy-1zEQUXHRBs3TTb13jX9yOxVvSaavCkBk,376
+gr_libs/_version.py,sha256=OjGGK5TcHVG44Y62aAqeJH4CskkZoY9ydbHOtCDew50,511
+gr_libs/all_experiments.py,sha256=0Xm1KZ1YDWGcAiYKc6IilZ-UyVuxm77iZNsUVzTURqY,11357
+gr_libs/odgr_executor.py,sha256=AdO5qpQ6fZcVRxJg0O-mSKDXim3gVQbq8vSmfx0AjQk,10615
+gr_libs/_evaluation/__init__.py,sha256=trZ-4PyOhzEEK_TvQLfbnNFcqYuN6SdRjDkkAdW6MW8,78
+gr_libs/_evaluation/_analyze_results_cross_alg_cross_domain.py,sha256=ksguC1zeokjpd_ItC5e6MX8HE9qEtjw-uxCXzwGsO88,9863
+gr_libs/_evaluation/_generate_experiments_results.py,sha256=Nj2XLDJ-g9Vn_3oA3tEDu8qWQcIT25Hf_tRySm00oGc,5163
+gr_libs/_evaluation/_generate_task_specific_statistics_plots.py,sha256=Jgst3PW-XTu1JHWhyl73zi4mqoUI3U3dHLIUemKSx7c,19051
+gr_libs/_evaluation/_get_plans_images.py,sha256=a_e97aOMiZ8toBiAIzJCx75lF9RLiVfxROYvcoNy6rM,2729
+gr_libs/_evaluation/_increasing_and_decreasing_.py,sha256=1VOHrriv9mdhc1fxNjVAsu-sO77KRnscbmFXNUub0YU,3868
+gr_libs/environment/__init__.py,sha256=xCCzTFDrj_ijdLoZ-PzGyyYDeU2aoW19X1da76_x9iM,1458
+gr_libs/environment/environment.py,sha256=G3XXuhJDtduOtNeMCbwbMAygfP55AI07Aufs9QrggWQ,16389
+gr_libs/environment/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/environment/_utils/utils.py,sha256=dKuWoUpyuGSJL6qHQfvvJnFf4g-Rh1t2ykuRNrsIvP8,614
+gr_libs/metrics/__init__.py,sha256=dQo4cMqrOB2-VLDxTIGryCm14mUnmEXs4F8jqcgNsY4,145
+gr_libs/metrics/metrics.py,sha256=tpjr4hKt5AGft5H2YxkbF0O8La5JZQaOmnkyjptD2M8,13430
+gr_libs/ml/__init__.py,sha256=xX9InKnWhYm8e0Lhsnnm0H68yBPTNEfq756w95xv-98,83
+gr_libs/ml/agent.py,sha256=ea1yRltKX0LSpRMnpAQLRKvvKoLMQz9MgMeWBPhQISw,2095
+gr_libs/ml/consts.py,sha256=vsEB1nk5V_qP3FjNlv4vBKeTTFngV3RNaNp6fWnmEz0,366
+gr_libs/ml/base/__init__.py,sha256=f63VN3Lv4tQp3dAZjtT78PGV5XuOD8WlU4svy43LZrU,123
+gr_libs/ml/base/rl_agent.py,sha256=Ewqu583gUkgRmeGWCJgkyDBKxTqQnN4qa2vxq0-ydoE,3843
+gr_libs/ml/neural/__init__.py,sha256=vGdjx1KzlB9UxNRwkAeYBEoYdVtRdhj0M4mtWuzqvU8,55
+gr_libs/ml/neural/deep_rl_learner.py,sha256=iy0N0BaUW3jRttLYUteApNWBI5pIYZTjJn2v32UVUQ4,26950
+gr_libs/ml/neural/utils/__init__.py,sha256=Av5wB2eSHR7spHqZFdgau_9EJV0FmijaYqXeyGMwktQ,69
+gr_libs/ml/neural/utils/dictlist.py,sha256=ORFez_KmaCzraStF97hxdgCAAALP4Er8u3e9RcqlvhM,1030
+gr_libs/ml/planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/planner/mcts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/planner/mcts/mcts_model.py,sha256=Cv9hDrxTSK5tiaqPqp6-oO68EbETWlvRFweVRfwfjgg,27827
+gr_libs/ml/planner/mcts/_utils/__init__.py,sha256=0ccEf23-6VIenUSrlVFCq0VNVDkCHHNzBw7jR09UiO4,46
+gr_libs/ml/planner/mcts/_utils/node.py,sha256=LcbBjzURMDF4v_Lvz24dyhhW5xb1xQKWdPkue-2lNLM,1056
+gr_libs/ml/planner/mcts/_utils/tree.py,sha256=ua_7pN00K7ECm6fk0TdRpDTe-z4J4iC6f84GCC0ceKc,3399
+gr_libs/ml/sequential/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/sequential/_lstm_model.py,sha256=3fXduJt1BkA2dPzA_jKInmZvUd1UpThHE8kqNCDCul0,10693
+gr_libs/ml/tabular/__init__.py,sha256=yzHIPrn1lqVEDJbLbSz7RzNSr8IjU4TBdP0pqzQSFGU,32
+gr_libs/ml/tabular/state.py,sha256=ImpIrYWF80PB-4EeQ2Q9nO7jMZ2s0hGbgsir1ZtsO88,700
+gr_libs/ml/tabular/tabular_q_learner.py,sha256=eZ4Db-YgzQd4DIpFl4DvO7zVM-w2mHGFNk18-5ZmB4c,20122
+gr_libs/ml/tabular/tabular_rl_agent.py,sha256=bL8Rk4dMY5HmeyVVmo986ZOizISfArskxLjf5DL87Uk,4205
+gr_libs/ml/utils/__init__.py,sha256=-shnIzZCGBxZfcpep39bIoBKYED-SIN8I_HFUkVjay0,164
+gr_libs/ml/utils/env.py,sha256=AWVN0OXYmFU-J3FUiwvEAIY93Suf1oL6VNcxtyWJraM,171
+gr_libs/ml/utils/format.py,sha256=Vn2l7zmfqZ9Hq2pk2nlzQuVElmVyXr6nME6GsVNvVPE,1068
+gr_libs/ml/utils/math.py,sha256=7Au9L-FHE7eB1ygLbbuR6AhZK6kq8D_9srVtu4iDMPk,429
+gr_libs/ml/utils/other.py,sha256=93oaveiHUzWt_rCDVqybrpHdAfI3UBPCto31Nm5yT0Y,506
+gr_libs/ml/utils/storage.py,sha256=CgZHWcC3GovKe-U3Cvwz0s5qCbBrYHY6w_CV-LnTquc,3791
+gr_libs/problems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/problems/consts.py,sha256=kgmaUi3wbHvcBfnIaXT8D79J_cD1yTrwgha6k3Y429Y,62096
+gr_libs/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/recognizer.py,sha256=gtUttI1473co5ZHgO7-wQ7HL-aYJp0S4X6goqVYyT24,3091
+gr_libs/recognizer/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/_utils/format.py,sha256=eCoqEwv7YdLrF5nb-xAbDXxQ-ogvq_DHf9I2uwdfv-0,512
+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=ztucO7YRZ3mZDGdt98OUAu_DJHVgUhUEvIngL2swfCE,9705
+gr_libs/recognizer/graml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/graml/_gr_dataset.py,sha256=JChqXOh7TP8yu-zQPCQ34ghw7iJFnAzd2FkeOyndvFk,10038
+gr_libs/recognizer/graml/graml_recognizer.py,sha256=M-tvipAMn_tiWbM3M74D5zH8yKbPEwR-sKTQy3FZT3E,26058
+gr_libs/tutorials/draco_panda_tutorial.py,sha256=9_scjcyMjkjw8l6g9E-GKOrFTxsIIndW_J1WKjE6-wo,2146
+gr_libs/tutorials/draco_parking_tutorial.py,sha256=jjbNzSv5l4EvjydwslNYh51xHoIkNmcjPbi0YL6WAeA,1896
+gr_libs/tutorials/gcdraco_panda_tutorial.py,sha256=KsYStJPk9vI7PUuJrwBaMcQ5a9GT-00-DGJgqRmYvgs,2230
+gr_libs/tutorials/gcdraco_parking_tutorial.py,sha256=wvhwIwXw_h_VP4OBdsnv2rn9WTTaXJXA_xZ8mLHxcmg,2053
+gr_libs/tutorials/graml_minigrid_tutorial.py,sha256=msw19nRKAFUJGZy0JNym1At3Zoe5cGxppt24xcElLTQ,2205
+gr_libs/tutorials/graml_panda_tutorial.py,sha256=DC0AyiZswc5zOKFd0xTYU72ugaCLlf7xtnOGFsmv7MQ,2140
+gr_libs/tutorials/graml_parking_tutorial.py,sha256=Qf39bdpF4lgppKlDO3qa1CfswmbubqKBXJlPMn2PfhI,1941
+gr_libs/tutorials/graml_point_maze_tutorial.py,sha256=L95_2u1SA1aZJS-C4dQdq-97Sv6nFYNve2FAX2p5_Mc,2188
+gr_libs/tutorials/graql_minigrid_tutorial.py,sha256=HT8kCFNbZXAraIau9wtgC_aW8xg-QNRZB2lcpGm3yWk,1941
+tests/test_draco.py,sha256=oIeTDgn6pt3RfTC-RPX3Bw5cG4BThxRGH3z8en3TX0M,385
+tests/test_gcdraco.py,sha256=vV6rp7PkJJk_WpAfRekb197QiMHjXXApqrBiLG9RTwo,308
+tests/test_graml.py,sha256=amSikMWrGS9BNVSXGNKc1n5tfRl-FfgCsyHYsJtduD4,608
+tests/test_graql.py,sha256=KxVKx6rcSCbN-PjxR2DFoKcILRUmMDz0dTM5SvJZMXg,154
+gr_libs-0.2.2.dist-info/METADATA,sha256=0hqzG9XaGJmqfJ36sKLPnlU1lFUqHdOr7if1icu1sV0,12992
+gr_libs-0.2.2.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+gr_libs-0.2.2.dist-info/top_level.txt,sha256=Yzc_VSW3gzbVM7ZtlV4r6VXmfAC8WXqGVUgK1r6JcLs,14
+gr_libs-0.2.2.dist-info/RECORD,,

{gr_libs-0.1.7.post0.dist-info → gr_libs-0.2.2.dist-info}/WHEEL

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

gr_libs-0.2.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+gr_libs
+tests

tests/test_draco.py

@@ -0,0 +1,14 @@
+from gr_libs.tutorials.draco_panda_tutorial import run_draco_panda_tutorial
+from gr_libs.tutorials.draco_parking_tutorial import run_draco_parking_tutorial
+
+
+def test_draco_panda_tutorial():
+    run_draco_panda_tutorial()
+
+
+def test_draco_parking_tutorial():
+    run_draco_parking_tutorial()
+
+if __name__ == "__main__":
+    test_draco_panda_tutorial()
+    test_draco_parking_tutorial()

tests/test_gcdraco.py

@@ -0,0 +1,10 @@
+from gr_libs.tutorials.gcdraco_panda_tutorial import run_gcdraco_panda_tutorial
+from gr_libs.tutorials.gcdraco_parking_tutorial import run_gcdraco_parking_tutorial
+
+
+def test_gcdraco_panda_tutorial():
+    run_gcdraco_panda_tutorial()
+
+
+def test_gcdraco_parking_tutorial():
+    run_gcdraco_parking_tutorial()

tests/test_graml.py

@@ -1,16 +1,20 @@
-from tutorials.graml_minigrid_tutorial import run_graml_minigrid_tutorial
-from tutorials.graml_panda_tutorial import run_graml_panda_tutorial
-from tutorials.graml_parking_tutorial import run_graml_parking_tutorial
-from tutorials.graml_point_maze_tutorial import run_graml_point_maze_tutorial
+from gr_libs.tutorials.graml_minigrid_tutorial import run_graml_minigrid_tutorial
+from gr_libs.tutorials.graml_panda_tutorial import run_graml_panda_tutorial
+from gr_libs.tutorials.graml_parking_tutorial import run_graml_parking_tutorial
+from gr_libs.tutorials.graml_point_maze_tutorial import run_graml_point_maze_tutorial
+
 
 def test_graml_minigrid_tutorial():
-	run_graml_minigrid_tutorial()
+    run_graml_minigrid_tutorial()
+
 
 def test_graml_panda_tutorial():
-	run_graml_panda_tutorial()
+    run_graml_panda_tutorial()
+
 
 def test_graml_parking_tutorial():
-	run_graml_parking_tutorial()
+    run_graml_parking_tutorial()
+
 
 def test_graml_point_maze_tutorial():
-	run_graml_point_maze_tutorial()
+    run_graml_point_maze_tutorial()

tests/test_graql.py

@@ -1,4 +1,5 @@
-from tutorials.graql_minigrid_tutorial import run_graql_minigrid_tutorial
+from gr_libs.tutorials.graql_minigrid_tutorial import run_graql_minigrid_tutorial
+
 
 def test_graql_minigrid_tutorial():
-	run_graql_minigrid_tutorial()
+    run_graql_minigrid_tutorial()

evaluation/analyze_results_cross_alg_cross_domain.py

@@ -1,277 +0,0 @@
-import copy
-import sys
-import matplotlib.pyplot as plt
-import numpy as np
-import os
-import dill
-from scipy.interpolate import make_interp_spline
-from scipy.ndimage import gaussian_filter1d
-from gr_libs.ml.utils.storage import get_experiment_results_path, set_global_storage_configs
-from scripts.generate_task_specific_statistics_plots import get_figures_dir_path
-
-def smooth_line(x, y, num_points=300):
-    x_smooth = np.linspace(np.min(x), np.max(x), num_points)
-    spline = make_interp_spline(x, y, k=3)  # Cubic spline
-    y_smooth = spline(x_smooth)
-    return x_smooth, y_smooth
-
-if __name__ == "__main__":
-
-	fragmented_accuracies = {
-		'graml': {
-			'panda': {'gd_agent': {
-									'0.3': [], # every list here should have number of tasks accuracies in it, since we done experiments for L111-L555. remember each accuracy is an average of #goals different tasks.
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-					  'gc_agent': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-			'minigrid': {'obstacles': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-						 'lava_crossing': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-			'point_maze': {'obstacles': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-					  	   'four_rooms': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-			'parking': {'gd_agent': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-						'gc_agent': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-		},
-		'graql': {
-			'panda': {'gd_agent': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-					  'gc_agent': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-			'minigrid': {'obstacles': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-						 'lava_crossing': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-			'point_maze': {'obstacles': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-					  	   'four_rooms': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-			'parking': {'gd_agent': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 },
-						'gc_agent': {
-									'0.3': [],
-									'0.5': [],
-									'0.7': [],
-									'0.9': [],	
-									'1'	: []
-								 }},
-		}
-	}
-
-	continuing_accuracies = copy.deepcopy(fragmented_accuracies)
- 
-	#domains = ['panda', 'minigrid', 'point_maze', 'parking']
-	domains = ['minigrid', 'point_maze', 'parking']
-	tasks = ['L111', 'L222', 'L333', 'L444', 'L555']
-	percentages = ['0.3', '0.5', '1']
-
-	for partial_obs_type, accuracies, is_same_learn in zip(['fragmented', 'continuing'], [fragmented_accuracies, continuing_accuracies], [False, True]):
-		for domain in domains:
-			for env in accuracies['graml'][domain].keys():
-				for task in tasks:
-					set_global_storage_configs(recognizer_str='graml', is_fragmented=partial_obs_type,
-											is_inference_same_length_sequences=True, is_learn_same_length_sequences=is_same_learn)
-					graml_res_file_path = f'{get_experiment_results_path(domain, env, task)}.pkl'
-					set_global_storage_configs(recognizer_str='graql', is_fragmented=partial_obs_type)
-					graql_res_file_path = f'{get_experiment_results_path(domain, env, task)}.pkl'
-					if os.path.exists(graml_res_file_path):
-						with open(graml_res_file_path, 'rb') as results_file:
-							results = dill.load(results_file)
-							for percentage in accuracies['graml'][domain][env].keys():
-								accuracies['graml'][domain][env][percentage].append(results[percentage]['accuracy'])
-					else:
-						assert(False, f"no file for {graml_res_file_path}")
-					if os.path.exists(graql_res_file_path):
-						with open(graql_res_file_path, 'rb') as results_file:
-							results = dill.load(results_file)
-							for percentage in accuracies['graml'][domain][env].keys():
-								accuracies['graql'][domain][env][percentage].append(results[percentage]['accuracy'])
-					else:
-						assert(False, f"no file for {graql_res_file_path}")
-
-	plot_styles = {
-		('graml', 'fragmented', 0.3): 'g--o',  # Green dashed line with circle markers
-		('graml', 'fragmented', 0.5): 'g--s',  # Green dashed line with square markers
-		('graml', 'fragmented', 0.7): 'g--^',  # Green dashed line with triangle-up markers
-		('graml', 'fragmented', 0.9): 'g--d',  # Green dashed line with diamond markers
-		('graml', 'fragmented', 1.0): 'g--*',  # Green dashed line with star markers
-		
-		('graml', 'continuing', 0.3): 'g-o',   # Green solid line with circle markers
-		('graml', 'continuing', 0.5): 'g-s',   # Green solid line with square markers
-		('graml', 'continuing', 0.7): 'g-^',   # Green solid line with triangle-up markers
-		('graml', 'continuing', 0.9): 'g-d',   # Green solid line with diamond markers
-		('graml', 'continuing', 1.0): 'g-*',   # Green solid line with star markers
-		
-		('graql', 'fragmented', 0.3): 'b--o',  # Blue dashed line with circle markers
-		('graql', 'fragmented', 0.5): 'b--s',  # Blue dashed line with square markers
-		('graql', 'fragmented', 0.7): 'b--^',  # Blue dashed line with triangle-up markers
-		('graql', 'fragmented', 0.9): 'b--d',  # Blue dashed line with diamond markers
-		('graql', 'fragmented', 1.0): 'b--*',  # Blue dashed line with star markers
-		
-		('graql', 'continuing', 0.3): 'b-o',   # Blue solid line with circle markers
-		('graql', 'continuing', 0.5): 'b-s',   # Blue solid line with square markers
-		('graql', 'continuing', 0.7): 'b-^',   # Blue solid line with triangle-up markers
-		('graql', 'continuing', 0.9): 'b-d',   # Blue solid line with diamond markers
-		('graql', 'continuing', 1.0): 'b-*',   # Blue solid line with star markers
-	}
-
-	def average_accuracies(accuracies, domain):
-		avg_acc = {algo: {perc: [] for perc in percentages} 
-				   for algo in ['graml', 'graql']}
-		
-		for algo in avg_acc.keys():
-			for perc in percentages:
-				for env in accuracies[algo][domain].keys():
-					env_acc = accuracies[algo][domain][env][perc] # list of 5, averages for L111 to L555.
-					if env_acc:
-						avg_acc[algo][perc].append(np.array(env_acc))
-		
-		for algo in avg_acc.keys():
-			for perc in percentages:
-				if avg_acc[algo][perc]:
-					avg_acc[algo][perc] = np.mean(np.array(avg_acc[algo][perc]), axis=0)
-		
-		return avg_acc
-
-	def plot_domain_accuracies(ax, fragmented_accuracies, continuing_accuracies, domain, sigma=1, line_width=1.5):
-		fragmented_avg_acc = average_accuracies(fragmented_accuracies, domain)
-		continuing_avg_acc = average_accuracies(continuing_accuracies, domain)
-		
-		x_vals = np.arange(1, 6)  # Number of goals
-		
-		# Create "waves" (shaded regions) for each algorithm
-		for algo in ['graml', 'graql']:
-			fragmented_y_vals_by_percentage = []
-			continuing_y_vals_by_percentage = []
-
-			for perc in percentages:
-				fragmented_y_vals = np.array(fragmented_avg_acc[algo][perc])
-				continuing_y_vals = np.array(continuing_avg_acc[algo][perc])
-
-				# Smooth the trends using Gaussian filtering
-				fragmented_y_smoothed = gaussian_filter1d(fragmented_y_vals, sigma=sigma)
-				continuing_y_smoothed = gaussian_filter1d(continuing_y_vals, sigma=sigma)
-
-				fragmented_y_vals_by_percentage.append(fragmented_y_smoothed)
-				continuing_y_vals_by_percentage.append(continuing_y_smoothed)
-
-				ax.plot(
-					x_vals, fragmented_y_smoothed, 
-					plot_styles[(algo, 'fragmented', float(perc))], 
-					label=f"{algo}, non-consecutive, {perc}",
-					linewidth=0.5  # Control line thickness here
-				)
-				ax.plot(
-					x_vals, continuing_y_smoothed, 
-					plot_styles[(algo, 'continuing', float(perc))], 
-					label=f"{algo}, consecutive, {perc}",
-					linewidth=0.5  # Control line thickness here
-				)
-		
-		ax.set_xticks(x_vals)
-		ax.set_yticks(np.linspace(0, 1, 6))
-		ax.set_ylim([0, 1])
-		ax.set_title(f'{domain.capitalize()} Domain', fontsize=16)
-		ax.grid(True)
-
-	fig, axes = plt.subplots(1, 4, figsize=(24, 6))  # Increase the figure size for better spacing (width 24, height 6)
-	
-	# Generate each plot in a subplot, including both fragmented and continuing accuracies
-	for i, domain in enumerate(domains):
-		plot_domain_accuracies(axes[i], fragmented_accuracies, continuing_accuracies, domain)
-
-	# Set a single x-axis and y-axis label for the entire figure
-	fig.text(0.5, 0.04, 'Number of Goals', ha='center', fontsize=20)  # Centered x-axis label
-	fig.text(0.04, 0.5, 'Accuracy', va='center', rotation='vertical', fontsize=20)  # Reduced spacing for y-axis label
-
-	# Adjust subplot layout to avoid overlap
-	plt.subplots_adjust(left=0.09, right=0.91, top=0.79, bottom=0.21, wspace=0.3)  # More space on top (top=0.82)
-	
-	# Place the legend above the plots with more space between legend and plots
-	handles, labels = axes[0].get_legend_handles_labels()
-	fig.legend(handles, labels, loc='upper center', ncol=4, bbox_to_anchor=(0.5, 1.05), fontsize=12)  # Moved above with bbox_to_anchor
-
-	# Save the figure and show it
-	save_dir = os.path.join('figures', 'all_domains_accuracy_plots')
-	if not os.path.exists(save_dir):
-		os.makedirs(save_dir)
-	plt.savefig(os.path.join(save_dir, 'accuracy_plots_smooth.png'), dpi=300)
- 

evaluation/create_minigrid_map_image.py

@@ -1,34 +0,0 @@
-from minigrid.wrappers import RGBImgPartialObsWrapper, ImgObsWrapper
-import numpy as np
-import gr_libs.ml as ml
-from minigrid.core.world_object import Wall
-#from q_table_plot import save_q_table_plot_image
-from gymnasium.envs.registration import register
-
-env_name = "MiniGrid-SimpleCrossingS13N4-DynamicGoal-5x9-v0"
-# create an agent and train it (if it is already trained, it will get q-table from cache)
-agent = ml.TabularQLearner(env_name='MiniGrid-Walls-13x13-v0',problem_name = "MiniGrid-SimpleCrossingS13N4-DynamicGoal-5x9-v0")
-# agent.learn()
-
-# save_q_table_plot_image(agent.q_table, 15, 15, (10,7))
-
-# add to the steps list the step the trained agent would take on the env in every state according to the q_table
-env = agent.env
-env = RGBImgPartialObsWrapper(env) # Get pixel observations
-env = ImgObsWrapper(env) # Get rid of the 'mission' field
-obs, _ = env.reset() # This now produces an RGB tensor only
-
-img = env.get_frame()
-
-####### save image to file
-from PIL import Image
-import numpy as np
-
-image_pil = Image.fromarray(np.uint8(img)).convert('RGB')
-image_pil.save(r"{}.png".format(env_name))
-
-# ####### show image
-# from gym_minigrid.window import Window
-# window = Window(r"z")
-# window.show_img(img=img)
-# window.close()

evaluation/file_system.py

@@ -1,42 +0,0 @@
-import os
-import dill
-import random
-import hashlib
-from typing import List
-
-def get_observations_path(env_name: str):
-    return f"dataset/{env_name}/observations"
-
-def get_observations_paths(path: str):
-    return [os.path.join(path, file_name) for file_name in os.listdir(path)]
-
-def create_partial_observabilities_files(env_name: str, observabilities: List[float]):
-    with open(r"dataset/{env_name}/observations/obs1.0.pkl".format(env_name=env_name), "rb") as f:
-        step_1_0 = dill.load(f)
-
-    number_of_items_to_randomize = [int(observability * len(step_1_0)) for observability in observabilities]
-    obs = []
-    for items_to_randomize in number_of_items_to_randomize:
-        obs.append(random.sample(step_1_0, items_to_randomize))
-    for index, observability in enumerate(observabilities):
-        partial_steps = obs[index]
-        file_path = r"dataset/{env_name}/observations/obs{obs}.pkl".format(env_name=env_name, obs=observability)
-        with open(file_path, "wb+") as f:
-            dill.dump(partial_steps, f)
-            
-def md5(file_path: str):
-    hash_md5 = hashlib.md5()
-    with open(file_path, "rb") as f:
-        for chunk in iter(lambda: f.read(4096), b""):
-            hash_md5.update(chunk)
-    return hash_md5.hexdigest()
-
-def get_md5(file_path_list: List[str]):
-    return [(file_path, md5(file_path=file_path)) for file_path in file_path_list]
-
-
-def print_md5(file_path_list: List[str]):
-    md5_of_observations = get_md5(file_path_list=file_path_list)
-    for file_name, file_md5 in md5_of_observations:
-        print(f"{file_name}:{file_md5}")
-    print("")