gr-libs 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

gr_libs/tutorials/gcaura_panda_tutorial.py

@@ -0,0 +1,168 @@
+import numpy as np
+from stable_baselines3 import PPO, SAC
+
+from gr_libs import GCAura
+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, 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_gcaura_panda_tutorial():
+    """
+    Tutorial for GCAura on the Panda environment.
+
+    This tutorial demonstrates:
+    1. Training a goal-conditioned model on a registered goal subspace (center area)
+    2. Adapting to goals both inside and outside this subspace
+    3. Testing inference on multiple goal types
+    """
+    print("Starting GCAura tutorial with Panda environment...")
+
+    print(f"Using training subspace with center-area goals")
+
+    # Initialize the recognizer with the center subspace environment
+    recognizer = GCAura(
+        domain_name=PANDA,
+        env_name="PandaMyReachDenseSubspaceCenterOnly-v3",  # Use the subspace environment
+        evaluation_function=mean_wasserstein_distance,
+        finetune_timesteps=50000,
+    )
+
+    # Domain learning phase - train on the center goal subspace
+    print("\nStarting domain learning phase - training on registered goal subspace...")
+    recognizer.domain_learning_phase(
+        {
+            "gc": {
+                "train_configs": [(SAC, 500000)],
+            }
+        }
+    )
+
+    # Define adaptation goals - mix of in-subspace and out-of-subspace goals
+    # Use predefined goals from our environment registration
+    in_subspace_goal = np.array([[0.0, 0.0, 0.1]])  # Center goal (in subspace)
+    out_subspace_goal1 = np.array([[-0.3, -0.3, 0.1]])  # Far corner (out of subspace)
+    out_subspace_goal2 = np.array([[0.2, 0.2, 0.1]])  # Far corner (out of subspace)
+
+    print(
+        "\nStarting goal adaptation phase with both in-subspace and out-of-subspace goals..."
+    )
+
+    # Goals adaptation phase with mixed goals
+    recognizer.goals_adaptation_phase(
+        dynamic_goals=[
+            in_subspace_goal,
+            out_subspace_goal1,
+            out_subspace_goal2,
+        ],
+    )
+
+    # Setup for testing
+    property_type = domain_to_env_property(PANDA)
+    env_property = property_type("PandaMyReachDense")
+
+    # Create test actor for in-subspace goal
+    print("\nCreating test actor for in-subspace goal...")
+    problem_name_in = env_property.goal_to_problem_str(in_subspace_goal)
+    actor_in = DeepRLAgent(
+        domain_name=PANDA,
+        problem_name=problem_name_in,
+        env_prop=env_property,
+        algorithm=PPO,
+        num_timesteps=250000,
+    )
+    actor_in.learn()
+
+    # Create test actor for out-of-subspace goal
+    print("\nCreating test actor for out-of-subspace goal...")
+    problem_name_out = env_property.goal_to_problem_str(out_subspace_goal1)
+    actor_out = DeepRLAgent(
+        domain_name=PANDA,
+        problem_name=problem_name_out,
+        env_prop=env_property,
+        algorithm=PPO,
+        num_timesteps=250000,
+    )
+    actor_out.learn()
+
+    # Test inference with in-subspace goal
+    print("\nTesting inference with in-subspace goal (should use base model)...")
+    full_sequence_in = actor_in.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_in = random_subset_with_order(
+        full_sequence_in, (int)(0.5 * len(full_sequence_in)), is_consecutive=False
+    )
+    recognized_goal_in = recognizer.inference_phase(
+        partial_sequence_in, in_subspace_goal, 0.5
+    )
+    print(f"Goal recognized for in-subspace sequence: {recognized_goal_in}")
+    print(f"Actual goal: {in_subspace_goal}")
+
+    assert str(recognized_goal_in) == str(
+        in_subspace_goal
+    ), f"In-subspace goal recognition failed. Expected goal does not match recognized goal {recognized_goal_in}."
+
+    # Test inference with out-of-subspace goal
+    print(
+        "\nTesting inference with out-of-subspace goal (should use fine-tuned model)..."
+    )
+    full_sequence_out = actor_out.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_out = random_subset_with_order(
+        full_sequence_out, (int)(0.5 * len(full_sequence_out)), is_consecutive=False
+    )
+    recognized_goal_out = recognizer.inference_phase(
+        partial_sequence_out, out_subspace_goal1, 0.5
+    )
+    print(f"Goal recognized for out-of-subspace sequence: {recognized_goal_out}")
+    print(f"Actual goal: {out_subspace_goal1}")
+
+    assert str(recognized_goal_out) == str(
+        out_subspace_goal1
+    ), f"Out-of-subspace goal recognition failed. Expected goal does not match recognized goal {recognized_goal_out}."
+
+    # Try another out-of-subspace goal
+    print("\nTesting inference with second out-of-subspace goal...")
+    problem_name_out2 = env_property.goal_to_problem_str(out_subspace_goal2)
+    actor_out2 = DeepRLAgent(
+        domain_name=PANDA,
+        problem_name=problem_name_out2,
+        env_prop=env_property,
+        algorithm=PPO,
+        num_timesteps=250000,
+    )
+    actor_out2.learn()
+
+    full_sequence_out2 = actor_out2.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_out2 = random_subset_with_order(
+        full_sequence_out2, (int)(0.5 * len(full_sequence_out2)), is_consecutive=False
+    )
+    recognized_goal_out2 = recognizer.inference_phase(
+        partial_sequence_out2, out_subspace_goal2, 0.5
+    )
+    print(
+        f"Goal recognized for second out-of-subspace sequence: {recognized_goal_out2}"
+    )
+    print(f"Actual goal: {out_subspace_goal2}")
+
+    assert str(recognized_goal_out2) == str(
+        out_subspace_goal2
+    ), f"Out-of-subspace goal recognition failed. Expected goal does not match recognized goal {recognized_goal_out2}."
+
+    print("\nGCAura tutorial completed successfully!")
+
+
+if __name__ == "__main__":
+    run_gcaura_panda_tutorial()

gr_libs/tutorials/gcaura_parking_tutorial.py

@@ -0,0 +1,167 @@
+from stable_baselines3 import SAC, TD3
+
+from gr_libs import GCAura
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import PARKING
+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
+
+
+def run_gcaura_parking_tutorial():
+    """
+    Tutorial for GCAura on the Parking environment.
+
+    This tutorial demonstrates:
+    1. Training a goal-conditioned model on a goal subspace (parking spots 1-10)
+    2. Adapting to goals both inside and outside this subspace
+    3. Testing inference on multiple goal types
+    """
+    print("Starting GCAura tutorial with Parking environment...")
+
+    print(f"Using training subspace with parking spots (1-10)")
+
+    # Initialize the recognizer with the standard parking environment
+    # We'll explicitly define the goal subspace in domain_learning_phase
+    recognizer = GCAura(
+        domain_name=PARKING,
+        env_name="Parking-S-14-PC--GI-8Y10Y13-v0",
+        evaluation_function=mean_wasserstein_distance,
+        finetune_timesteps=40000,  # Fine-tuning timesteps for out-of-subspace goals
+    )
+
+    # Domain learning phase - train on the goal subspace
+    print("\nStarting domain learning phase - training on goal subspace...")
+    recognizer.domain_learning_phase(
+        {
+            "gc": {
+                "train_configs": [(SAC, 500000)],
+            }
+        }
+    )
+
+    # Define adaptation goals - mix of in-subspace and out-of-subspace goals
+    in_subspace_goal = "8"  # Parking spot 8 (in subspace)
+    out_subspace_goal1 = "1"  # Parking spot 1 (out of subspace)
+    out_subspace_goal2 = "18"  # Parking spot 18 (out of subspace)
+
+    print(
+        "\nStarting goal adaptation phase with both in-subspace and out-of-subspace goals..."
+    )
+
+    # Goals adaptation phase with mixed goals
+    recognizer.goals_adaptation_phase(
+        dynamic_goals=[
+            in_subspace_goal,  # In subspace - will use base model
+            out_subspace_goal1,  # Out of subspace - will be fine-tuned
+            out_subspace_goal2,  # Out of subspace - will be fine-tuned
+        ],
+    )
+
+    # Setup for testing
+    property_type = domain_to_env_property(PARKING)
+    env_property = property_type("Parking-S-14-PC--v0")
+
+    # Create test actor for in-subspace goal
+    print("\nCreating test actor for in-subspace goal...")
+    problem_name_in = env_property.goal_to_problem_str(in_subspace_goal)
+    actor_in = DeepRLAgent(
+        domain_name=PARKING,
+        problem_name=problem_name_in,
+        env_prop=env_property,
+        algorithm=TD3,
+        num_timesteps=400000,
+    )
+    actor_in.learn()
+
+    # Create test actor for out-of-subspace goal
+    print("\nCreating test actor for out-of-subspace goal...")
+    problem_name_out = env_property.goal_to_problem_str(out_subspace_goal1)
+    actor_out = DeepRLAgent(
+        domain_name=PARKING,
+        problem_name=problem_name_out,
+        env_prop=env_property,
+        algorithm=TD3,
+        num_timesteps=400000,
+    )
+    actor_out.learn()
+
+    # Test inference with in-subspace goal
+    print("\nTesting inference with in-subspace goal (should use base model)...")
+    full_sequence_in = actor_in.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_in = random_subset_with_order(
+        full_sequence_in, (int)(0.5 * len(full_sequence_in)), is_consecutive=False
+    )
+    recognized_goal_in = recognizer.inference_phase(
+        partial_sequence_in, in_subspace_goal, 0.5
+    )
+    print(f"Goal recognized for in-subspace sequence: {recognized_goal_in}")
+    print(f"Actual goal: {in_subspace_goal}")
+
+    assert (
+        recognized_goal_in == in_subspace_goal
+    ), f"In-subspace goal recognition failed, expected to recognize the parking spot {in_subspace_goal}."
+
+    # Test inference with out-of-subspace goal
+    print(
+        "\nTesting inference with out-of-subspace goal (should use fine-tuned model)..."
+    )
+    full_sequence_out = actor_out.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_out = random_subset_with_order(
+        full_sequence_out, (int)(0.5 * len(full_sequence_out)), is_consecutive=False
+    )
+    recognized_goal_out = recognizer.inference_phase(
+        partial_sequence_out, out_subspace_goal1, 0.5
+    )
+    print(f"Goal recognized for out-of-subspace sequence: {recognized_goal_out}")
+    print(f"Actual goal: {out_subspace_goal1}")
+
+    assert (
+        recognized_goal_out == out_subspace_goal1
+    ), f"Out-of-subspace goal recognition failed, expected to recognize the parking spot {out_subspace_goal1}."
+
+    # Try another out-of-subspace goal
+    print("\nTesting inference with second out-of-subspace goal...")
+    problem_name_out2 = env_property.goal_to_problem_str(out_subspace_goal2)
+    actor_out2 = DeepRLAgent(
+        domain_name=PARKING,
+        problem_name=problem_name_out2,
+        env_prop=env_property,
+        algorithm=TD3,
+        num_timesteps=400000,
+    )
+    actor_out2.learn()
+
+    full_sequence_out2 = actor_out2.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_out2 = random_subset_with_order(
+        full_sequence_out2, (int)(0.5 * len(full_sequence_out2)), is_consecutive=False
+    )
+    recognized_goal_out2 = recognizer.inference_phase(
+        partial_sequence_out2, out_subspace_goal2, 0.5
+    )
+    print(
+        f"Goal recognized for second out-of-subspace sequence: {recognized_goal_out2}"
+    )
+    print(f"Actual goal: {out_subspace_goal2}")
+
+    assert (
+        recognized_goal_out2 == out_subspace_goal2
+    ), f"Second out-of-subspace goal recognition failed, expected to recognize the parking spot {out_subspace_goal2}."
+
+    print("\nGCAura Parking tutorial completed successfully!")
+
+
+if __name__ == "__main__":
+    run_gcaura_parking_tutorial()

gr_libs/tutorials/gcaura_point_maze_tutorial.py

@@ -0,0 +1,169 @@
+from stable_baselines3 import SAC, PPO
+
+from gr_libs import GCAura
+from gr_libs.environment._utils.utils import domain_to_env_property
+from gr_libs.environment.environment import POINT_MAZE
+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
+
+
+def run_gcaura_point_maze_tutorial():
+    """
+    Tutorial for GCAura on the Point Maze environment with MultiGoals.
+
+    This tutorial demonstrates:
+    1. Training a goal-conditioned model on a goal subspace (center goal only)
+    2. Adapting to goals both inside and outside this subspace
+    3. Testing inference on all goals types
+    """
+    print("Starting GCAura tutorial with Point Maze MultiGoals environment...")
+
+    # Use the registered multigoals environment with 3 goals: [(2, 2), (9, 9), (5, 5)]
+    # But define our goal subspace to include ONLY the center goal (5, 5)
+    # This lets us properly test the subspace functionality
+
+    # Initialize the recognizer with the multigoals empty maze environment
+    recognizer = GCAura(
+        domain_name=POINT_MAZE,
+        env_name="PointMaze-EmptyEnvDense-11x11-MultiGoals-2x2-9x9-5x5",
+        evaluation_function=mean_wasserstein_distance,
+        finetune_timesteps=70000,  # Fine-tuning for out-of-subspace goals
+    )
+
+    # Domain learning phase - train on the center goal subspace only
+    print("\nStarting domain learning phase - training on center goal subspace...")
+    recognizer.domain_learning_phase(
+        {
+            "gc": {
+                "train_configs": [(SAC, 700000)],
+            }
+        }
+    )
+
+    # Define adaptation goals - one in-subspace (center) and two out-of-subspace (corners)
+    # These all exist in the registered environment
+    in_subspace_goal = (5, 5)  # Center goal (in subspace)
+    out_subspace_goal1 = (9, 1)  # Bottom left corner (out of subspace)
+    out_subspace_goal2 = (1, 9)  # Top right corner (out of subspace)
+
+    print(
+        "\nStarting goal adaptation phase with both in-subspace and out-of-subspace goals..."
+    )
+
+    # Goals adaptation phase with mixed goals
+    recognizer.goals_adaptation_phase(
+        dynamic_goals=[
+            in_subspace_goal,  # In subspace - will use base model
+            out_subspace_goal1,  # Out of subspace - will be fine-tuned
+            out_subspace_goal2,  # Out of subspace - will be fine-tuned
+        ],
+    )
+
+    # Setup for testing
+    property_type = domain_to_env_property(POINT_MAZE)
+    env_property = property_type("PointMaze-EmptyEnvDense-11x11")
+
+    # Create test actor for in-subspace goal (center)
+    print("\nCreating test actor for in-subspace goal (center)...")
+    problem_name_in = env_property.goal_to_problem_str(in_subspace_goal)
+    actor_in = DeepRLAgent(
+        domain_name=POINT_MAZE,
+        problem_name=problem_name_in,
+        env_prop=env_property,
+        algorithm=PPO,
+        num_timesteps=700000,
+    )
+    actor_in.learn()
+
+    # Create test actor for out-of-subspace goal (bottom left corner)
+    print("\nCreating test actor for out-of-subspace goal (bottom left corner)...")
+    problem_name_out = env_property.goal_to_problem_str(out_subspace_goal1)
+    actor_out = DeepRLAgent(
+        domain_name=POINT_MAZE,
+        problem_name=problem_name_out,
+        env_prop=env_property,
+        algorithm=PPO,
+        num_timesteps=500000,
+    )
+    actor_out.learn()
+
+    # Test inference with in-subspace goal (center)
+    print("\nTesting inference with in-subspace goal (should use base model)...")
+    full_sequence_in = actor_in.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_in = random_subset_with_order(
+        full_sequence_in, (int)(0.5 * len(full_sequence_in)), is_consecutive=False
+    )
+    recognized_goal_in = recognizer.inference_phase(
+        partial_sequence_in, in_subspace_goal, 0.5
+    )
+    print(f"Goal recognized for in-subspace sequence: {recognized_goal_in}")
+    print(f"Actual goal: {in_subspace_goal}")
+
+    assert str(recognized_goal_in) == str(
+        in_subspace_goal
+    ), "In-subspace goal recognition failed, expected to recognize the center goal."
+
+    # Test inference with out-of-subspace goal (bottom left corner)
+    print(
+        "\nTesting inference with out-of-subspace goal (should use fine-tuned model)..."
+    )
+    full_sequence_out = actor_out.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_out = random_subset_with_order(
+        full_sequence_out, (int)(0.5 * len(full_sequence_out)), is_consecutive=False
+    )
+    recognized_goal_out = recognizer.inference_phase(
+        partial_sequence_out, out_subspace_goal1, 0.5
+    )
+    print(f"Goal recognized for out-of-subspace sequence: {recognized_goal_out}")
+    print(f"Actual goal: {out_subspace_goal1}")
+
+    assert str(recognized_goal_out) == str(
+        out_subspace_goal1
+    ), "Out-of-subspace goal recognition failed, expected to recognize the bottom left corner goal."
+
+    # Test with second out-of-subspace goal (top right corner)
+    print("\nTesting inference with second out-of-subspace goal (top right corner)...")
+    problem_name_out2 = env_property.goal_to_problem_str(out_subspace_goal2)
+    actor_out2 = DeepRLAgent(
+        domain_name=POINT_MAZE,
+        problem_name=problem_name_out2,
+        env_prop=env_property,
+        algorithm=PPO,
+        num_timesteps=500000,
+    )
+    actor_out2.learn()
+
+    full_sequence_out2 = actor_out2.generate_observation(
+        action_selection_method=stochastic_amplified_selection,
+        random_optimalism=True,
+        with_dict=True,
+    )
+    partial_sequence_out2 = random_subset_with_order(
+        full_sequence_out2, (int)(0.5 * len(full_sequence_out2)), is_consecutive=False
+    )
+    recognized_goal_out2 = recognizer.inference_phase(
+        partial_sequence_out2, out_subspace_goal2, 0.5
+    )
+    print(
+        f"Goal recognized for second out-of-subspace sequence: {recognized_goal_out2}"
+    )
+    print(f"Actual goal: {out_subspace_goal2}")
+
+    assert str(recognized_goal_out2) == str(
+        out_subspace_goal2
+    ), "Second out-of-subspace goal recognition failed, expected to recognize the top right corner goal."
+
+    print("\nGCAura Point Maze tutorial completed successfully!")
+
+
+if __name__ == "__main__":
+    run_gcaura_point_maze_tutorial()

{gr_libs-0.2.5.dist-info → gr_libs-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.2.5
+Version: 0.2.6
 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>
@@ -108,16 +108,16 @@ For any issues or troubleshooting, please refer to the repository's issue tracke
 
 ## 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** | **Goal Conditioned** | **Fine-Tuning** | **Supported Environments**                |
+|---------------------|----------------|---------------------------|---------------------|----------------------|----------------------|-----------------------|------------------|----------------|----------------|---------------------|-----------------|-------------------------------------------|
+| Graql               | ❌             | ✅                        | ✅                  | ❌                   | ✅                   | ❌                    | ❌               | ✅             | ❌             | ❌                  | ❌              | Minigrid                                   |
+| Draco               | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ❌                  | ❌              | PointMaze, Panda Reach, Parking            |
+| GCDraco             | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ✅                  | ❌              | Panda Reach, Parking                       |
+| GCAura              | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ✅                  | ✅              | PointMaze, Panda Reach, Parking            |
+| ExpertBasedGraml    | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ❌                  | ❌              | Panda Reach, Parking                       |
+| BGGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ❌                  | ❌              | Minigrid, PointMaze                        |
+| GCGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ✅                  | ❌              | Panda Reach, Parking                       |
 
-| **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
 
@@ -283,7 +283,12 @@ python gr_libs/all_experiments.py \
 
 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.
+After execution summary files are generated in `outputs/summaries/` for further analysis and plotting.
+
+another execution example:
+```sh
+python gr_libs/all_experiments.py --domains parking --envs Parking-S-14-PC- --tasks L1 L2 L3 L4 L5 --recognizers GCAura GCGraml GCDraco BGGraml Draco --n 5
+```
 
 ### 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.

{gr_libs-0.2.5.dist-info → gr_libs-0.2.6.dist-info}/RECORD

@@ -1,10 +1,10 @@
-gr_libs/__init__.py,sha256=XGx0_nWGgy-1zEQUXHRBs3TTb13jX9yOxVvSaavCkBk,376
-gr_libs/_version.py,sha256=N3oBwJUFmS-AwCjqOcSlRW4GvSq-uJJMaBvoGfv1-hM,511
+gr_libs/__init__.py,sha256=3gXejmK_mOfmD9RmB2jMG1Xm7DUyCwAILB7h7sheYxQ,405
+gr_libs/_version.py,sha256=nObnONsicQ3YX6SG5MVBxmIp5dmRacXDauSqZijWQbY,511
 gr_libs/all_experiments.py,sha256=OTTMx5ddy7z3kJbElQcR5nwEtshPsoehNPwDuMzojcc,10006
-gr_libs/odgr_executor.py,sha256=ttfEjeEBjr_YusegCX2zx11NBMfeXUwyKJjryYS6QaY,10685
+gr_libs/odgr_executor.py,sha256=MKDK-8fNc4HHlwnZFTjyeS-UbYafdmVbe84gRNG7stI,10806
 gr_libs/_evaluation/_generate_experiments_results.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gr_libs/environment/__init__.py,sha256=xCCzTFDrj_ijdLoZ-PzGyyYDeU2aoW19X1da76_x9iM,1458
-gr_libs/environment/environment.py,sha256=fAjkM5XyfFBlP6U3yjMyGj_WDI2c4fM2Ac-e7-kSKuM,16940
+gr_libs/environment/environment.py,sha256=neKNy0fkJK1i53LIh0JFP4tl0-4ntTM8F2wTkCvJtm4,19706
 gr_libs/environment/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gr_libs/environment/_utils/utils.py,sha256=dKuWoUpyuGSJL6qHQfvvJnFf4g-Rh1t2ykuRNrsIvP8,614
 gr_libs/evaluation/__init__.py,sha256=trZ-4PyOhzEEK_TvQLfbnNFcqYuN6SdRjDkkAdW6MW8,78
@@ -13,11 +13,11 @@ gr_libs/metrics/__init__.py,sha256=dQo4cMqrOB2-VLDxTIGryCm14mUnmEXs4F8jqcgNsY4,1
 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/consts.py,sha256=TsuTuQZNRrZ5bFRaUkFOeYnzljHjtyFszQJpqg4xq7s,420
 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=fq5n78RelIi794nNIl9x-W8ZnO5kXmD0LYv2q_2xMs8,26690
+gr_libs/ml/neural/deep_rl_learner.py,sha256=ND1D8b5Tc96ZpWc3yu-JjtP7662E2q4cKVLV9aFheD0,30141
 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
@@ -41,16 +41,19 @@ gr_libs/ml/utils/storage.py,sha256=CgZHWcC3GovKe-U3Cvwz0s5qCbBrYHY6w_CV-LnTquc,3
 gr_libs/problems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gr_libs/problems/consts.py,sha256=FQk2TaKAFHdZiISubGXeYleBaOXpk8ZC749NtP5RqWs,68520
 gr_libs/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/recognizer/recognizer.py,sha256=gtUttI1473co5ZHgO7-wQ7HL-aYJp0S4X6goqVYyT24,3091
+gr_libs/recognizer/recognizer.py,sha256=IZ3KU5jopf5WhQZe_dQWYZp_fdMFvcabqoU3z6ZOFK8,3128
 gr_libs/recognizer/_utils/__init__.py,sha256=MvXPRyr30W5C_n-Dul3aheE_9SWy2aIMGINKWj36mfM,42
-gr_libs/recognizer/_utils/format.py,sha256=eCoqEwv7YdLrF5nb-xAbDXxQ-ogvq_DHf9I2uwdfv-0,512
+gr_libs/recognizer/_utils/format.py,sha256=6m-csTBg8hBLrrKwRGFwS1uKGmulihsABH_BUl5TV80,567
 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=asjsjg52f43vlFPw1iT7PK8oOopa-u0UN7XBgiuufAY,10158
+gr_libs/recognizer/gr_as_rl/gr_as_rl_recognizer.py,sha256=efQtSECx73FMzIB1bpldN8CqBrlIrXf0ELvHeEMEImA,15664
 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=BVV-qn46AffkALRudBydHU24BGwMnvGFB1WSkIOAcWs,26292
+gr_libs/recognizer/graml/graml_recognizer.py,sha256=BL2sydjRoFRx2wZBm0-IfkBvDfVy07JyOsKjodaIGGU,26340
 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/gcaura_panda_tutorial.py,sha256=Z8RmzLLHboRzCfGWbM_Bhc_glJ4VIWCGMNky1_3i_VA,6189
+gr_libs/tutorials/gcaura_parking_tutorial.py,sha256=OgSa6NvG0W0pm3h-lbN8v4YY1Br7WY3tIguGd9P4HWY,6221
+gr_libs/tutorials/gcaura_point_maze_tutorial.py,sha256=Z39Tydx7VqXlB37YNhHOc9ge5Zjo0EQNQte_q6ZUXLE,6593
 gr_libs/tutorials/gcdraco_panda_tutorial.py,sha256=HzGKqZR--rcTYj3RQMuQCzTVll2Q-Z_RQbmGpcZPovg,2301
 gr_libs/tutorials/gcdraco_parking_tutorial.py,sha256=kd7xRsjGPCHohwhbJEK5XAsD3R9k8rcd0qz8IZIgjN4,2103
 gr_libs/tutorials/graml_minigrid_tutorial.py,sha256=bEsi21-9-AiOw4-H98Fr3YaCrp8_uSXOiiGahaCO4mg,2356
@@ -59,14 +62,16 @@ gr_libs/tutorials/graml_parking_tutorial.py,sha256=vRvcbrbM8N7npt7W_0g-CbUhALkXV
 gr_libs/tutorials/graml_point_maze_tutorial.py,sha256=KA28__CNKslxq3p6O5htjJFDKOXXbiA1bOX-oPJxjmI,2463
 gr_libs/tutorials/graql_minigrid_tutorial.py,sha256=HT8kCFNbZXAraIau9wtgC_aW8xg-QNRZB2lcpGm3yWk,1941
 tests/test_draco.py,sha256=oIeTDgn6pt3RfTC-RPX3Bw5cG4BThxRGH3z8en3TX0M,385
+tests/test_gcaura.py,sha256=mPqBGnqPto4uFkoLj8OrKySvG0Ph-w5ucIlAQ4bw8Yw,466
 tests/test_gcdraco.py,sha256=vV6rp7PkJJk_WpAfRekb197QiMHjXXApqrBiLG9RTwo,308
 tests/test_graml.py,sha256=amSikMWrGS9BNVSXGNKc1n5tfRl-FfgCsyHYsJtduD4,608
 tests/test_graql.py,sha256=KxVKx6rcSCbN-PjxR2DFoKcILRUmMDz0dTM5SvJZMXg,154
 tests/test_odgr_executor_expertbasedgraml.py,sha256=UQh1pzaqAy9kRN1O--x1tQLGWkRXuYnz5ujB2H1XMas,558
+tests/test_odgr_executor_gcaura.py,sha256=rggRtH-1xU67_m_mtHRwk_tX-hNFiWNdcyp3kzmOEXs,502
 tests/test_odgr_executor_gcdraco.py,sha256=VUmnO33tuMVlNYz7Fh08VUW4jfUXhhUsJu7oPiLF2iU,506
 tests/test_odgr_executor_gcgraml.py,sha256=MmyadmboVxFwfRigqe9jondZopqUjhbQ3gXjCbK4yAs,506
 tests/test_odgr_executor_graql.py,sha256=06p_kPAUn2OQrL-nBik58C22UPbTDC4CwDaB7MUk61o,514
-gr_libs-0.2.5.dist-info/METADATA,sha256=TYD_l_WXrcWoyi8fb4RkGjamcfdbcOeiPfrxypb-sQs,14421
-gr_libs-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gr_libs-0.2.5.dist-info/top_level.txt,sha256=Yzc_VSW3gzbVM7ZtlV4r6VXmfAC8WXqGVUgK1r6JcLs,14
-gr_libs-0.2.5.dist-info/RECORD,,
+gr_libs-0.2.6.dist-info/METADATA,sha256=Le6ZmUIXTb7B8D9ohgOCo0YkiGeXvvioS_usH_Q_oDc,15032
+gr_libs-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gr_libs-0.2.6.dist-info/top_level.txt,sha256=Yzc_VSW3gzbVM7ZtlV4r6VXmfAC8WXqGVUgK1r6JcLs,14
+gr_libs-0.2.6.dist-info/RECORD,,

tests/test_gcaura.py

@@ -0,0 +1,15 @@
+from gr_libs.tutorials.gcaura_panda_tutorial import run_gcaura_panda_tutorial
+from gr_libs.tutorials.gcaura_parking_tutorial import run_gcaura_parking_tutorial
+from gr_libs.tutorials.gcaura_point_maze_tutorial import run_gcaura_point_maze_tutorial
+
+
+def test_gcaura_panda_tutorial():
+    run_gcaura_panda_tutorial()
+
+
+def test_gcaura_parking_tutorial():
+    run_gcaura_parking_tutorial()
+
+
+def test_gcaura_point_maze_tutorial():
+    run_gcaura_point_maze_tutorial()

tests/test_odgr_executor_gcaura.py

@@ -0,0 +1,14 @@
+import subprocess
+import sys
+
+def test_odgr_executor_gcaura_parking():
+    """Test odgr_executor.py with GCAura on parking, L1, easiest env."""
+    result = subprocess.run([
+        sys.executable, "gr_libs/odgr_executor.py",
+        "--domain", "parking",
+        "--env_name", "Parking-S-14-PC-",
+        "--recognizer", "GCAura",
+        "--task", "L1",
+        "--collect_stats"
+    ], capture_output=True, text=True)
+    assert result.returncode == 0, f"GCAura parking L1 failed: {result.stderr}"