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

gr_libs/recognizer/recognizer.py

@@ -4,42 +4,53 @@ from gr_libs.environment.environment import EnvProperty, SUPPORTED_DOMAINS
 from gr_libs.environment.utils.utils import domain_to_env_property
 from gr_libs.ml.base.rl_agent import RLAgent
 
+
 class Recognizer(ABC):
-	def __init__(self, domain_name: str, env_name:str, collect_statistics=False, rl_agent_type: Type[RLAgent]=None):
-		assert domain_name in SUPPORTED_DOMAINS
-		self.rl_agent_type = rl_agent_type
-		self.domain_name = domain_name
-		self.env_prop_type = domain_to_env_property(self.domain_name)
-		self.env_prop = self.env_prop_type(env_name)
-		self.collect_statistics = collect_statistics
-
-	@abstractmethod
-	def inference_phase(self, inf_sequence, true_goal, percentage) -> str:
-		pass
+    def __init__(
+        self,
+        domain_name: str,
+        env_name: str,
+        collect_statistics=False,
+        rl_agent_type: Type[RLAgent] = None,
+        **kwargs,
+    ):
+        assert domain_name in SUPPORTED_DOMAINS
+        self.rl_agent_type = rl_agent_type
+        self.domain_name = domain_name
+        self.env_prop_type = domain_to_env_property(self.domain_name)
+        self.env_prop = self.env_prop_type(env_name)
+        self.collect_statistics = collect_statistics
+
+    @abstractmethod
+    def inference_phase(self, inf_sequence, true_goal, percentage) -> str:
+        pass
+
 
 class LearningRecognizer(Recognizer):
-	def __init__(self, *args, **kwargs):
-		super().__init__(*args, **kwargs)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def domain_learning_phase(self, base_goals: List[str], train_configs: List):
+        self.original_train_configs = train_configs
 
-	def domain_learning_phase(self, base_goals: List[str], train_configs: List):
-		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):
-	def __init__(self, *args, **kwargs):
-		super().__init__(*args, **kwargs)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def goals_adaptation_phase(self, dynamic_goals: List[str], dynamic_train_configs):
+        pass
 
-	@abstractmethod
-	def goals_adaptation_phase(self, dynamic_goals: List[str], dynamic_train_configs):
-		pass
+    def domain_learning_phase(self, base_goals: List[str], train_configs: List):
+        super().domain_learning_phase(base_goals, train_configs)
 
-	def domain_learning_phase(self, base_goals: List[str], train_configs: List):
-		super().domain_learning_phase(base_goals, train_configs)
 
 class GaAdaptingRecognizer(Recognizer):
-	def __init__(self, *args, **kwargs):
-		super().__init__(*args, **kwargs)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
-	@abstractmethod
-	def goals_adaptation_phase(self, dynamic_goals: List[str]):
-		pass
+    @abstractmethod
+    def goals_adaptation_phase(self, dynamic_goals: List[str]):
+        pass

gr_libs/recognizer/utils/__init__.py

@@ -1 +1 @@
-from .format import recognizer_str_to_obj
+from .format import recognizer_str_to_obj

gr_libs/recognizer/utils/format.py

@@ -1,6 +1,11 @@
-from gr_libs.recognizer.graml.graml_recognizer import GCGraml, ExpertBasedGraml, MCTSBasedGraml
+from gr_libs.recognizer.graml.graml_recognizer import (
+    GCGraml,
+    ExpertBasedGraml,
+    MCTSBasedGraml,
+)
 from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql, Draco, GCDraco
 
+
 def recognizer_str_to_obj(recognizer_str: str):
     recognizer_map = {
         "GCGraml": GCGraml,
@@ -8,6 +13,6 @@ def recognizer_str_to_obj(recognizer_str: str):
         "MCTSBasedGraml": MCTSBasedGraml,
         "Graql": Graql,
         "Draco": Draco,
-        "GCDraco": GCDraco
+        "GCDraco": GCDraco,
     }
-    return recognizer_map.get(recognizer_str)
+    return recognizer_map.get(recognizer_str)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.7.post0
+Version: 0.1.8
 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>

gr_libs-0.1.8.dist-info/RECORD

@@ -0,0 +1,70 @@
+evaluation/analyze_results_cross_alg_cross_domain.py,sha256=ioAySQ92yWMg9rNUxy5TQ-viPMTRjIPqBLwYmUIgaCA,11346
+evaluation/create_minigrid_map_image.py,sha256=l8MukZBGV63EnEjdGhbdH-9sXR7kTbfPnEzE5ZJkw6w,1257
+evaluation/file_system.py,sha256=Asaqq0_4CFVhQ8VyfEuaDBQK3-QkjMJIUfx5SA8y1Co,1645
+evaluation/generate_experiments_results.py,sha256=RIlztqGh9OtZg6usLRypEJJdPmZA_M3x6bHi-T0WCxs,5257
+evaluation/generate_experiments_results_new_ver1.py,sha256=yGg8MFU-9xwdYsOyZCehGwTvWnwoudN7ctpUOLmi070,10305
+evaluation/generate_experiments_results_new_ver2.py,sha256=ERJRuAY446QGOvqRlbUWYELF_fFO4GgOeMcdTXIOvrY,14267
+evaluation/generate_task_specific_statistics_plots.py,sha256=IIL-4qSbR2YLih8vvOIkz-poIq7p7_NuEZG1xR10vXw,19126
+evaluation/get_plans_images.py,sha256=F2Tez4ZeFsU22R8x0pjeUQ2GMQrpbN6g8XCHDPrz_F8,2730
+evaluation/increasing_and_decreasing_.py,sha256=MscBjQwGauBdRoFxgHfLpcd-iu6WqNgmD_iHx4wfh2U,3866
+gr_libs/__init__.py,sha256=MpvF14G0wRxRm9dxz97p5JxRhIbAfyFc3MJ1S8YRsNM,297
+gr_libs/_version.py,sha256=AjUi5zEL_BoWoXMXR1FnWc3mD6FHX7snDXjDHVLoens,511
+gr_libs/environment/__init__.py,sha256=mttRtyD8jXs9qMTjqruKO5JohrFhlS4QPEDYw5Se2MA,1150
+gr_libs/environment/environment.py,sha256=4_LbPuIDdPI-yM0wnQFL_xqrC9VOa9Q_8ejkIUKTbvs,10445
+gr_libs/environment/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/environment/utils/utils.py,sha256=4K5yy4bs-dNRsfl3KUctQw4Kx-lzYuN_8JzI-xxk_Ng,630
+gr_libs/metrics/__init__.py,sha256=cNIyyAB4YJHAG5wzIh8ZW1792vYrt6iW9i2mkBJUa9Q,110
+gr_libs/metrics/metrics.py,sha256=Yj3qYRAyrQeTxHK_shIjrgAKic4vMibK6ClyKavTzZ0,9016
+gr_libs/ml/__init__.py,sha256=r2SBzpSNpR6wynSn_npew8CCz0E_PBwQbuBGWFfIKRQ,235
+gr_libs/ml/agent.py,sha256=ea1yRltKX0LSpRMnpAQLRKvvKoLMQz9MgMeWBPhQISw,2095
+gr_libs/ml/consts.py,sha256=vsEB1nk5V_qP3FjNlv4vBKeTTFngV3RNaNp6fWnmEz0,366
+gr_libs/ml/base/__init__.py,sha256=nofgF53Gho5KlAV6BWTi0jfQACDynp6bq3kctm1R6aM,69
+gr_libs/ml/base/rl_agent.py,sha256=OIrcdtgSHk7ZcUdSyQHbPnwU9T1SqGRQkOzx5rSt8LY,1600
+gr_libs/ml/neural/__init__.py,sha256=g-0D5oFX8W52To4OR8vO8kDoBLSxAupVqwcQw8XjT5E,180
+gr_libs/ml/neural/deep_rl_learner.py,sha256=mv89WoCCGHcrnyEOzHldCMlQeUyAIbGoYHMQmahzM0w,21808
+gr_libs/ml/neural/utils/__init__.py,sha256=xbJ40_o7rTrzS9LXidjurGaRMdMjvSUnXsTjbJf9kR8,107
+gr_libs/ml/neural/utils/dictlist.py,sha256=ORFez_KmaCzraStF97hxdgCAAALP4Er8u3e9RcqlvhM,1030
+gr_libs/ml/neural/utils/penv.py,sha256=v_yy2E05ZyspH-95trnjB0es10A2i13iBr3Zub_goZA,1897
+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=zbYKhb_49iS2I9Tgh7NtAf1iwM5lH6ZC3y3-uDvr40I,26466
+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=49i1ZLYV-9w-lh09Mb4qd3zQ92EqpyYWn5cQA5mo1F0,3409
+gr_libs/ml/sequential/__init__.py,sha256=HTtnXxcqxF7e_uPh0--kOhHZtF2YasvgKJDIig38NkM,62
+gr_libs/ml/sequential/lstm_model.py,sha256=1MESuStASSTptJ5dWIUyex76o7UNria2yBPoza3sCOo,10868
+gr_libs/ml/tabular/__init__.py,sha256=jAfjfTFZLLlVm1KUiJdxdnaNGFp1J2KBU89q_vvradM,177
+gr_libs/ml/tabular/state.py,sha256=ImpIrYWF80PB-4EeQ2Q9nO7jMZ2s0hGbgsir1ZtsO88,700
+gr_libs/ml/tabular/tabular_q_learner.py,sha256=CSzyN0qVBPFUqiJ_uJSTemh7FddeEJVar4Zu8z2IZ6I,19060
+gr_libs/ml/tabular/tabular_rl_agent.py,sha256=JzFgVhiILjhgA_aBbsJYgQaFUPEJOxlHTcsPKrg-h4E,3658
+gr_libs/ml/utils/__init__.py,sha256=eYkoOi-rIjxog1ikMqrCmXVOiSP9XHQh66fwWfBsfKs,284
+gr_libs/ml/utils/env.py,sha256=AWVN0OXYmFU-J3FUiwvEAIY93Suf1oL6VNcxtyWJraM,171
+gr_libs/ml/utils/format.py,sha256=xh2TKzVZsy1XmK8JCk_MJhB5zn37VIHVx060Rd-YqKE,3581
+gr_libs/ml/utils/math.py,sha256=4U_F67eS6xuS7fN9hNtZFcFPObmSN2soi-2O3AGVgVs,442
+gr_libs/ml/utils/other.py,sha256=QM44H4Bx1ajaz594P23sQ7tJ0JDraABeQSD23ygWf9w,506
+gr_libs/ml/utils/storage.py,sha256=a5F-KXRMdGGHPTKSQpGeNRHfZyv9m6j7ZhuLLNNjTvE,4947
+gr_libs/problems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/problems/consts.py,sha256=tzad2l2DVnQxHen1AS8rPYmGiy02x_53NOrjmv9KL9E,62096
+gr_libs/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/recognizer.py,sha256=Q4EpAQFgahkDMdhm8Dgsu2aRB8EetpxxELtrTuv-ri4,1897
+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=LG_nVjujzcmC9euyouTB9CywvCHpuqe4CPB8jTlzgfA,6743
+gr_libs/recognizer/graml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/graml/gr_dataset.py,sha256=c0-n4kzMQN78DUQV_7egz_oyHC9EMmmYixMRA2DFO3k,10106
+gr_libs/recognizer/graml/graml_recognizer.py,sha256=qm6kdRX8HpKOb6S3D_8oWj6HA4pzk1jnsA9BekTOKyE,19867
+gr_libs/recognizer/utils/__init__.py,sha256=MvXPRyr30W5C_n-Dul3aheE_9SWy2aIMGINKWj36mfM,42
+gr_libs/recognizer/utils/format.py,sha256=O1NbaZ_3bgl5jKgcGwdA0R1NWGm9Ha0EG6mHJcivpTY,512
+tests/test_gcdraco.py,sha256=o4badhWKXMhysPVt0a2jjvKDR-mfzt5KqyRyIutZnS0,292
+tests/test_graml.py,sha256=1h9LjRbss_fpqViDX7KBjLKfu4EZstREOnVHQCDJct4,576
+tests/test_graql.py,sha256=VM6o6wHuf2y76YQo7pbBrerbBZe4MwYv9sFvj1Y-nZ0,146
+tutorials/gcdraco_panda_tutorial.py,sha256=hfZ--4Q0JEwFTnmZ9PStIhJxk3fHAgnP1XhE_Mq4nS4,2287
+tutorials/gcdraco_parking_tutorial.py,sha256=iWhfRGFFqUXUEKNXEWww1SIoEIo8dJ8GOp5FzFfAlKE,2097
+tutorials/graml_minigrid_tutorial.py,sha256=eHNe5G5gMktWb-3Z_nHvQP6O5UNbFVQpCp6HUnJsxYQ,2204
+tutorials/graml_panda_tutorial.py,sha256=8zpPyoA8GI0bTjGI3mKCBW2eZwlZ2dQ5NNtVcg9t5rU,2241
+tutorials/graml_parking_tutorial.py,sha256=EuQ_j1KqJmMaFEgINvNSlSe6TKkL3XP-mh0M0ZC6IIA,2011
+tutorials/graml_point_maze_tutorial.py,sha256=dgvz1qnE6k2YOE_5dyRDF8MQYRAuLGYcdpvi-NiNoSs,2186
+tutorials/graql_minigrid_tutorial.py,sha256=pznoOcO8PU-VwfH9sxlJBOQskmilfrHg9nky1m2Adz0,1940
+gr_libs-0.1.8.dist-info/METADATA,sha256=-DZi3tJBEZF7hdoh6L5PRWycjIihDp4iKVALsBM7VME,9614
+gr_libs-0.1.8.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+gr_libs-0.1.8.dist-info/top_level.txt,sha256=fJQF8Q8Dfh_D3pA2mhNodazNjzW6b3oWfnx6Jdo-pBU,35
+gr_libs-0.1.8.dist-info/RECORD,,

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

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

tests/test_gcdraco.py

@@ -0,0 +1,10 @@
+from tutorials.gcdraco_panda_tutorial import run_gcdraco_panda_tutorial
+from 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

@@ -3,14 +3,18 @@ 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
 
+
 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
 
+
 def test_graql_minigrid_tutorial():
-	run_graql_minigrid_tutorial()
+    run_graql_minigrid_tutorial()

tutorials/gcdraco_panda_tutorial.py

@@ -0,0 +1,66 @@
+from stable_baselines3 import PPO, SAC
+from gr_libs.metrics import (
+    stochastic_amplified_selection,
+    mean_p_value,
+    mean_wasserstein_distance,
+)
+from gr_libs import GCDraco
+from gr_libs.environment.utils.utils import domain_to_env_property
+import numpy as np
+from gr_libs.environment.environment import PANDA, PandaProperty
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
+from gr_libs.ml.utils.format import random_subset_with_order
+import gr_envs.panda_scripts
+
+
+def run_gcdraco_panda_tutorial():
+    recognizer = GCDraco(
+        domain_name=PANDA,
+        env_name="PandaMyReachDense",
+        evaluation_function=mean_wasserstein_distance,  # or mean_p_value
+    )
+
+    recognizer.domain_learning_phase(
+        base_goals=[np.array([PandaProperty.sample_goal()]) for _ in range(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")
+    problem_name = env_property.goal_to_problem_str(np.array([[-0.1, -0.1, 0.1]]))
+    actor = DeepRLAgent(
+        domain_name=PANDA,
+        problem_name=problem_name,
+        env_prop=env_property,
+        algorithm=PPO,
+        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(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,  # the noise that's added to the actions
+        with_dict=True,
+    )
+    partial_sequence = random_subset_with_order(
+        full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False
+    )
+    closest_goal = recognizer.inference_phase(
+        partial_sequence, np.array([[-0.1, -0.1, 0.1]]), 0.5
+    )
+    print(
+        f"closest_goal returned by GCDRACO: {closest_goal}\nactual goal actor aimed towards: [-0.1, -0.1, 0.1]"
+    )
+
+
+if __name__ == "__main__":
+    run_gcdraco_panda_tutorial()

tutorials/gcdraco_parking_tutorial.py

@@ -0,0 +1,61 @@
+from stable_baselines3 import PPO, TD3
+from gr_libs.metrics import (
+    stochastic_amplified_selection,
+    mean_p_value,
+    mean_wasserstein_distance,
+)
+from gr_libs import GCDraco
+from gr_libs.environment.utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PARKING, ParkingProperty
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
+from gr_libs.ml.utils.format import random_subset_with_order
+import gr_envs
+
+
+def run_gcdraco_parking_tutorial():
+    recognizer = GCDraco(
+        domain_name=PARKING,
+        env_name="Parking-S-14-PC-",
+        evaluation_function=mean_wasserstein_distance,  # or mean_p_value
+    )
+
+    recognizer.domain_learning_phase([i for i in range(1, 21)], [(PPO, 200000)])
+    recognizer.goals_adaptation_phase(
+        dynamic_goals=["1", "11", "21"]
+        # no need for expert sequence generation since GCRL is used
+    )
+
+    property_type = domain_to_env_property(PARKING)
+    env_property = property_type("Parking-S-14-PC-")
+
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    actor = DeepRLAgent(
+        domain_name="parking",
+        problem_name="Parking-S-14-PC--GI-11-v0",
+        env_prop=env_property,
+        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(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,  # the noise that's added to the actions
+        with_dict=True,
+    )
+
+    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-11-v0").str_to_goal(),
+        0.5,
+    )
+    print(
+        f"closest_goal returned by GCDRACO: {closest_goal}\nactual goal actor aimed towards: 11"
+    )
+
+
+if __name__ == "__main__":
+    run_gcdraco_parking_tutorial()

tutorials/graml_minigrid_tutorial.py

@@ -1,34 +1,64 @@
 from gr_libs.environment.environment import MINIGRID, QLEARNING
+from gr_libs.environment.utils.utils import domain_to_env_property
 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
 
+
 def run_graml_minigrid_tutorial():
     recognizer = ExpertBasedGraml(
-        domain_name=MINIGRID,
-        env_name="MiniGrid-SimpleCrossingS13N4"
+        domain_name=MINIGRID, env_name="MiniGrid-SimpleCrossingS13N4"
     )
 
-    recognizer.domain_learning_phase(base_goals=[(11,1), (11,11), (1,11), (7,11), (8,1), (10,6), (6,9), (11,3), (11,5)],
-                                    train_configs=[(QLEARNING, 100000) for _ in range(9)])
+    recognizer.domain_learning_phase(
+        base_goals=[
+            (11, 1),
+            (11, 11),
+            (1, 11),
+            (7, 11),
+            (8, 1),
+            (10, 6),
+            (6, 9),
+            (11, 3),
+            (11, 5),
+        ],
+        train_configs=[(QLEARNING, 100000) for _ in range(9)],
+    )
 
     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.
+        dynamic_goals=[(11, 1), (11, 11), (1, 11)],
+        dynamic_train_configs=[
+            (QLEARNING, 100000) for _ in range(3)
+        ],  # for expert sequence generation.
     )
+
+    property_type = domain_to_env_property(MINIGRID)
+    env_property = property_type("MiniGrid-SimpleCrossingS13N4")
+
     # TD3 is different from recognizer and expert algorithms, which are SAC #
-    actor = TabularQLearner(domain_name="minigrid", problem_name="MiniGrid-SimpleCrossingS13N4-DynamicGoal-11x1-v0", algorithm=QLEARNING, num_timesteps=100000)
+    actor = TabularQLearner(
+        domain_name="minigrid",
+        problem_name="MiniGrid-SimpleCrossingS13N4-DynamicGoal-11x1-v0",
+        env_prop=env_property,
+        algorithm=QLEARNING,
+        num_timesteps=100000,
+    )
     actor.learn()
     # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
     full_sequence = actor.generate_observation(
         action_selection_method=stochastic_amplified_selection,
-        random_optimalism=True, # the noise that's added to the actions
+        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_consecutive=False
+    )
+    closest_goal = recognizer.inference_phase(partial_sequence, (11, 1), 0.5)
+    print(
+        f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (11, 1)"
     )
 
-    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)
-    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (11, 1)")
 
 if __name__ == "__main__":
-    run_graml_minigrid_tutorial()
+    run_graml_minigrid_tutorial()

tutorials/graml_panda_tutorial.py

@@ -1,41 +1,62 @@
-
 import numpy as np
 from stable_baselines3 import PPO, SAC
 import gr_libs.environment.environment
-from gr_libs.environment.environment import PANDA, EnvProperty, GCEnvProperty, PandaProperty
+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
 from gr_libs.ml.utils.format import random_subset_with_order
 from gr_libs import GCGraml
 
+
 def run_graml_panda_tutorial():
-    recognizer = GCGraml( # TODO make these tutorials into pytests
-        domain_name=PANDA,
-        env_name="PandaMyReachDense"
+    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)]
+        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]])]
+        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")
     problem_name = env_property.goal_to_problem_str(np.array([[-0.1, -0.1, 0.1]]))
-    actor = DeepRLAgent(domain_name=PANDA, problem_name=problem_name, algorithm=PPO, num_timesteps=400000)
+    actor = DeepRLAgent(
+        domain_name=PANDA,
+        problem_name=problem_name,
+        env_prop=env_property,
+        algorithm=PPO,
+        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(
         action_selection_method=stochastic_amplified_selection,
-        random_optimalism=True, # the noise that's added to the actions
+        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_consecutive=False
+    )
+    closest_goal = recognizer.inference_phase(
+        partial_sequence, np.array([[-0.1, -0.1, 0.1]]), 0.5
+    )
+    print(
+        f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: [-0.1, -0.1, 0.1]"
     )
 
-    partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
-    closest_goal = recognizer.inference_phase(partial_sequence, np.array([[-0.1, -0.1, 0.1]]), 0.5)
-    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: [-0.1, -0.1, 0.1]")
 
 if __name__ == "__main__":
-    run_graml_panda_tutorial()
+    run_graml_panda_tutorial()

tutorials/graml_parking_tutorial.py

@@ -1,39 +1,56 @@
-
 from stable_baselines3 import PPO, SAC, TD3
-from gr_libs.environment.environment import PARKING, EnvProperty, GCEnvProperty, ParkingProperty
+from gr_libs.environment.environment import (
+    PARKING,
+    EnvProperty,
+    GCEnvProperty,
+    ParkingProperty,
+)
+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
+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, GCGraml
-import gr_libs.environment.environment
+
 
 def run_graml_parking_tutorial():
-    recognizer = GCGraml(
-        domain_name=PARKING,
-        env_name="Parking-S-14-PC-"
-    )
-                        
-    recognizer.domain_learning_phase(
-        [i for i in range(1,21)],
-        [(PPO, 200000)]
-    )
+    recognizer = GCGraml(domain_name=PARKING, env_name="Parking-S-14-PC-")
+
+    recognizer.domain_learning_phase([i for i in range(1, 21)], [(PPO, 200000)])
     recognizer.goals_adaptation_phase(
-        dynamic_goals = ["1", "11", "21"]
+        dynamic_goals=["1", "11", "21"]
         # no need for expert sequence generation since GCRL is used
     )
 
+    property_type = domain_to_env_property(PARKING)
+    env_property = property_type("Parking-S-14-PC-")
+
     # TD3 is different from recognizer and expert algorithms, which are SAC #
-    actor = DeepRLAgent(domain_name="parking", problem_name="Parking-S-14-PC--GI-11-v0", algorithm=TD3, num_timesteps=400000)
+    actor = DeepRLAgent(
+        domain_name="parking",
+        problem_name="Parking-S-14-PC--GI-11-v0",
+        env_prop=env_property,
+        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(
         action_selection_method=stochastic_amplified_selection,
-        random_optimalism=True, # the noise that's added to the actions
+        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_consecutive=False
+    )
+    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"
     )
 
-    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-11-v0").str_to_goal(), 0.5)
-    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: 11")
 
 if __name__ == "__main__":
-    run_graml_parking_tutorial()
+    run_graml_parking_tutorial()