gr-libs 0.1.3__py3-none-any.whl

evaluation/generate_task_specific_statistics_plots.py

@@ -0,0 +1,272 @@
+import argparse
+import sys
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import ast
+import inspect
+import torch
+import dill
+
+from gr_libs.ml.utils import get_embeddings_result_path
+from gr_libs.ml.utils.storage import get_experiment_results_path, set_global_storage_configs, get_graql_experiment_confidence_path
+from gr_libs.metrics.metrics import measure_average_sequence_distance
+
+def get_tasks_embeddings_dir_path(env_name):
+	return os.path.join("../gr_libs", get_embeddings_result_path(env_name))
+
+def get_figures_dir_path(domain_name, env_name):
+	return os.path.join("../gr_libs", "figures", domain_name, env_name)
+
+def similarities_vector_to_std_deviation_units_vector(ref_dict: dict, relative_to_largest):
+	"""
+	Calculate the number of standard deviation units every other element is 
+	from the largest/smallest element in the vector.
+	
+	Parameters:
+	- vector: list or numpy array of numbers.
+	- relative_to_largest: boolean, if True, measure in relation to the largest element,
+						   if False, measure in relation to the smallest element.
+	
+	Returns:
+	- List of number of standard deviation units for each element in the vector.
+	"""
+	vector = np.array(list(ref_dict.values()))
+	mean = np.mean(vector) # for the future maybe another method for measurement
+	std_dev = np.std(vector)
+	
+	# Determine the reference element (largest or smallest)
+	if relative_to_largest:
+		reference_value = np.max(vector)
+	else:
+		reference_value = np.min(vector)
+	for goal, value in ref_dict.items():
+		ref_dict[goal] = abs(value - reference_value) / std_dev
+	return ref_dict
+
+def analyze_and_produce_plots(recognizer_type: str, domain_name: str, env_name: str, fragmented_status: str, inf_same_length_status: str, learn_same_length_status: str):
+	if recognizer_type == "graml":
+		assert os.path.exists(get_embeddings_result_path(domain_name)), "Embeddings weren't made for this environment, run graml_main.py with this environment first."
+		tasks_embedding_dicts = {}
+		tasks_plans_dict = {}
+		goals_similarity_dict = {}
+		plans_similarity_dict = {}
+
+		embeddings_dir_path = get_tasks_embeddings_dir_path(domain_name)
+		for embeddings_file_name in [filename for filename in os.listdir(embeddings_dir_path) if 'embeddings' in filename]:
+			with open(os.path.join(embeddings_dir_path, embeddings_file_name), 'rb') as emb_file:
+				splitted_name = embeddings_file_name.split('_')
+				goal, percentage = splitted_name[0], splitted_name[1]
+				with open(os.path.join(embeddings_dir_path, f'{goal}_{percentage}_plans_dict.pkl'), 'rb') as plan_file:
+					tasks_plans_dict[f"{goal}_{percentage}"] = dill.load(plan_file)
+				tasks_embedding_dicts[f"{goal}_{percentage}"] = dill.load(emb_file)
+	
+		for goal_percentage, embedding_dict in tasks_embedding_dicts.items():
+			goal, percentage = goal_percentage.split('_')
+			similarities = {dynamic_goal: [] for dynamic_goal in embedding_dict.keys() if 'true' not in dynamic_goal}
+			real_goal_embedding = embedding_dict[f"{goal}_true"]
+			for dynamic_goal, goal_embedding in embedding_dict.items():
+				if 'true' in dynamic_goal: continue
+				curr_similarity = torch.exp(-torch.sum(torch.abs(goal_embedding-real_goal_embedding)))
+				similarities[dynamic_goal] = curr_similarity.item()
+			if goal not in goals_similarity_dict.keys(): goals_similarity_dict[goal] = {}
+			goals_similarity_dict[goal][percentage] = similarities_vector_to_std_deviation_units_vector(ref_dict=similarities, relative_to_largest=True)
+   
+		for goal_percentage, plans_dict in tasks_plans_dict.items():
+			goal, percentage = goal_percentage.split('_')
+			real_plan = plans_dict[f"{goal}_true"]
+			sequence_similarities = {d_goal:measure_average_sequence_distance(real_plan, plan) for d_goal,plan in plans_dict.items() if 'true' not in d_goal} # aps = agent plan sequence?
+			if goal not in plans_similarity_dict.keys(): plans_similarity_dict[goal] = {}
+			plans_similarity_dict[goal][percentage] = similarities_vector_to_std_deviation_units_vector(ref_dict=sequence_similarities, relative_to_largest=False)
+
+		goals = list(goals_similarity_dict.keys())
+		percentages = sorted(set(percentage for similarities in goals_similarity_dict.values() for percentage in similarities.keys()))
+		num_percentages = len(percentages)
+		fig_string = f"{recognizer_type}_{domain_name}_{env_name}_{fragmented_status}_{inf_same_length_status}_{learn_same_length_status}"
+
+	else: # algorithm = "graql"
+		assert os.path.exists(get_graql_experiment_confidence_path(domain_name)), "Embeddings weren't made for this environment, run graml_main.py with this environment first."
+		tasks_scores_dict = {}
+		goals_similarity_dict = {}
+		experiments_dir_path = get_graql_experiment_confidence_path(domain_name)
+		for experiments_file_name in os.listdir(experiments_dir_path):
+			with open(os.path.join(experiments_dir_path, experiments_file_name), 'rb') as exp_file:
+				splitted_name = experiments_file_name.split('_')
+				goal, percentage = splitted_name[1], splitted_name[2]
+				tasks_scores_dict[f"{goal}_{percentage}"] = dill.load(exp_file)
+
+		for goal_percentage, scores_list in tasks_scores_dict.items():
+			goal, percentage = goal_percentage.split('_')
+			similarities = {dynamic_goal: score for (dynamic_goal, score) in scores_list}
+			if goal not in goals_similarity_dict.keys(): goals_similarity_dict[goal] = {}
+			goals_similarity_dict[goal][percentage] = similarities_vector_to_std_deviation_units_vector(ref_dict=similarities, relative_to_largest=False)
+	
+		goals = list(goals_similarity_dict.keys())
+		percentages = sorted(set(percentage for similarities in goals_similarity_dict.values() for percentage in similarities.keys()))
+		num_percentages = len(percentages)
+		fig_string = f"{recognizer_type}_{domain_name}_{env_name}_{fragmented_status}"
+
+	# -------------------- Start of Confusion Matrix Code --------------------
+	# Initialize matrices of size len(goals) x len(goals)
+	confusion_matrix_goals, confusion_matrix_plans = np.zeros((len(goals), len(goals))), np.zeros((len(goals), len(goals)))
+
+	# if domain_name == 'point_maze' and args.task == 'L555':
+	# 	if env_name == 'obstacles':
+	# 		goals = ['(4, 7)', '(3, 6)', '(5, 5)', '(8, 8)', '(6, 3)', '(7, 4)']
+	# 	else: # if env_name is 'four_rooms'
+	# 		goals = ['(2, 8)', '(3, 7)', '(3, 4)', '(4, 4)', '(4, 3)', '(7, 3)', '(8, 2)']
+
+	# Populate confusion matrix with similarity values for goals
+	for i, true_goal in enumerate(goals):
+		for j, dynamic_goal in enumerate(goals):
+			percentage = percentages[-3]
+			confusion_matrix_goals[i, j] = goals_similarity_dict[true_goal][percentage].get(dynamic_goal, 0)
+
+	if plans_similarity_dict:
+		# Populate confusion matrix with similarity values for plans
+		for i, true_goal in enumerate(goals):
+			for j, dynamic_goal in enumerate(goals):
+				percentage = percentages[-1]
+				confusion_matrix_plans[i, j] = plans_similarity_dict[true_goal][percentage].get(dynamic_goal, 0)
+
+	# Create the figure and subplots for the unified display
+	fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6), sharex=True)
+
+	# Plot for goal similarities
+	im1 = ax1.imshow(confusion_matrix_goals, cmap='Blues', interpolation='nearest')
+	cbar1 = fig.colorbar(im1, ax=ax1, fraction=0.046, pad=0.04)
+	cbar1.set_label('St. dev from most probable goal', fontsize=18)
+	ax1.set_title('Embeddings', fontsize=22, pad=20)
+	ax1.set_xticks(np.arange(len(goals)))
+	ax1.set_xticklabels(goals, rotation=45, ha="right", fontsize=16)
+	ax1.set_yticks(np.arange(len(goals)))
+	ax1.set_yticklabels(goals, fontsize=16)  # y-tick labels for ax1
+
+	# Plot for plan similarities
+	im2 = ax2.imshow(confusion_matrix_plans, cmap='Greens', interpolation='nearest')
+	cbar2 = fig.colorbar(im2, ax=ax2, fraction=0.046, pad=0.04)
+	cbar2.set_label('Distance between plans', fontsize=18)
+	ax2.set_title('Sequences', fontsize=22, pad=20)
+	ax2.set_xticks(np.arange(len(goals)))
+	ax2.set_xticklabels(goals, rotation=45, ha="right", fontsize=16)
+	ax2.set_yticks(np.arange(len(goals)))  # y-ticks for ax2 explicitly
+	ax2.set_yticklabels(goals, fontsize=16)  # y-tick labels for ax2
+
+	# Adjust the figure layout to reduce overlap
+	plt.subplots_adjust(left=0.15, right=0.9, bottom=0.25, top=0.85, wspace=0.1)
+
+	# Unified axis labels, placed closer to the left
+	fig.text(0.57, 0.07, 'Goals Adaptation Phase', ha='center', fontsize=22)
+	fig.text(0.12, 0.5, 'Inference Phase', va='center', rotation='vertical', fontsize=22)
+
+	# Save the combined plot
+	fig_dir = get_figures_dir_path(domain_name=domain_name, env_name=env_name)
+	if not os.path.exists(fig_dir):
+		os.makedirs(fig_dir)
+	confusion_matrix_combined_path = os.path.join(fig_dir, f"{fig_string}_combined_conf_mat.png")
+	plt.savefig(confusion_matrix_combined_path, dpi=300)
+	print(f"Combined confusion matrix figure saved at: {confusion_matrix_combined_path}")
+
+	# -------------------- End of Confusion Matrix Code --------------------
+	fig, axes = plt.subplots(nrows=num_percentages, ncols=1, figsize=(10, 6 * num_percentages))
+
+	if num_percentages == 1:
+		axes = [axes]
+
+	for i, percentage in enumerate(percentages):
+		correct_tasks, tasks_num = 0, 0
+		ax = axes[i]
+		dynamic_goals = list(next(iter(goals_similarity_dict.values()))[percentage].keys())
+		num_goals = len(goals)
+		num_dynamic_goals = len(dynamic_goals)
+		bar_width = 0.8 / num_dynamic_goals
+		bar_positions = np.arange(num_goals)
+
+		if recognizer_type == "graml":
+			for j, dynamic_goal in enumerate(dynamic_goals):
+				goal_similarities = [goals_similarity_dict[goal][percentage][dynamic_goal] + 0.04 for goal in goals]
+				plan_similarities = [plans_similarity_dict[goal][percentage][dynamic_goal] + 0.04 for goal in goals]
+				ax.bar(bar_positions + j * bar_width, goal_similarities, bar_width/2, label=f"embedding of {dynamic_goal}")
+				ax.bar(bar_positions + j * bar_width + bar_width/2, plan_similarities, bar_width/2, label=f"plan to {dynamic_goal}")
+		else:
+				for j, dynamic_goal in enumerate(dynamic_goals):
+					goal_similarities = [goals_similarity_dict[goal][percentage][dynamic_goal] + 0.04 for goal in goals]
+					ax.bar(bar_positions + j * bar_width, goal_similarities, bar_width, label=f"policy to {dynamic_goal}")
+
+		x_labels = []
+		for true_goal in goals:
+			guessed_goal = min(goals_similarity_dict[true_goal][percentage], key=goals_similarity_dict[true_goal][percentage].get)
+			tasks_num += 1
+			if true_goal == guessed_goal: correct_tasks += 1
+			second_lowest_value = sorted(goals_similarity_dict[true_goal][percentage].values())[1]
+			confidence_level = abs(goals_similarity_dict[true_goal][percentage][guessed_goal] - second_lowest_value)
+			label = f"True: {true_goal}\nGuessed: {guessed_goal}\nConfidence: {confidence_level:.2f}"
+			x_labels.append(label)
+
+		ax.set_ylabel('Distance (units in st. deviations)', fontsize=10)
+		ax.set_title(f'Confidence level for {domain_name}, {env_name}, {fragmented_status}. Accuracy: {correct_tasks / tasks_num}', fontsize=12)
+		ax.set_xticks(bar_positions + bar_width * (num_dynamic_goals - 1) / 2)
+		ax.set_xticklabels(x_labels, fontsize=8)
+		ax.legend()
+
+	fig_path = os.path.join(fig_dir, f"{fig_string}_stats.png")
+	fig.savefig(fig_path)
+	print(f"general figure saved at: {fig_path}")
+
+ 
+def parse_args():
+	parser = argparse.ArgumentParser(
+		description="Parse command-line arguments for the RL experiment.",
+		formatter_class=argparse.RawTextHelpFormatter
+	)
+
+	# Required arguments
+	required_group = parser.add_argument_group("Required arguments")
+	required_group.add_argument("--domain", choices=["point_maze", "minigrid", "parking", "franka_kitchen", "panda"], required=True, help="Domain type (point_maze, minigrid, parking, or franka_kitchen)")
+	required_group.add_argument("--recognizer", choices=["graml", "graql", "draco"], required=True, help="Recognizer type (graml, graql, draco). graql only for discrete domains.")
+	required_group.add_argument("--task", choices=["L1", "L2", "L3", "L4", "L5", "L11", "L22", "L33", "L44", "L55", "L111", "L222", "L333", "L444", "L555"], required=True, help="Task identifier (e.g., L1, L2,...,L5)")
+	required_group.add_argument("--partial_obs_type", required=True, choices=["fragmented", "continuing"], help="Give fragmented or continuing partial observations for inference phase inputs.")
+
+	# Optional arguments
+	optional_group = parser.add_argument_group("Optional arguments")
+	optional_group.add_argument("--minigrid_env", choices=["four_rooms", "obstacles"], help="Minigrid environment (four_rooms or obstacles)")
+	optional_group.add_argument("--parking_env", choices=["gd_agent", "gc_agent"], help="Parking environment (agent or gc_agent)")
+	optional_group.add_argument("--point_maze_env", choices=["obstacles", "four_rooms"], help="Parking environment (agent or gc_agent)")
+	optional_group.add_argument("--franka_env", choices=["comb1", "comb2"], help="Franka Kitchen environment (comb1 or comb2)")
+	optional_group.add_argument("--panda_env", choices=["gc_agent", "gd_agent"], help="Panda Robotics environment (gc_agent or gd_agent)")
+	optional_group.add_argument("--learn_same_seq_len", action="store_true", help="Learn with the same sequence length")
+	optional_group.add_argument("--inference_same_seq_len", action="store_true", help="Infer with the same sequence length")
+
+	args = parser.parse_args()
+ 
+	### VALIDATE INPUTS ###
+	# Assert that all required arguments are provided
+	assert args.domain is not None and args.recognizer is not None and args.task is not None, "Missing required arguments: domain, recognizer, or task"
+
+	 # Validate the combination of domain and environment
+	if args.domain == "minigrid" and args.minigrid_env is None:
+		parser.error("Missing required argument: --minigrid_env must be provided when --domain is minigrid")
+	elif args.domain == "parking" and args.parking_env is None:
+		parser.error("Missing required argument: --parking_env must be provided when --domain is parking")
+	elif args.domain == "point_maze" and args.point_maze_env is None:
+		parser.error("Missing required argument: --point_maze_env must be provided when --domain is point_maze")
+	elif args.domain == "franka_kitchen" and args.franka_env is None:
+		parser.error("Missing required argument: --franka_env must be provided when --domain is franka_kitchen")
+
+	if args.recognizer != "graml":
+		if args.learn_same_seq_len == True: parser.error("learn_same_seq_len is only relevant for graml.")
+		if args.inference_same_seq_len == True: parser.error("inference_same_seq_len is only relevant for graml.")
+
+	return args
+
+if __name__ == "__main__":
+	args = parse_args()
+	set_global_storage_configs(recognizer_str=args.recognizer, is_fragmented=args.partial_obs_type,
+							is_inference_same_length_sequences=args.inference_same_seq_len, is_learn_same_length_sequences=args.learn_same_seq_len)
+	env_name, = [x for x in [args.minigrid_env, args.parking_env, args.point_maze_env, args.franka_env] if isinstance(x, str)]
+	if args.inference_same_seq_len: inference_same_seq_len = "inference_same_seq_len"
+	else: inference_same_seq_len = "inference_diff_seq_len"
+	if args.learn_same_seq_len: learn_same_seq_len = "learn_same_seq_len"
+	else: learn_same_seq_len = "learn_diff_seq_len"
+	analyze_and_produce_plots(args.recognizer, domain_name=args.domain, env_name=env_name, fragmented_status=args.partial_obs_type,
+						   inf_same_length_status=inference_same_seq_len, learn_same_length_status=learn_same_seq_len)

evaluation/get_plans_images.py

@@ -0,0 +1,47 @@
+import sys
+import os
+import pickle
+import inspect
+
+
+currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+GRAML_itself = os.path.dirname(currentdir)
+GRAML_includer = os.path.dirname(os.path.dirname(currentdir))
+sys.path.insert(0, GRAML_includer)
+sys.path.insert(0, GRAML_itself)
+
+def get_plans_result_path(env_name):
+	return os.path.join("dataset", (env_name), "plans")
+
+def get_policy_sequences_result_path(env_name):
+	return os.path.join("dataset", (env_name), "policy_sequences")
+
+
+# TODO: instead of loading the model and having it produce the sequence again, just save the sequence from the framework run, and have this script accept the whole path (including is_fragmented etc.)
+def analyze_and_produce_images(env_name):
+	models_dir = get_models_dir(env_name=env_name)
+	for dirname in os.listdir(models_dir):
+		if dirname.startswith('MiniGrid'):
+			model_dir = get_model_dir(env_name=env_name, model_name=dirname, class_name="MCTS")
+			model_file_path = os.path.join(model_dir, "mcts_model.pth")
+			try:
+				with open(model_file_path, 'rb') as file:  # Load the pre-existing model
+					monteCarloTreeSearch = pickle.load(file)
+					full_plan = monteCarloTreeSearch.generate_full_policy_sequence()
+					plan = [pos for ((state, pos), action) in full_plan]
+					plans_result_path = get_plans_result_path(env_name)
+					if not os.path.exists(plans_result_path): os.makedirs(plans_result_path)
+					img_path = os.path.join(get_plans_result_path(env_name), dirname)
+					print(f"plan to {dirname} is:\n\t{plan}\ngenerating image at {img_path}.")
+					create_sequence_image(plan, img_path, dirname)
+					
+			except FileNotFoundError as e:
+				print(f"Warning: {e.filename} doesn't exist. It's probably a base goal, not generating policy sequence for it.")
+
+if __name__ == "__main__":
+	# preventing circular imports. only needed for running this as main anyway.
+	from gr_libs.ml.utils.storage import get_models_dir, get_model_dir
+	# checks:
+	assert len(sys.argv) == 2, f"Assertion failed: len(sys.argv) is {len(sys.argv)} while it needs to be 2.\n Example: \n\t /usr/bin/python scripts/get_plans_images.py MiniGrid-Walls-13x13-v0"
+	assert os.path.exists(get_models_dir(sys.argv[1])), "plans weren't made for this environment, run graml_main.py with this environment first."
+	analyze_and_produce_images(sys.argv[1])

evaluation/increasing_and_decreasing_.py

@@ -0,0 +1,63 @@
+import os
+import dill
+import numpy as np
+import matplotlib.pyplot as plt
+from gr_libs.ml.utils.storage import get_experiment_results_path, set_global_storage_configs
+
+if __name__ == "__main__":
+
+	# Define the tasks and percentages
+	increasing_base_goals = ['L1', 'L2', 'L3', 'L4', 'L5']
+	increasing_dynamic_goals = ['L111', 'L222', 'L555', 'L333', 'L444']
+	percentages = ['0.3', '0.5', '0.7', '0.9', '1']
+	
+	# Prepare a dictionary to hold accuracy data
+	accuracies = {task: {perc: [] for perc in percentages} for task in increasing_base_goals + increasing_dynamic_goals}
+
+	# Collect data for both sets of goals
+	for task in increasing_base_goals + increasing_dynamic_goals:
+		set_global_storage_configs(recognizer_str='graml', is_fragmented='fragmented',
+								   is_inference_same_length_sequences=True, is_learn_same_length_sequences=False)
+		res_file_path = f'{get_experiment_results_path("parking", "gd_agent", task)}.pkl'
+		
+		if os.path.exists(res_file_path):
+			with open(res_file_path, 'rb') as results_file:
+				results = dill.load(results_file)
+				for percentage in percentages:
+					accuracies[task][percentage].append(results[percentage]['accuracy'])
+		else:
+			print(f"Warning: no file for {res_file_path}")
+
+	# Create the figure with two subplots
+	fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+
+	# Bar plot function
+	def plot_accuracies(ax, task_set, title, type):
+		"""Plot accuracies for a given set of tasks on the provided axis."""
+		x_vals = np.arange(len(task_set))  # X-axis positions for the number of goals
+		bar_width = 0.15  # Width of each bar
+		for i, perc in enumerate(['0.3', '0.5', '1']):
+			if perc == '1': y_vals = [max([accuracies[task]['0.5'][0], accuracies[task]['0.7'][0], accuracies[task]['0.9'][0], accuracies[task]['1'][0]]) for task in task_set]  # Get mean accuracies
+			else: y_vals = [accuracies[task][perc][0] for task in task_set]  # Get mean accuracies
+			if type != 'base': ax.bar(x_vals + i * bar_width, y_vals, width=bar_width, label=f'Percentage {perc}')
+			else: ax.bar(x_vals + i * bar_width, y_vals, width=bar_width)
+		ax.set_xticks(x_vals + bar_width)  # Center x-ticks
+		ax.set_xticklabels([i+3 for i in range(len(task_set))], fontsize=16)  # Set custom x-tick labels
+		ax.set_yticks(np.linspace(0, 1, 6))
+		ax.set_ylim([0, 1])
+		ax.set_title(title, fontsize=20)
+		ax.set_xlabel(f'Number of {type} Goals', fontsize=20)
+		if type == 'base':
+			ax.set_ylabel('Accuracy', fontsize=22)
+		ax.legend()
+
+	# Plot for increasing base goals
+	plot_accuracies(axes[0], increasing_base_goals, 'Increasing Base Goals', "base")
+
+	# Plot for increasing dynamic goals
+	plot_accuracies(axes[1], increasing_dynamic_goals, 'Increasing Active Goals', "active")
+	plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1, wspace=0.3, hspace=0.3)
+	# Adjust layout and save the figure
+	plt.tight_layout()
+	plt.savefig('increasing_goals_plot_bars.png', dpi=300)  # Save the figure as a PNG file
+	print('Figure saved at: increasing_goals_plot_bars.png')

gr_libs/__init__.py

@@ -0,0 +1,2 @@
+from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql

gr_libs/environment/environment.py

@@ -0,0 +1,227 @@
+from abc import abstractmethod
+from collections import namedtuple
+import os
+
+import gymnasium
+from PIL import Image
+import numpy as np
+from gymnasium.envs.registration import register
+from minigrid.core.world_object import Wall, Lava
+from minigrid.wrappers import RGBImgPartialObsWrapper, ImgObsWrapper
+
+MINIGRID, PANDA, PARKING, POINT_MAZE = "minigrid", "panda", "parking", "point_maze"
+
+QLEARNING = "QLEARNING"
+
+SUPPORTED_DOMAINS = [MINIGRID, PANDA, PARKING, POINT_MAZE]
+
+LSTMProperties = namedtuple('LSTMProperties', ['input_size', 'hidden_size', 'batch_size', 'num_samples'])
+
+
+
+class EnvProperty:
+    def __init__(self, name):
+        self.name = name
+
+    def __str__(self):
+        return f"{self.name}"
+
+    def __repr__(self):
+        return f"{self.name}"
+
+    def __eq__(self, other):
+        return self.name == other.name
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+    
+    @abstractmethod
+    def str_to_goal(self):
+        pass
+
+    @abstractmethod
+    def gc_adaptable(self):
+        pass
+
+    @abstractmethod
+    def problem_list_to_str_tuple(self, problems):
+        pass
+
+    @abstractmethod
+    def goal_to_problem_str(self, goal):
+        pass
+
+    @abstractmethod
+    def is_action_discrete(self):
+        pass
+
+    @abstractmethod
+    def is_state_discrete(self):
+        pass
+
+    @abstractmethod
+    def get_lstm_props(self):
+        pass
+
+class GCEnvProperty(EnvProperty):
+    @abstractmethod
+    def use_goal_directed_problem(self):
+        pass
+
+    def problem_list_to_str_tuple(self, problems):
+        return "goal_conditioned"
+
+class MinigridProperty(EnvProperty):
+    def __init__(self, name):
+        super().__init__(name)
+        self.domain_name = "minigrid"
+
+    def goal_to_problem_str(self, goal):
+        return self.name + f"-DynamicGoal-{goal[0]}x{goal[1]}-v0"
+
+    def str_to_goal(self, problem_name):
+        parts = problem_name.split("-")
+        goal_part = [part for part in parts if "x" in part]
+        width, height = goal_part[0].split("x")
+        return (int(width), int(height))
+
+    def gc_adaptable(self):
+        return False
+    
+    def problem_list_to_str_tuple(self, problems):
+        return "_".join([f"[{s.split('-')[-2]}]" for s in problems])
+    
+    def is_action_discrete(self):
+        return True
+
+    def is_state_discrete(self):
+        return True
+
+    def get_lstm_props(self):
+        return LSTMProperties(batch_size=16, input_size=4, hidden_size=8, num_samples=40000)
+    
+    def create_sequence_image(self, sequence, img_path, problem_name):
+        if not os.path.exists(os.path.dirname(img_path)): os.makedirs(os.path.dirname(img_path))
+        env_id = problem_name.split("-DynamicGoal-")[0] + "-DynamicGoal-" + problem_name.split("-DynamicGoal-")[1]
+        result = register(
+            id=env_id,
+            entry_point="gr_libss.minigrid_scripts.envs:CustomColorEnv",
+            kwargs={"size": 13 if 'Simple' in problem_name else 9,
+                    "num_crossings": 4 if 'Simple' in problem_name else 3,
+                    "goal_pos": self.str_to_goal(problem_name),
+                    "obstacle_type": Wall if 'Simple' in problem_name else Lava,
+                    "start_pos": (1, 1) if 'Simple' in problem_name else (3, 1),
+                    "plan": sequence},
+        )
+        #print(result)
+        env = gymnasium.make(id=env_id)
+        env = RGBImgPartialObsWrapper(env) # Get pixel observations
+        env = ImgObsWrapper(env) # Get rid of the 'mission' field
+        obs, _ = env.reset() # This now produces an RGB tensor only
+
+        img = env.unwrapped.get_frame()
+
+        ####### save image to file
+        image_pil = Image.fromarray(np.uint8(img)).convert('RGB')
+        image_pil.save(r"{}.png".format(img_path))
+
+    
+class PandaProperty(GCEnvProperty):
+    def __init__(self, name):
+        super().__init__(name)
+        self.domain_name = "panda"
+
+    def str_to_goal(self, problem_name):
+        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)
+        except Exception as e:
+            return "general"
+        
+    def goal_to_problem_str(self, goal):
+        goal_str = 'X'.join([str(float(g)).replace(".", "y").replace("-","M") for g in goal[0]])
+        return f"PandaMyReachDenseX{goal_str}-v3"
+
+    def gc_adaptable(self):
+        return True
+    
+    def use_goal_directed_problem(self):
+        return False
+    
+    def is_action_discrete(self):
+        return False
+
+    def is_state_discrete(self):
+        return False
+
+    def get_lstm_props(self):
+        return LSTMProperties(batch_size=32, input_size=9, hidden_size=8, num_samples=20000)
+    
+    def sample_goal():
+        goal_range_low = np.array([-0.40, -0.40, 0.10])
+        goal_range_high = np.array([0.2, 0.2, 0.10])
+        return np.random.uniform(goal_range_low, goal_range_high)
+
+        
+class ParkingProperty(GCEnvProperty):
+    # def str_to_goal(self): # TODO not use it, goal is not a part of the env property anymore.
+    #     return self.name.split("-")[-2]
+
+    def __init__(self, name):
+        super().__init__(name)
+        self.domain_name = "parking"
+
+    def goal_to_problem_str(self, goal):
+        return self.name.split("-v0")[0] + f"-GI-{goal}-v0"
+
+    def gc_adaptable(self):
+        return True
+    
+    def is_action_discrete(self):
+        return False
+
+    def is_state_discrete(self):
+        return False
+    
+    def use_goal_directed_problem(self):
+        return True
+    
+    def get_lstm_props(self):
+        return LSTMProperties(batch_size=32, input_size=8, hidden_size=8, num_samples=20000)
+
+
+class PointMazeProperty(EnvProperty):
+    def __init__(self, name):
+        super().__init__(name)
+        self.domain_name = "point_maze"
+
+    def str_to_goal(self):
+        parts = self.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]
+        # Extract width and height from the goal part
+        width, height = goal_part.split("x")
+        return (int(width), int(height))
+    
+    def gc_adaptable(self):
+        return False
+
+    def problem_list_to_str_tuple(self, problems):
+        return "_".join([f"[{s.split('-')[-1]}]" for s in problems])
+
+    def is_action_discrete(self):
+        return False
+
+    def is_state_discrete(self):
+        return False
+    
+    def get_lstm_props(self):
+        return LSTMProperties(batch_size=32, input_size=6, hidden_size=8, num_samples=20000)
+
+    def goal_to_problem_str(self, goal):
+        return self.name + f"-Goal-{goal[0]}x{goal[1]}"

gr_libs/environment/utils/utils.py

@@ -0,0 +1,17 @@
+import logging
+import sys
+from gr_libs.environment.environment import MINIGRID, PANDA, PARKING, POINT_MAZE, EnvProperty, MinigridProperty, PandaProperty, ParkingProperty, PointMazeProperty
+
+
+def domain_to_env_property(domain_name: str):
+	if domain_name == MINIGRID:
+		return MinigridProperty
+	elif domain_name == PARKING:
+		return ParkingProperty
+	elif domain_name == PANDA:
+		return PandaProperty
+	elif domain_name == POINT_MAZE:
+		return PointMazeProperty
+	else:
+		logging.error(f"Domain {domain_name} is not supported.")
+		sys.exit(1)