gr-libs 0.1.8__py3-none-any.whl → 0.2.5__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():
@@ -21,8 +17,12 @@ def run_gcdraco_panda_tutorial():
     )
 
     recognizer.domain_learning_phase(
-        base_goals=[np.array([PandaProperty.sample_goal()]) for _ in range(30)],
-        train_configs=[(SAC, 800000)],
+        {
+            "gc": {
+                "goals": [np.array([PandaProperty.sample_goal()]) for _ in range(30)],
+                "train_configs": [(SAC, 800000)],
+            }
+        }
     )
 
     recognizer.goals_adaptation_phase(
@@ -30,7 +30,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():
@@ -19,7 +15,9 @@ def run_gcdraco_parking_tutorial():
         evaluation_function=mean_wasserstein_distance,  # or mean_p_value
     )
 
-    recognizer.domain_learning_phase([i for i in range(1, 21)], [(PPO, 200000)])
+    recognizer.domain_learning_phase(
+        {"gc": {"goals": [i for i in range(1, 21)], "train_configs": [(PPO, 200000)]}}
+    )
     recognizer.goals_adaptation_phase(
         dynamic_goals=["1", "11", "21"]
         # no need for expert sequence generation since GCRL is used

{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():
@@ -12,18 +12,22 @@ def run_graml_minigrid_tutorial():
     )
 
     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)],
+        {
+            "bg": {
+                "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(

{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():
@@ -19,8 +14,12 @@ def run_graml_panda_tutorial():
         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)],
+        {
+            "gc": {
+                "goals": [np.array([PandaProperty.sample_goal()]) for _ in range(30)],
+                "train_configs": [(SAC, 800000)],
+            }
+        }
     )
     recognizer.goals_adaptation_phase(
         dynamic_goals=[

{tutorials → gr_libs/tutorials}/graml_parking_tutorial.py

@@ -1,21 +1,19 @@
-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():
     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.domain_learning_phase(
+        {"gc": {"goals": [i for i in range(1, 21)], "train_configs": [(PPO, 200000)]}}
+    )
     recognizer.goals_adaptation_phase(
         dynamic_goals=["1", "11", "21"]
         # no need for expert sequence generation since GCRL is used

{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
@@ -13,8 +14,21 @@ def run_graml_point_maze_tutorial():
     )
 
     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)],
+        {
+            "bg": {
+                "goals": [
+                    (9, 1),
+                    (9, 9),
+                    (1, 9),
+                    (3, 3),
+                    (3, 4),
+                    (8, 2),
+                    (3, 7),
+                    (2, 8),
+                ],
+                "train_configs": [(SAC, 200000) for _ in range(8)],
+            }
+        }
     )
 
     recognizer.goals_adaptation_phase(

{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.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.8
+Version: 0.2.5
 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,28 @@ 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** | **Supported Environments**                |
+|---------------------|----------------|---------------------------|---------------------|----------------------|----------------------|-----------------------|------------------|----------------|----------------|--------------------------------------------|
+| Graql               | ❌             | ✅                        | ✅                  | ❌                   | ✅                   | ❌                    | ❌               | ✅             | ❌             | Minigrid                                   |
+| Draco               | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | PointMaze, Panda Reach, Parking            |
+| GCDraco             | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | Panda Reach, Parking                       |
+| ExpertBasedGraml    | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Panda Reach, Parking                       |
+| BGGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Minigrid, PointMaze                        |
+| GCGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Panda Reach, Parking                       |
+
+## 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 +138,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 +214,85 @@ 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.
 
-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.
+### 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.
 
-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`
+#### Running all_experiments.py
+
+You can now run `all_experiments.py` with your desired combination of domains, environments, tasks, and recognizers directly from the command line, without editing the script:
+
+```sh
+python gr_libs/all_experiments.py \
+    --domains minigrid parking \
+    --envs MiniGrid-SimpleCrossingS13N4 Parking-S-14-PC- \
+    --tasks L1 L2 L3 L4 L5 \
+    --recognizers ExpertBasedGraml Graql \
+    --n 5
+```
+
+- `--domains`: List of domains to run experiments on.
+- `--envs`: List of environments (must be in the same order as domains).
+- `--tasks`: List of tasks (applied to all domain/env pairs).
+- `--recognizers`: List of recognizers/algorithms to evaluate.
+- `--n`: Number of times to execute each task (default: 5).
+
+This script uses multiprocessing to simultaneously execute many `odgr_executor.py` runs as child processes. It logs failures and successful executions for debugability.
+
+After execution, summary files are generated in `outputs/summaries/` for further analysis and plotting.
+
+### 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
+```