gr-libs 0.1.8__py3-none-any.whl → 0.2.2__py3-none-any.whl

gr_libs/recognizer/recognizer.py

@@ -1,7 +1,7 @@
 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.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import SUPPORTED_DOMAINS
 from gr_libs.ml.base.rl_agent import RLAgent
 
 
@@ -11,7 +11,7 @@ class Recognizer(ABC):
         domain_name: str,
         env_name: str,
         collect_statistics=False,
-        rl_agent_type: Type[RLAgent] = None,
+        rl_agent_type: type[RLAgent] = None,
         **kwargs,
     ):
         assert domain_name in SUPPORTED_DOMAINS
@@ -27,30 +27,79 @@ class Recognizer(ABC):
 
 
 class LearningRecognizer(Recognizer):
+    """
+    A class that represents a learning recognizer.
+
+    Inherits from the Recognizer class.
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-    def domain_learning_phase(self, base_goals: List[str], train_configs: List):
+    def domain_learning_phase(self, base_goals: list[str], train_configs: list):
+        """
+        Perform the domain learning phase.
+
+        Args:
+            base_goals (List[str]): The base goals for the learning phase.
+            train_configs (List): The training configurations.
+
+        """
         self.original_train_configs = train_configs
 
 
 # a recognizer that needs to train agents for every new goal as part of the goal adaptation phase (that's why it needs dynamic train configs)
 class GaAgentTrainerRecognizer(Recognizer):
+    """
+    A class representing a recognizer for GaAgentTrainer.
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     @abstractmethod
-    def goals_adaptation_phase(self, dynamic_goals: List[str], dynamic_train_configs):
-        pass
+    def goals_adaptation_phase(self, dynamic_goals: list[str], dynamic_train_configs):
+        """
+        Perform the goals adaptation phase.
+
+        Args:
+            dynamic_goals (List[str]): The list of dynamic goals.
+            dynamic_train_configs: The dynamic training configurations.
 
-    def domain_learning_phase(self, base_goals: List[str], train_configs: List):
+        Returns:
+            None
+        """
+
+    def domain_learning_phase(self, base_goals: list[str], train_configs: list):
+        """
+        Perform the domain learning phase.
+
+        Args:
+            base_goals (List[str]): List of base goals.
+            train_configs (List): List of training configurations.
+
+        Returns:
+            None
+        """
         super().domain_learning_phase(base_goals, train_configs)
 
 
 class GaAdaptingRecognizer(Recognizer):
+    """
+    A recognizer that doesn't require more training given a set of new goals, hence it doesn't receive train configs in the goal adaptation phase.
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     @abstractmethod
-    def goals_adaptation_phase(self, dynamic_goals: List[str]):
-        pass
+    def goals_adaptation_phase(self, dynamic_goals: list[str]):
+        """
+        Perform the goals adaptation phase.
+
+        Args:
+            dynamic_goals (List[str]): A list of dynamic goals to be adapted.
+
+        Returns:
+            None
+        """

gr_libs/tutorials/draco_panda_tutorial.py

@@ -0,0 +1,58 @@
+import numpy as np
+from stable_baselines3 import PPO
+
+from gr_libs import Draco
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PANDA
+from gr_libs.metrics import mean_wasserstein_distance
+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
+
+
+def run_draco_panda_tutorial():
+    recognizer = Draco(
+        domain_name=PANDA,
+        env_name="PandaMyReachDense",
+        evaluation_function=mean_wasserstein_distance,  # or mean_p_value
+    )
+
+    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]]),
+        ],
+        dynamic_train_configs=[(PPO, 200000), (PPO, 200000), (PPO, 200000)],
+    )
+    # 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,
+        env_prop=env_property,
+        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
+        with_dict=True,
+    )
+    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 DRACO: {closest_goal}\nactual goal actor aimed towards: [-0.1, -0.1, 0.1]"
+    )
+
+
+if __name__ == "__main__":
+    run_draco_panda_tutorial()

gr_libs/tutorials/draco_parking_tutorial.py

@@ -0,0 +1,56 @@
+from stable_baselines3 import SAC, TD3
+
+from gr_libs import Draco
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PARKING, ParkingProperty
+from gr_libs.metrics import mean_wasserstein_distance
+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
+
+
+def run_draco_parking_tutorial():
+    recognizer = Draco(
+        domain_name=PARKING,
+        env_name="Parking-S-14-PC-",
+        evaluation_function=mean_wasserstein_distance,  # or mean_p_value
+    )
+
+    recognizer.goals_adaptation_phase(
+        dynamic_goals=["1", "11", "21"],
+        dynamic_train_configs=[(SAC, 200000), (SAC, 200000), (SAC, 200000)],
+    )
+
+    property_type = domain_to_env_property(PARKING)
+    env_property = property_type("Parking-S-14-PC-")
+    # 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",
+        env_prop=env_property,
+        algorithm=TD3,
+        num_timesteps=400000,
+    )
+    actor.learn()
+
+    full_sequence = actor.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,  # the noise that's added to the actions
+        with_dict=True,
+    )
+
+    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 GCDRACO: {closest_goal}\nactual goal actor aimed towards: 11"
+    )
+
+
+if __name__ == "__main__":
+    run_draco_parking_tutorial()

{tutorials → gr_libs/tutorials}/gcdraco_panda_tutorial.py

@@ -1,16 +1,12 @@
+import numpy as np
 from stable_baselines3 import PPO, SAC
-from gr_libs.metrics import (
-    stochastic_amplified_selection,
-    mean_p_value,
-    mean_wasserstein_distance,
-)
+
 from gr_libs import GCDraco
-from gr_libs.environment.utils.utils import domain_to_env_property
-import numpy as np
+from gr_libs.environment._utils.utils import domain_to_env_property
 from gr_libs.environment.environment import PANDA, PandaProperty
+from gr_libs.metrics import mean_wasserstein_distance, stochastic_amplified_selection
 from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
 from gr_libs.ml.utils.format import random_subset_with_order
-import gr_envs.panda_scripts
 
 
 def run_gcdraco_panda_tutorial():
@@ -30,7 +26,7 @@ def run_gcdraco_panda_tutorial():
             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 #

{tutorials → gr_libs/tutorials}/gcdraco_parking_tutorial.py

@@ -1,15 +1,11 @@
 from stable_baselines3 import PPO, TD3
-from gr_libs.metrics import (
-    stochastic_amplified_selection,
-    mean_p_value,
-    mean_wasserstein_distance,
-)
+
 from gr_libs import GCDraco
-from gr_libs.environment.utils.utils import domain_to_env_property
+from gr_libs.environment._utils.utils import domain_to_env_property
 from gr_libs.environment.environment import PARKING, ParkingProperty
+from gr_libs.metrics import mean_wasserstein_distance, stochastic_amplified_selection
 from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
 from gr_libs.ml.utils.format import random_subset_with_order
-import gr_envs
 
 
 def run_gcdraco_parking_tutorial():

{tutorials → gr_libs/tutorials}/graml_minigrid_tutorial.py

@@ -1,9 +1,9 @@
+from gr_libs import ExpertBasedGraml
+from gr_libs.environment._utils.utils import domain_to_env_property
 from gr_libs.environment.environment import MINIGRID, QLEARNING
-from gr_libs.environment.utils.utils import domain_to_env_property
 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():

{tutorials → gr_libs/tutorials}/graml_panda_tutorial.py

@@ -1,17 +1,12 @@
 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 import GCGraml
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PANDA, PandaProperty
 from gr_libs.metrics.metrics import stochastic_amplified_selection
-from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent, GCDeepRLAgent
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent
 from gr_libs.ml.utils.format import random_subset_with_order
-from gr_libs import GCGraml
 
 
 def run_graml_panda_tutorial():

{tutorials → gr_libs/tutorials}/graml_parking_tutorial.py

@@ -1,15 +1,11 @@
-from stable_baselines3 import PPO, SAC, TD3
-from gr_libs.environment.environment import (
-    PARKING,
-    EnvProperty,
-    GCEnvProperty,
-    ParkingProperty,
-)
-from gr_libs.environment.utils.utils import domain_to_env_property
+from stable_baselines3 import PPO, TD3
+
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PARKING, ParkingProperty
 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, GCGraml
+from gr_libs.recognizer.graml.graml_recognizer import GCGraml
 
 
 def run_graml_parking_tutorial():

{tutorials → gr_libs/tutorials}/graml_point_maze_tutorial.py

@@ -1,6 +1,7 @@
 from stable_baselines3 import SAC, TD3
+
+from gr_libs.environment._utils.utils import domain_to_env_property
 from gr_libs.environment.environment import POINT_MAZE, PointMazeProperty
-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

{tutorials → gr_libs/tutorials}/graql_minigrid_tutorial.py

@@ -1,9 +1,9 @@
+from gr_libs import Graql
+from gr_libs.environment._utils.utils import domain_to_env_property
 from gr_libs.environment.environment import MINIGRID, QLEARNING
-from gr_libs.environment.utils.utils import domain_to_env_property
 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():

{gr_libs-0.1.8.dist-info → gr_libs-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.8
+Version: 0.2.2
 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>
@@ -106,6 +106,25 @@ If you prefer using Conda, follow these steps:
 
 For any issues or troubleshooting, please refer to the repository's issue tracker.
 
+## Supported Algorithms
+
+Successors of algorithms that don't differ in their specifics are added in parentheses after the algorithm name. For example, since GC-DRACO and DRACO share the same column values, they're written on one line as DRACO (GC).
+
+| **Algorithm** | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** |
+|--------------|--------------|------------------------|------------------|------------------|--------------|--------------|--------------|--------------|--------------|
+| GRAQL       | ❌           | ✅                     | ✅                | ❌                | ✅                | ❌                | ❌           | ✅           | ❌           |
+| DRACO (GC)  | ❌           | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ❌           |
+| GRAML (GC, BG) | ✅        | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ✅           |
+
+## Supported Domains
+
+| **Domain**  | **Action Space** | **State Space** |
+|------------|----------------|----------------|
+| Minigrid   | Discrete       | Discrete       |
+| PointMaze  | Continuous     | Continuous     |
+| Parking    | Continuous     | Continuous     |
+| Panda      | Continuous     | Continuous     |
+
 ## Usage Guide
 
 After installing GRLib, you will have access to custom Gym environments, allowing you to set up and execute an Online Dynamic Goal Recognition (ODGR) scenario with the algorithm of your choice.
@@ -116,9 +135,10 @@ Tutorials demonstrating basic ODGR scenarios is available in the sub-package `tu
 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
+pip install gdown
 python download_dataset.py
 ```
-
+Alternatively, you can visit the google-drive links where download_dataset.py points to and manually download the zipped folders, and unzip them into the project directory.
 An alternative is to use our docker image, which includes the dataset in it.
 You can:
 1. pull the image:
@@ -191,42 +211,77 @@ docker run -it ghcr.io/MatanShamir1/gr_test_base:latest bash
 
 The `consts.py` file contains predefined ODGR problem configurations. You can use existing configurations or define new ones.
 
-To execute a single task using the configuration file:
+To execute an ODGR problem using the configuration file, you specify a recognizer, a domain, a gym environment within that domain and the task:
 ```sh
-python odgr_executor.py --recognizer MCTSBasedGraml --domain minigrid --task L1 --minigrid_env MinigridSimple
+python odgr_executor.py --recognizer ExpertBasedGraml --domain minigrid --task L1 --env_name MiniGrid-SimpleCrossingS13N4
 ```
 
-## Supported Algorithms
+If you also add the flag:
+```sh
+ --collect_stats
+```
+to the cmd, 3 kinds of outputs will be generated from the ODGR problem's execution:
+a. Into:
+```sh
+outputs\\minigrid\MiniGrid-SimpleCrossingS13N4\MiniGrid-SimpleCrossingS13N4\L1\experiment_results
+```
+a .pkl and a .txt summary in a dictionary format will be generated, including the summary of all ODGR executions, including runtime and overall accuracies for all lengths and types of input sequences.
 
-Successors of algorithms that don't differ in their specifics are added in parentheses after the algorithm name. For example, since GC-DRACO and DRACO share the same column values, they're written on one line as DRACO (GC).
+b. Into:
+```sh
+outputs\ExpertBasedGraml\minigrid\MiniGrid-SimpleCrossingS13N4\policy_sequences\MiniGrid-SimpleCrossingS13N4-DynamicGoal-1x11-v0_inference_seq/plan_image.png
+```
+a visulzation of the sequence the agent generated will be dumped, either in a png or an mp4 format, depending on the domain, for debugability.
 
-| **Algorithm** | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** |
-|--------------|--------------|------------------------|------------------|------------------|--------------|--------------|--------------|--------------|--------------|
-| GRAQL       | ❌           | ✅                     | ✅                | ❌                | ✅                | ❌                | ❌           | ✅           | ❌           |
-| DRACO (GC)  | ❌           | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ❌           |
-| GRAML (GC, BG) | ✅        | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ✅           |
+c. Into:
+either:
+```sh
+outputs\ExpertBasedGraml\minigrid\MiniGrid-SimpleCrossingS13N4\goal_embeddings
+```
+In Graml algorithms, or:
+```sh
+outputs\Graql\minigrid\MiniGrid-SimpleCrossingS13N4\confidence
+```
+In GRAsRL algorithms,
+pickled results from which confidence of the results can be obtained, for offline analysis.
 
-## Supported Domains
+For GRAsRL outputs, for every possible goal, the likelihood of it being the true goal from the input sequence, based on the policy distance metric.
 
-| **Domain**  | **Action Space** | **State Space** |
-|------------|----------------|----------------|
-| Minigrid   | Discrete       | Discrete       |
-| PointMaze  | Continuous     | Continuous     |
-| Parking    | Continuous     | Continuous     |
-| Panda      | Continuous     | Continuous     |
+For GRAML outputs, the embeddings of the sequences are pickled for every goal-directed sequence. Offline, since, since in the embdding space of GRAML's metric model- sequences towards the same sequences are close and vice versa, one could reproduce the most likely goal by measuring the elementwise vector distance of the embeddings, and retrieve a confidence of it.
 
 ## Running Experiments
 
-The repository provides benchmark domains and scripts for analyzing experimental results. The `scripts` directory contains tools for processing and visualizing results.
+In light of the previous section, the user should already know how to scale the experiments using odgr_executor, and they should also understand how to use the 3 types of outputs for offline analysis of the algorithms.
+gr_libs also provides another scaling method to run odgr_executor on multiple domains and environments, for many ODGR problems, as well as python scripts for analysis of these results, to create plots and statistics over the executions.
+
+### Scaling odgr_executor runs
+A part of the contribution of this package is standardizing the evaluations of MDP-based GR frameworks.
+consts.py provides a set of ODGR problems on which the framework can be evaluated.
+The 'evaluations' sub-package provides scripts to analyze the results of the all_experiments.py execution, done over the ODGR the problems defined at consts.py.
 
-1. **`analyze_results_cross_alg_cross_domain.py`**
-   - Runs without arguments.
-   - Reads data from `get_experiment_results_path` (e.g., `dataset/graml/minigrid/continuing/.../experiment_results.pkl`).
-   - Generates plots comparing algorithm performance across domains.
+In order to parallelize executions of odgr_executor.py, you can edit all_experiments.py with your combination of domains, environments and tasks.
+This script use multiprocessing to simultaniously execute many odgr_executor.py python executions as child processes.
 
-2. **`generate_task_specific_statistics_plots.py`**
-   - Produces task-specific accuracy and confidence plots.
-   - Generates a confusion matrix displaying confidence levels.
-   - Example output paths:
-     - `figures/point_maze/obstacles/graql_point_maze_obstacles_fragmented_stats.png`
-     - `figures/point_maze/obstacles/graml_point_maze_obstacles_conf_mat.png`
+It logs failures and successful executions for debugability.
+
+After execution, another level of abstraction for the results is created. For example, when running for Graql in the minigrid domain:
+```sh
+outputs\summaries\detailed_summary_minigrid_Graql.txt
+```
+Will show the accuracies for every ODGR problem, for every percentage and type of input in a table-like .txt format, whike:
+```sh
+outputs\summaries\compiled_summary_minigrid_Graql.txt
+```
+Will show the same results in a more compact summary.
+
+### Using analysis scripts
+The repository provides benchmark domains and scripts for analyzing experimental results. The `evaluation` directory contains tools for processing and visualizing the results from odgr_executor.py and all_experiments.py.
+Please follow the README.md file in the 'evaluation' directory for more details.
+
+## For Developers
+Developers will need to work slightly different: instead of installing the packages, they need to clone the repos and either install them as editables or add their paths to PYTHONPATH so they will function as packages effectively.
+Additional packages to install as a developer:
+```sh
+pip install pre-commit
+pre-commit install
+```

gr_libs-0.2.2.dist-info/RECORD

@@ -0,0 +1,71 @@
+gr_libs/__init__.py,sha256=XGx0_nWGgy-1zEQUXHRBs3TTb13jX9yOxVvSaavCkBk,376
+gr_libs/_version.py,sha256=OjGGK5TcHVG44Y62aAqeJH4CskkZoY9ydbHOtCDew50,511
+gr_libs/all_experiments.py,sha256=0Xm1KZ1YDWGcAiYKc6IilZ-UyVuxm77iZNsUVzTURqY,11357
+gr_libs/odgr_executor.py,sha256=AdO5qpQ6fZcVRxJg0O-mSKDXim3gVQbq8vSmfx0AjQk,10615
+gr_libs/_evaluation/__init__.py,sha256=trZ-4PyOhzEEK_TvQLfbnNFcqYuN6SdRjDkkAdW6MW8,78
+gr_libs/_evaluation/_analyze_results_cross_alg_cross_domain.py,sha256=ksguC1zeokjpd_ItC5e6MX8HE9qEtjw-uxCXzwGsO88,9863
+gr_libs/_evaluation/_generate_experiments_results.py,sha256=Nj2XLDJ-g9Vn_3oA3tEDu8qWQcIT25Hf_tRySm00oGc,5163
+gr_libs/_evaluation/_generate_task_specific_statistics_plots.py,sha256=Jgst3PW-XTu1JHWhyl73zi4mqoUI3U3dHLIUemKSx7c,19051
+gr_libs/_evaluation/_get_plans_images.py,sha256=a_e97aOMiZ8toBiAIzJCx75lF9RLiVfxROYvcoNy6rM,2729
+gr_libs/_evaluation/_increasing_and_decreasing_.py,sha256=1VOHrriv9mdhc1fxNjVAsu-sO77KRnscbmFXNUub0YU,3868
+gr_libs/environment/__init__.py,sha256=xCCzTFDrj_ijdLoZ-PzGyyYDeU2aoW19X1da76_x9iM,1458
+gr_libs/environment/environment.py,sha256=G3XXuhJDtduOtNeMCbwbMAygfP55AI07Aufs9QrggWQ,16389
+gr_libs/environment/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/environment/_utils/utils.py,sha256=dKuWoUpyuGSJL6qHQfvvJnFf4g-Rh1t2ykuRNrsIvP8,614
+gr_libs/metrics/__init__.py,sha256=dQo4cMqrOB2-VLDxTIGryCm14mUnmEXs4F8jqcgNsY4,145
+gr_libs/metrics/metrics.py,sha256=tpjr4hKt5AGft5H2YxkbF0O8La5JZQaOmnkyjptD2M8,13430
+gr_libs/ml/__init__.py,sha256=xX9InKnWhYm8e0Lhsnnm0H68yBPTNEfq756w95xv-98,83
+gr_libs/ml/agent.py,sha256=ea1yRltKX0LSpRMnpAQLRKvvKoLMQz9MgMeWBPhQISw,2095
+gr_libs/ml/consts.py,sha256=vsEB1nk5V_qP3FjNlv4vBKeTTFngV3RNaNp6fWnmEz0,366
+gr_libs/ml/base/__init__.py,sha256=f63VN3Lv4tQp3dAZjtT78PGV5XuOD8WlU4svy43LZrU,123
+gr_libs/ml/base/rl_agent.py,sha256=Ewqu583gUkgRmeGWCJgkyDBKxTqQnN4qa2vxq0-ydoE,3843
+gr_libs/ml/neural/__init__.py,sha256=vGdjx1KzlB9UxNRwkAeYBEoYdVtRdhj0M4mtWuzqvU8,55
+gr_libs/ml/neural/deep_rl_learner.py,sha256=iy0N0BaUW3jRttLYUteApNWBI5pIYZTjJn2v32UVUQ4,26950
+gr_libs/ml/neural/utils/__init__.py,sha256=Av5wB2eSHR7spHqZFdgau_9EJV0FmijaYqXeyGMwktQ,69
+gr_libs/ml/neural/utils/dictlist.py,sha256=ORFez_KmaCzraStF97hxdgCAAALP4Er8u3e9RcqlvhM,1030
+gr_libs/ml/planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/planner/mcts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/planner/mcts/mcts_model.py,sha256=Cv9hDrxTSK5tiaqPqp6-oO68EbETWlvRFweVRfwfjgg,27827
+gr_libs/ml/planner/mcts/_utils/__init__.py,sha256=0ccEf23-6VIenUSrlVFCq0VNVDkCHHNzBw7jR09UiO4,46
+gr_libs/ml/planner/mcts/_utils/node.py,sha256=LcbBjzURMDF4v_Lvz24dyhhW5xb1xQKWdPkue-2lNLM,1056
+gr_libs/ml/planner/mcts/_utils/tree.py,sha256=ua_7pN00K7ECm6fk0TdRpDTe-z4J4iC6f84GCC0ceKc,3399
+gr_libs/ml/sequential/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/ml/sequential/_lstm_model.py,sha256=3fXduJt1BkA2dPzA_jKInmZvUd1UpThHE8kqNCDCul0,10693
+gr_libs/ml/tabular/__init__.py,sha256=yzHIPrn1lqVEDJbLbSz7RzNSr8IjU4TBdP0pqzQSFGU,32
+gr_libs/ml/tabular/state.py,sha256=ImpIrYWF80PB-4EeQ2Q9nO7jMZ2s0hGbgsir1ZtsO88,700
+gr_libs/ml/tabular/tabular_q_learner.py,sha256=eZ4Db-YgzQd4DIpFl4DvO7zVM-w2mHGFNk18-5ZmB4c,20122
+gr_libs/ml/tabular/tabular_rl_agent.py,sha256=bL8Rk4dMY5HmeyVVmo986ZOizISfArskxLjf5DL87Uk,4205
+gr_libs/ml/utils/__init__.py,sha256=-shnIzZCGBxZfcpep39bIoBKYED-SIN8I_HFUkVjay0,164
+gr_libs/ml/utils/env.py,sha256=AWVN0OXYmFU-J3FUiwvEAIY93Suf1oL6VNcxtyWJraM,171
+gr_libs/ml/utils/format.py,sha256=Vn2l7zmfqZ9Hq2pk2nlzQuVElmVyXr6nME6GsVNvVPE,1068
+gr_libs/ml/utils/math.py,sha256=7Au9L-FHE7eB1ygLbbuR6AhZK6kq8D_9srVtu4iDMPk,429
+gr_libs/ml/utils/other.py,sha256=93oaveiHUzWt_rCDVqybrpHdAfI3UBPCto31Nm5yT0Y,506
+gr_libs/ml/utils/storage.py,sha256=CgZHWcC3GovKe-U3Cvwz0s5qCbBrYHY6w_CV-LnTquc,3791
+gr_libs/problems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/problems/consts.py,sha256=kgmaUi3wbHvcBfnIaXT8D79J_cD1yTrwgha6k3Y429Y,62096
+gr_libs/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/recognizer.py,sha256=gtUttI1473co5ZHgO7-wQ7HL-aYJp0S4X6goqVYyT24,3091
+gr_libs/recognizer/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/_utils/format.py,sha256=eCoqEwv7YdLrF5nb-xAbDXxQ-ogvq_DHf9I2uwdfv-0,512
+gr_libs/recognizer/gr_as_rl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/gr_as_rl/gr_as_rl_recognizer.py,sha256=ztucO7YRZ3mZDGdt98OUAu_DJHVgUhUEvIngL2swfCE,9705
+gr_libs/recognizer/graml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gr_libs/recognizer/graml/_gr_dataset.py,sha256=JChqXOh7TP8yu-zQPCQ34ghw7iJFnAzd2FkeOyndvFk,10038
+gr_libs/recognizer/graml/graml_recognizer.py,sha256=M-tvipAMn_tiWbM3M74D5zH8yKbPEwR-sKTQy3FZT3E,26058
+gr_libs/tutorials/draco_panda_tutorial.py,sha256=9_scjcyMjkjw8l6g9E-GKOrFTxsIIndW_J1WKjE6-wo,2146
+gr_libs/tutorials/draco_parking_tutorial.py,sha256=jjbNzSv5l4EvjydwslNYh51xHoIkNmcjPbi0YL6WAeA,1896
+gr_libs/tutorials/gcdraco_panda_tutorial.py,sha256=KsYStJPk9vI7PUuJrwBaMcQ5a9GT-00-DGJgqRmYvgs,2230
+gr_libs/tutorials/gcdraco_parking_tutorial.py,sha256=wvhwIwXw_h_VP4OBdsnv2rn9WTTaXJXA_xZ8mLHxcmg,2053
+gr_libs/tutorials/graml_minigrid_tutorial.py,sha256=msw19nRKAFUJGZy0JNym1At3Zoe5cGxppt24xcElLTQ,2205
+gr_libs/tutorials/graml_panda_tutorial.py,sha256=DC0AyiZswc5zOKFd0xTYU72ugaCLlf7xtnOGFsmv7MQ,2140
+gr_libs/tutorials/graml_parking_tutorial.py,sha256=Qf39bdpF4lgppKlDO3qa1CfswmbubqKBXJlPMn2PfhI,1941
+gr_libs/tutorials/graml_point_maze_tutorial.py,sha256=L95_2u1SA1aZJS-C4dQdq-97Sv6nFYNve2FAX2p5_Mc,2188
+gr_libs/tutorials/graql_minigrid_tutorial.py,sha256=HT8kCFNbZXAraIau9wtgC_aW8xg-QNRZB2lcpGm3yWk,1941
+tests/test_draco.py,sha256=oIeTDgn6pt3RfTC-RPX3Bw5cG4BThxRGH3z8en3TX0M,385
+tests/test_gcdraco.py,sha256=vV6rp7PkJJk_WpAfRekb197QiMHjXXApqrBiLG9RTwo,308
+tests/test_graml.py,sha256=amSikMWrGS9BNVSXGNKc1n5tfRl-FfgCsyHYsJtduD4,608
+tests/test_graql.py,sha256=KxVKx6rcSCbN-PjxR2DFoKcILRUmMDz0dTM5SvJZMXg,154
+gr_libs-0.2.2.dist-info/METADATA,sha256=0hqzG9XaGJmqfJ36sKLPnlU1lFUqHdOr7if1icu1sV0,12992
+gr_libs-0.2.2.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+gr_libs-0.2.2.dist-info/top_level.txt,sha256=Yzc_VSW3gzbVM7ZtlV4r6VXmfAC8WXqGVUgK1r6JcLs,14
+gr_libs-0.2.2.dist-info/RECORD,,

{gr_libs-0.1.8.dist-info → gr_libs-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gr_libs-0.2.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+gr_libs
+tests

tests/test_draco.py

@@ -0,0 +1,14 @@
+from gr_libs.tutorials.draco_panda_tutorial import run_draco_panda_tutorial
+from gr_libs.tutorials.draco_parking_tutorial import run_draco_parking_tutorial
+
+
+def test_draco_panda_tutorial():
+    run_draco_panda_tutorial()
+
+
+def test_draco_parking_tutorial():
+    run_draco_parking_tutorial()
+
+if __name__ == "__main__":
+    test_draco_panda_tutorial()
+    test_draco_parking_tutorial()

tests/test_gcdraco.py

@@ -1,5 +1,5 @@
-from tutorials.gcdraco_panda_tutorial import run_gcdraco_panda_tutorial
-from tutorials.gcdraco_parking_tutorial import run_gcdraco_parking_tutorial
+from gr_libs.tutorials.gcdraco_panda_tutorial import run_gcdraco_panda_tutorial
+from gr_libs.tutorials.gcdraco_parking_tutorial import run_gcdraco_parking_tutorial
 
 
 def test_gcdraco_panda_tutorial():

tests/test_graml.py

@@ -1,7 +1,7 @@
-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
+from gr_libs.tutorials.graml_minigrid_tutorial import run_graml_minigrid_tutorial
+from gr_libs.tutorials.graml_panda_tutorial import run_graml_panda_tutorial
+from gr_libs.tutorials.graml_parking_tutorial import run_graml_parking_tutorial
+from gr_libs.tutorials.graml_point_maze_tutorial import run_graml_point_maze_tutorial
 
 
 def test_graml_minigrid_tutorial():

tests/test_graql.py

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