gr-libs 0.1.7.post0__tar.gz → 0.2.2__tar.gz

{gr_libs-0.1.7.post0 → gr_libs-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.1.7.post0
+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.1.7.post0 → gr_libs-0.2.2}/README.md

@@ -77,6 +77,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.
@@ -87,9 +106,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:
@@ -162,42 +182,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.1.7.post0 → gr_libs-0.2.2}/gr_libs/__init__.py

@@ -1,5 +1,8 @@
+"""gr_libs: Baselines for goal recognition executions on gym environments."""
+
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco, Graql
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql
+
 try:
     from ._version import version as __version__
 except ImportError:

gr_libs-0.2.2/gr_libs/_evaluation/__init__.py

@@ -0,0 +1 @@
+""" This is a directory that includes scripts for analysis of GR results. """

gr_libs-0.2.2/gr_libs/_evaluation/_analyze_results_cross_alg_cross_domain.py

@@ -0,0 +1,260 @@
+import copy
+import os
+
+import dill
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.interpolate import make_interp_spline
+from scipy.ndimage import gaussian_filter1d
+
+from gr_libs.ml.utils.storage import get_experiment_results_path
+
+
+def smooth_line(x, y, num_points=300):
+    x_smooth = np.linspace(np.min(x), np.max(x), num_points)
+    spline = make_interp_spline(x, y, k=3)  # Cubic spline
+    y_smooth = spline(x_smooth)
+    return x_smooth, y_smooth
+
+
+if __name__ == "__main__":
+
+    fragmented_accuracies = {
+        "ExpertBasedGraml": {
+            "minigrid": {
+                "obstacles": {"0.3": [], "0.5": [], "0.7": [], "0.9": [], "1": []},
+                "lava_crossing": {"0.3": [], "0.5": [], "0.7": [], "0.9": [], "1": []},
+            }
+        },
+        "Graql": {
+            "minigrid": {
+                "obstacles": {"0.3": [], "0.5": [], "0.7": [], "0.9": [], "1": []},
+                "lava_crossing": {"0.3": [], "0.5": [], "0.7": [], "0.9": [], "1": []},
+            }
+        },
+    }
+
+    continuing_accuracies = copy.deepcopy(fragmented_accuracies)
+
+    # domains = ['panda', 'minigrid', 'point_maze', 'parking']
+    domains = ["minigrid"]
+    tasks = ["L1", "L2", "L3", "L4", "L5"]
+    percentages = ["0.3", "0.5", "1"]
+
+    for partial_obs_type, accuracies, is_same_learn in zip(
+        ["fragmented", "continuing"],
+        [fragmented_accuracies, continuing_accuracies],
+        [False, True],
+    ):
+        for domain in domains:
+            for env in accuracies["ExpertBasedGraml"][domain].keys():
+                for task in tasks:
+                    graml_res_file_path = f"{get_experiment_results_path(domain, env, task, 'ExpertBasedGraml')}.pkl"
+                    graql_res_file_path = (
+                        f"{get_experiment_results_path(domain, env, task, 'Graql')}.pkl"
+                    )
+                    if os.path.exists(graml_res_file_path):
+                        with open(graml_res_file_path, "rb") as results_file:
+                            results = dill.load(results_file)
+                            for percentage in accuracies["expertbasedgraml"][domain][
+                                env
+                            ].keys():
+                                accuracies["expertbasedgraml"][domain][env][
+                                    percentage
+                                ].append(results[percentage]["accuracy"])
+                    else:
+                        assert False, f"no file for {graml_res_file_path}"
+                    if os.path.exists(graql_res_file_path):
+                        with open(graql_res_file_path, "rb") as results_file:
+                            results = dill.load(results_file)
+                            for percentage in accuracies["expertbasedgraml"][domain][
+                                env
+                            ].keys():
+                                accuracies["Graql"][domain][env][percentage].append(
+                                    results[percentage]["accuracy"]
+                                )
+                    else:
+                        assert False, f"no file for {graql_res_file_path}"
+
+    plot_styles = {
+        (
+            "expertbasedgraml",
+            "fragmented",
+            0.3,
+        ): "g--o",  # Green dashed line with circle markers
+        (
+            "expertbasedgraml",
+            "fragmented",
+            0.5,
+        ): "g--s",  # Green dashed line with square markers
+        (
+            "expertbasedgraml",
+            "fragmented",
+            0.7,
+        ): "g--^",  # Green dashed line with triangle-up markers
+        (
+            "expertbasedgraml",
+            "fragmented",
+            0.9,
+        ): "g--d",  # Green dashed line with diamond markers
+        (
+            "expertbasedgraml",
+            "fragmented",
+            1.0,
+        ): "g--*",  # Green dashed line with star markers
+        (
+            "expertbasedgraml",
+            "continuing",
+            0.3,
+        ): "g-o",  # Green solid line with circle markers
+        (
+            "expertbasedgraml",
+            "continuing",
+            0.5,
+        ): "g-s",  # Green solid line with square markers
+        (
+            "expertbasedgraml",
+            "continuing",
+            0.7,
+        ): "g-^",  # Green solid line with triangle-up markers
+        (
+            "expertbasedgraml",
+            "continuing",
+            0.9,
+        ): "g-d",  # Green solid line with diamond markers
+        (
+            "expertbasedgraml",
+            "continuing",
+            1.0,
+        ): "g-*",  # Green solid line with star markers
+        ("Graql", "fragmented", 0.3): "b--o",  # Blue dashed line with circle markers
+        ("Graql", "fragmented", 0.5): "b--s",  # Blue dashed line with square markers
+        (
+            "Graql",
+            "fragmented",
+            0.7,
+        ): "b--^",  # Blue dashed line with triangle-up markers
+        ("Graql", "fragmented", 0.9): "b--d",  # Blue dashed line with diamond markers
+        ("Graql", "fragmented", 1.0): "b--*",  # Blue dashed line with star markers
+        ("Graql", "continuing", 0.3): "b-o",  # Blue solid line with circle markers
+        ("Graql", "continuing", 0.5): "b-s",  # Blue solid line with square markers
+        ("Graql", "continuing", 0.7): "b-^",  # Blue solid line with triangle-up markers
+        ("Graql", "continuing", 0.9): "b-d",  # Blue solid line with diamond markers
+        ("Graql", "continuing", 1.0): "b-*",  # Blue solid line with star markers
+    }
+
+    def average_accuracies(accuracies, domain):
+        avg_acc = {
+            algo: {perc: [] for perc in percentages}
+            for algo in ["ExpertBasedGraml", "Graql"]
+        }
+
+        for algo in avg_acc.keys():
+            for perc in percentages:
+                for env in accuracies[algo][domain].keys():
+                    env_acc = accuracies[algo][domain][env][
+                        perc
+                    ]  # list of 5, averages for L111 to L555.
+                    if env_acc:
+                        avg_acc[algo][perc].append(np.array(env_acc))
+
+        for algo in avg_acc.keys():
+            for perc in percentages:
+                if avg_acc[algo][perc]:
+                    avg_acc[algo][perc] = np.mean(np.array(avg_acc[algo][perc]), axis=0)
+
+        return avg_acc
+
+    def plot_domain_accuracies(
+        ax,
+        fragmented_accuracies,
+        continuing_accuracies,
+        domain,
+        sigma=1,
+        line_width=1.5,
+    ):
+        fragmented_avg_acc = average_accuracies(fragmented_accuracies, domain)
+        continuing_avg_acc = average_accuracies(continuing_accuracies, domain)
+
+        x_vals = np.arange(1, 6)  # Number of goals
+
+        # Create "waves" (shaded regions) for each algorithm
+        for algo in ["ExpertBasedGraml", "Graql"]:
+            fragmented_y_vals_by_percentage = []
+            continuing_y_vals_by_percentage = []
+
+            for perc in percentages:
+                fragmented_y_vals = np.array(fragmented_avg_acc[algo][perc])
+                continuing_y_vals = np.array(continuing_avg_acc[algo][perc])
+
+                # Smooth the trends using Gaussian filtering
+                fragmented_y_smoothed = gaussian_filter1d(
+                    fragmented_y_vals, sigma=sigma
+                )
+                continuing_y_smoothed = gaussian_filter1d(
+                    continuing_y_vals, sigma=sigma
+                )
+
+                fragmented_y_vals_by_percentage.append(fragmented_y_smoothed)
+                continuing_y_vals_by_percentage.append(continuing_y_smoothed)
+
+                ax.plot(
+                    x_vals,
+                    fragmented_y_smoothed,
+                    plot_styles[(algo, "fragmented", float(perc))],
+                    label=f"{algo}, non-consecutive, {perc}",
+                    linewidth=0.5,  # Control line thickness here
+                )
+                ax.plot(
+                    x_vals,
+                    continuing_y_smoothed,
+                    plot_styles[(algo, "continuing", float(perc))],
+                    label=f"{algo}, consecutive, {perc}",
+                    linewidth=0.5,  # Control line thickness here
+                )
+
+        ax.set_xticks(x_vals)
+        ax.set_yticks(np.linspace(0, 1, 6))
+        ax.set_ylim([0, 1])
+        ax.set_title(f"{domain.capitalize()} Domain", fontsize=16)
+        ax.grid(True)
+
+    fig, axes = plt.subplots(
+        1, 4, figsize=(24, 6)
+    )  # Increase the figure size for better spacing (width 24, height 6)
+
+    # Generate each plot in a subplot, including both fragmented and continuing accuracies
+    for i, domain in enumerate(domains):
+        plot_domain_accuracies(
+            axes[i], fragmented_accuracies, continuing_accuracies, domain
+        )
+
+    # Set a single x-axis and y-axis label for the entire figure
+    fig.text(
+        0.5, 0.04, "Number of Goals", ha="center", fontsize=20
+    )  # Centered x-axis label
+    fig.text(
+        0.04, 0.5, "Accuracy", va="center", rotation="vertical", fontsize=20
+    )  # Reduced spacing for y-axis label
+
+    # Adjust subplot layout to avoid overlap
+    plt.subplots_adjust(
+        left=0.09, right=0.91, top=0.79, bottom=0.21, wspace=0.3
+    )  # More space on top (top=0.82)
+
+    # Place the legend above the plots with more space between legend and plots
+    handles, labels = axes[0].get_legend_handles_labels()
+    fig.legend(
+        handles,
+        labels,
+        loc="upper center",
+        ncol=4,
+        bbox_to_anchor=(0.5, 1.05),
+        fontsize=12,
+    )  # Moved above with bbox_to_anchor
+
+    # Save the figure and show it
+    save_dir = os.path.join("figures", "all_domains_accuracy_plots")
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    plt.savefig(os.path.join(save_dir, "accuracy_plots_smooth.png"), dpi=300)