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

gr_libs-0.2.5.dist-info/RECORD

@@ -0,0 +1,72 @@
+gr_libs/__init__.py,sha256=XGx0_nWGgy-1zEQUXHRBs3TTb13jX9yOxVvSaavCkBk,376
+gr_libs/_version.py,sha256=N3oBwJUFmS-AwCjqOcSlRW4GvSq-uJJMaBvoGfv1-hM,511
+gr_libs/all_experiments.py,sha256=OTTMx5ddy7z3kJbElQcR5nwEtshPsoehNPwDuMzojcc,10006
+gr_libs/odgr_executor.py,sha256=ttfEjeEBjr_YusegCX2zx11NBMfeXUwyKJjryYS6QaY,10685
+gr_libs/_evaluation/_generate_experiments_results.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/environment/__init__.py,sha256=xCCzTFDrj_ijdLoZ-PzGyyYDeU2aoW19X1da76_x9iM,1458
+gr_libs/environment/environment.py,sha256=fAjkM5XyfFBlP6U3yjMyGj_WDI2c4fM2Ac-e7-kSKuM,16940
+gr_libs/environment/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/environment/_utils/utils.py,sha256=dKuWoUpyuGSJL6qHQfvvJnFf4g-Rh1t2ykuRNrsIvP8,614
+gr_libs/evaluation/__init__.py,sha256=trZ-4PyOhzEEK_TvQLfbnNFcqYuN6SdRjDkkAdW6MW8,78
+gr_libs/evaluation/generate_experiments_results.py,sha256=mXsGlOJKqRwtTDxuIVlsZhwgLyHAKb3zmK6jAVE7G7o,3420
+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=fq5n78RelIi794nNIl9x-W8ZnO5kXmD0LYv2q_2xMs8,26690
+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=FQk2TaKAFHdZiISubGXeYleBaOXpk8ZC749NtP5RqWs,68520
+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=MvXPRyr30W5C_n-Dul3aheE_9SWy2aIMGINKWj36mfM,42
+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=asjsjg52f43vlFPw1iT7PK8oOopa-u0UN7XBgiuufAY,10158
+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=BVV-qn46AffkALRudBydHU24BGwMnvGFB1WSkIOAcWs,26292
+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=HzGKqZR--rcTYj3RQMuQCzTVll2Q-Z_RQbmGpcZPovg,2301
+gr_libs/tutorials/gcdraco_parking_tutorial.py,sha256=kd7xRsjGPCHohwhbJEK5XAsD3R9k8rcd0qz8IZIgjN4,2103
+gr_libs/tutorials/graml_minigrid_tutorial.py,sha256=bEsi21-9-AiOw4-H98Fr3YaCrp8_uSXOiiGahaCO4mg,2356
+gr_libs/tutorials/graml_panda_tutorial.py,sha256=e2pm62Hj6wyzKO-RvSz_qnDxLZoqKqnzc8B_ylVoGVM,2208
+gr_libs/tutorials/graml_parking_tutorial.py,sha256=vRvcbrbM8N7npt7W_0g-CbUhALkXVqUejoVWlPMuj04,1991
+gr_libs/tutorials/graml_point_maze_tutorial.py,sha256=KA28__CNKslxq3p6O5htjJFDKOXXbiA1bOX-oPJxjmI,2463
+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
+tests/test_odgr_executor_expertbasedgraml.py,sha256=UQh1pzaqAy9kRN1O--x1tQLGWkRXuYnz5ujB2H1XMas,558
+tests/test_odgr_executor_gcdraco.py,sha256=VUmnO33tuMVlNYz7Fh08VUW4jfUXhhUsJu7oPiLF2iU,506
+tests/test_odgr_executor_gcgraml.py,sha256=MmyadmboVxFwfRigqe9jondZopqUjhbQ3gXjCbK4yAs,506
+tests/test_odgr_executor_graql.py,sha256=06p_kPAUn2OQrL-nBik58C22UPbTDC4CwDaB7MUk61o,514
+gr_libs-0.2.5.dist-info/METADATA,sha256=TYD_l_WXrcWoyi8fb4RkGjamcfdbcOeiPfrxypb-sQs,14421
+gr_libs-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gr_libs-0.2.5.dist-info/top_level.txt,sha256=Yzc_VSW3gzbVM7ZtlV4r6VXmfAC8WXqGVUgK1r6JcLs,14
+gr_libs-0.2.5.dist-info/RECORD,,

{gr_libs-0.1.8.dist-info → gr_libs-0.2.5.dist-info}/WHEEL

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

gr_libs-0.2.5.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

@@ -1,5 +1,5 @@
-from tutorials.gcdraco_panda_tutorial import run_gcdraco_panda_tutorial
-from tutorials.gcdraco_parking_tutorial import run_gcdraco_parking_tutorial
+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():

tests/test_graml.py

@@ -1,7 +1,7 @@
-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():

tests/test_graql.py

@@ -1,4 +1,4 @@
-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():

tests/test_odgr_executor_expertbasedgraml.py

@@ -0,0 +1,14 @@
+import subprocess
+import sys
+
+def test_odgr_executor_expertbasedgraml_minigrid():
+    """Test odgr_executor.py with ExpertBasedGraml on minigrid, L1, easiest env."""
+    result = subprocess.run([
+        sys.executable, "gr_libs/odgr_executor.py",
+        "--domain", "minigrid",
+        "--env_name", "MiniGrid-SimpleCrossingS13N4",
+        "--recognizer", "ExpertBasedGraml",
+        "--task", "L1",
+        "--collect_stats"
+    ], capture_output=True, text=True)
+    assert result.returncode == 0, f"ExpertBasedGraml minigrid L1 failed: {result.stderr}"

tests/test_odgr_executor_gcdraco.py

@@ -0,0 +1,14 @@
+import subprocess
+import sys
+
+def test_odgr_executor_gcdraco_parking():
+    """Test odgr_executor.py with GCDraco on parking, L1, easiest env."""
+    result = subprocess.run([
+        sys.executable, "gr_libs/odgr_executor.py",
+        "--domain", "parking",
+        "--env_name", "Parking-S-14-PC-",
+        "--recognizer", "GCDraco",
+        "--task", "L1",
+        "--collect_stats"
+    ], capture_output=True, text=True)
+    assert result.returncode == 0, f"GCDraco parking L1 failed: {result.stderr}"

tests/test_odgr_executor_gcgraml.py

@@ -0,0 +1,14 @@
+import subprocess
+import sys
+
+def test_odgr_executor_gcgraml_parking():
+    """Test odgr_executor.py with GCGraml on parking, L1, easiest env."""
+    result = subprocess.run([
+        sys.executable, "gr_libs/odgr_executor.py",
+        "--domain", "parking",
+        "--env_name", "Parking-S-14-PC-",
+        "--recognizer", "GCGraml",
+        "--task", "L1",
+        "--collect_stats"
+    ], capture_output=True, text=True)
+    assert result.returncode == 0, f"GCGraml parking L1 failed: {result.stderr}"

tests/test_odgr_executor_graql.py

@@ -0,0 +1,14 @@
+import subprocess
+import sys
+
+def test_odgr_executor_graql_minigrid():
+    """Test odgr_executor.py with Graql on minigrid, L1, easiest env."""
+    result = subprocess.run([
+        sys.executable, "gr_libs/odgr_executor.py",
+        "--domain", "minigrid",
+        "--env_name", "MiniGrid-SimpleCrossingS13N4",
+        "--recognizer", "Graql",
+        "--task", "L1",
+        "--collect_stats"
+    ], capture_output=True, text=True)
+    assert result.returncode == 0, f"Graql minigrid L1 failed: {result.stderr}"

evaluation/analyze_results_cross_alg_cross_domain.py

@@ -1,267 +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,38 +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,53 +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("")