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

gr_libs/environment/__init__.py

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

gr_libs/environment/environment.py

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

gr_libs/ml/neural/deep_rl_learner.py

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

gr_libs/recognizer/graml/graml_recognizer.py

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

gr_libs/recognizer/recognizer.py

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

{gr_libs-0.1.4.dist-info → gr_libs-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.4
+Version: 0.1.5
 Summary: Package with goal recognition frameworks baselines
 Author: Ben Nageris
 Author-email: Matan Shamir <matan.shamir@live.biu.ac.il>, Osher Elhadad <osher.elhadad@live.biu.ac.il>

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

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

tutorials/graml_minigrid_tutorial.py

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

tutorials/graml_panda_tutorial.py

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

tutorials/graml_parking_tutorial.py

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

tutorials/graml_point_maze_tutorial.py

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