gr-libs 0.1.5__tar.gz → 0.1.6.post1__tar.gz

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

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

@@ -0,0 +1,10 @@
+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.5 → gr_libs-0.1.6.post1}/.github/workflows/release.yml

@@ -6,27 +6,28 @@ on:
       - "v*"
 
 jobs:
-  build-and-publish:
+  release:
     runs-on: ubuntu-latest
-
     steps:
-      - name: Check out the repository
+# 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@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.11"
 
-      - name: Install build dependencies
+      - 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  # Uses pyproject.toml instead of setup.py
+        run: python -m build
 
       - name: Publish to PyPI
         env:
-          PYPY_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
-        run: python -m twine upload dist/* -u __token__ -p $PYPY_API_TOKEN
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: python -m twine upload dist/*

gr_libs-0.1.6.post1/CI/README.md

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

@@ -0,0 +1,15 @@
+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.5/gr_libs.egg-info → gr_libs-0.1.6.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.5
+Version: 0.1.6.post1
 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>
@@ -17,6 +17,7 @@ Requires-Dist: torchvision
 Requires-Dist: rl_zoo3
 Requires-Dist: stable_baselines3[extra]
 Requires-Dist: sb3_contrib
+Requires-Dist: pytest
 Provides-Extra: minigrid
 Requires-Dist: gr_envs[minigrid]; extra == "minigrid"
 Provides-Extra: highway
@@ -111,6 +112,25 @@ After installing GRLib, you will have access to custom Gym environments, allowin
 
 Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tutorials`. These tutorials walk through the initialization and deployment process, showcasing how different GR algorithms adapt to emerging goals in various Gym environments.
 
+## Working with an initial dataset of trained agents
+gr_libs also includes a library of trained agents for the various supported environments within the package.
+To get the dataset of trained agents, you can run:
+```sh
+python download_dataset.py
+```
+
+An alternative is to use our docker image, which includes the dataset in it.
+You can:
+1. pull the image:
+```sh
+docker pull ghcr.io/MatanShamir1/gr_test_base:latest
+```
+2. run a container:
+```sh
+docker run -it ghcr.io/MatanShamir1/gr_test_base:latest bash
+```
+3. don't forget to install the package from within the container, go back to 'Setup' for that.
+
 ### Method 1: Writing a Custom Script
 
 1. **Create a recognizer**
@@ -118,6 +138,7 @@ Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tu
    Specify the domain name and specific environment for the recognizer, effectively telling it the domain theory - the collection of states and actions in the environment.
 
    ```python
+   import gr_libs.environment # Triggers gym env registration - you must run it!
    recognizer = Graql(
        domain_name="minigrid",
        env_name="MiniGrid-SimpleCrossingS13N4"

{gr_libs-0.1.5 → gr_libs-0.1.6.post1}/README.md

@@ -83,6 +83,25 @@ After installing GRLib, you will have access to custom Gym environments, allowin
 
 Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tutorials`. These tutorials walk through the initialization and deployment process, showcasing how different GR algorithms adapt to emerging goals in various Gym environments.
 
+## Working with an initial dataset of trained agents
+gr_libs also includes a library of trained agents for the various supported environments within the package.
+To get the dataset of trained agents, you can run:
+```sh
+python download_dataset.py
+```
+
+An alternative is to use our docker image, which includes the dataset in it.
+You can:
+1. pull the image:
+```sh
+docker pull ghcr.io/MatanShamir1/gr_test_base:latest
+```
+2. run a container:
+```sh
+docker run -it ghcr.io/MatanShamir1/gr_test_base:latest bash
+```
+3. don't forget to install the package from within the container, go back to 'Setup' for that.
+
 ### Method 1: Writing a Custom Script
 
 1. **Create a recognizer**
@@ -90,6 +109,7 @@ Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tu
    Specify the domain name and specific environment for the recognizer, effectively telling it the domain theory - the collection of states and actions in the environment.
 
    ```python
+   import gr_libs.environment # Triggers gym env registration - you must run it!
    recognizer = Graql(
        domain_name="minigrid",
        env_name="MiniGrid-SimpleCrossingS13N4"

gr_libs-0.1.6.post1/download_dataset.py

@@ -0,0 +1,19 @@
+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/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.6.post1'
+__version_tuple__ = version_tuple = (0, 1, 6)

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

@@ -12,11 +12,11 @@ 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", "parking", "point_maze"]:
+for env in ["minigrid", "panda", "highway", "point_maze"]:
 	if is_extra_installed("gr_libs", f"gr_envs[{env}]"):
 		try:
 			importlib.import_module(f"gr_envs.{env}_scripts.envs")
 		except ImportError:
-			raise ImportError(f"gr_libs[{env}] was not installed, but gr_libs[{env}] requires it! if you messed with gr_libs installation, you can reinstall gr_libs.")
+			raise ImportError(f"gr_envs[{env}] was not installed, but gr_libs[{env}] requires it! if you messed with gr_envs installation, you can reinstall gr_libs.")
 	else:
 		warnings.warn(f"gr_libs[{env}] was not installed, skipping {env} imports.", RuntimeWarning)

{gr_libs-0.1.5 → gr_libs-0.1.6.post1}/gr_libs/environment/environment.py

@@ -105,7 +105,7 @@ class MinigridProperty(EnvProperty):
         env_id = problem_name.split("-DynamicGoal-")[0] + "-DynamicGoal-" + problem_name.split("-DynamicGoal-")[1]
         result = register(
             id=env_id,
-            entry_point="gr_libss.minigrid_scripts.envs:CustomColorEnv",
+            entry_point="gr_envs.minigrid_scripts.envs:CustomColorEnv",
             kwargs={"size": 13 if 'Simple' in problem_name else 9,
                     "num_crossings": 4 if 'Simple' in problem_name else 3,
                     "goal_pos": self.str_to_goal(problem_name),

{gr_libs-0.1.5 → gr_libs-0.1.6.post1}/gr_libs/metrics/metrics.py

@@ -5,7 +5,6 @@ import numpy as np
 
 from typing import Callable, Generator, List, Dict, Tuple, Any
 from math import log2
-from numpy.core.fromnumeric import mean
 from scipy.stats import wasserstein_distance
 from gymnasium.spaces.discrete import Discrete
 # import torch
@@ -43,7 +42,7 @@ def kl_divergence_norm_softmax(observations: List[Tuple[State, Any]], agent, act
         qp2_flatten_distribution_list: List[float] = agent.get_actions_probabilities(
             observation=(observation, agent_pos))
         distances.append(kl_divergence(qp1, qp2_flatten_distribution_list))
-    return mean(distances)
+    return np.mean(distances)
 
 
 def amplify(values, alpha=1.0):

{gr_libs-0.1.5 → gr_libs-0.1.6.post1}/gr_libs/recognizer/recognizer.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 from typing import List, Type
-
 from gr_libs.environment.environment import EnvProperty, SUPPORTED_DOMAINS
 from gr_libs.environment.utils.utils import domain_to_env_property
 from gr_libs.ml.base.rl_agent import RLAgent

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.5
+Version: 0.1.6.post1
 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>
@@ -17,6 +17,7 @@ Requires-Dist: torchvision
 Requires-Dist: rl_zoo3
 Requires-Dist: stable_baselines3[extra]
 Requires-Dist: sb3_contrib
+Requires-Dist: pytest
 Provides-Extra: minigrid
 Requires-Dist: gr_envs[minigrid]; extra == "minigrid"
 Provides-Extra: highway
@@ -111,6 +112,25 @@ After installing GRLib, you will have access to custom Gym environments, allowin
 
 Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tutorials`. These tutorials walk through the initialization and deployment process, showcasing how different GR algorithms adapt to emerging goals in various Gym environments.
 
+## Working with an initial dataset of trained agents
+gr_libs also includes a library of trained agents for the various supported environments within the package.
+To get the dataset of trained agents, you can run:
+```sh
+python download_dataset.py
+```
+
+An alternative is to use our docker image, which includes the dataset in it.
+You can:
+1. pull the image:
+```sh
+docker pull ghcr.io/MatanShamir1/gr_test_base:latest
+```
+2. run a container:
+```sh
+docker run -it ghcr.io/MatanShamir1/gr_test_base:latest bash
+```
+3. don't forget to install the package from within the container, go back to 'Setup' for that.
+
 ### Method 1: Writing a Custom Script
 
 1. **Create a recognizer**
@@ -118,6 +138,7 @@ Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tu
    Specify the domain name and specific environment for the recognizer, effectively telling it the domain theory - the collection of states and actions in the environment.
 
    ```python
+   import gr_libs.environment # Triggers gym env registration - you must run it!
    recognizer = Graql(
        domain_name="minigrid",
        env_name="MiniGrid-SimpleCrossingS13N4"

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

@@ -1,10 +1,14 @@
 .gitignore
 README.md
 all_experiments.py
-consts.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
@@ -15,6 +19,7 @@ evaluation/generate_task_specific_statistics_plots.py
 evaluation/get_plans_images.py
 evaluation/increasing_and_decreasing_.py
 gr_libs/__init__.py
+gr_libs/_version.py
 gr_libs.egg-info/PKG-INFO
 gr_libs.egg-info/SOURCES.txt
 gr_libs.egg-info/dependency_links.txt
@@ -54,6 +59,8 @@ gr_libs/ml/utils/format.py
 gr_libs/ml/utils/math.py
 gr_libs/ml/utils/other.py
 gr_libs/ml/utils/storage.py
+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
@@ -64,6 +71,8 @@ gr_libs/recognizer/graml/gr_dataset.py
 gr_libs/recognizer/graml/graml_recognizer.py
 gr_libs/recognizer/utils/__init__.py
 gr_libs/recognizer/utils/format.py
+tests/test_graml.py
+tests/test_graql.py
 tutorials/graml_minigrid_tutorial.py
 tutorials/graml_panda_tutorial.py
 tutorials/graml_parking_tutorial.py

{gr_libs-0.1.5 → gr_libs-0.1.6.post1}/gr_libs.egg-info/requires.txt

@@ -6,6 +6,7 @@ torchvision
 rl_zoo3
 stable_baselines3[extra]
 sb3_contrib
+pytest
 
 [highway]
 gr_envs[highway]

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

@@ -1,4 +1,6 @@
+CI
 dist
 evaluation
 gr_libs
+tests
 tutorials

{gr_libs-0.1.5 → gr_libs-0.1.6.post1}/odgr_executor.py

@@ -13,7 +13,7 @@ from gr_libs.recognizer.recognizer import GaAgentTrainerRecognizer, LearningReco
 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 consts import PROBLEMS
+from gr_libs.problems.consts import PROBLEMS
 
 def validate(args, recognizer_type, task_inputs):
 	if "base" in task_inputs.keys():

{gr_libs-0.1.5 → gr_libs-0.1.6.post1}/pyproject.toml

@@ -22,7 +22,8 @@ dependencies = [
     "torchvision",
     "rl_zoo3",
     "stable_baselines3[extra]",
-    "sb3_contrib"
+    "sb3_contrib",
+    "pytest"
 ]
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -42,3 +43,4 @@ packages = {find = {}}
 [tool.setuptools_scm]
 version_scheme = "post-release"
 local_scheme = "node-and-date"
+write_to = "gr_libs/_version.py"  # This line writes the version to a file within the package

gr_libs-0.1.6.post1/tests/test_graml.py

@@ -0,0 +1,16 @@
+from tutorials.graml_minigrid_tutorial import run_graml_minigrid_tutorial
+from tutorials.graml_panda_tutorial import run_graml_panda_tutorial
+from tutorials.graml_parking_tutorial import run_graml_parking_tutorial
+from tutorials.graml_point_maze_tutorial import run_graml_point_maze_tutorial
+
+def test_graml_minigrid_tutorial():
+	run_graml_minigrid_tutorial()
+
+def test_graml_panda_tutorial():
+	run_graml_panda_tutorial()
+
+def test_graml_parking_tutorial():
+	run_graml_parking_tutorial()
+
+def test_graml_point_maze_tutorial():
+	run_graml_point_maze_tutorial()

gr_libs-0.1.6.post1/tests/test_graql.py

@@ -0,0 +1,4 @@
+from tutorials.graql_minigrid_tutorial import run_graql_minigrid_tutorial
+
+def test_graql_minigrid_tutorial():
+	run_graql_minigrid_tutorial()

gr_libs-0.1.6.post1/tutorials/graml_minigrid_tutorial.py

@@ -0,0 +1,34 @@
+from gr_libs.environment.environment import MINIGRID, QLEARNING
+from gr_libs.metrics.metrics import stochastic_amplified_selection
+from gr_libs.ml.tabular.tabular_q_learner import TabularQLearner
+from gr_libs.ml.utils.format import random_subset_with_order
+from gr_libs import ExpertBasedGraml
+
+def run_graml_minigrid_tutorial():
+    recognizer = ExpertBasedGraml(
+        domain_name=MINIGRID,
+        env_name="MiniGrid-SimpleCrossingS13N4"
+    )
+
+    recognizer.domain_learning_phase(base_goals=[(11,1), (11,11), (1,11), (7,11), (8,1), (10,6), (6,9), (11,3), (11,5)],
+                                    train_configs=[(QLEARNING, 100000) for _ in range(9)])
+
+    recognizer.goals_adaptation_phase(
+        dynamic_goals = [(11,1), (11,11), (1,11)],
+        dynamic_train_configs=[(QLEARNING, 100000) for _ in range(3)] # for expert sequence generation.
+    )
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    actor = TabularQLearner(domain_name="minigrid", problem_name="MiniGrid-SimpleCrossingS13N4-DynamicGoal-11x1-v0", algorithm=QLEARNING, num_timesteps=100000)
+    actor.learn()
+    # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
+    full_sequence = actor.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True, # the noise that's added to the actions
+    )
+
+    partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
+    closest_goal = recognizer.inference_phase(partial_sequence, (11,1), 0.5)
+    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (11, 1)")
+
+if __name__ == "__main__":
+    run_graml_minigrid_tutorial()

gr_libs-0.1.6.post1/tutorials/graml_panda_tutorial.py

@@ -0,0 +1,41 @@
+
+import numpy as np
+from stable_baselines3 import PPO, SAC
+import gr_libs.environment.environment
+from gr_libs.environment.environment import PANDA, EnvProperty, GCEnvProperty, PandaProperty
+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, GCDeepRLAgent
+from gr_libs.ml.utils.format import random_subset_with_order
+from gr_libs import GCGraml
+
+def run_graml_panda_tutorial():
+    recognizer = GCGraml( # TODO make these tutorials into pytests
+        domain_name=PANDA,
+        env_name="PandaMyReachDense"
+    )
+    recognizer.domain_learning_phase(
+        base_goals=[np.array([PandaProperty.sample_goal()]) for _ in range(1,30)],
+        train_configs=[(SAC, 800000)]
+    )
+    recognizer.goals_adaptation_phase(
+        dynamic_goals=[np.array([[-0.1, -0.1, 0.1]]), np.array([[-0.1, 0.1, 0.1]]), np.array([[0.2, 0.2, 0.1]])]
+    )
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    property_type = domain_to_env_property(PANDA)
+    env_property = property_type("PandaMyReachDense")
+    problem_name = env_property.goal_to_problem_str(np.array([[-0.1, -0.1, 0.1]]))
+    actor = DeepRLAgent(domain_name=PANDA, problem_name=problem_name, algorithm=PPO, num_timesteps=400000)
+    actor.learn()
+    # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
+    full_sequence = actor.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True, # the noise that's added to the actions
+    )
+
+    partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
+    closest_goal = recognizer.inference_phase(partial_sequence, np.array([[-0.1, -0.1, 0.1]]), 0.5)
+    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: [-0.1, -0.1, 0.1]")
+
+if __name__ == "__main__":
+    run_graml_panda_tutorial()

gr_libs-0.1.6.post1/tutorials/graml_parking_tutorial.py

@@ -0,0 +1,38 @@
+
+from stable_baselines3 import PPO, SAC, TD3
+from gr_libs.environment.environment import PARKING, EnvProperty, GCEnvProperty, ParkingProperty
+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
+
+def run_graml_parking_tutorial():
+    recognizer = GCGraml(
+        domain_name=PARKING,
+        env_name="Parking-S-14-PC-"
+    )
+                        
+    recognizer.domain_learning_phase(
+        [i for i in range(1,21)],
+        [(PPO, 200000)]
+    )
+    recognizer.goals_adaptation_phase(
+        dynamic_goals = ["1", "11", "21"]
+        # no need for expert sequence generation since GCRL is used
+    )
+
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    actor = DeepRLAgent(domain_name="parking", problem_name="Parking-S-14-PC--GI-11-v0", algorithm=TD3, num_timesteps=400000)
+    actor.learn()
+    # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
+    full_sequence = actor.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True, # the noise that's added to the actions
+    )
+
+    partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
+    closest_goal = recognizer.inference_phase(partial_sequence, ParkingProperty("Parking-S-14-PC--GI-11-v0").str_to_goal(), 0.5)
+    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: 11")
+
+if __name__ == "__main__":
+    run_graml_parking_tutorial()

gr_libs-0.1.6.post1/tutorials/graml_point_maze_tutorial.py

@@ -0,0 +1,39 @@
+
+from stable_baselines3 import SAC, TD3
+from gr_libs.environment.environment import POINT_MAZE, PointMazeProperty
+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.recognizer.graml.graml_recognizer import ExpertBasedGraml
+
+def run_graml_point_maze_tutorial():
+    recognizer = ExpertBasedGraml(
+        domain_name=POINT_MAZE,
+        env_name="PointMaze-FourRoomsEnvDense-11x11"
+    )
+
+    recognizer.domain_learning_phase(
+        [(9,1), (9,9), (1,9), (3,3), (3,4), (8,2), (3,7), (2,8)],
+        [(SAC, 200000) for _ in range(8)]
+    )
+
+    recognizer.goals_adaptation_phase(
+        dynamic_goals = [(4,4), (7,3), (3,7)],
+        dynamic_train_configs=[(SAC, 200000) for _ in range(3)] # for expert sequence generation.
+    )
+
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    actor = DeepRLAgent(domain_name="point_maze", problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4", algorithm=TD3, num_timesteps=200000)
+    actor.learn()
+    # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
+    full_sequence = actor.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True, # the noise that's added to the actions
+    )
+
+    partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)))
+    closest_goal = recognizer.inference_phase(partial_sequence, PointMazeProperty("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4").str_to_goal(), 0.5)
+    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (4, 4)")
+
+if __name__ == "__main__":
+    run_graml_point_maze_tutorial()

gr_libs-0.1.6.post1/tutorials/graql_minigrid_tutorial.py

@@ -0,0 +1,34 @@
+from gr_libs.environment.environment import QLEARNING
+from gr_libs.metrics.metrics import stochastic_amplified_selection
+from gr_libs.ml.tabular.tabular_q_learner import TabularQLearner
+from gr_libs.ml.utils.format import random_subset_with_order
+from gr_libs import Graql
+
+def run_graql_minigrid_tutorial():
+    recognizer = Graql(
+        domain_name="minigrid",
+        env_name="MiniGrid-SimpleCrossingS13N4"
+    )
+
+    #Graql doesn't have a domain learning phase, so we skip it
+
+    recognizer.goals_adaptation_phase(
+        dynamic_goals = [(11,1), (11,11), (1,11)],
+        dynamic_train_configs=[(QLEARNING, 100000) for _ in range(3)] # for expert sequence generation.
+    )
+    # TD3 is different from recognizer and expert algorithms, which are SAC #
+    actor = TabularQLearner(domain_name="minigrid", problem_name="MiniGrid-SimpleCrossingS13N4-DynamicGoal-11x1-v0", algorithm=QLEARNING, num_timesteps=100000)
+    actor.learn()
+    # sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
+    full_sequence = actor.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True, # the noise that's added to the actions
+    )
+
+    partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
+    closest_goal = recognizer.inference_phase(partial_sequence, (11,1), 0.5)
+    print(f"closest_goal returned by Graql: {closest_goal}\nactual goal actor aimed towards: (11, 1)")
+    return closest_goal, (11,1)
+
+if __name__ == "__main__":
+    run_graql_minigrid_tutorial()

gr_libs-0.1.5/tutorials/graml_minigrid_tutorial.py

@@ -1,30 +0,0 @@
-from gr_libs.environment.environment import MINIGRID, QLEARNING
-from gr_libs.metrics.metrics import stochastic_amplified_selection
-from gr_libs.ml.tabular.tabular_q_learner import TabularQLearner
-from gr_libs.ml.utils.format import random_subset_with_order
-from gr_libs import ExpertBasedGraml
-
-recognizer = ExpertBasedGraml(
-	domain_name=MINIGRID,
-	env_name="MiniGrid-SimpleCrossingS13N4"
-)
-
-recognizer.domain_learning_phase(base_goals=[(11,1), (11,11), (1,11), (7,11), (8,1), (10,6), (6,9), (11,3), (11,5)],
-                                 train_configs=[(QLEARNING, 100000) for _ in range(9)])
-
-recognizer.goals_adaptation_phase(
-    dynamic_goals = [(11,1), (11,11), (1,11)],
-    dynamic_train_configs=[(QLEARNING, 100000) for _ in range(3)] # for expert sequence generation.
-)
-# TD3 is different from recognizer and expert algorithms, which are SAC #
-actor = TabularQLearner(domain_name="minigrid", problem_name="MiniGrid-SimpleCrossingS13N4-DynamicGoal-11x1-v0", algorithm=QLEARNING, num_timesteps=100000)
-actor.learn()
-# sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
-full_sequence = actor.generate_observation(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
-
-partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
-closest_goal = recognizer.inference_phase(partial_sequence, (11,1), 0.5)
-print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (11, 1)")

gr_libs-0.1.5/tutorials/graml_panda_tutorial.py

@@ -1,37 +0,0 @@
-
-import numpy as np
-from stable_baselines3 import PPO, SAC
-import gr_libs.environment.environment
-from gr_libs.environment.environment import PANDA, EnvProperty, GCEnvProperty, PandaProperty
-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, GCDeepRLAgent
-from gr_libs.ml.utils.format import random_subset_with_order
-from gr_libs import GCGraml
-
-recognizer = GCGraml( # TODO make these tutorials into pytests
-    domain_name=PANDA,
-	env_name="PandaMyReachDense"
-)
-recognizer.domain_learning_phase(
-	base_goals=[np.array([PandaProperty.sample_goal()]) for _ in range(1,30)],
-	train_configs=[(SAC, 800000)]
-)
-recognizer.goals_adaptation_phase(
-	dynamic_goals=[np.array([[-0.1, -0.1, 0.1]]), np.array([[-0.1, 0.1, 0.1]]), np.array([[0.2, 0.2, 0.1]])]
-)
-# TD3 is different from recognizer and expert algorithms, which are SAC #
-property_type = domain_to_env_property(PANDA)
-env_property = property_type("PandaMyReachDense")
-problem_name = env_property.goal_to_problem_str(np.array([[-0.1, -0.1, 0.1]]))
-actor = DeepRLAgent(domain_name=PANDA, problem_name=problem_name, algorithm=PPO, num_timesteps=400000)
-actor.learn()
-# sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
-full_sequence = actor.generate_observation(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
-
-partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
-closest_goal = recognizer.inference_phase(partial_sequence, np.array([[-0.1, -0.1, 0.1]]), 0.5)
-print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: [-0.1, -0.1, 0.1]")

gr_libs-0.1.5/tutorials/graml_parking_tutorial.py

@@ -1,34 +0,0 @@
-
-from stable_baselines3 import PPO, SAC, TD3
-from gr_libs.environment.environment import PARKING, EnvProperty, GCEnvProperty, ParkingProperty
-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
-
-recognizer = GCGraml(
-	domain_name=PARKING,
-	env_name="Parking-S-14-PC-"
-)
-					
-recognizer.domain_learning_phase(
-	[i for i in range(1,21)],
-	[(PPO, 200000)]
-)
-recognizer.goals_adaptation_phase(
-    dynamic_goals = ["1", "11", "21"]
-	# no need for expert sequence generation since GCRL is used
-)
-
-# TD3 is different from recognizer and expert algorithms, which are SAC #
-actor = DeepRLAgent(domain_name="parking", problem_name="Parking-S-14-PC--GI-11-v0", algorithm=TD3, num_timesteps=400000)
-actor.learn()
-# sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
-full_sequence = actor.generate_observation(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
-
-partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
-closest_goal = recognizer.inference_phase(partial_sequence, ParkingProperty("Parking-S-14-PC--GI-11-v0").str_to_goal(), 0.5)
-print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: 11")

gr_libs-0.1.5/tutorials/graml_point_maze_tutorial.py

@@ -1,35 +0,0 @@
-
-from stable_baselines3 import SAC, TD3
-from gr_libs.environment.environment import POINT_MAZE, PointMazeProperty
-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.recognizer.graml.graml_recognizer import ExpertBasedGraml
-
-recognizer = ExpertBasedGraml(
-	domain_name=POINT_MAZE,
-	env_name="PointMaze-FourRoomsEnvDense-11x11"
-)
-
-recognizer.domain_learning_phase(
-	[(9,1), (9,9), (1,9), (3,3), (3,4), (8,2), (3,7), (2,8)],
-	[(SAC, 200000) for _ in range(8)]
-)
-
-recognizer.goals_adaptation_phase(
-    dynamic_goals = [(4,4), (7,3), (3,7)],
-    dynamic_train_configs=[(SAC, 200000) for _ in range(3)] # for expert sequence generation.
-)
-
-# TD3 is different from recognizer and expert algorithms, which are SAC #
-actor = DeepRLAgent(domain_name="point_maze", problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4", algorithm=TD3, num_timesteps=200000)
-actor.learn()
-# sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
-full_sequence = actor.generate_observation(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
-
-partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)))
-closest_goal = recognizer.inference_phase(partial_sequence, PointMazeProperty("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4").str_to_goal(), 0.5)
-print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (4, 4)")

gr_libs-0.1.5/tutorials/graql_minigrid_tutorial.py

@@ -1,29 +0,0 @@
-from gr_libs.environment.environment import QLEARNING
-from gr_libs.metrics.metrics import stochastic_amplified_selection
-from gr_libs.ml.tabular.tabular_q_learner import TabularQLearner
-from gr_libs.ml.utils.format import random_subset_with_order
-from gr_libs import Graql
-
-recognizer = Graql(
-	domain_name="minigrid",
-	env_name="MiniGrid-SimpleCrossingS13N4"
-)
-
-#Graql doesn't have a domain learning phase, so we skip it
-
-recognizer.goals_adaptation_phase(
-    dynamic_goals = [(11,1), (11,11), (1,11)],
-    dynamic_train_configs=[(QLEARNING, 100000) for _ in range(3)] # for expert sequence generation.
-)
-# TD3 is different from recognizer and expert algorithms, which are SAC #
-actor = TabularQLearner(domain_name="minigrid", problem_name="MiniGrid-SimpleCrossingS13N4-DynamicGoal-11x1-v0", algorithm=QLEARNING, num_timesteps=100000)
-actor.learn()
-# sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
-full_sequence = actor.generate_observation(
-    action_selection_method=stochastic_amplified_selection,
-    random_optimalism=True, # the noise that's added to the actions
-)
-
-partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
-closest_goal = recognizer.inference_phase(partial_sequence, (11,1), 0.5)
-print(f"closest_goal returned by Graql: {closest_goal}\nactual goal actor aimed towards: (11, 1)")