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

gr_libs/recognizer/graml/graml_recognizer.py

@@ -82,14 +82,14 @@ class Graml(LearningRecognizer):
 							dev_loader=DataLoader(dev_dataset, batch_size=self.env_prop.get_lstm_props().batch_size, shuffle=False, collate_fn=self.collate_func))
 			save_weights(model=self.model, path=self.model_file_path)
 
-	def goals_adaptation_phase(self, dynamic_goals: List[EnvProperty]):
+	def goals_adaptation_phase(self, dynamic_goals: List[EnvProperty], save_fig=False):
 		self.is_first_inf_since_new_goals = True
 		self.current_goals = dynamic_goals
 		# start by training each rl agent on the base goal set
 		self.embeddings_dict = {} # relevant if the embedding of the plan occurs during the goals adaptation phase
 		self.plans_dict = {} # relevant if the embedding of the plan occurs during the inference phase
 		for goal in self.current_goals:
-			obss = self.generate_sequences_library(goal)
+			obss = self.generate_sequences_library(goal, save_fig=save_fig)
 			self.plans_dict[str(goal)] = obss
 
 	def get_goal_plan(self, goal):
@@ -150,7 +150,7 @@ class Graml(LearningRecognizer):
 		return closest_goal
 	
 	@abstractmethod
-	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		pass
 
 	# this function duplicates every sequence and creates a consecutive and non-consecutive version of it
@@ -192,10 +192,10 @@ class MCTSBasedGraml(BGGraml, GaAdaptingRecognizer):
 		super().__init__(*args, **kwargs)
 		if self.rl_agent_type==None: self.rl_agent_type = TabularQLearner
 
-	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		problem_name = self.env_prop.goal_to_problem_str(goal)
 		img_path = os.path.join(get_policy_sequences_result_path(self.env_prop.domain_name, recognizer=self.__class__.__name__), problem_name + "_MCTS")
-		return mcts_model.plan(self.env_prop.name, problem_name, goal, save_fig=True, img_path=img_path, env_prop=self.env_prop)
+		return mcts_model.plan(self.env_prop.name, problem_name, goal, save_fig=save_fig, img_path=img_path, env_prop=self.env_prop)
 
 class ExpertBasedGraml(BGGraml, GaAgentTrainerRecognizer):
 	def __init__(self, *args, **kwargs):
@@ -206,15 +206,23 @@ class ExpertBasedGraml(BGGraml, GaAgentTrainerRecognizer):
 			else:
 				self.rl_agent_type = DeepRLAgent
 
-	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		problem_name = self.env_prop.goal_to_problem_str(goal)
 		kwargs = {"domain_name":self.domain_name, "problem_name":problem_name}
 		if self.dynamic_train_configs_dict[problem_name][0] != None: kwargs["algorithm"] = self.dynamic_train_configs_dict[problem_name][0]
 		if self.dynamic_train_configs_dict[problem_name][1] != None: kwargs["num_timesteps"] = self.dynamic_train_configs_dict[problem_name][1]
 		agent = self.rl_agent_type(**kwargs)
 		agent.learn()
-		fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_bg_sequence")
-		return [agent.generate_observation(action_selection_method=metrics.greedy_selection, random_optimalism=False, save_fig=True, fig_path=fig_path, env_prop=self.env_prop)]
+		agent_kwargs = {
+			"action_selection_method": metrics.greedy_selection,
+			"random_optimalism": False,
+			"save_fig": save_fig,
+			"env_prop": self.env_prop
+		}
+		if save_fig:
+			fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_bg_sequence")
+			agent_kwargs["fig_path"] = fig_path
+		return [agent.generate_observation(**agent_kwargs)]
 
 	def goals_adaptation_phase(self, dynamic_goals: List[str], dynamic_train_configs):
 		self.dynamic_goals_problems = [self.env_prop.goal_to_problem_str(g) for g in dynamic_goals]
@@ -244,20 +252,21 @@ class GCGraml(Graml, GaAdaptingRecognizer):
 		gc_agent.learn()
 		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]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		problem_name = self.env_prop.goal_to_problem_str(goal)
 		kwargs = {"domain_name":self.domain_name, "problem_name":self.env_prop.name} # problem name is env name in gc case
 		if self.original_train_configs[0][0] != None: kwargs["algorithm"] = self.original_train_configs[0][0]
 		if self.original_train_configs[0][1] != None: kwargs["num_timesteps"] = self.original_train_configs[0][1]
 		agent = self.rl_agent_type(**kwargs)
 		agent.learn()
-		fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_gc_sequence")
 		agent_kwargs = {
 			"action_selection_method": metrics.stochastic_amplified_selection,
 			"random_optimalism": True,
-			"save_fig": True,
-			"fig_path": fig_path
+			"save_fig": save_fig
 		}
+		if save_fig:
+			fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_gc_sequence")
+			agent_kwargs["fig_path"] = fig_path
 		if self.env_prop.use_goal_directed_problem(): agent_kwargs["goal_directed_problem"] = problem_name
 		else: agent_kwargs["goal_directed_goal"] = goal
 		obss = []

gr_libs/recognizer/recognizer.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 from typing import List, Type
-
 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.5
+Version: 0.1.7.post0
 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>
@@ -17,6 +17,7 @@ Requires-Dist: torchvision
 Requires-Dist: rl_zoo3
 Requires-Dist: stable_baselines3[extra]
 Requires-Dist: sb3_contrib
+Requires-Dist: pytest
 Provides-Extra: minigrid
 Requires-Dist: gr_envs[minigrid]; extra == "minigrid"
 Provides-Extra: highway
@@ -111,6 +112,25 @@ After installing GRLib, you will have access to custom Gym environments, allowin
 
 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.
 
+## Working with an initial dataset of trained agents
+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
+python download_dataset.py
+```
+
+An alternative is to use our docker image, which includes the dataset in it.
+You can:
+1. pull the image:
+```sh
+docker pull ghcr.io/MatanShamir1/gr_test_base:latest
+```
+2. run a container:
+```sh
+docker run -it ghcr.io/MatanShamir1/gr_test_base:latest bash
+```
+3. don't forget to install the package from within the container, go back to 'Setup' for that.
+
 ### Method 1: Writing a Custom Script
 
 1. **Create a recognizer**
@@ -118,6 +138,7 @@ Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tu
    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
+   import gr_libs.environment # Triggers gym env registration - you must run it!
    recognizer = Graql(
        domain_name="minigrid",
        env_name="MiniGrid-SimpleCrossingS13N4"

{gr_libs-0.1.5.dist-info → gr_libs-0.1.7.post0.dist-info}/RECORD

@@ -7,13 +7,14 @@ evaluation/generate_experiments_results_new_ver2.py,sha256=jeKj_wgdM50o2vi8WZI-s
 evaluation/generate_task_specific_statistics_plots.py,sha256=rBsqaMe2irP_Cfo-icwIg4_dsleFjEH6eiQCcUBj6WU,15286
 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=oxEKmdvzQLKbbMxedqEf3bGsSJvp2XL9Bxr5JEO6a5o,1038
-gr_libs/environment/environment.py,sha256=Ca9m6W8KEt4le0HFSAUvSHW5lSHg_wwJaBqFSq1KlUg,6781
+gr_libs/__init__.py,sha256=WlSRpZIpz5GxLNk96nhympbk3Z5nsMiSOyiAWj17S88,280
+gr_libs/_version.py,sha256=Zy3HQFB_Viry2Rl81-7LPU4kL2FTQegnwLvl0VxTs3E,526
+gr_libs/environment/__init__.py,sha256=KlRp3qdgxEmej31zDoDsYPwbcAqyDglx6x0mH0KRmHU,1032
+gr_libs/environment/environment.py,sha256=d6ZbiAQ4H1aLrUFI8sm0BN9DVW3JtzpkodSi_70Z_PY,6780
 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
-gr_libs/metrics/metrics.py,sha256=IYPL90tuxbTRaNLaFvgzd5SMUwS8gsSANuWZcSVuKkM,8737
+gr_libs/metrics/metrics.py,sha256=4bnvs5suv-QrK9i1NuOzkE_E8uIzS1nlEazNDRXvZGs,8700
 gr_libs/ml/__init__.py,sha256=jrjxYqvSRgWwFWw7XQP9DzOwvmprMZ2umwT7t-DYtDU,233
 gr_libs/ml/agent.py,sha256=DSnK8nRx9SS76fAOZZEEvA68_meLjzm9lfQpMUXmGQU,1957
 gr_libs/ml/consts.py,sha256=mrbZk8n6QoGzLGaKmaxq4QlAsBbk4fhkCgXLuO9jXKw,365
@@ -34,30 +35,33 @@ gr_libs/ml/sequential/__init__.py,sha256=rusN4ahTvAeAq1Saz6qS_9HEU7WuXDJu2zwhc9W
 gr_libs/ml/sequential/lstm_model.py,sha256=Vzm-C1URR84PGNEecj69GUtn3ZmOVyh1BAY6CUnfL1Q,8978
 gr_libs/ml/tabular/__init__.py,sha256=jAfjfTFZLLlVm1KUiJdxdnaNGFp1J2KBU89q_vvradM,177
 gr_libs/ml/tabular/state.py,sha256=8xroKF3y3nRX0LK1QX5fRT2PS2WmvcDPp0UvPFdSx2A,733
-gr_libs/ml/tabular/tabular_q_learner.py,sha256=q6Dz4RTX0GjBumUiS2mUFKvEiKUBecj0q1RpWvPvmmE,18972
+gr_libs/ml/tabular/tabular_q_learner.py,sha256=5QU9ZWC-Cu5jxv5K1TohoRjQrRDhCgTs1Mt18cqM_Sc,18970
 gr_libs/ml/tabular/tabular_rl_agent.py,sha256=7w8PYbKi8QgxHJyECWU_rURtT89spg0tHIMI1cDwYc8,3764
 gr_libs/ml/utils/__init__.py,sha256=qH3pcnem5Z6rkQ4RTZi47AXJRe1RkFEST_-DrBmfWcM,258
 gr_libs/ml/utils/env.py,sha256=AWVN0OXYmFU-J3FUiwvEAIY93Suf1oL6VNcxtyWJraM,171
 gr_libs/ml/utils/format.py,sha256=nu7RzVwn_raG_fqqmnqlJgUjtA0yzKztkB3a5QZnRYo,3071
 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/ml/utils/storage.py,sha256=52wR2pgFmcCOhqbu5Km3tegjAmtI1Fb4HYAVUnUubZk,4626
+gr_libs/problems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/problems/consts.py,sha256=ON7yfKTAKETg7i3okDYuOzEU7KWvynyubl0m7TlU6Hs,38808
 gr_libs/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/recognizer/recognizer.py,sha256=2lMlJNE7X13Y3FMpNfql-WAYw23NImIiomnVmCI75bM,1706
-gr_libs/recognizer/recognizer_doc.md,sha256=RnTvbZhl2opvU7-QT4pULCV5HCdJTw2dsu8WQOOiR3E,2521
+gr_libs/recognizer/recognizer.py,sha256=ZrApJVdBQxKRYhhDiWLCNGmlxgi674nwgb30BgVggC8,1705
 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=SGs7rtkA73lbCv9HISa6dfjVUJUhlH54QriVsoGVRss,15672
+gr_libs/recognizer/graml/graml_recognizer.py,sha256=1xLl1gHj3JxWhHtV9h3SvsW7oJdxsQQV0F-VLtlTmKQ,15911
 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=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.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,,
+tests/test_graml.py,sha256=ZJB2jqtf4Q2-KZredkJq90teqmHBIvigCAQpvR5G110,559
+tests/test_graql.py,sha256=-onMi13e2wStOmB5bYv2f3Ita3QFFiw416XMBkby0OI,141
+tutorials/graml_minigrid_tutorial.py,sha256=ONvxFi79R7d8dcd6gy083Z_yy9A2flhGTDIDRxurdx8,1782
+tutorials/graml_panda_tutorial.py,sha256=wtv_lsw0vsU7j45GKeWecTfE7jzfh4iVGEVnQyaWthM,2063
+tutorials/graml_parking_tutorial.py,sha256=M6bt1WQOOgn8_CRyG2kjxF14PMeyXVAWRDq1ZRwGTXo,1808
+tutorials/graml_point_maze_tutorial.py,sha256=mYq3IxYbf9jidq-4VdT3MdStV80Q5lytFv6Xzzn22Ys,1835
+tutorials/graql_minigrid_tutorial.py,sha256=Jb0TCUhiZQkFeafJWUTPnCISd4FKfPrqP-xfHiqCGKE,1635
+gr_libs-0.1.7.post0.dist-info/METADATA,sha256=aS7y9Nl1JErXYdpAHstuQP_W1QMcKMbGet6IfxfJ_Do,9620
+gr_libs-0.1.7.post0.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+gr_libs-0.1.7.post0.dist-info/top_level.txt,sha256=fJQF8Q8Dfh_D3pA2mhNodazNjzW6b3oWfnx6Jdo-pBU,35
+gr_libs-0.1.7.post0.dist-info/RECORD,,

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

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

{gr_libs-0.1.5.dist-info → gr_libs-0.1.7.post0.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
 evaluation
 gr_libs
+tests
 tutorials

tests/test_graml.py

@@ -0,0 +1,16 @@
+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
+
+def test_graml_minigrid_tutorial():
+	run_graml_minigrid_tutorial()
+
+def test_graml_panda_tutorial():
+	run_graml_panda_tutorial()
+
+def test_graml_parking_tutorial():
+	run_graml_parking_tutorial()
+
+def test_graml_point_maze_tutorial():
+	run_graml_point_maze_tutorial()

tests/test_graql.py

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

tutorials/graml_minigrid_tutorial.py

@@ -4,27 +4,31 @@ 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,
-	env_name="MiniGrid-SimpleCrossingS13N4"
-)
+def run_graml_minigrid_tutorial():
+    recognizer = ExpertBasedGraml(
+        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.
-)
-# 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.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
-)
+    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.
+    )
+    # 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.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
+    )
 
-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()

tutorials/graml_panda_tutorial.py

@@ -9,29 +9,33 @@ 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
 
-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]])]
-)
-# 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.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
-)
+def run_graml_panda_tutorial():
+    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]])]
+    )
+    # 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.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
+    )
 
-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()

tutorials/graml_parking_tutorial.py

@@ -5,30 +5,35 @@ 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
+import gr_libs.environment.environment
 
-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"]
-	# no need for expert sequence generation since GCRL is used
-)
+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.goals_adaptation_phase(
+        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(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(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
+    # 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.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
+    )
 
-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()

tutorials/graml_point_maze_tutorial.py

@@ -6,30 +6,34 @@ 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
 
-recognizer = ExpertBasedGraml(
-	domain_name=POINT_MAZE,
-	env_name="PointMaze-FourRoomsEnvDense-11x11"
-)
+def run_graml_point_maze_tutorial():
+    recognizer = ExpertBasedGraml(
+        domain_name=POINT_MAZE,
+        env_name="PointMaze-FourRoomsEnvDense-11x11"
+    )
 
-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.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 = [(4,4), (7,3), (3,7)],
-    dynamic_train_configs=[(SAC, 200000) for _ in range(3)] # for expert sequence generation.
-)
+    recognizer.goals_adaptation_phase(
+        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(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(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    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(
+        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)))
-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)")
+    partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)))
+    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)")
+
+if __name__ == "__main__":
+    run_graml_point_maze_tutorial()

tutorials/graql_minigrid_tutorial.py

@@ -4,26 +4,31 @@ 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 Graql
 
-recognizer = Graql(
-	domain_name="minigrid",
-	env_name="MiniGrid-SimpleCrossingS13N4"
-)
+def run_graql_minigrid_tutorial():
+    recognizer = Graql(
+        domain_name="minigrid",
+        env_name="MiniGrid-SimpleCrossingS13N4"
+    )
 
-#Graql doesn't have a domain learning phase, so we skip it
+    #Graql doesn't have a domain learning phase, so we skip it
 
-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.
-)
-# 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.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
-)
+    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.
+    )
+    # 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.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
+    )
 
-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 Graql: {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 Graql: {closest_goal}\nactual goal actor aimed towards: (11, 1)")
+    return closest_goal, (11,1)
+
+if __name__ == "__main__":
+    run_graql_minigrid_tutorial()

gr_libs/recognizer/recognizer_doc.md

@@ -1,61 +0,0 @@
-# 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.