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

gr_libs/__init__.py

@@ -1,6 +1,11 @@
 """gr_libs: Baselines for goal recognition executions on gym environments."""
 
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco, Graql
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import (
+    Draco,
+    GCDraco,
+    Graql,
+    GCAura,
+)
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
 
 try:

gr_libs/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.5'
-__version_tuple__ = version_tuple = (0, 2, 5)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)

gr_libs/environment/environment.py

@@ -1,4 +1,4 @@
-""" environment.py """
+"""environment.py"""
 
 import os
 import sys
@@ -14,6 +14,8 @@ from minigrid.wrappers import ImgObsWrapper, RGBImgPartialObsWrapper
 from PIL import Image
 from stable_baselines3.common.vec_env import DummyVecEnv
 
+from gr_envs.wrappers.goal_wrapper import GoalRecognitionWrapper
+
 MINIGRID, PANDA, PARKING, POINT_MAZE = "minigrid", "panda", "parking", "point_maze"
 
 QLEARNING = "QLEARNING"
@@ -110,6 +112,12 @@ class EnvProperty:
         Convert a list of problems to a string tuple.
         """
 
+    @abstractmethod
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+
     @abstractmethod
     def goal_to_problem_str(self, goal):
         """
@@ -166,6 +174,29 @@ class EnvProperty:
         Change the goal to a specific desired goal.
         """
 
+    def is_goal_in_subspace(self, goal):
+        """
+        Check if a goal is within the specified goal subspace.
+
+        Args:
+            goal: The goal to check
+            goal_subspace: The goal subspace to check against
+
+        Returns:
+            bool: True if the goal is within the subspace, False otherwise
+        """
+        env = gym.make(id=self.name)
+        while env is not None and hasattr(env, "env"):
+            if isinstance(env, GoalRecognitionWrapper) and hasattr(
+                env, "is_goal_in_subspace"
+            ):
+                # If the environment has a goal recognition wrapper, use its method
+                return env.is_goal_in_subspace(goal)
+            # Traverse through wrappers to find the base environment
+            env = env.env
+
+        return True
+
 
 class GCEnvProperty(EnvProperty):
     """
@@ -194,16 +225,25 @@ class MinigridProperty(EnvProperty):
         super().__init__(name)
         self.domain_name = "minigrid"
 
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+        return f"{goal[0]}x{goal[1]}"
+
     def goal_to_problem_str(self, goal):
         """
         Convert a goal to a problem string.
         """
-        return self.name + f"-DynamicGoal-{goal[0]}x{goal[1]}-v0"
+        return self.name + f"-DynamicGoal-{self.goal_to_str(goal)}-v0"
 
-    def str_to_goal(self, problem_name):
+    def str_to_goal(self, problem_name=None):
         """
         Convert a problem name to a goal.
         """
+        if problem_name is None:
+            problem_name = self.name
+
         parts = problem_name.split("-")
         goal_part = [part for part in parts if "x" in part]
         width, height = goal_part[0].split("x")
@@ -325,30 +365,36 @@ class PandaProperty(GCEnvProperty):
         super().__init__(name)
         self.domain_name = "panda"
 
-    def str_to_goal(self, problem_name):
+    def str_to_goal(self, problem_name=None):
         """
         Convert a problem name to a goal.
         """
+        if problem_name is None:
+            return "general"
         try:
             numeric_part = problem_name.split("PandaMyReachDenseX")[1]
             components = [
                 component.replace("-v3", "").replace("y", ".").replace("M", "-")
                 for component in numeric_part.split("X")
             ]
-            floats = []
-            for component in components:
-                floats.append(float(component))
-            return np.array([floats], dtype=np.float32)
+            floats = [float(component) for component in components]
+            return np.array([floats])
         except Exception:
             return "general"
 
-    def goal_to_problem_str(self, goal):
+    def goal_to_str(self, goal):
         """
-        Convert a goal to a problem string.
+        Convert a goal to a string representation.
         """
-        goal_str = "X".join(
+        return "X".join(
             [str(float(g)).replace(".", "y").replace("-", "M") for g in goal[0]]
         )
+
+    def goal_to_problem_str(self, goal):
+        """
+        Convert a goal to a problem string.
+        """
+        goal_str = self.goal_to_str(goal)
         return f"PandaMyReachDenseX{goal_str}-v3"
 
     def gc_adaptable(self):
@@ -450,10 +496,34 @@ class ParkingProperty(GCEnvProperty):
         super().__init__(name)
         self.domain_name = "parking"
 
+    def str_to_goal(self, problem_name=None):
+        """
+        Convert a problem name to a goal.
+        """
+        if not problem_name:
+            problem_name = self.name
+        # Extract the goal from the part
+        return int(problem_name.split("GI-")[1].split("-v0")[0])
+
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+        if isinstance(goal, int):
+            return str(goal)
+        elif isinstance(goal, str):
+            return goal
+        else:
+            raise ValueError(
+                f"Unsupported goal type: {type(goal)}. Expected int or str."
+            )
+
     def goal_to_problem_str(self, goal):
         """
         Convert a goal to a problem string.
         """
+        if "-GI-" in self.name:
+            return self.name.split("-GI-")[0] + f"-GI-{goal}-v0"
         return self.name.split("-v0")[0] + f"-GI-{goal}-v0"
 
     def gc_adaptable(self):
@@ -536,9 +606,11 @@ class PointMazeProperty(EnvProperty):
         super().__init__(name)
         self.domain_name = "point_maze"
 
-    def str_to_goal(self):
+    def str_to_goal(self, problem_name=None):
         """Convert a problem name to a goal."""
-        parts = self.name.split("-")
+        if not problem_name:
+            problem_name = self.name
+        parts = problem_name.split("-")
         # Find the part containing the goal size (usually after "DynamicGoal")
         sizes_parts = [part for part in parts if "x" in part]
         goal_part = sizes_parts[1]
@@ -546,9 +618,15 @@ class PointMazeProperty(EnvProperty):
         width, height = goal_part.split("x")
         return (int(width), int(height))
 
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+        return f"{goal[0]}x{goal[1]}"
+
     def gc_adaptable(self):
         """Check if the environment is goal-conditioned adaptable."""
-        return False
+        return True
 
     def problem_list_to_str_tuple(self, problems):
         """Convert a list of problems to a string tuple."""
@@ -574,7 +652,12 @@ class PointMazeProperty(EnvProperty):
         """
         Convert a goal to a problem string.
         """
-        return self.name + f"-Goal-{goal[0]}x{goal[1]}"
+        possible_suffixes = ["-Goals-", "-Goal-", "-MultiGoals-", "-GoalConditioned-"]
+        for suffix in possible_suffixes:
+            if suffix in self.name:
+                return self.name.split(suffix)[0] + f"-Goal-{self.goal_to_str(goal)}"
+
+        return self.name + f"-Goal-{self.goal_to_str(goal)}"
 
     def change_done_by_specific_desired(self, obs, desired, old_success_done):
         """
@@ -592,6 +675,12 @@ class PointMazeProperty(EnvProperty):
         assert isinstance(done, np.ndarray)
         return done[0]
 
+    def use_goal_directed_problem(self):
+        """
+        Check if the environment uses a goal-directed problem.
+        """
+        return True
+
     def is_success(self, info):
         """
         Check if the episode is successful.

gr_libs/ml/consts.py

@@ -20,3 +20,4 @@ OPTIM_ALPHA = 0.99
 CLIP_EPS = 0.2
 RECURRENCE = 1
 TEXT = False
+FINETUNE_TIMESTEPS = 100000  # for GCAura fine-tuning

gr_libs/ml/neural/deep_rl_learner.py

@@ -1,6 +1,7 @@
 import gc
 from collections import OrderedDict
 from types import MethodType
+from typing import Any
 
 import cv2
 import numpy as np
@@ -22,6 +23,10 @@ from stable_baselines3.common.base_class import BaseAlgorithm
 
 from gr_libs.ml.utils import device
 
+from gr_libs.ml.consts import (
+    FINETUNE_TIMESTEPS,
+)
+
 # TODO do we need this?
 NETWORK_SETUP = {
     SAC: OrderedDict(
@@ -236,27 +241,46 @@ class DeepRLAgent:
             self._model_file_path, env=self.env, device=device, **self.model_kwargs
         )
 
-    def learn(self):
+    def learn(self, goal=None, total_timesteps=None):
         """Train the agent."""
-        if os.path.exists(self._model_file_path):
-            print(f"Loading pre-existing model in {self._model_file_path}")
+        model_file_path = self._model_file_path
+        old_model_file_path = model_file_path
+        if goal is not None:
+            model_file_path = self._model_file_path.replace(
+                ".pth", f"_{goal}.pth"
+            ).replace(".zip", f"_{goal}.zip")
+            if total_timesteps is not None:
+                model_file_path = model_file_path.replace(
+                    ".pth", f"_{total_timesteps}.pth"
+                ).replace(".zip", f"_{total_timesteps}.zip")
+
+        self._model_file_path = model_file_path
+
+        if os.path.exists(model_file_path):
+            print(f"Loading pre-existing model in {model_file_path}")
             self.load_model()
         else:
-            print(f"No existing model in {self._model_file_path}, starting learning")
-            if self.exploration_rate is not None:
-                self._model = self.algorithm(
-                    "MultiInputPolicy",
-                    self.env,
-                    ent_coef=self.exploration_rate,
-                    verbose=1,
-                )
-            else:
-                self._model = self.algorithm("MultiInputPolicy", self.env, verbose=1)
+            print(f"No existing model in {model_file_path}, starting learning")
+            if total_timesteps is None:
+                total_timesteps = self.num_timesteps
+                if self.exploration_rate is not None:
+                    self._model = self.algorithm(
+                        "MultiInputPolicy",
+                        self.env,
+                        ent_coef=self.exploration_rate,
+                        verbose=1,
+                    )
+                else:
+                    self._model = self.algorithm(
+                        "MultiInputPolicy", self.env, verbose=1
+                    )
             self._model.learn(
-                total_timesteps=self.num_timesteps, progress_bar=True
+                total_timesteps=total_timesteps, progress_bar=True
             )  # comment this in a normal env
             self.save_model()
 
+        self._model_file_path = old_model_file_path
+
     def safe_env_reset(self):
         """
         Reset the environment safely, suppressing output.
@@ -503,6 +527,69 @@ class DeepRLAgent:
         self.env.close()
         return observations
 
+    def fine_tune(
+        self,
+        goal: Any,
+        num_timesteps: int = FINETUNE_TIMESTEPS,
+    ) -> None:
+        """
+        Fine-tune this goal-conditioned agent on a single specified goal.
+        Overrides optimizer LR if provided, resets the env to the goal, and continues training.
+
+        Args:
+            goal: The specific goal to fine-tune on. Type depends on the environment.
+            num_timesteps: Number of timesteps for fine-tuning. Defaults to FINETUNE_TIMESTEPS.
+            learning_rate: Learning rate for fine-tuning. Defaults to FINETUNE_LR.
+        """
+        # Store original environment and problem
+        original_env = self.env
+        original_problem = self.problem_name
+        created_new_env = False
+
+        try:
+            # Try to create a goal-specific environment
+            if hasattr(self.env_prop, "goal_to_problem_str") and callable(
+                self.env_prop.goal_to_problem_str
+            ):
+                try:
+                    goal_problem = self.env_prop.goal_to_problem_str(goal)
+
+                    # Create the goal-specific environment
+                    env_kwargs = {"id": goal_problem, "render_mode": "rgb_array"}
+                    new_env = self.env_prop.create_vec_env(env_kwargs)
+
+                    # Update the model's environment
+                    self._model.set_env(new_env)
+                    self.env = new_env
+                    self.problem_name = goal_problem
+                    created_new_env = True
+                    print(f"Created a new environment for fine-tuning: {goal_problem}")
+                except Exception as e:
+                    print(f"Warning: Could not create goal-specific environment: {e}")
+
+            if not created_new_env:
+                print(
+                    (
+                        "Fine-tuning requires a goal-specific environment."
+                        "Please ensure that the environment with the specified goal exists."
+                    )
+                )
+
+            print(f"Fine-tuning for {num_timesteps} timesteps...")
+            self.learn(
+                goal=self.env_prop.goal_to_str(goal), total_timesteps=num_timesteps
+            )
+            print("Fine-tuning complete. Model saved.")
+
+        finally:
+            # Restore original environment if needed
+            if created_new_env:
+                self.env.close()
+                self._model.set_env(original_env)
+                self.env = original_env
+                self.problem_name = original_problem
+                print("Restored original environment.")
+
 
 class GCDeepRLAgent(DeepRLAgent):
     """

gr_libs/odgr_executor.py

@@ -15,7 +15,7 @@ from gr_libs.ml.utils.storage import (
 )
 from gr_libs.problems.consts import PROBLEMS
 from gr_libs.recognizer._utils import recognizer_str_to_obj
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco, GCAura
 from gr_libs.recognizer.graml.graml_recognizer import Graml
 from gr_libs.recognizer.recognizer import GaAgentTrainerRecognizer, LearningRecognizer
 
@@ -102,7 +102,11 @@ def run_odgr_problem(args):
             }
 
             # need to dump the whole plan for draco because it needs it for inference phase for checking likelihood.
-            if (recognizer_type == Draco or recognizer_type == GCDraco) and issubclass(
+            if (
+                recognizer_type == Draco
+                or recognizer_type == GCDraco
+                or recognizer_type == GCAura
+            ) and issubclass(
                 rl_agent_type, DeepRLAgent
             ):  # TODO remove this condition, remove the assumption.
                 generate_obs_kwargs["with_dict"] = True
@@ -224,6 +228,7 @@ def parse_args():
             "Graql",
             "Draco",
             "GCDraco",
+            "GCAura",
         ],
         required=True,
         help="Recognizer type. Follow readme.md and recognizer folder for more information and rules.",

gr_libs/recognizer/_utils/format.py

@@ -1,4 +1,9 @@
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco, Graql
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import (
+    Draco,
+    GCDraco,
+    Graql,
+    GCAura,
+)
 from gr_libs.recognizer.graml.graml_recognizer import (
     ExpertBasedGraml,
     GCGraml,
@@ -14,5 +19,6 @@ def recognizer_str_to_obj(recognizer_str: str):
         "Graql": Graql,
         "Draco": Draco,
         "GCDraco": GCDraco,
+        "GCAura": GCAura,
     }
     return recognizer_map.get(recognizer_str)

gr_libs/recognizer/gr_as_rl/gr_as_rl_recognizer.py

@@ -8,12 +8,14 @@ from gr_libs.ml.base import RLAgent
 from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent, GCDeepRLAgent
 from gr_libs.ml.tabular.tabular_q_learner import TabularQLearner
 from gr_libs.ml.utils.storage import get_gr_as_rl_experiment_confidence_path
+from gymnasium.envs.registration import register, registry
 from gr_libs.recognizer.recognizer import (
     GaAdaptingRecognizer,
     GaAgentTrainerRecognizer,
     LearningRecognizer,
     Recognizer,
 )
+from gr_libs.ml.consts import FINETUNE_TIMESTEPS
 
 
 class GRAsRL(Recognizer):
@@ -234,7 +236,7 @@ class GCDraco(GRAsRL, LearningRecognizer, GaAdaptingRecognizer):
         base = problems["gc"]
         base_goals = base["goals"]
         train_configs = base["train_configs"]
-        super().domain_learning_phase(base_goals, train_configs)
+        super().domain_learning_phase(train_configs, base_goals)
         agent_kwargs = {
             "domain_name": self.env_prop.domain_name,
             "problem_name": self.env_prop.name,
@@ -256,3 +258,146 @@ class GCDraco(GRAsRL, LearningRecognizer, GaAdaptingRecognizer):
 
     def choose_agent(self, problem_name: str) -> RLAgent:
         return next(iter(self.agents.values()))
+
+
+class GCAura(GRAsRL, LearningRecognizer, GaAdaptingRecognizer):
+    """
+    GCAura uses goal-conditioned reinforcement learning with adaptive fine-tuning.
+
+    It trains a base goal-conditioned policy over a goal subspace in the domain learning phase.
+    During the goal adaptation phase, it checks if new goals are within the original goal subspace:
+    - If a goal is within the subspace, it uses the original trained model
+    - If a goal is outside the subspace, it fine-tunes the model for that specific goal
+
+    This approach combines the efficiency of goal-conditioned RL with the precision of
+    goal-specific fine-tuning when needed.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        assert (
+            self.env_prop.gc_adaptable()
+            and not self.env_prop.is_state_discrete()
+            and not self.env_prop.is_action_discrete()
+        )
+        if self.rl_agent_type is None:
+            self.rl_agent_type = GCDeepRLAgent
+        self.evaluation_function = kwargs.get("evaluation_function")
+        if self.evaluation_function is None:
+            from gr_libs.metrics.metrics import mean_wasserstein_distance
+
+            self.evaluation_function = mean_wasserstein_distance
+        assert callable(
+            self.evaluation_function
+        ), "Evaluation function must be a callable function."
+
+        # Store fine-tuning parameters
+        self.finetune_timesteps = kwargs.get("finetune_timesteps", FINETUNE_TIMESTEPS)
+
+        # Dictionary to store fine-tuned agents for specific goals
+        self.fine_tuned_agents = {}
+
+    def domain_learning_phase(self, problems):
+        base = problems["gc"]
+        train_configs = base["train_configs"]
+
+        # Store the goal subspace for later checks
+        self.original_train_configs = train_configs
+
+        super().domain_learning_phase(train_configs)
+
+        agent_kwargs = {
+            "domain_name": self.env_prop.domain_name,
+            "problem_name": self.env_prop.name,
+            "algorithm": train_configs[0][0],
+            "num_timesteps": train_configs[0][1],
+            "env_prop": self.env_prop,
+        }
+
+        agent = self.rl_agent_type(**agent_kwargs)
+        agent.learn()
+        self.agents[self.env_prop.name] = agent
+        self.action_space = agent.env.action_space
+
+    def _is_goal_in_subspace(self, goal):
+        """
+        Check if a goal is within the original training subspace.
+
+        Delegates to the environment property's implementation.
+
+        Args:
+            goal: The goal to check
+
+        Returns:
+            bool: True if the goal is within the training subspace
+        """
+        # Use the environment property's implementation
+        return self.env_prop.is_goal_in_subspace(goal)
+
+    def goals_adaptation_phase(self, dynamic_goals):
+        """
+        Adapt to new goals, fine-tuning if necessary.
+
+        For goals outside the original training subspace, fine-tune the model.
+
+        Args:
+            dynamic_goals: List of goals to adapt to
+        """
+        self.active_goals = dynamic_goals
+        self.active_problems = [
+            self.env_prop.goal_to_problem_str(goal) for goal in dynamic_goals
+        ]
+
+        # Check each goal and fine-tune if needed
+        for goal in dynamic_goals:
+            if not self._is_goal_in_subspace(goal):
+                print(f"Goal {goal} is outside the training subspace. Fine-tuning...")
+
+                # Create a new agent for this goal
+                agent_kwargs = {
+                    "domain_name": self.env_prop.domain_name,
+                    "problem_name": self.env_prop.name,
+                    "algorithm": self.original_train_configs[0][0],
+                    "num_timesteps": self.original_train_configs[0][1],
+                    "env_prop": self.env_prop,
+                }
+
+                # Create new agent with base model
+                fine_tuned_agent = self.rl_agent_type(**agent_kwargs)
+                fine_tuned_agent.learn()  # This loads the existing model
+
+                # Fine-tune for this specific goal
+                fine_tuned_agent.fine_tune(
+                    goal=goal,
+                    num_timesteps=self.finetune_timesteps,
+                )
+
+                # Store the fine-tuned agent
+                self.fine_tuned_agents[
+                    f"{self.env_prop.goal_to_str(goal)}_{self.finetune_timesteps}"
+                ] = fine_tuned_agent
+            else:
+                print(f"Goal {goal} is within the training subspace. Using base agent.")
+
+    def choose_agent(self, problem_name: str) -> RLAgent:
+        """
+        Return the appropriate agent for the given problem.
+
+        If the goal has a fine-tuned agent, return that; otherwise return the base agent.
+
+        Args:
+            problem_name: The problem name to get agent for
+
+        Returns:
+            The appropriate agent (base or fine-tuned)
+        """
+        # Extract the goal from the problem name
+        goal = self.env_prop.str_to_goal(problem_name)
+        agent_name = f"{self.env_prop.goal_to_str(goal)}_{self.finetune_timesteps}"
+
+        # Check if we have a fine-tuned agent for this goal
+        if agent_name in self.fine_tuned_agents:
+            return self.fine_tuned_agents[agent_name]
+
+        # Otherwise return the base agent
+        return self.agents[self.env_prop.name]

gr_libs/recognizer/graml/graml_recognizer.py

@@ -1,4 +1,4 @@
-""" Collection of recognizers that use GRAML methods: metric learning for ODGR. """
+"""Collection of recognizers that use GRAML methods: metric learning for ODGR."""
 
 import os
 from abc import abstractmethod
@@ -124,7 +124,7 @@ class Graml(LearningRecognizer):
         pass
 
     def domain_learning_phase(self, base_goals: list[str], train_configs: list):
-        super().domain_learning_phase(base_goals, train_configs)
+        super().domain_learning_phase(train_configs, base_goals)
         self.train_agents_on_base_goals(base_goals, train_configs)
         # train the network so it will find a metric for the observations of the base agents such that traces of agents to different goals are far from one another
         self.model_directory = get_lstm_model_dir(
@@ -343,7 +343,7 @@ class BGGraml(Graml):
         assert len(base_goals) == len(
             train_configs
         ), "base_goals and train_configs should have the same length"
-        super().domain_learning_phase(base_goals, train_configs)
+        super().domain_learning_phase(train_configs=train_configs, base_goals=base_goals)
 
     # In case we need goal-directed agent for every goal
     def train_agents_on_base_goals(self, base_goals: list[str], train_configs: list):
@@ -556,7 +556,7 @@ class GCGraml(Graml, GaAdaptingRecognizer):
         assert (
             len(train_configs) == 1
         ), "GCGraml should only have one train config for the base goals, it uses a single agent"
-        super().domain_learning_phase(base_goals, train_configs)
+        super().domain_learning_phase(train_configs=train_configs, base_goals=base_goals)
 
     # In case we need goal-directed agent for every goal
     def train_agents_on_base_goals(self, base_goals: list[str], train_configs: list):

gr_libs/recognizer/recognizer.py

@@ -36,7 +36,7 @@ class LearningRecognizer(Recognizer):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-    def domain_learning_phase(self, base_goals: list[str], train_configs: list):
+    def domain_learning_phase(self, train_configs: list, base_goals: list[str] = None):
         """
         Perform the domain learning phase.
 
@@ -70,18 +70,18 @@ class GaAgentTrainerRecognizer(Recognizer):
             None
         """
 
-    def domain_learning_phase(self, base_goals: list[str], train_configs: list):
+    def domain_learning_phase(self, train_configs: list, base_goals: list[str] = None):
         """
         Perform the domain learning phase.
 
         Args:
-            base_goals (List[str]): List of base goals.
             train_configs (List): List of training configurations.
+            base_goals (List[str]): List of base goals for the learning phase.
 
         Returns:
             None
         """
-        super().domain_learning_phase(base_goals, train_configs)
+        super().domain_learning_phase(train_configs, base_goals)
 
 
 class GaAdaptingRecognizer(Recognizer):