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

evaluation/generate_task_specific_statistics_plots.py

@@ -1,272 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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/environment/utils/utils.py

@@ -1,17 +0,0 @@
-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)

gr_libs/ml/neural/utils/penv.py

@@ -1,57 +0,0 @@
-import multiprocessing
-import gymnasium as gym
-
-#multiprocessing.set_start_method("fork")
-
-
-def worker(conn, env):
-    while True:
-        cmd, data = conn.recv()
-        if cmd == "step":
-            obs, reward, terminated, truncated, info = env.step(data)
-            if terminated or truncated:
-                obs, _ = env.reset()
-            conn.send((obs, reward, terminated, truncated, info))
-        elif cmd == "reset":
-            obs, _ = env.reset()
-            conn.send(obs)
-        else:
-            raise NotImplementedError
-
-
-class ParallelEnv(gym.Env):
-    """A concurrent execution of environments in multiple processes."""
-
-    def __init__(self, envs):
-        assert len(envs) >= 1, "No environment given."
-
-        self.envs = envs
-        self.observation_space = self.envs[0].observation_space
-        self.action_space = self.envs[0].action_space
-
-        self.locals = []
-        for env in self.envs[1:]:
-            local, remote = multiprocessing.Pipe()
-            self.locals.append(local)
-            p = multiprocessing.Process(target=worker, args=(remote, env))
-            p.daemon = True
-            p.start()
-            remote.close()
-
-    def reset(self):
-        for local in self.locals:
-            local.send(("reset", None))
-        results = [self.envs[0].reset()[0]] + [local.recv() for local in self.locals]
-        return results
-
-    def step(self, actions):
-        for local, action in zip(self.locals, actions[1:]):
-            local.send(("step", action))
-        obs, reward, terminated, truncated, info = self.envs[0].step(actions[0])
-        if terminated or truncated:
-            obs, _ = self.envs[0].reset()
-        results = zip(*[(obs, reward, terminated, truncated, info)] + [local.recv() for local in self.locals])
-        return results
-
-    def render(self):
-        raise NotImplementedError

gr_libs/ml/sequential/lstm_model.py

@@ -1,192 +0,0 @@
-import os
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.optim as optim
-from types import MethodType
-import numpy as np
-from gr_libs.ml.utils import device
-from torch.nn.utils.rnn import pack_padded_sequence
-
-
-def accuracy_per_epoch(model, data_loader):
-	model.eval()
-	correct = total = 0.0
-	sum_loss = 0.0
-	with torch.no_grad():
-		for (first_traces, second_traces, is_same_goals, first_traces_lengths, second_traces_lengths) in data_loader:
-			y_pred = model.forward_tab(first_traces, second_traces, first_traces_lengths, second_traces_lengths)
-			loss = F.binary_cross_entropy(y_pred, is_same_goals)
-			sum_loss += loss.item()
-			y_pred = (y_pred >= 0.5)
-			correct += torch.sum(y_pred == is_same_goals)
-			total += len(is_same_goals)
-	return correct / total, sum_loss / 32
-
-def accuracy_per_epoch_cont(model, data_loader):
-	model.eval()
-	correct = total = 0.0
-	sum_loss = 0.0
-	with torch.no_grad():
-		for (first_traces_images, first_traces_texts, second_traces_images, second_traces_texts, is_same_goals, first_traces_lengths, second_traces_lengths) in data_loader:
-			y_pred = model.forward_cont(first_traces_images, first_traces_texts, second_traces_images, second_traces_texts, first_traces_lengths, second_traces_lengths)
-			loss = F.binary_cross_entropy(y_pred, is_same_goals)
-			sum_loss += loss.item()
-			y_pred = (y_pred >= 0.5)
-			correct += torch.sum(y_pred == is_same_goals)
-			total += len(is_same_goals)
-	return correct / total, sum_loss / 32
-
-# class CNNImageEmbeddor(nn.Module):
-# 	def __init__(self, obs_space, action_space, use_text=False):
-# 		super().__init__()
-# 		self.use_text = use_text
-# 		self.image_conv = nn.Sequential(
-# 			nn.Conv2d(3, 4, kernel_size=(3, 3), padding=1),  # Reduced filters, added padding
-#             nn.ReLU(),
-#             nn.MaxPool2d((2, 2)),
-#             nn.Conv2d(4, 4, (3, 3), padding=1),  # Reduced filters, added padding
-#             nn.ReLU(),
-#             nn.MaxPool2d((2, 2)),  # Added additional pooling to reduce size
-#             nn.Conv2d(4, 8, (3, 3), padding=1),  # Reduced filters, added padding
-#             nn.ReLU(),
-#             nn.BatchNorm2d(8)
-# 		)
-# 		n = obs_space["image"][0]
-# 		m = obs_space["image"][1]
-# 		self.image_embedding_size = ((n - 4) // 4 - 3) * ((m - 4) // 4 - 3) * 8
-# 		if self.use_text:
-# 			self.word_embedding_size = 32
-# 			self.word_embedding = nn.Embedding(obs_space["text"], self.word_embedding_size)
-# 			self.text_embedding_size = 128
-# 			self.text_rnn = nn.GRU(self.word_embedding_size, self.text_embedding_size, batch_first=True)
-
-	def forward(self, images, texts):
-	 	# images shape: batch_size X max_sequence_len X sample_size. same for text.
-		# need to reshape image to num_channels X height X width, like nn.Conv expects it to be.
-		x = images.transpose(2, 4).transpose(3, 4)
-		orig_shape = x.shape
-		# combine batch and sequence to 1 dimension so conv could handle it
-		x = x.view(orig_shape[0]*orig_shape[1], orig_shape[2], orig_shape[3], orig_shape[4]) # x shape: batch_size * max_sequence_len X sample_size
-		x = self.image_conv(x) # x shape:  batch_size * max_sequence_len X last_conv_size X 1 X 1
-		# reshape x back to divide batches from sequences
-		x = x.view(orig_shape[0], orig_shape[1], x.shape[1]) # x shape: batch_size X max_sequence_len X last_conv_size. last 2 dimensions (1,1) are collapsed to last conv.
-		embedding = x
-  
-		if self.use_text:
-			embed_text = self._get_embed_text(texts)
-			embedding = torch.cat((embedding, embed_text), dim=1)
-			
-		return embedding
-
-	def _get_embed_text(self, text):
-		_, hidden = self.text_rnn(self.word_embedding(text))
-		return hidden[-1]
-
-class LstmObservations(nn.Module):
-	
-	def __init__(self, input_size, hidden_size): # TODO make sure the right cuda is used!
-		super(LstmObservations,self).__init__()
-		#self.embeddor = CNNImageEmbeddor(obs_space, action_space)
-		# check if the traces are a bunch of images
-		self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, batch_first=True)
-		self.dropout = nn.Dropout(0.5)  # Added dropout layer
-		# Initialize weights
-		for name, param in self.lstm.named_parameters():
-			if 'weight' in name:
-				nn.init.xavier_uniform_(param)
-			elif 'bias' in name:
-				nn.init.zeros_(param)
-		
-
-	# tabular
-	def forward_tab(self, traces1, traces2, lengths1, lengths2):
-		out1, (ht1, ct1) = self.lstm(pack_padded_sequence(traces1, lengths1, batch_first=True, enforce_sorted=False), None) # traces1 & traces 2 shapes: batch_size X max sequence_length X embedding_size
-		out2, (ht2, ct2) = self.lstm(pack_padded_sequence(traces2, lengths2, batch_first=True, enforce_sorted=False), None)
-		# out1, _ = pad_packed_sequence(out1, batch_first=True, total_length=max(lengths1))
-		# out2, _ = pad_packed_sequence(out2, batch_first=True, total_length=max(lengths2))
-		manhattan_dis = torch.exp(-torch.sum(torch.abs(ht1[-1]-ht2[-1]),dim=1,keepdim=True))
-		return manhattan_dis.squeeze()
-
-	# continuous
-	# def forward_cont(self, traces1_images, traces1_texts, traces2_images, traces2_texts, lengths1, lengths2):
-	#  	# we also embed '0' images, but we take them out of the equation in the lstm (it knows to not treat them when batching)
-	# 	traces1 = self.embeddor(traces1_images, traces1_texts)
-	# 	traces2 = self.embeddor(traces2_images, traces2_texts) # traces1 & traces 2 shapes: batch_size X max_sequence_length X embedding_size
-	# 	out1, (ht1, ct1) = self.lstm(pack_padded_sequence(traces1, lengths1, batch_first=True, enforce_sorted=False), None)
-	# 	out2, (ht2, ct2) = self.lstm(pack_padded_sequence(traces2, lengths2, batch_first=True, enforce_sorted=False), None)
-	# 	manhattan_dis = torch.exp(-torch.sum(torch.abs(ht1[-1]-ht2[-1]),dim=1,keepdim=True))
-	# 	return manhattan_dis.squeeze()
-
-	def embed_sequence(self, trace):
-		trace = torch.stack([torch.tensor(observation, dtype=torch.float32) for observation in trace]).to(device)
-		out, (ht, ct) = self.lstm(trace, None)
-		return ht[-1]
-
-	# def embed_sequence_cont(self, sequence, preprocess_obss):
-	# 	sequence = [preprocess_obss([obs])[0] for ((obs, (_, _)), _) in sequence]
-	# 	trace_images = torch.tensor(np.expand_dims(torch.stack([step.image for step in sequence]), axis=0)).to(device)
-	# 	trace_texts = torch.tensor(np.expand_dims(torch.stack([step.text for step in sequence]), axis=0)).to(device)
-	# 	embedded_trace = self.embeddor(trace_images, trace_texts)
-	# 	out, (ht, ct) = self.lstm(embedded_trace)
-	# 	return ht[-1]
-
-def train_metric_model(model, train_loader, dev_loader, nepochs=5, patience = 2):
-	devAccuracy = []
-	best_dev_accuracy = 0.0
-	no_improvement_count = 0
-	optimizer = torch.optim.Adadelta(model.parameters(), weight_decay=0.1)
-	scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=2, factor=0.5)
-	for epoch in range(nepochs):
-		sum_loss, denominator = 0.0, 0.0
-		model.train()
-		for (first_traces, second_traces, is_same_goals, first_traces_lengths, second_traces_lengths) in train_loader:
-			model.zero_grad()
-			y_pred = model.forward_tab(first_traces, second_traces, first_traces_lengths, second_traces_lengths)
-			if len(is_same_goals) == 1: is_same_goals = torch.squeeze(is_same_goals) # for the case of batches in size 1...
-			loss = F.binary_cross_entropy(y_pred, is_same_goals)
-			sum_loss += loss.item()
-			denominator += 1
-			loss.backward()
-			optimizer.step()
-   
-		dev_accuracy, dev_loss = accuracy_per_epoch(model, dev_loader)
-		devAccuracy.append(dev_accuracy)
-		if dev_accuracy > best_dev_accuracy:
-			best_dev_accuracy = dev_accuracy
-			no_improvement_count = 0
-		else:
-			no_improvement_count = 1
-
-		print("epoch - {}/{}...".format(epoch + 1, nepochs),
-				"train loss - {:.6f}...".format(sum_loss / denominator),
-				"dev loss - {:.6f}...".format(dev_loss),
-				"dev accuracy - {:.6f}".format(dev_accuracy))
-
-		if no_improvement_count >= patience:
-			print(f"Early stopping after {epoch + 1} epochs with no improvement.")
-			break
-  
-def train_metric_model_cont(model, train_loader, dev_loader, nepochs=5):
-	devAccuracy = []
-	optimizer = torch.optim.Adadelta(model.parameters(),weight_decay=1.25)
-	for epoch in range(nepochs):
-		sum_loss, denominator = 0.0, 0.0
-		model.train()
-		for (first_traces_images, first_traces_texts, second_traces_images, second_traces_texts, is_same_goals, first_traces_lengths, second_traces_lengths) in train_loader:
-			model.zero_grad()
-			y_pred = model.forward_cont(first_traces_images, first_traces_texts, second_traces_images, second_traces_texts, first_traces_lengths, second_traces_lengths)
-			loss = F.binary_cross_entropy(y_pred, is_same_goals)
-			sum_loss += loss.item()
-			denominator += 1
-			loss.backward()
-			optimizer.step()
-   
-		dev_accuracy, dev_loss = accuracy_per_epoch_cont(model, dev_loader)
-		devAccuracy.append(dev_accuracy)
-
-		print("epoch - {}/{}...".format(epoch + 1, nepochs),
-				"train loss - {:.6f}...".format(sum_loss / denominator),
-				"dev loss - {:.6f}...".format(dev_loss),
-				"dev accuracy - {:.6f}".format(dev_accuracy))
-