gr-libs 0.1.6.post1__tar.gz → 0.1.7.post0__tar.gz

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.6.post1
+Version: 0.1.7.post0
 Summary: Package with goal recognition frameworks baselines
 Author: Ben Nageris
 Author-email: Matan Shamir <matan.shamir@live.biu.ac.il>, Osher Elhadad <osher.elhadad@live.biu.ac.il>

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs/__init__.py

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

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs/_version.py

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

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs/environment/__init__.py

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

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs/ml/tabular/tabular_q_learner.py

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

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs/ml/utils/storage.py

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

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs/recognizer/graml/graml_recognizer.py

@@ -82,14 +82,14 @@ class Graml(LearningRecognizer):
 							dev_loader=DataLoader(dev_dataset, batch_size=self.env_prop.get_lstm_props().batch_size, shuffle=False, collate_fn=self.collate_func))
 			save_weights(model=self.model, path=self.model_file_path)
 
-	def goals_adaptation_phase(self, dynamic_goals: List[EnvProperty]):
+	def goals_adaptation_phase(self, dynamic_goals: List[EnvProperty], save_fig=False):
 		self.is_first_inf_since_new_goals = True
 		self.current_goals = dynamic_goals
 		# start by training each rl agent on the base goal set
 		self.embeddings_dict = {} # relevant if the embedding of the plan occurs during the goals adaptation phase
 		self.plans_dict = {} # relevant if the embedding of the plan occurs during the inference phase
 		for goal in self.current_goals:
-			obss = self.generate_sequences_library(goal)
+			obss = self.generate_sequences_library(goal, save_fig=save_fig)
 			self.plans_dict[str(goal)] = obss
 
 	def get_goal_plan(self, goal):
@@ -150,7 +150,7 @@ class Graml(LearningRecognizer):
 		return closest_goal
 	
 	@abstractmethod
-	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		pass
 
 	# this function duplicates every sequence and creates a consecutive and non-consecutive version of it
@@ -192,10 +192,10 @@ class MCTSBasedGraml(BGGraml, GaAdaptingRecognizer):
 		super().__init__(*args, **kwargs)
 		if self.rl_agent_type==None: self.rl_agent_type = TabularQLearner
 
-	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		problem_name = self.env_prop.goal_to_problem_str(goal)
 		img_path = os.path.join(get_policy_sequences_result_path(self.env_prop.domain_name, recognizer=self.__class__.__name__), problem_name + "_MCTS")
-		return mcts_model.plan(self.env_prop.name, problem_name, goal, save_fig=True, img_path=img_path, env_prop=self.env_prop)
+		return mcts_model.plan(self.env_prop.name, problem_name, goal, save_fig=save_fig, img_path=img_path, env_prop=self.env_prop)
 
 class ExpertBasedGraml(BGGraml, GaAgentTrainerRecognizer):
 	def __init__(self, *args, **kwargs):
@@ -206,15 +206,23 @@ class ExpertBasedGraml(BGGraml, GaAgentTrainerRecognizer):
 			else:
 				self.rl_agent_type = DeepRLAgent
 
-	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		problem_name = self.env_prop.goal_to_problem_str(goal)
 		kwargs = {"domain_name":self.domain_name, "problem_name":problem_name}
 		if self.dynamic_train_configs_dict[problem_name][0] != None: kwargs["algorithm"] = self.dynamic_train_configs_dict[problem_name][0]
 		if self.dynamic_train_configs_dict[problem_name][1] != None: kwargs["num_timesteps"] = self.dynamic_train_configs_dict[problem_name][1]
 		agent = self.rl_agent_type(**kwargs)
 		agent.learn()
-		fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_bg_sequence")
-		return [agent.generate_observation(action_selection_method=metrics.greedy_selection, random_optimalism=False, save_fig=True, fig_path=fig_path, env_prop=self.env_prop)]
+		agent_kwargs = {
+			"action_selection_method": metrics.greedy_selection,
+			"random_optimalism": False,
+			"save_fig": save_fig,
+			"env_prop": self.env_prop
+		}
+		if save_fig:
+			fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_bg_sequence")
+			agent_kwargs["fig_path"] = fig_path
+		return [agent.generate_observation(**agent_kwargs)]
 
 	def goals_adaptation_phase(self, dynamic_goals: List[str], dynamic_train_configs):
 		self.dynamic_goals_problems = [self.env_prop.goal_to_problem_str(g) for g in dynamic_goals]
@@ -244,20 +252,21 @@ class GCGraml(Graml, GaAdaptingRecognizer):
 		gc_agent.learn()
 		self.agents.append(ContextualAgent(problem_name=self.env_prop.name, problem_goal="general", agent=gc_agent))
 
-	def generate_sequences_library(self, goal: str) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
+	def generate_sequences_library(self, goal: str, save_fig=False) -> List[List[Tuple[np.ndarray, np.ndarray]]]:
 		problem_name = self.env_prop.goal_to_problem_str(goal)
 		kwargs = {"domain_name":self.domain_name, "problem_name":self.env_prop.name} # problem name is env name in gc case
 		if self.original_train_configs[0][0] != None: kwargs["algorithm"] = self.original_train_configs[0][0]
 		if self.original_train_configs[0][1] != None: kwargs["num_timesteps"] = self.original_train_configs[0][1]
 		agent = self.rl_agent_type(**kwargs)
 		agent.learn()
-		fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_gc_sequence")
 		agent_kwargs = {
 			"action_selection_method": metrics.stochastic_amplified_selection,
 			"random_optimalism": True,
-			"save_fig": True,
-			"fig_path": fig_path
+			"save_fig": save_fig
 		}
+		if save_fig:
+			fig_path = get_and_create(f"{os.path.abspath(os.path.join(get_policy_sequences_result_path(domain_name=self.env_prop.domain_name, env_name=self.env_prop.name, recognizer=self.__class__.__name__), problem_name))}_gc_sequence")
+			agent_kwargs["fig_path"] = fig_path
 		if self.env_prop.use_goal_directed_problem(): agent_kwargs["goal_directed_problem"] = problem_name
 		else: agent_kwargs["goal_directed_goal"] = goal
 		obss = []

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.6.post1
+Version: 0.1.7.post0
 Summary: Package with goal recognition frameworks baselines
 Author: Ben Nageris
 Author-email: Matan Shamir <matan.shamir@live.biu.ac.il>, Osher Elhadad <osher.elhadad@live.biu.ac.il>

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs.egg-info/SOURCES.txt

@@ -1,14 +1,5 @@
-.gitignore
 README.md
-all_experiments.py
-download_dataset.py
-odgr_executor.py
 pyproject.toml
-.github/workflows/common_test_steps.yml
-.github/workflows/pr_flow.yml
-.github/workflows/release.yml
-CI/README.md
-CI/docker_build_context/Dockerfile
 evaluation/analyze_results_cross_alg_cross_domain.py
 evaluation/create_minigrid_map_image.py
 evaluation/file_system.py
@@ -63,7 +54,6 @@ gr_libs/problems/__init__.py
 gr_libs/problems/consts.py
 gr_libs/recognizer/__init__.py
 gr_libs/recognizer/recognizer.py
-gr_libs/recognizer/recognizer_doc.md
 gr_libs/recognizer/gr_as_rl/__init__.py
 gr_libs/recognizer/gr_as_rl/gr_as_rl_recognizer.py
 gr_libs/recognizer/graml/__init__.py

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/gr_libs.egg-info/top_level.txt

@@ -1,4 +1,5 @@
 CI
+build
 dist
 evaluation
 gr_libs

{gr_libs-0.1.6.post1 → gr_libs-0.1.7.post0}/tutorials/graml_parking_tutorial.py

@@ -5,6 +5,7 @@ from gr_libs.metrics.metrics import stochastic_amplified_selection
 from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent, GCDeepRLAgent
 from gr_libs.ml.utils.format import random_subset_with_order
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
+import gr_libs.environment.environment
 
 def run_graml_parking_tutorial():
     recognizer = GCGraml(

gr_libs-0.1.6.post1/.github/workflows/common_test_steps.yml

@@ -1,26 +0,0 @@
-name: Common Test Steps
-
-on:
-  workflow_call:
-
-jobs:
-  test_steps:
-    runs-on: ubuntu-latest
-    container:
-      image: ghcr.io/matanshamir1/gr_test_base_slim:latest
-    steps:
-      - name: Check out the repository
-        uses: actions/checkout@v4
-
-      - name: Install gr_libs with all extras and test tools
-        env:
-          SETUPTOOLS_SCM_PRETEND_VERSION_FOR_GR_LIBS: "0.0.0"
-        run: |
-          python -m pip install --upgrade pip
-          pip install setuptools_scm
-          pip install gr_envs[minigrid,panda,parking,maze]
-          pip install .[minigrid,panda,parking,maze]
-          pip install pytest
-
-      - name: Run tests
-        run: pytest tests/

gr_libs-0.1.6.post1/.github/workflows/pr_flow.yml

@@ -1,10 +0,0 @@
-name: PR Test Flow
-
-on:
-  pull_request:
-    branches:
-      - main  # or whichever branch you're targeting for PRs
-
-jobs:
-  run_tests:
-    uses: ./.github/workflows/common_test_steps.yml

gr_libs-0.1.6.post1/.github/workflows/release.yml

@@ -1,33 +0,0 @@
-name: Publish to PyPI
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-# from here to remov when returning uses: ./.github/workflows/common_test_steps.yml
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install build tools
-        run: |
-          python -m pip install --upgrade pip
-          pip install build twine
-# until here!
-      - name: Build the package
-        run: python -m build
-
-      - name: Publish to PyPI
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
-        run: python -m twine upload dist/*

gr_libs-0.1.6.post1/.gitignore

@@ -1,160 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/#use-with-ide
-.pdm.toml
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/

gr_libs-0.1.6.post1/CI/README.md

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

gr_libs-0.1.6.post1/CI/docker_build_context/Dockerfile

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

gr_libs-0.1.6.post1/all_experiments.py

@@ -1,194 +0,0 @@
-import os
-import sys
-import threading
-import dill
-import subprocess
-import concurrent.futures
-import numpy as np
-
-from gr_libs.ml.utils.storage import get_experiment_results_path
-
-# Define the lists
-# domains = ['minigrid', 'point_maze', 'parking', 'panda']
-# envs = {
-#     'minigrid': ['obstacles', 'lava_crossing'],
-#     'point_maze': ['four_rooms', 'lava_crossing'],
-#     'parking': ['gc_agent', 'gd_agent'],
-#     'panda': ['gc_agent', 'gd_agent']
-# }
-# tasks = {
-#     'minigrid': ['L111', 'L222', 'L333', 'L444', 'L555'],
-#     'point_maze': ['L111', 'L222', 'L333', 'L444', 'L555'],
-#     'parking': ['L111', 'L222', 'L333', 'L444', 'L555'],
-#     'panda': ['L111', 'L222', 'L333', 'L444', 'L555']
-# }
-configs = {
-    'minigrid': {
-        'MiniGrid-SimpleCrossingS13N4': ['L1', 'L2', 'L3', 'L4', 'L5'],
-        'MiniGrid-LavaCrossingS9N2': ['L1', 'L2', 'L3', 'L4', 'L5']
-    }
-    # 'point_maze': {
-    #     'PointMaze-FourRoomsEnvDense-11x11': ['L1', 'L2', 'L3', 'L4', 'L5'],
-    #     'PointMaze-ObstaclesEnvDense-11x11': ['L1', 'L2', 'L3', 'L4', 'L5']
-    # }
-    # 'parking': {
-    #     'Parking-S-14-PC-': ['L1', 'L2', 'L3', 'L4', 'L5'],
-    #     'Parking-S-14-PC-': ['L1', 'L2', 'L3', 'L4', 'L5']
-    # }
-    # 'panda': {
-    #     'PandaMyReachDense': ['L1', 'L2', 'L3', 'L4', 'L5'],
-    #     'PandaMyReachDense': ['L1', 'L2', 'L3', 'L4', 'L5']
-    # }
-}
-# for minigrid: #TODO assert these instead i the beggingning of the code before beginning with the actual threading
-recognizers = ['ExpertBasedGraml']
-# recognizers = ['Graql']
-
-# for point_maze:
-# recognizers = ['ExpertBasedGraml']
-# recognizers = ['Draco']
-
-# for parking:
-# recognizers = ['GCGraml']
-# recognizers = ['GCDraco']
-
-# for panda:
-# recognizers = ['GCGraml']
-# recognizers = ['GCDraco']
-
-n = 5  # Number of times to execute each task
-
-# Function to read results from the result file
-def read_results(res_file_path):
-    with open(res_file_path, 'rb') as f:
-        results = dill.load(f)
-    return results
-
-# Every thread worker executes this function.
-def run_experiment(domain, env, task, recognizer, i, generate_new=False):
-    cmd = f"python odgr_executor.py --domain {domain} --recognizer {recognizer} --env_name {env} --task {task} --collect_stats"
-    print(f"Starting execution: {cmd}")
-    try:
-        res_file_path = get_experiment_results_path(domain, env, task, recognizer)
-        res_file_path_txt = res_file_path + '.txt'
-        i_res_file_path_txt = res_file_path + f'_{i}.txt'
-        res_file_path_pkl = res_file_path + '.pkl'
-        i_res_file_path_pkl = res_file_path + f'_{i}.pkl'
-        if generate_new or (not os.path.exists(i_res_file_path_txt) or not os.path.exists(i_res_file_path_pkl)):
-            if os.path.exists(i_res_file_path_txt) or os.path.exists(i_res_file_path_pkl):
-                i_res_file_path_txt = i_res_file_path_txt.replace(f'_{i}', f'_{i}_new')
-                i_res_file_path_pkl = i_res_file_path_pkl.replace(f'_{i}', f'_{i}_new')
-            # every thread in the current process starts a new process which executes the command. the current thread waits for the subprocess to finish.
-            process = subprocess.Popen(cmd, shell=True)
-            process.wait()
-            # result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
-            if process.returncode != 0:
-                print(f"Execution failed: {cmd}")
-                print(f"Error: {result.stderr}")
-                return None
-            else:
-                print(f"Finished execution successfully: {cmd}")
-            file_lock = threading.Lock()
-            with file_lock:
-                os.rename(res_file_path_pkl, i_res_file_path_pkl)
-                os.rename(res_file_path_txt, i_res_file_path_txt)
-        else:
-            print(f"File {i_res_file_path_txt} already exists. Skipping execution of {cmd}")
-        return ((domain, env, task, recognizer), read_results(i_res_file_path_pkl))
-    except Exception as e:
-        print(f"Exception occurred while running experiment: {e}")
-        return None
-
-# Collect results
-results = {}
-
-# create an executor that manages a pool of threads.
-# Note that any failure in the threads will not stop the main thread from continuing and vice versa, nor will the debugger view the failure if in debug mode.
-# Use prints and if any thread's printing stops suspect failure. If failure happened, use breakpoints before failure and use the watch to see the failure by pasting the problematic piece of code.
-with concurrent.futures.ThreadPoolExecutor() as executor:
-    futures = []
-    for domain, envs in configs.items():
-        for env, tasks in envs.items():
-            for task in tasks:
-                for recognizer in recognizers:
-                    for i in range(n):
-                        # submit returns a future object that represents the execution of the function by some thread in the pool. the method is added to the list and the executor will run it as soon as it can.
-                        futures.append(executor.submit(run_experiment, domain, env, task, recognizer, i, generate_new=True if len(sys.argv) > 1 and sys.argv[1] == '--generate_new' else False))
-
-    # main thread continues execution after the loop above. Here, it waits for all threads. every time a thread finishes, the main thread reads the results from the future object.
-    # If debugging main thread, note the executor will stop creating new threads and running them since it exists and runs in the main thread.
-    # probably, the main thread gets interrupted by the return of a future and knows to start execution of new threads and then continue main thread execution
-    for future in concurrent.futures.as_completed(futures):
-        # the objects returned by the 'result' func are tuples with key being the args inserted to 'submit'.
-        if future.result() is None:
-            print(f"for future {future}, future.result() is None. Continuing to next future.")
-            continue
-        key, result = future.result()
-        print(f"main thread reading results from future {key}")
-        # list because every experiment is executed n times.
-        if key not in results:
-            results[key] = []
-        results[key].append(result)
-
-# Calculate average accuracy and standard deviation for each percentage
-detailed_summary = {}
-compiled_accuracies = {}
-for key, result_list in results.items():
-    domain, env, task, recognizer = key
-    percentages = result_list[0].keys()
-    detailed_summary[key] = {}
-    if (domain, recognizer) not in compiled_accuracies:
-        compiled_accuracies[(domain, recognizer)] = {}
-    for percentage in percentages:
-        if percentage == 'total':
-            continue
-        if percentage not in compiled_accuracies[(domain, recognizer)].keys(): compiled_accuracies[(domain, recognizer)][percentage] = {}
-        if percentage not in detailed_summary[key].keys(): detailed_summary[key][percentage] = {}
-        consecutive_accuracies = [result[percentage]['consecutive']['accuracy'] for result in result_list] # accuracies in all different n executions
-        non_consecutive_accuracies = [result[percentage]['non_consecutive']['accuracy'] for result in result_list]
-        if 'consecutive' in compiled_accuracies[(domain, recognizer)][percentage].keys():
-            compiled_accuracies[(domain, recognizer)][percentage]['consecutive'].extend(consecutive_accuracies)
-        else:
-            compiled_accuracies[(domain, recognizer)][percentage]['consecutive'] = consecutive_accuracies
-        if 'non_consecutive' in compiled_accuracies[(domain, recognizer)][percentage].keys():
-            compiled_accuracies[(domain, recognizer)][percentage]['non_consecutive'].extend(non_consecutive_accuracies)
-        else:
-            compiled_accuracies[(domain, recognizer)][percentage]['non_consecutive'] = non_consecutive_accuracies
-        avg_consecutive_accuracy = np.mean(consecutive_accuracies)
-        consecutive_std_dev = np.std(consecutive_accuracies)
-        detailed_summary[key][percentage]['consecutive'] = (avg_consecutive_accuracy, consecutive_std_dev)
-        avg_non_consecutive_accuracy = np.mean(non_consecutive_accuracies)
-        non_consecutive_std_dev = np.std(non_consecutive_accuracies)
-        detailed_summary[key][percentage]['non_consecutive'] = (avg_non_consecutive_accuracy, non_consecutive_std_dev)
-     
-compiled_summary = {}   
-for key, percentage_dict in compiled_accuracies.items():
-    compiled_summary[key] = {}
-    for percentage, cons_accuracies in percentage_dict.items():
-        compiled_summary[key][percentage] = {}
-        for is_cons, accuracies in cons_accuracies.items():
-            avg_accuracy = np.mean(accuracies)
-            std_dev = np.std(accuracies)
-            compiled_summary[key][percentage][is_cons] = (avg_accuracy, std_dev)
-
-# Write different summary results to different files
-detailed_summary_file_path = os.path.join('summaries',f"detailed_summary_{''.join(configs.keys())}_{recognizers[0]}.txt")
-compiled_summary_file_path = os.path.join('summaries',f"compiled_summary_{''.join(configs.keys())}_{recognizers[0]}.txt")
-with open(detailed_summary_file_path, 'w') as f:
-    for key, percentage_dict in detailed_summary.items():
-        domain, env, task, recognizer = key
-        f.write(f"{domain}\t{env}\t{task}\t{recognizer}\n")
-        for percentage, cons_info in percentage_dict.items():
-            for is_cons, (avg_accuracy, std_dev) in cons_info.items():
-                f.write(f"\t\t{percentage}\t{is_cons}\t{avg_accuracy:.4f}\t{std_dev:.4f}\n")
-            
-with open(compiled_summary_file_path, 'w') as f:
-    for key, percentage_dict in compiled_summary.items():
-        domain, recognizer = key
-        f.write(f"{domain}\t{recognizer}\n")
-        for percentage, cons_info in percentage_dict.items():
-            for is_cons, (avg_accuracy, std_dev) in cons_info.items():
-                f.write(f"\t\t{percentage}\t{is_cons}\t{avg_accuracy:.4f}\t{std_dev:.4f}\n")
-
-print(f"Detailed summary results written to {detailed_summary_file_path}")
-print(f"Compiled summary results written to {compiled_summary_file_path}")

gr_libs-0.1.6.post1/download_dataset.py

@@ -1,19 +0,0 @@
-import requests
-import zipfile
-import os
-
-def download_and_extract_dataset(google_drive_url, extract_to):
-    os.makedirs(extract_to, exist_ok=True)
-    download_url = google_drive_url + "&export=download"
-    response = requests.get(download_url)
-    response.raise_for_status()
-    with open('dataset.zip', 'wb') as f:
-        f.write(response.content)
-    with zipfile.ZipFile('dataset.zip', 'r') as zip_ref:
-        zip_ref.extractall(extract_to)
-    os.remove('dataset.zip')
-
-if __name__ == "__main__":
-    google_drive_url = "https://drive.google.com/file/d/1PK1iZONTyiQZBgLErUO88p1YWdL4B9Xn/view?usp=sharing"
-    extract_to = "dataset"
-    download_and_extract_dataset(google_drive_url, extract_to)

gr_libs-0.1.6.post1/gr_libs/recognizer/recognizer_doc.md

@@ -1,61 +0,0 @@
-# Recognizer Module Documentation
-
-This document provides an overview of the recognizer module, including its class hierarchy and instructions for adding a new class of recognizer.
-
-## Class Hierarchy
-
-The recognizer module consists of an abstract base class `Recognizer` and several derived classes, each implementing specific behaviors. The main classes are:
-
-1. **Recognizer (Abstract Base Class)**
-   - `inference_phase()` (abstract method)
-
-2. **LearningRecognizer (Extends Recognizer)**
-   - `domain_learning_phase()`
-
-3. **GaAgentTrainerRecognizer (Extends Recognizer)**
-   - `goals_adaptation_phase()` (abstract method)
-   - `domain_learning_phase()`
-
-4. **GaAdaptingRecognizer (Extends Recognizer)**
-   - `goals_adaptation_phase()` (abstract method)
-
-5. **GRAsRL (Extends Recognizer)**
-   - Implements `goals_adaptation_phase()`
-   - Implements `inference_phase()`
-
-6. **Specific Implementations:**
-   - `Graql (Extends GRAsRL, GaAgentTrainerRecognizer)`
-   - `Draco (Extends GRAsRL, GaAgentTrainerRecognizer)`
-   - `GCDraco (Extends GRAsRL, LearningRecognizer, GaAdaptingRecognizer)`
-   - `Graml (Extends LearningRecognizer)`
-
-## How to Add a New Recognizer Class
-
-To add a new class of recognizer, follow these steps:
-
-1. **Determine the Type of Recognizer:**
-   - Will it require learning? Extend `LearningRecognizer`.
-   - Will it adapt goals dynamically? Extend `GaAdaptingRecognizer`.
-   - Will it train agents for new goals? Extend `GaAgentTrainerRecognizer`.
-   - Will it involve RL-based recognition? Extend `GRAsRL`.
-
-2. **Define the Class:**
-   - Create a new class that extends the appropriate base class(es).
-   - Implement the required abstract methods (`inference_phase()`, `goals_adaptation_phase()`, etc.).
-
-3. **Initialize the Recognizer:**
-   - Ensure proper initialization by calling `super().__init__(*args, **kwargs)`.
-   - Set up any necessary agent storage or evaluation functions.
-
-4. **Implement Core Methods:**
-   - Define how the recognizer processes inference sequences.
-   - Implement learning or goal adaptation logic if applicable.
-
-5. **Register the Recognizer:**
-   - Ensure it integrates properly with the existing system by using the correct `domain_to_env_property()`.
-
-6. **Test the New Recognizer:**
-   - Run experiments to validate its behavior.
-   - Compare results against existing recognizers to ensure correctness.
-
-By following these steps, you can seamlessly integrate a new recognizer into the framework while maintaining compatibility with the existing structure.

gr_libs-0.1.6.post1/odgr_executor.py

@@ -1,125 +0,0 @@
-import argparse
-import os
-import time
-import dill
-
-from gr_libs.environment.utils.utils import domain_to_env_property
-from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco, Graql
-from gr_libs.recognizer import Graml
-from gr_libs.metrics.metrics import stochastic_amplified_selection
-from gr_libs.ml.utils.format import random_subset_with_order
-from gr_libs.recognizer.recognizer import GaAgentTrainerRecognizer, LearningRecognizer
-from gr_libs.recognizer.utils import recognizer_str_to_obj
-from gr_libs.ml.utils.storage import create_folders_if_necessary, get_and_create, get_experiment_results_path, get_policy_sequences_result_path
-
-from gr_libs.problems.consts import PROBLEMS
-
-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])
-			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": True,
-									"random_optimalism": True,
-									"fig_path": fig_path,
-									"env_prop": env_property}
-
-			# 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(f'{res_file_path}.pkl', 'wb') as results_file:
-		dill.dump(results, results_file)
-	with open(f'{res_file_path}.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)