gr-libs 0.1.3__py3-none-any.whl

gr_libs/recognizer/graml/graml_recognizer.py

@@ -0,0 +1,266 @@
+from abc import ABC, abstractmethod
+from collections import namedtuple
+import os
+from gr_libs.environment.environment import EnvProperty, GCEnvProperty, LSTMProperties
+from gr_libs.ml import utils
+from gr_libs.ml.base import ContextualAgent
+from typing import List, Tuple
+import numpy as np
+from torch.utils.data import DataLoader
+from torch.nn.utils.rnn import pad_sequence
+import torch
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent, GCDeepRLAgent
+from gr_libs.ml.planner.mcts import mcts_model
+import dill
+from gr_libs.ml.tabular.tabular_q_learner import TabularQLearner
+from gr_libs.recognizer.graml.gr_dataset import GRDataset, generate_datasets
+from gr_libs.ml.sequential.lstm_model import LstmObservations, train_metric_model
+from gr_libs.ml.utils.format import random_subset_with_order
+from gr_libs.ml.utils.storage import get_and_create, get_lstm_model_dir, get_embeddings_result_path, get_policy_sequences_result_path
+from gr_libs.metrics import metrics
+from gr_libs.recognizer.recognizer import GaAdaptingRecognizer, GaAgentTrainerRecognizer, LearningRecognizer, Recognizer # import first, very dependent
+
+### TODO IMPLEMENT MORE SELECTION METHODS, MAKE SURE action_probs IS AS IT SEEMS: list of action-probability 'es ###
+
+def collate_fn(batch):
+	first_traces, second_traces, is_same_goals = zip(*batch)
+	# torch.stack takes tensor tuples (fixed size) and stacks them up in a matrix
+	first_traces_padded = pad_sequence([torch.stack(sequence) for sequence in first_traces], batch_first=True)
+	second_traces_padded = pad_sequence([torch.stack(sequence) for sequence in second_traces], batch_first=True)
+	first_traces_lengths = [len(trace) for trace in first_traces]
+	second_traces_lengths = [len(trace) for trace in second_traces]
+	return first_traces_padded.to(utils.device), second_traces_padded.to(utils.device), torch.stack(is_same_goals).to(utils.device), first_traces_lengths, second_traces_lengths
+
+def load_weights(loaded_model : LstmObservations, path):
+	# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+	loaded_model.load_state_dict(torch.load(path, map_location=utils.device))
+	loaded_model.to(utils.device)  # Ensure model is on the right device
+	return loaded_model
+
+def save_weights(model : LstmObservations, path):
+	directory = os.path.dirname(path)
+	if not os.path.exists(directory):
+		os.makedirs(directory)
+	torch.save(model.state_dict(), path)
+
+class Graml(LearningRecognizer):
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		self.agents: List[ContextualAgent] = []
+		self.train_func = train_metric_model; self.collate_func = collate_fn
+
+	@abstractmethod
+	def train_agents_on_base_goals(self, base_goals: List[str], train_configs: List):
+		pass
+
+	def domain_learning_phase(self, base_goals: List[str], train_configs: List):
+		super().domain_learning_phase(base_goals, train_configs)
+		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(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name , model_name=self.env_prop.problem_list_to_str_tuple(self.original_problems), recognizer=self.__class__.__name__)
+		last_path = r"lstm_model.pth"
+		self.model_file_path = os.path.join(self.model_directory, last_path)
+		self.model = LstmObservations(input_size=self.env_prop.get_lstm_props().input_size, hidden_size=self.env_prop.get_lstm_props().hidden_size)
+		self.model.to(utils.device)
+
+		if os.path.exists(self.model_file_path):
+			print(f"Loading pre-existing lstm model in {self.model_file_path}")
+			load_weights(loaded_model=self.model, path=self.model_file_path)
+		else:
+			print(f"{self.model_file_path} doesn't exist, training the model")
+			train_samples, dev_samples = generate_datasets(num_samples=self.env_prop.get_lstm_props().num_samples,
+												  		   agents=self.agents,
+													   	   observation_creation_method=metrics.stochastic_amplified_selection,
+														   problems=self.original_problems,
+														   env_prop=self.env_prop,
+														   gc_goal_set=self.gc_goal_set if hasattr(self, 'gc_goal_set') else None,
+														   recognizer_name=self.__class__.__name__)
+
+			train_dataset = GRDataset(len(train_samples), train_samples)
+			dev_dataset = GRDataset(len(dev_samples), dev_samples)
+			self.train_func(self.model,	train_loader=DataLoader(train_dataset, batch_size=self.env_prop.get_lstm_props().batch_size, shuffle=False, collate_fn=self.collate_func),
+							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]):
+		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)
+			self.plans_dict[str(goal)] = obss
+
+	def get_goal_plan(self, goal):
+		assert self.plans_dict, "plans_dict wasn't created during goals_adaptation_phase and now inference phase can't return the plans. when inference_same_length, keep the plans and not their embeddings during goals_adaptation_phase."
+		return self.plans_dict[goal]
+
+	def dump_plans(self, true_sequence, true_goal, percentage):
+		assert self.plans_dict, "plans_dict wasn't created during goals_adaptation_phase and now inference phase can't return the plans. when inference_same_length, keep the plans and not their embeddings during goals_adaptation_phase."
+		# Arrange storage
+		embeddings_path = get_and_create(get_embeddings_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__))
+		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":
+					to_dump[goal] = self.agents[0].agent.simplify_observation(obss)
+				else:
+					to_dump[goal] = []
+					for obs in obss:
+						addition = self.agents[0].agent.simplify_observation(obs) if self.is_first_inf_since_new_goals else obs
+						to_dump[goal].append(addition)
+			dill.dump(to_dump, plans_file)
+		self.plans_dict.pop(f"{true_goal}_true")
+
+	def create_embeddings_dict(self):
+		for goal, obss in self.plans_dict.items():
+			self.embeddings_dict[goal] = []
+			for (cons_seq, non_cons_seq) in obss:
+				self.embeddings_dict[goal].append((self.model.embed_sequence(cons_seq), self.model.embed_sequence(non_cons_seq)))
+
+	def inference_phase(self, inf_sequence, true_goal, percentage) -> str:
+		embeddings_path = get_and_create(get_embeddings_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__))
+		simplified_inf_sequence = self.agents[0].agent.simplify_observation(inf_sequence)
+		new_embedding = self.model.embed_sequence(simplified_inf_sequence)
+		assert self.plans_dict, "plans_dict wasn't created during goals_adaptation_phase and now inference phase can't embed the plans. when inference_same_length, keep the plans and not their embeddings during goals_adaptation_phase."
+		if self.is_first_inf_since_new_goals:
+			self.is_first_inf_since_new_goals = False
+			self.update_sequences_library_inference_phase(inf_sequence)
+			self.create_embeddings_dict()
+		
+		closest_goal, greatest_similarity = None, 0
+		for (goal, embeddings) in self.embeddings_dict.items():
+			sum_curr_similarities = 0
+			for cons_embedding, non_cons_embedding in embeddings:
+				sum_curr_similarities += max(torch.exp(-torch.sum(torch.abs(cons_embedding-new_embedding))), torch.exp(-torch.sum(torch.abs(non_cons_embedding-new_embedding))))
+			mean_similarity = sum_curr_similarities/len(embeddings)
+			if mean_similarity > greatest_similarity:
+				closest_goal = goal
+				greatest_similarity = mean_similarity
+
+		self.embeddings_dict[f"{true_goal}_true"] = new_embedding
+		if self.collect_statistics:
+			with open(os.path.join(embeddings_path, f'{true_goal}_{percentage}_embeddings_dict.pkl'), 'wb') as embeddings_file:
+				dill.dump(self.embeddings_dict, embeddings_file)
+		self.embeddings_dict.pop(f"{true_goal}_true")
+
+		return closest_goal
+	
+	@abstractmethod
+	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+		pass
+
+	# this function duplicates every sequence and creates a consecutive and non-consecutive version of it
+	def update_sequences_library_inference_phase(self, inf_sequence) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+		new_plans_dict = {}
+		for goal, obss in self.plans_dict.items():
+			new_obss = []
+			for obs in obss:
+				consecutive_partial_obs = random_subset_with_order(obs, len(inf_sequence), is_consecutive=True)
+				non_consecutive_partial_obs = random_subset_with_order(obs, len(inf_sequence), is_consecutive=False)
+				simplified_consecutive_partial_obs = self.agents[0].agent.simplify_observation(consecutive_partial_obs)
+				simplified_non_consecutive_partial_obs = self.agents[0].agent.simplify_observation(non_consecutive_partial_obs)
+				new_obss.append((simplified_consecutive_partial_obs, simplified_non_consecutive_partial_obs))
+			new_plans_dict[goal] = new_obss # override old full observations with new partial observations with consecutive and non-consecutive versions.
+		self.plans_dict = new_plans_dict
+
+class BGGraml(Graml):
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+
+	def domain_learning_phase(self, base_goals: List[str], train_configs: List):
+		assert len(train_configs) == len(base_goals), "There should be train configs for every goal in BGGraml."
+		return super().domain_learning_phase(base_goals, train_configs)
+	
+	# In case we need goal-directed agent for every goal
+	def train_agents_on_base_goals(self, base_goals: List[str], train_configs: List):
+		self.original_problems = [self.env_prop.goal_to_problem_str(g) for g in base_goals]
+		# start by training each rl agent on the base goal set
+		for (problem, goal), (algorithm, num_timesteps) in zip(zip(self.original_problems, base_goals), train_configs):
+			kwargs = {"domain_name":self.domain_name, "problem_name":problem}
+			if algorithm != None: kwargs["algorithm"] = algorithm
+			if num_timesteps != None: kwargs["num_timesteps"] = num_timesteps
+			agent = self.rl_agent_type(**kwargs)
+			agent.learn()
+			self.agents.append(ContextualAgent(problem_name=problem, problem_goal=goal, agent=agent))
+
+class MCTSBasedGraml(BGGraml, GaAdaptingRecognizer):
+	def __init__(self, *args, **kwargs):
+		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]]]:
+		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)
+
+class ExpertBasedGraml(BGGraml, GaAgentTrainerRecognizer):
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		if self.rl_agent_type==None:
+			if self.env_prop.is_state_discrete() and self.env_prop.is_action_discrete():
+				self.rl_agent_type = TabularQLearner
+			else:
+				self.rl_agent_type = DeepRLAgent
+
+	def generate_sequences_library(self, goal: str) -> 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)]
+
+	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]
+		self.dynamic_train_configs_dict = {problem:config for problem, config in zip(self.dynamic_goals_problems,dynamic_train_configs)}
+		return super().goals_adaptation_phase(dynamic_goals)
+
+class GCGraml(Graml, GaAdaptingRecognizer):
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		if self.rl_agent_type==None: self.rl_agent_type = GCDeepRLAgent
+		assert self.env_prop.gc_adaptable() and not self.env_prop.is_state_discrete() and not self.env_prop.is_action_discrete()
+
+	def domain_learning_phase(self, base_goals: List[str], train_configs: List):
+		assert len(train_configs) == 1, "There should be one train config for the sole gc agent in GCGraml."
+		return super().domain_learning_phase(base_goals, train_configs)
+
+	# In case we need goal-directed agent for every goal
+	def train_agents_on_base_goals(self, base_goals: List[str], train_configs: List):
+		self.gc_goal_set = base_goals
+		self.original_problems = self.env_prop.name # needed for gr_dataset
+		# start by training each rl agent on the base goal set
+		kwargs = {"domain_name":self.domain_name, "problem_name":self.env_prop.name}
+		algorithm, num_timesteps = train_configs[0] # should only be one, was asserted
+		if algorithm != None: kwargs["algorithm"] = algorithm
+		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
+
+	def generate_sequences_library(self, goal: str) -> 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
+		}
+		if self.env_prop.use_goal_directed_problem(): agent_kwargs["goal_directed_problem"] = problem_name
+		else: agent_kwargs["goal_directed_goal"] = goal
+		obss = []
+		for _ in range(5): obss.append(agent.generate_observation(**agent_kwargs))
+		return obss

gr_libs/recognizer/recognizer.py

@@ -0,0 +1,46 @@
+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
+
+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
+
+class LearningRecognizer(Recognizer): # TODO add a class diagram with the inheritance of all calsses
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+
+	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): # TODO add a class diagram with the inheritance of all calsses
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+
+	@abstractmethod
+	def goals_adaptation_phase(self, dynamic_goals: List[str], dynamic_train_configs):
+		pass
+
+	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
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+
+	@abstractmethod
+	def goals_adaptation_phase(self, dynamic_goals: List[str]):
+		pass

gr_libs/recognizer/utils/__init__.py

@@ -0,0 +1 @@
+from .format import recognizer_str_to_obj

gr_libs/recognizer/utils/format.py

@@ -0,0 +1,13 @@
+from gr_libs.recognizer.graml.graml_recognizer import GCGraml, ExpertBasedGraml, MCTSBasedGraml
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql, Draco, GCDraco
+
+def recognizer_str_to_obj(recognizer_str: str):
+    recognizer_map = {
+        "GCGraml": GCGraml,
+        "ExpertBasedGraml": ExpertBasedGraml,
+        "MCTSBasedGraml": MCTSBasedGraml,
+        "Graql": Graql,
+        "Draco": Draco,
+        "GCDraco": GCDraco
+    }
+    return recognizer_map.get(recognizer_str)

gr_libs-0.1.3.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: gr_libs
+Version: 0.1.3
+Summary: Package with goal recognition frameworks baselines
+Author: Osher Elhadad, Ben Nageris
+Author-email: Matan Shamir <matan.shamir@live.biu.ac.il>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: gr_envs
+Requires-Dist: dill
+Requires-Dist: opencv-python
+
+# GRLib
+GRLib is a python package containing implementations of Goal Recognition (GR) algorithms which use MDPs to represent the decision making process. All agents in those algorithms interact with an environment that's registered in gym API.
+## Setup:
+If you're on linux, great, If on windows, use git bash for the next commands to work.
+1. Find where your python is installed. If you want to find where's your python3.12, you can run:
+```sh
+py -3.12 -c "import sys; print(sys.executable)"
+```
+2. Create a new empty venv from that python venv module:
+```sh
+C:/Users/path/to/Programs/Python/Python312/python.exe -m venv test_env
+```
+3. Activate the environment:
+```sh
+source test_env/Scripts/activate
+```
+4. There's no equivalent to conda env list to check the global virtual environments status, so you can verify the active one via:
+```sh
+echo $VIRTUAL_ENV
+```
+5. Install and upgrade basic package management modules:
+```sh
+/path/to/python.exe -m pip install --upgrade pip setuptools wheel versioneer
+```
+6. Install the gr_libss package (can add -e for editable mode):
+```sh
+cd /path/to/clone/of/GoalRecognitionLibs
+pip install -e .
+```
+7. Install gr_libs package (can add -e for editable mode):
+```sh
+cd /path/to/clone/of/Grlib
+pip install -e .
+```
+
+
+<!-- 1. Ensure you have python 3.11 installed.
+If you have root permissions, simply use:
+```sh
+mkdir -p ~/.local/python3.11
+dnf install python3.11 --prefix ~/.local/python3.11
+echo 'export PATH=$HOME/.local/python3.11/bin:$PATH' >> ~/.bashrc
+source ~/.bashrc
+```
+Else, use pyenv:
+```sh
+pyenv install 3.11.0
+```
+2. Create a new venv or use an existing 3.11 venv, and activate it. To create a new venv:
+```sh
+~/.pyenv/versions/3.11.0/bin/python -m venv graml_env
+./Python-3.11.0/graml_env/bin/activate
+```
+If you're not a sudo, and you have problems with building python getting such warnings:
+```sh
+WARNING: The Python ctypes extension was not compiled. Missing the libffi lib?
+```
+That means you don't have the necesarry libraries for building python, and you probably can't change that since you're not a sudoer.
+An alternative solution can be using a conda env:
+```sh
+conda create -n graml_env python=3.11
+conda activate graml_env
+```
+3. Install GoalRecognitionLibs to get all needed dependencies:
+```sh
+git clone [GoalRecognitionLibs address]
+cd GoalRecognitionLibs
+pip install -e . # using the conda's pip of course
+``` -->
+
+### Issues & Problems ###
+If you're not a sudo, and you have problems with building python getting such warnings:
+```sh
+WARNING: The Python ctypes extension was not compiled. Missing the libffi lib?
+```
+That means you don't have the necesarry libraries for building python.
+
+### How to use Grlib ###
+Now that you've installed the package, you have additional custom gym environments and you can start creating an ODGR scenario with the algorithm you wish to test.
+The tutorial at tutorials/tutorial.py follows a simple ODGR scnenario. We guide through the initialization and deployment process following an example where GRAML is expected to adapt to new emerging goals in the point_maze gym environment.
+
+#### Method 1: write your own script
+1. create the recognizer: we need to state the base problems on which the recognizer train.
+we also need the env_name for the sake of storing the trained models.
+Other notable parameters include the parameters for the training of the model: For example, Graml's LSTM needs to accept input sizes the size of the concatenation of the state space with the action space.
+
+```python
+recognizer = Graml(
+    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 i in range(8)],
+    partial_obs_type="fragmented",
+    batch_size=32,
+    input_size=6,
+    hidden_size=8,
+    num_samples=20000,
+    problem_list_to_str_tuple=lambda problems: "_".join([f"[{s.split('-')[-1]}]" for s in problems]),
+    is_learn_same_length_sequences=False,
+    goals_adaptation_sequence_generation_method=AGENT_BASED # take expert samples in goals adaptation phase
+)
+```
+
+2. The domain learning phase: In GRAML's case, the recognizer generates a dataset by training agents towards the base goals and trains an metric model combined of an LSTM on traces generated by those agents.
+
+```python
+recognizer.domain_learning_phase()
+```
+3. The goals adaptation phase: The recognizer receives new goals, along with configurations to the training of those agents - since the sequence generation method in this case is from an expert.
+```python
+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 i in range(3)] # for expert sequence generation
+)
+```
+4. Inference phase - this snippet generates a partial sequence by an agent trained towards one of the goals of the inference phase. Note how the trace is generated using a different agent from the recognizer's inner agents or expert (TD3 rather than SAC), and with noise added to every action to simulate suboptimal behavior.
+```python
+actor = DeepRLAgent(env_name="point_maze", problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4", algorithm=TD3, num_timesteps=200000)
+actor.learn()
+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_fragmented="fragmented")
+closest_goal = recognizer.inference_phase(partial_sequence, maze_str_to_goal("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4"), 0.5)
+```
+5. check the result returned by GRAML and print whether it was right or not.
+```python
+print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (4, 4)")
+```
+
+#### Method 2: use a configuration file
+The configuraiton file consts.py holds configurations of ODGR problems.
+You can either use existing ones or add new ones.
+Note that using the config file, despite being easier on a large scale, some inputs to the ODGR problem are not as flexible as they would be using method 1.
+For example, the sequence generation will be performed by trained agents and is non configurable. The sequences will either be completely consecutive or randomly sampled from the trace.
+Example for a problem:
+
+You can use odgr_executor.py to execute a single task:
+```sh
+python odgr_executor.py --recognizer MCTSBasedGraml --domain minigrid --task L1 --minigrid_env MinigridSimple
+```
+
+
+## Supported Algorithms
+
+| **Name**         | **Supervised**      | **RL**          | **Discrete**     | **Continuous** | **Model-Based**  | **Model-Free** | **Actions Only** |
+| ------------------- | ------------------ | ------------------ | ------------------ | ------------------- | ------------------ | --------------------------------- |
+| GRAQL   | :x: | :heavy_check_mark: | :heavy_check_mark: | :x: | :x: | :heavy_check_mark: | :x: |
+| DRACO   | :x: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x: | :heavy_check_mark: | :x: |
+| GRAML   | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x: | :heavy_check_mark: | :heavy_check_mark: |
+
+## Supported Domains
+
+| **Name**         | **Action**      | **State**          |
+| ------------------- | ------------------ | ------------------ |
+| Minigrid   | Discrete | Discrete |
+|  PointMaze  | Continuous | Continuous |
+| Parking   | Continuous | Continuous |
+| Panda   | Continuous | Continuous |
+
+### Experiments
+Given here is a guide for executing the experiments. There are benchmark domains suggested in the repository, and the 'scripts' directory suggests a series of tools to analyze them. They are defaultly set on the domains used for GRAML and GRAQL analysis during the writing of GRAML paper, but can easily be adjusted for new domains and algorithms.
+1. analyze_results_cross_alg_cross_domain.py: this script runs with no arguments. it injects information from get_experiment_results_path (for example: dataset\graml\minigrid\continuing\inference_same_seq_len\learn_diff_seq_len\experiment_results\obstacles\L111\experiment_results.pkl), and produces a plot with 4 figures showing the accuracy trend of algorithms on the domains checked one against the other. Currently GRAML is checked against GRAQL or DRACO but it can easily be adjusted from within the script.
+2. generate_task_specific_statistics_plots.py - this script produces, for a specific task execution (results of execution of experiments.py), a summary combined of a figure with sticks with the accuracies and confidence levels of an algorithm on the task on the varying percentages. figures\point_maze\obstacles\graql_point_maze_obstacles_fragmented_stats.png is an example of a path at which the output is dumped. Another product of this script is a confusion matrix with the confidence levels - visualizing the same data, and the output file resides in this path: figures\point_maze\obstacles\graml_point_maze_obstacles_fragmented_inference_same_seq_len_learn_diff_seq_len_goals_conf_mat.png.
+
+### How to add a new environment
+1. bla
+2. blalba
+
+### How to add a new Learner

gr_libs-0.1.3.dist-info/RECORD

@@ -0,0 +1,62 @@
+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
+evaluation/generate_experiments_results.py,sha256=oMFt2-TX7g3O6aBflFtQ5q0PT6sngEb8104kpPVMi0s,4051
+evaluation/generate_experiments_results_new_ver1.py,sha256=P9gz3xa0DoRRMQ16GQL3_wVSDYUfh8oZ3BCIUjphKaM,8909
+evaluation/generate_experiments_results_new_ver2.py,sha256=jeKj_wgdM50o2vi8WZI-s3GbsQdsjultHX-8H4Xvus4,12276
+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=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/environment/environment.py,sha256=0-3kZJCmLMF9o0NignZaMEwQb94NZQ2gmsOyfjPXKDI,6919
+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/ml/__init__.py,sha256=jrjxYqvSRgWwFWw7XQP9DzOwvmprMZ2umwT7t-DYtDU,233
+gr_libs/ml/agent.py,sha256=DSnK8nRx9SS76fAOZZEEvA68_meLjzm9lfQpMUXmGQU,1957
+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/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
+gr_libs/ml/planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/planner/mcts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/planner/mcts/mcts_model.py,sha256=N4B2SRWAySW7sJ1JIIkKHbzpxMYo2GcuaSB-eauJmBg,21068
+gr_libs/ml/planner/mcts/utils/__init__.py,sha256=8OE_XolCHiWIZZwS23lqLaLd72tsHwO8cQRRToTC0Lk,45
+gr_libs/ml/planner/mcts/utils/node.py,sha256=WXXaEjfU857yIBF8gKVjr0ZGmU2Du9s1d-dBcA4QS10,1220
+gr_libs/ml/planner/mcts/utils/tree.py,sha256=mLtLtPoqoU0eauNEExY94px5mdbmH-HCsYAYQDZqioI,3382
+gr_libs/ml/sequential/__init__.py,sha256=rusN4ahTvAeAq1Saz6qS_9HEU7WuXDJu2zwhc9WUEYQ,61
+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_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/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/recognizer.py,sha256=ysJYOGe5OlERMAeMwclKpwqw2tQvbSvGnLZrq4qP0xk,1895
+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/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/graql_minigrid_tutorial.py,sha256=VoXbEgL_hjQLfau6WohXxPK8rrv1VLA874F8PZ7ZtPk,1421
+gr_libs-0.1.3.dist-info/METADATA,sha256=Jgcr7b3qVESwqOa_odcgVjqMQK4OF0doW2if37Uwe3g,10484
+gr_libs-0.1.3.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+gr_libs-0.1.3.dist-info/top_level.txt,sha256=k7_l789QSJEr9JrtvsRMxNoTIDwNduq8mhIN-YoPJUM,29
+gr_libs-0.1.3.dist-info/RECORD,,

gr_libs-0.1.3.dist-info/WHEEL

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

gr_libs-0.1.3.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+evaluation
+gr_libs
+tutorials

tutorials/graml_minigrid_tutorial.py

@@ -0,0 +1,30 @@
+from gr_libs.environment.environment import 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",
+	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.
+)
+# 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)")