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

gr_libs/recognizer/recognizer.py

@@ -1,45 +1,105 @@
 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.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import SUPPORTED_DOMAINS
 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)
+    """
+    A class that represents a learning recognizer.
+
+    Inherits from the Recognizer class.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def domain_learning_phase(self, base_goals: list[str], train_configs: list):
+        """
+        Perform the domain learning phase.
+
+        Args:
+            base_goals (List[str]): The base goals for the learning phase.
+            train_configs (List): The training configurations.
+
+        """
+        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)
+    """
+    A class representing a recognizer for GaAgentTrainer.
+    """
 
-	@abstractmethod
-	def goals_adaptation_phase(self, dynamic_goals: List[str], dynamic_train_configs):
-		pass
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def goals_adaptation_phase(self, dynamic_goals: list[str], dynamic_train_configs):
+        """
+        Perform the goals adaptation phase.
+
+        Args:
+            dynamic_goals (List[str]): The list of dynamic goals.
+            dynamic_train_configs: The dynamic training configurations.
+
+        Returns:
+            None
+        """
+
+    def domain_learning_phase(self, base_goals: list[str], train_configs: list):
+        """
+        Perform the domain learning phase.
+
+        Args:
+            base_goals (List[str]): List of base goals.
+            train_configs (List): List of training configurations.
+
+        Returns:
+            None
+        """
+        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)
+    """
+    A recognizer that doesn't require more training given a set of new goals, hence it doesn't receive train configs in the goal adaptation phase.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def goals_adaptation_phase(self, dynamic_goals: list[str]):
+        """
+        Perform the goals adaptation phase.
+
+        Args:
+            dynamic_goals (List[str]): A list of dynamic goals to be adapted.
 
-	@abstractmethod
-	def goals_adaptation_phase(self, dynamic_goals: List[str]):
-		pass
+        Returns:
+            None
+        """

gr_libs/tutorials/draco_panda_tutorial.py

@@ -0,0 +1,58 @@
+import numpy as np
+from stable_baselines3 import PPO
+
+from gr_libs import Draco
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PANDA
+from gr_libs.metrics import mean_wasserstein_distance
+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
+
+
+def run_draco_panda_tutorial():
+    recognizer = Draco(
+        domain_name=PANDA,
+        env_name="PandaMyReachDense",
+        evaluation_function=mean_wasserstein_distance,  # or mean_p_value
+    )
+
+    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_train_configs=[(PPO, 200000), (PPO, 200000), (PPO, 200000)],
+    )
+    # 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 DRACO: {closest_goal}\nactual goal actor aimed towards: [-0.1, -0.1, 0.1]"
+    )
+
+
+if __name__ == "__main__":
+    run_draco_panda_tutorial()

gr_libs/tutorials/draco_parking_tutorial.py

@@ -0,0 +1,56 @@
+from stable_baselines3 import SAC, TD3
+
+from gr_libs import Draco
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PARKING, ParkingProperty
+from gr_libs.metrics import mean_wasserstein_distance
+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
+
+
+def run_draco_parking_tutorial():
+    recognizer = Draco(
+        domain_name=PARKING,
+        env_name="Parking-S-14-PC-",
+        evaluation_function=mean_wasserstein_distance,  # or mean_p_value
+    )
+
+    recognizer.goals_adaptation_phase(
+        dynamic_goals=["1", "11", "21"],
+        dynamic_train_configs=[(SAC, 200000), (SAC, 200000), (SAC, 200000)],
+    )
+
+    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()
+
+    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_draco_parking_tutorial()

gr_libs/tutorials/gcdraco_panda_tutorial.py

@@ -0,0 +1,62 @@
+import numpy as np
+from stable_baselines3 import PPO, SAC
+
+from gr_libs import GCDraco
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PANDA, PandaProperty
+from gr_libs.metrics import mean_wasserstein_distance, stochastic_amplified_selection
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
+from gr_libs.ml.utils.format import random_subset_with_order
+
+
+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()

gr_libs/tutorials/gcdraco_parking_tutorial.py

@@ -0,0 +1,57 @@
+from stable_baselines3 import PPO, TD3
+
+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.metrics import mean_wasserstein_distance, stochastic_amplified_selection
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
+from gr_libs.ml.utils.format import random_subset_with_order
+
+
+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()

gr_libs/tutorials/graml_minigrid_tutorial.py

@@ -0,0 +1,64 @@
+from gr_libs import ExpertBasedGraml
+from gr_libs.environment._utils.utils import domain_to_env_property
+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
+
+
+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.goals_adaptation_phase(
+        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",
+        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
+    )
+
+    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()

gr_libs/tutorials/graml_panda_tutorial.py

@@ -0,0 +1,57 @@
+import numpy as np
+from stable_baselines3 import PPO, SAC
+
+from gr_libs import GCGraml
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PANDA, PandaProperty
+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
+
+
+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,
+        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
+    )
+
+    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()

gr_libs/tutorials/graml_parking_tutorial.py

@@ -0,0 +1,52 @@
+from stable_baselines3 import PPO, TD3
+
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PARKING, ParkingProperty
+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 GCGraml
+
+
+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
+    )
+
+    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
+    )
+
+    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()

gr_libs/tutorials/graml_point_maze_tutorial.py

@@ -0,0 +1,60 @@
+from stable_baselines3 import SAC, TD3
+
+from gr_libs.environment._utils.utils import domain_to_env_property
+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
+
+
+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.goals_adaptation_phase(
+        dynamic_goals=[(4, 4), (7, 3), (3, 7)],
+        dynamic_train_configs=[
+            (SAC, 200000) for _ in range(3)
+        ],  # for expert sequence generation.
+    )
+
+    property_type = domain_to_env_property(POINT_MAZE)
+    env_property = property_type("PointMaze-FourRoomsEnvDense-11x11")
+
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    actor = DeepRLAgent(
+        domain_name="point_maze",
+        problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4",
+        env_prop=env_property,
+        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)"
+    )
+
+
+if __name__ == "__main__":
+    run_graml_point_maze_tutorial()

gr_libs/tutorials/graql_minigrid_tutorial.py

@@ -0,0 +1,50 @@
+from gr_libs import Graql
+from gr_libs.environment._utils.utils import domain_to_env_property
+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
+
+
+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
+
+    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.
+    )
+
+    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",
+        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
+    )
+
+    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()