gr-libs 0.1.3__py3-none-any.whl

tutorials/graml_panda_tutorial.py

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

tutorials/graml_parking_tutorial.py

@@ -0,0 +1,38 @@
+
+from stable_baselines3 import PPO, SAC, TD3
+from gr_libs.environment.environment import EnvProperty, GCEnvProperty, ParkingProperty
+from gr_libs.metrics.metrics import stochastic_amplified_selection
+from gr_libs.ml.neural.deep_rl_learner import DeepRLAgent, GCDeepRLAgent
+from gr_libs.ml.utils.format import random_subset_with_order
+from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
+
+# Consider extracting all these to "default point_maze (or every other domain) variables" module which would simplify things like the problem_list_to_str_tuple function, sizes of inputs, etc.
+recognizer = GCGraml(
+    env_name="parking", # TODO change to macros which are importable from some info or env module of enums.
+    problems=[ParkingProperty("parking-v0")],
+    train_configs=[(PPO, 400000)],
+	gc_goal_set=[f"Parking-S-14-PC--GI-{i}-v0" for i in range(1,21)]
+)
+recognizer.domain_learning_phase()
+recognizer.goals_adaptation_phase(
+    dynamic_goals_problems = [ParkingProperty(p) for p in ["Parking-S-14-PC--GI-1-v0",
+                              "Parking-S-14-PC--GI-4-v0",
+                              "Parking-S-14-PC--GI-8-v0",
+                              "Parking-S-14-PC--GI-11-v0",
+                              "Parking-S-14-PC--GI-14-v0",
+                              "Parking-S-14-PC--GI-18-v0",
+                              "Parking-S-14-PC--GI-21-v0"]] # TODO detach the goal from the environment instance in every gym env, add the ability to alter it from outside.
+    #dynamic_train_configs=[(SAC, 400000) for _ in range(7)] # for expert sequence generation. TODO change to require this only if sequence generation method is EXPERT.
+)
+# TD3 is different from recognizer and expert algorithms, which are SAC #
+actor = DeepRLAgent(env_name="parking", problem_name="Parking-S-14-PC--GI-8-v0", algorithm=TD3, num_timesteps=400000)
+actor.learn()
+# sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
+full_sequence = actor.generate_observation(
+    action_selection_method=stochastic_amplified_selection,
+    random_optimalism=True, # the noise that's added to the actions
+)
+
+partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)), is_consecutive=False)
+closest_goal = recognizer.inference_phase(partial_sequence, ParkingProperty("Parking-S-14-PC--GI-8-v0").str_to_goal(), 0.5)
+print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: 8")

tutorials/graml_point_maze_tutorial.py

@@ -0,0 +1,43 @@
+
+from stable_baselines3 import SAC, TD3
+from gr_libs.environment.utils.format import maze_str_to_goal
+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
+
+# Consider extracting all these to "default point_maze (or every other domain) variables" module which would simplify things like the problem_list_to_str_tuple function, sizes of inputs, etc.
+recognizer = ExpertBasedGraml(
+    env_name="point_maze", # TODO change to macros which are importable from some info or env module of enums.
+    problems=[("PointMaze-FourRoomsEnvDense-11x11-Goal-9x1"),
+              ("PointMaze-FourRoomsEnv-11x11-Goal-9x9"), # this one doesn't work with dense rewards because of encountering local minima
+              ("PointMaze-FourRoomsEnvDense-11x11-Goal-1x9"),
+              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x3"),
+              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x4"),
+              ("PointMaze-FourRoomsEnvDense-11x11-Goal-8x2"),
+              ("PointMaze-FourRoomsEnvDense-11x11-Goal-3x7"),
+              ("PointMaze-FourRoomsEnvDense-11x11-Goal-2x8")],
+    task_str_to_goal=maze_str_to_goal,
+    method=DeepRLAgent,
+    collect_statistics=False,
+    train_configs=[(SAC, 200000) for _ in range(8)],
+)
+recognizer.domain_learning_phase()
+recognizer.goals_adaptation_phase(
+    dynamic_goals_problems = ["PointMaze-FourRoomsEnvDense-11x11-Goal-4x4",
+                              "PointMaze-FourRoomsEnvDense-11x11-Goal-7x3",
+                              "PointMaze-FourRoomsEnvDense-11x11-Goal-3x7"],
+    dynamic_train_configs=[(SAC, 200000) for _ in range(3)] # for expert sequence generation. TODO change to require this only if sequence generation method is EXPERT.
+)
+# TD3 is different from recognizer and expert algorithms, which are SAC #
+actor = DeepRLAgent(env_name="point_maze", problem_name="PointMaze-FourRoomsEnvDense-11x11-Goal-4x4", algorithm=TD3, num_timesteps=200000)
+actor.learn()
+# sample is generated stochastically to simulate suboptimal behavior, noise is added to the actions values #
+full_sequence = actor.generate_observation(
+    action_selection_method=stochastic_amplified_selection,
+    random_optimalism=True, # the noise that's added to the actions
+)
+
+partial_sequence = random_subset_with_order(full_sequence, (int)(0.5 * len(full_sequence)))
+closest_goal = recognizer.inference_phase(partial_sequence, maze_str_to_goal("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4"), 0.5)
+print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (4, 4)")

tutorials/graql_minigrid_tutorial.py

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