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

gr_libs/ml/utils/format.py

@@ -1,100 +1,31 @@
-import numpy
-import re
-import torch
-import gr_libs.ml
-import gymnasium as gym
-import random
-
-def get_obss_preprocessor(obs_space):
-	# Check if obs_space is an image space
-	if isinstance(obs_space, gym.spaces.Box):
-		obs_space = {"image": obs_space.shape}
-
-		def preprocess_obss(obss, device=None):
-			return ml.DictList({
-				"image": preprocess_images(obss, device=device)
-			})
-
-	# Check if it is a MiniGrid observation space
-	elif isinstance(obs_space, gym.spaces.Dict) and "image" in obs_space.spaces.keys():
-		obs_space = {"image": obs_space.spaces["image"].shape, "text": 100}
-
-		vocab = Vocabulary(obs_space["text"])
-
-		def preprocess_obss(obss, device=None):
-			return ml.DictList({
-				"image": preprocess_images([obs["image"] for obs in obss], device=device),
-				"text": preprocess_texts([obs["mission"] for obs in obss], vocab, device=device)
-			})
-
-		preprocess_obss.vocab = vocab
-
-	# Check if it is a MiniGrid observation space
-	elif isinstance(obs_space, gym.spaces.Dict) and "observation" in obs_space.spaces.keys():
-		obs_space = {"observation": obs_space.spaces["observation"].shape}
-
-		def preprocess_obss(obss, device=None):
-			return ml.DictList({
-				"observation": preprocess_images(obss, device=device)
-		})
-
-
-	else:
-		raise ValueError("Unknown observation space: " + str(obs_space))
-
-	return obs_space, preprocess_obss
-
+""" formatting-related utilities """
 
-def preprocess_images(images, device=None):
-	# Bug of Pytorch: very slow if not first converted to numpy array
-	images = numpy.array(images)
-	return torch.tensor(images, device=device, dtype=torch.float)
-
-
-def random_subset_with_order(sequence, subset_size, is_consecutive = True):
-	if subset_size >= len(sequence):
-		return sequence
-	else:
-		if is_consecutive:
-			indices_to_select = [i for i in range(subset_size)]
-		else:
-			indices_to_select = sorted(random.sample(range(len(sequence)), subset_size))  # Randomly select indices to keep
-		return [sequence[i] for i in indices_to_select]  # Return the elements corresponding to the selected indices
-
-
-
-def preprocess_texts(texts, vocab, device=None):
-	var_indexed_texts = []
-	max_text_len = 0
-
-	for text in texts:
-		tokens = re.findall("([a-z]+)", text.lower())
-		var_indexed_text = numpy.array([vocab[token] for token in tokens])
-		var_indexed_texts.append(var_indexed_text)
-		max_text_len = max(len(var_indexed_text), max_text_len)
-
-	indexed_texts = numpy.zeros((len(texts), max_text_len))
-
-	for i, indexed_text in enumerate(var_indexed_texts):
-		indexed_texts[i, :len(indexed_text)] = indexed_text
-
-	return torch.tensor(indexed_texts, device=device, dtype=torch.long)
-
-
-class Vocabulary:
-	"""A mapping from tokens to ids with a capacity of `max_size` words.
-	It can be saved in a `vocab.json` file."""
-
-	def __init__(self, max_size):
-		self.max_size = max_size
-		self.vocab = {}
+import random
 
-	def load_vocab(self, vocab):
-		self.vocab = vocab
 
-	def __getitem__(self, token):
-		if not token in self.vocab.keys():
-			if len(self.vocab) >= self.max_size:
-				raise ValueError("Maximum vocabulary capacity reached")
-			self.vocab[token] = len(self.vocab) + 1
-		return self.vocab[token]
+def random_subset_with_order(sequence, subset_size, is_consecutive=True):
+    """
+    Returns a random subset of elements from the given sequence with a specified subset size.
+
+    Args:
+        sequence (list): The sequence of elements to select from.
+        subset_size (int): The size of the desired subset.
+        is_consecutive (bool, optional): Whether the selected subset should be consecutive elements from the sequence.
+            Defaults to True.
+
+    Returns:
+        list: A random subset of elements from the sequence.
+
+    """
+    if subset_size >= len(sequence):
+        return sequence
+    else:
+        if is_consecutive:
+            indices_to_select = [i for i in range(subset_size)]
+        else:
+            indices_to_select = sorted(
+                random.sample(range(len(sequence)), subset_size)
+            )  # Randomly select indices to keep
+        return [
+            sequence[i] for i in indices_to_select
+        ]  # Return the elements corresponding to the selected indices

gr_libs/ml/utils/math.py

@@ -1,7 +1,9 @@
+""" math-related functions """
+
 import math
-from typing import Callable, Generator, List
 
-def softmax(values: List[float]) -> List[float]:
+
+def softmax(values: list[float]) -> list[float]:
     """Computes softmax probabilities for an array of values
     TODO We should probably use numpy arrays here
     Args:
@@ -10,4 +12,4 @@ def softmax(values: List[float]) -> List[float]:
     Returns:
         np.array: softmax probabilities
     """
-    return [(math.exp(q)) / sum([math.exp(_q) for _q in values]) for q in values]
+    return [(math.exp(q)) / sum([math.exp(_q) for _q in values]) for q in values]

gr_libs/ml/utils/other.py

@@ -1,8 +1,8 @@
+import collections
 import random
+
 import numpy
 import torch
-import collections
-
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
@@ -21,4 +21,4 @@ def synthesize(array):
     d["std"] = numpy.std(array)
     d["min"] = numpy.amin(array)
     d["max"] = numpy.amax(array)
-    return d
+    return d

gr_libs/ml/utils/storage.py

@@ -1,134 +1,141 @@
-import csv
 import os
-import torch
-import logging
-import sys
 
-from .other import device
 
 def create_folders_if_necessary(path):
     if not os.path.exists(path):
         os.makedirs(path)
 
 
-def get_storage_framework_dir(recognizer: str):
-    return os.path.join(get_storage_dir(),recognizer)
+def get_outputs_dir():
+    return "outputs"
 
-def get_storage_dir():
+
+def get_recognizer_outputs_dir(recognizer: str):
+    return os.path.join(get_outputs_dir(), recognizer)
+
+
+def get_gr_cache_dir():
     # Prefer local directory if it exists (e.g., in GitHub workspace)
-    if os.path.exists("dataset"):
-        return "dataset"
+    if os.path.exists("gr_cache"):
+        return "gr_cache"
     # Fall back to pre-mounted directory (e.g., in Docker container)
-    if os.path.exists("/preloaded_data"):
-        return "/preloaded_data"
+    if os.path.exists("/gr_cache"):
+        return "/gr_cache"
     # Default to "dataset" even if it doesn't exist (e.g., will be created)
-    return "dataset"
+    return "gr_cache"
+
+
+def get_trained_agents_dir():
+    # Prefer local directory if it exists (e.g., in GitHub workspace)
+    if os.path.exists("trained_agents"):
+        return "trained_agents"
+    # Fall back to pre-mounted directory (e.g., in Docker container)
+    if os.path.exists("/trained_agents"):
+        return "/trained_agents"
+    # Default to "dataset" even if it doesn't exist (e.g., will be created)
+    return "trained_agents"
 
-def _get_models_directory_name():
-    return "models"
 
 def _get_siamese_datasets_directory_name():
     return "siamese_datasets"
 
+
 def _get_observations_directory_name():
     return "observations"
 
-def get_observation_file_name(observability_percentage: float):
-    return 'obs' + str(observability_percentage) + '.pkl'
 
+def get_observation_file_name(observability_percentage: float):
+    return "obs" + str(observability_percentage) + ".pkl"
 
-def get_domain_dir(domain_name, recognizer:str):
-    return os.path.join(get_storage_framework_dir(recognizer), domain_name)
 
-def get_env_dir(domain_name, env_name, recognizer:str):
-    return os.path.join(get_domain_dir(domain_name, recognizer), env_name)
+def get_domain_outputs_dir(domain_name, recognizer: str):
+    return os.path.join(get_recognizer_outputs_dir(recognizer), domain_name)
 
-def get_observations_dir(domain_name, env_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name=domain_name, env_name=env_name, recognizer=recognizer), _get_observations_directory_name())
 
-def get_agent_model_dir(domain_name, model_name, class_name):
-    return os.path.join(get_storage_dir(), _get_models_directory_name(), domain_name, model_name, class_name)
+def get_env_outputs_dir(domain_name, env_name, recognizer: str):
+    return os.path.join(get_domain_outputs_dir(domain_name, recognizer), env_name)
 
-def get_lstm_model_dir(domain_name, env_name, model_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name=domain_name, env_name=env_name, recognizer=recognizer), model_name)
 
-def get_models_dir(domain_name, env_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name=domain_name, env_name=env_name, recognizer=recognizer), _get_models_directory_name())
+def get_observations_dir(domain_name, env_name, recognizer: str):
+    return os.path.join(
+        get_env_outputs_dir(
+            domain_name=domain_name, env_name=env_name, recognizer=recognizer
+        ),
+        _get_observations_directory_name(),
+    )
 
-### GRAML PATHS ###
 
-def get_siamese_dataset_path(domain_name, env_name, model_name, recognizer:str):
-    return os.path.join(get_lstm_model_dir(domain_name, env_name, model_name, recognizer), _get_siamese_datasets_directory_name())
+def get_agent_model_dir(domain_name, model_name, class_name):
+    return os.path.join(
+        get_trained_agents_dir(),
+        domain_name,
+        model_name,
+        class_name,
+    )
 
-def get_embeddings_result_path(domain_name, env_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name, env_name=env_name, recognizer=recognizer), "goal_embeddings")
 
-def get_embeddings_result_path(domain_name, env_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name, env_name=env_name, recognizer=recognizer), "goal_embeddings")
+def get_lstm_model_dir(domain_name, env_name, model_name, recognizer: str):
+    return os.path.join(
+        get_gr_cache_dir(), recognizer, domain_name, env_name, model_name
+    )
 
-def get_and_create(path):
-    create_folders_if_necessary(path)
-    return path
 
-def get_experiment_results_path(domain, env_name, task, recognizer:str):
-    return os.path.join(get_env_dir(domain, env_name=env_name, recognizer=recognizer), "experiment_results", env_name, task, "experiment_results")
+### GRAML PATHS ###
 
-def get_plans_result_path(domain_name, env_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name, env_name=env_name, recognizer=recognizer), "plans")
 
-def get_policy_sequences_result_path(domain_name, env_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name, env_name, recognizer=recognizer), "policy_sequences")
+def get_siamese_dataset_path(domain_name, env_name, model_name, recognizer: str):
+    return os.path.join(
+        get_lstm_model_dir(domain_name, env_name, model_name, recognizer),
+        _get_siamese_datasets_directory_name(),
+    )
 
-### END GRAML PATHS ###
-''
-### GRAQL PATHS ###
 
-def get_gr_as_rl_experiment_confidence_path(domain_name, env_name, recognizer:str):
-    return os.path.join(get_env_dir(domain_name=domain_name, env_name=env_name, recognizer=recognizer), "experiments")
+def get_embeddings_result_path(domain_name, env_name, recognizer: str):
+    return os.path.join(
+        get_env_outputs_dir(domain_name, env_name=env_name, recognizer=recognizer),
+        "goal_embeddings",
+    )
 
-### GRAQL PATHS ###
 
-def get_status_path(model_dir):
-    return os.path.join(model_dir, "status.pt")
+def get_and_create(path):
+    create_folders_if_necessary(path)
+    return path
 
 
-def get_status(model_dir):
-    path = get_status_path(model_dir)
-    return torch.load(path, map_location=device)
+def get_experiment_results_path(domain, env_name, task, recognizer: str):
+    return os.path.join(
+        get_env_outputs_dir(domain, env_name=env_name, recognizer=recognizer),
+        task,
+        "experiment_results",
+    )
 
 
-def save_status(status, model_dir):
-    path = get_status_path(model_dir)
-    utils.create_folders_if_necessary(path)
-    torch.save(status, path)
+def get_plans_result_path(domain_name, env_name, recognizer: str):
+    return os.path.join(
+        get_env_outputs_dir(domain_name, env_name=env_name, recognizer=recognizer),
+        "plans",
+    )
 
 
-def get_vocab(model_dir):
-    return get_status(model_dir)["vocab"]
+def get_policy_sequences_result_path(domain_name, env_name, recognizer: str):
+    return os.path.join(
+        get_env_outputs_dir(domain_name, env_name, recognizer=recognizer),
+        "policy_sequences",
+    )
 
 
-def get_model_state(model_dir):
-    return get_status(model_dir)["model_state"]
+### END GRAML PATHS ###
 
+### GRAQL PATHS ###
 
-def get_txt_logger(model_dir):
-    path = os.path.join(model_dir, "log.txt")
-    utils.create_folders_if_necessary(path)
 
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(message)s",
-        handlers=[
-            logging.FileHandler(filename=path),
-            logging.StreamHandler(sys.stdout)
-        ]
+def get_gr_as_rl_experiment_confidence_path(domain_name, env_name, recognizer: str):
+    return os.path.join(
+        get_env_outputs_dir(
+            domain_name=domain_name, env_name=env_name, recognizer=recognizer
+        ),
+        "confidence",
     )
 
-    return logging.getLogger()
 
-
-def get_csv_logger(model_dir):
-    csv_path = os.path.join(model_dir, "log.csv")
-    utils.create_folders_if_necessary(csv_path)
-    csv_file = open(csv_path, "a")
-    return csv_file, csv.writer(csv_file)
+### GRAQL PATHS ###

gr_libs/odgr_executor.py

@@ -0,0 +1,268 @@
+import argparse
+import os
+import time
+
+import dill
+
+from gr_libs.environment.utils.utils import domain_to_env_property
+from gr_libs.metrics.metrics import stochastic_amplified_selection
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
+from gr_libs.ml.utils.format import random_subset_with_order
+from gr_libs.ml.utils.storage import (
+    get_and_create,
+    get_experiment_results_path,
+    get_policy_sequences_result_path,
+)
+from gr_libs.problems.consts import PROBLEMS
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco
+from gr_libs.recognizer.graml.graml_recognizer import Graml
+from gr_libs.recognizer.recognizer import GaAgentTrainerRecognizer, LearningRecognizer
+from gr_libs.recognizer.utils import recognizer_str_to_obj
+
+
+def validate(args, recognizer_type, task_inputs):
+    if "base" in task_inputs.keys():
+        # assert issubclass(recognizer_type, LearningRecognizer), f"base is in the task_inputs for the recognizer {args.recognizer}, which doesn't have a domain learning phase (is not a learning recognizer)."
+        assert (
+            list(task_inputs.keys())[0] == "base"
+        ), "In case of LearningRecognizer, base should be the first element in the task_inputs dict in consts.py"
+        assert (
+            "base" not in list(task_inputs.keys())[1:]
+        ), "In case of LearningRecognizer, base should be only in the first element in the task_inputs dict in consts.py"
+    # else:
+    # assert not issubclass(recognizer_type, LearningRecognizer), f"base is not in the task_inputs for the recognizer {args.recognizer}, which has a domain learning phase (is a learning recognizer). Remove it from the task_inputs dict in consts.py."
+
+
+def run_odgr_problem(args):
+    recognizer_type = recognizer_str_to_obj(args.recognizer)
+    env_inputs = PROBLEMS[args.domain]
+    assert (
+        args.env_name in env_inputs.keys()
+    ), f"env_name {args.env_name} is not in the list of available environments for the domain {args.domain}. Add it to PROBLEMS dict in consts.py"
+    task_inputs = env_inputs[args.env_name][args.task]
+    recognizer = recognizer_type(
+        domain_name=args.domain,
+        env_name=args.env_name,
+        collect_statistics=args.collect_stats,
+    )
+    validate(args, recognizer_type, task_inputs)
+    ga_times, results = [], {}
+    for key, value in task_inputs.items():
+        if key == "base":
+            dlp_time = 0
+            if issubclass(recognizer_type, LearningRecognizer):
+                start_dlp_time = time.time()
+                recognizer.domain_learning_phase(
+                    base_goals=value["goals"], train_configs=value["train_configs"]
+                )
+                dlp_time = time.time() - start_dlp_time
+        elif key.startswith("G_"):
+            start_ga_time = time.time()
+            kwargs = {"dynamic_goals": value["goals"]}
+            if issubclass(recognizer_type, GaAgentTrainerRecognizer):
+                kwargs["dynamic_train_configs"] = value["train_configs"]
+            recognizer.goals_adaptation_phase(**kwargs)
+            ga_times.append(time.time() - start_ga_time)
+        elif key.startswith("I_"):
+            goal, train_config, consecutive, consecutive_str, percentage = (
+                value["goal"],
+                value["train_config"],
+                value["consecutive"],
+                "consecutive" if value["consecutive"] == True else "non_consecutive",
+                value["percentage"],
+            )
+            results.setdefault(str(percentage), {})
+            results[str(percentage)].setdefault(
+                consecutive_str,
+                {
+                    "correct": 0,
+                    "num_of_tasks": 0,
+                    "accuracy": 0,
+                    "average_inference_time": 0,
+                },
+            )
+            property_type = domain_to_env_property(args.domain)
+            env_property = property_type(args.env_name)
+            problem_name = env_property.goal_to_problem_str(goal)
+            rl_agent_type = recognizer.rl_agent_type
+            agent = rl_agent_type(
+                domain_name=args.domain,
+                problem_name=problem_name,
+                algorithm=train_config[0],
+                num_timesteps=train_config[1],
+                env_prop=env_property,
+            )
+            agent.learn()
+            fig_path = get_and_create(
+                f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=args.domain, env_name=args.env_name, recognizer=args.recognizer), problem_name))}_inference_seq"
+            )
+            generate_obs_kwargs = {
+                "action_selection_method": stochastic_amplified_selection,
+                "save_fig": args.collect_stats,
+                "random_optimalism": True,
+                "fig_path": fig_path if args.collect_stats else None,
+            }
+
+            # need to dump the whole plan for draco because it needs it for inference phase for checking likelihood.
+            if (recognizer_type == Draco or recognizer_type == GCDraco) and issubclass(
+                rl_agent_type, DeepRLAgent
+            ):  # TODO remove this condition, remove the assumption.
+                generate_obs_kwargs["with_dict"] = True
+            sequence = agent.generate_observation(**generate_obs_kwargs)
+            if issubclass(
+                recognizer_type, Graml
+            ):  # need to dump the plans to compute offline plan similarity only in graml's case for evaluation.
+                recognizer.dump_plans(
+                    true_sequence=sequence, true_goal=goal, percentage=percentage
+                )
+            partial_sequence = random_subset_with_order(
+                sequence, (int)(percentage * len(sequence)), is_consecutive=consecutive
+            )
+            # add evaluation_function to kwargs if this is graql. move everything to kwargs...
+            start_inf_time = time.time()
+            closest_goal = recognizer.inference_phase(
+                partial_sequence, goal, percentage
+            )
+            results[str(percentage)][consecutive_str]["average_inference_time"] += (
+                time.time() - start_inf_time
+            )
+            # print(f'real goal {goal}, closest goal is: {closest_goal}')
+            if all(a == b for a, b in zip(str(goal), closest_goal)):
+                results[str(percentage)][consecutive_str]["correct"] += 1
+            results[str(percentage)][consecutive_str]["num_of_tasks"] += 1
+
+    for percentage in results.keys():
+        for consecutive_str in results[str(percentage)].keys():
+            results[str(percentage)][consecutive_str]["average_inference_time"] /= len(
+                results[str(percentage)][consecutive_str]
+            )
+            results[str(percentage)][consecutive_str]["accuracy"] = (
+                results[str(percentage)][consecutive_str]["correct"]
+                / results[str(percentage)][consecutive_str]["num_of_tasks"]
+            )
+
+    # aggregate
+    total_correct = sum(
+        [
+            result["correct"]
+            for cons_result in results.values()
+            for result in cons_result.values()
+        ]
+    )
+    total_tasks = sum(
+        [
+            result["num_of_tasks"]
+            for cons_result in results.values()
+            for result in cons_result.values()
+        ]
+    )
+    total_average_inference_time = (
+        sum(
+            [
+                result["average_inference_time"]
+                for cons_result in results.values()
+                for result in cons_result.values()
+            ]
+        )
+        / total_tasks
+    )
+
+    results["total"] = {
+        "total_correct": total_correct,
+        "total_tasks": total_tasks,
+        "total_accuracy": total_correct / total_tasks,
+        "total_average_inference_time": total_average_inference_time,
+        "goals_adaptation_time": sum(ga_times) / len(ga_times),
+        "domain_learning_time": dlp_time,
+    }
+    print(str(results))
+    res_file_path = get_and_create(
+        get_experiment_results_path(
+            domain=args.domain,
+            env_name=args.env_name,
+            task=args.task,
+            recognizer=args.recognizer,
+        )
+    )
+    print(f"generating results into {res_file_path}")
+    with open(os.path.join(res_file_path, "res.pkl"), "wb") as results_file:
+        dill.dump(results, results_file)
+    with open(os.path.join(res_file_path, "res.txt"), "w") as results_file:
+        results_file.write(str(results))
+
+
+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", "panda"],
+        required=True,
+        help="Domain name (point_maze, minigrid, parking, or panda)",
+    )
+    required_group.add_argument(
+        "--env_name",
+        required=True,
+        help="Env name (point_maze, minigrid, parking, or panda). For example, Parking-S-14-PC--v0",
+    )
+    required_group.add_argument(
+        "--recognizer",
+        choices=[
+            "MCTSBasedGraml",
+            "ExpertBasedGraml",
+            "GCGraml",
+            "Graql",
+            "Draco",
+            "GCDraco",
+        ],
+        required=True,
+        help="Recognizer type. Follow readme.md and recognizer folder for more information and rules.",
+    )
+    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)",
+    )
+
+    # Optional arguments
+    optional_group = parser.add_argument_group("Optional arguments")
+    optional_group.add_argument(
+        "--collect_stats", action="store_true", help="Whether to collect statistics"
+    )
+    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"
+    return args
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    run_odgr_problem(args)