gr-libs 0.1.6.post1__py3-none-any.whl → 0.1.7.post0__py3-none-any.whl

gr_libs/__init__.py

@@ -1,2 +1,6 @@
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "0.0.0"  # fallback if file isn't present

gr_libs/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.6.post1'
-__version_tuple__ = version_tuple = (0, 1, 6)
+__version__ = version = '0.1.7.post0'
+__version_tuple__ = version_tuple = (0, 1, 7, 'post0')

gr_libs/environment/__init__.py

@@ -12,7 +12,7 @@ def is_extra_installed(package: str, extra: str) -> bool:
         return False  # The package is not installed
 
 # Check if `gr_libs[minigrid]` was installed
-for env in ["minigrid", "panda", "highway", "point_maze"]:
+for env in ["minigrid", "panda", "highway", "maze"]:
 	if is_extra_installed("gr_libs", f"gr_envs[{env}]"):
 		try:
 			importlib.import_module(f"gr_envs.{env}_scripts.envs")

gr_libs/ml/tabular/tabular_q_learner.py

@@ -351,7 +351,7 @@ class TabularQLearner(TabularRLAgent):
     def simplify_observation(self, observation):
         return [(obs['direction'], agent_pos_x, agent_pos_y, action) for ((obs, (agent_pos_x, agent_pos_y)), action) in observation] # list of tuples, each tuple the sample
         
-    def generate_observation(self, action_selection_method: MethodType, random_optimalism, save_fig = False, fig_path: str=None, env_prop=None):
+    def generate_observation(self, action_selection_method: MethodType, random_optimalism, save_fig=False, fig_path: str=None, env_prop=None):
         """
         Generate a single observation given a list of agents
 

gr_libs/ml/utils/storage.py

@@ -15,6 +15,13 @@ def get_storage_framework_dir(recognizer: str):
     return os.path.join(get_storage_dir(),recognizer)
 
 def get_storage_dir():
+    # Prefer local directory if it exists (e.g., in GitHub workspace)
+    if os.path.exists("dataset"):
+        return "dataset"
+    # Fall back to pre-mounted directory (e.g., in Docker container)
+    if os.path.exists("/preloaded_data"):
+        return "/preloaded_data"
+    # Default to "dataset" even if it doesn't exist (e.g., will be created)
     return "dataset"
 
 def _get_models_directory_name():

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-0.1.6.post1.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.6.post1
+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>

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

@@ -1,5 +1,3 @@
-CI/README.md,sha256=CbWNAWrXFFwYq3sWAORhoQIE5busoNyYh_rFWVH1enw,800
-CI/docker_build_context/Dockerfile,sha256=Rk7LYTxOW7VVJcmNa8csZ4BwkunMYIiHX4WVSuMam50,311
 evaluation/analyze_results_cross_alg_cross_domain.py,sha256=s_DDh4rNfRnvQ0PDa2d5411jYOa7CaI1YeB8Dpup7QU,9803
 evaluation/create_minigrid_map_image.py,sha256=jaSW3n3tY222iFUeAMqedBP9cvD88GCzPrQ6_XHv5oQ,1242
 evaluation/file_system.py,sha256=SSYnj8QGFkq-8V_0s7x2MWbD88aFaoFY4Ogc_Pt8m6U,1601
@@ -9,9 +7,9 @@ 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/_version.py,sha256=C8Me-BH17Mqlv65Ba3Tqc5gFEzabp8fxxyIA9C_XdDQ,517
-gr_libs/environment/__init__.py,sha256=HFVGBcufWf8-ahCo6h_s2pFEyvDy59cFg8z908RgdYo,1038
+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
@@ -37,34 +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=ZrApJVdBQxKRYhhDiWLCNGmlxgi674nwgb30BgVggC8,1705
-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=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
 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=46-sfxmYA9jLRSpqIF9z69MLSfOSTJarfjlQ_Igq294,1769
+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.6.post1.dist-info/METADATA,sha256=UPwlwVlbGTpTsUhYwWH5hYr-hSBpcWjrFIA7sWg0Kj4,9620
-gr_libs-0.1.6.post1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-gr_libs-0.1.6.post1.dist-info/top_level.txt,sha256=rL-bbK-KnLzVbLIUCdN1riH58lup3jG0NJ3LTt_qSwo,38
-gr_libs-0.1.6.post1.dist-info/RECORD,,
+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.6.post1.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.6.post1.dist-info → gr_libs-0.1.7.post0.dist-info}/top_level.txt

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

tutorials/graml_parking_tutorial.py

@@ -5,6 +5,7 @@ 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
 
 def run_graml_parking_tutorial():
     recognizer = GCGraml(

CI/README.md

@@ -1,12 +0,0 @@
-## How to build a new docker image including new trained agents:
-1. Install docker
-2. Make sure you have a dataset.zip at your repo root
-3. Make sure you have a classic token in github: https://github.com/settings/tokens . If you don't, create one with package write, read and delete permissions and copy it somewhere safe.
-4. Authenticate to ghcr with docker by running:
-```sh
-echo ghp_REST_OF_TOKEN | docker login ghcr.io -u MatanShamir1 --password-stdin
-```
-3. docker build -t ghcr.io/<your-username>/gr_test_base:latest -f CI/Dockerfile .
-(the -f Dockerfile tells docker which Dockerfile to use and the '.' tells docker what's the build context, or where the dataset.zip should live)
-4. docker push ghcr.io/<your-username>/gr_test_base:latest
-docker push ghcr.io/MatanShamir1/gr_test_base:latest

CI/docker_build_context/Dockerfile

@@ -1,15 +0,0 @@
-FROM python:3.11-slim
-
-# Set workdir
-WORKDIR /app
-
-# Install unzip
-RUN apt-get update && apt-get install -y unzip && rm -rf /var/lib/apt/lists/*
-
-# Copy and unzip the dataset
-COPY dataset.zip .
-RUN unzip dataset.zip && rm dataset.zip
-RUN mv dataset_new dataset
-
-# Just start with bash by default
-CMD [ "bash" ]

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.