gr-libs 0.1.7.post0__py3-none-any.whl → 0.2.2__py3-none-any.whl

gr_libs/recognizer/graml/gr_dataset.py

@@ -1,134 +0,0 @@
-import numpy as np
-from torch.utils.data import Dataset
-import random
-from types import MethodType
-from typing import List
-from gr_libs.environment.environment import EnvProperty
-from gr_libs.metrics.metrics import measure_average_sequence_distance
-from gr_libs.ml.base.rl_agent import ContextualAgent
-from gr_libs.ml.utils import get_siamese_dataset_path
-from gr_libs.ml.base import RLAgent
-import os
-import dill
-import torch
-
-class GRDataset(Dataset):
-	def __init__(self, num_samples, samples):
-		self.num_samples = num_samples
-		self.samples = samples
-
-	def __len__(self):
-		return self.num_samples
-
-	def __getitem__(self, idx):
-		return self.samples[idx] # returns a tuple - as appended in 'generate_dataset' last line
-
-def check_diff_goals(first_agent_goal, second_agent_goal):
-	try:
-		assert first_agent_goal != second_agent_goal
-	except Exception as e:
-		try:
-			assert any(first_agent_goal != second_agent_goal)
-		except Exception as e:
-			for arr1, arr2 in zip(first_agent_goal, second_agent_goal):
-				assert any(elm1!=elm2 for elm1, elm2 in zip(arr1, arr2))
-
-def generate_datasets(num_samples, agents: List[ContextualAgent], observation_creation_method : MethodType, problems: List[str], env_prop:EnvProperty, recognizer_name:str, gc_goal_set=None):
-	if gc_goal_set: model_name = env_prop.name
-	else: model_name = env_prop.problem_list_to_str_tuple(problems)
-	dataset_directory = get_siamese_dataset_path(domain_name=env_prop.domain_name, env_name=env_prop.name, model_name=model_name, recognizer=recognizer_name)
-	dataset_train_path, dataset_dev_path = os.path.join(dataset_directory, 'train.pkl'), os.path.join(dataset_directory, 'dev.pkl')
-	if os.path.exists(dataset_train_path) and os.path.exists(dataset_dev_path):
-		print(f"Loading pre-existing datasets in {dataset_directory}")
-		with open(dataset_train_path, 'rb') as train_file:
-			train_samples = dill.load(train_file)
-		with open(dataset_dev_path, 'rb') as dev_file:
-			dev_samples = dill.load(dev_file)
-	else:
-		print(f"{dataset_directory} doesn't exist, generating datasets")
-		if not os.path.exists(dataset_directory):
-			os.makedirs(dataset_directory)
-		all_samples = []
-		for i in range(num_samples):
-			if gc_goal_set != None: # TODO change to having one flow for both cases and injecting according to gc_goal_set or not
-				assert env_prop.gc_adaptable() == True, "shouldn't specify a goal directed representation if not generating datasets with a general agent."
-				is_same_goal = (np.random.choice([1, 0], 1, p=[1/max(len(gc_goal_set), 6), 1 - 1/max(len(gc_goal_set), 6)]))[0]
-				first_is_consecutive = np.random.choice([True, False], 1, p=[0.5, 0.5])[0]
-				first_random_index = np.random.randint(0, len(gc_goal_set)) # works for lists of every object type, while np.choice only works for 1d arrays
-				first_agent_goal = gc_goal_set[first_random_index] # could be either a real goal or a goal-directed problem name
-				#first_agent_goal = np.random.choice(gc_goal_set)
-				first_trace_percentage = random.choice([0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
-				first_observation = []
-				first_agent_kwargs = {
-					"action_selection_method": observation_creation_method,
-					"percentage": first_trace_percentage,
-					"is_consecutive": first_is_consecutive,
-					"save_fig": False
-				}
-				while first_observation == []:
-					# needs to be different than agents[0] problem_name, it should be from the gc_goal_set.
-					# but the problem is with the panda because it
-					if env_prop.use_goal_directed_problem(): first_agent_kwargs["goal_directed_problem"] = first_agent_goal
-					else: first_agent_kwargs["goal_directed_goal"] = first_agent_goal
-					first_observation = agents[0].agent.generate_partial_observation(**first_agent_kwargs)
-				first_observation = agents[0].agent.simplify_observation(first_observation)
-
-				second_is_consecutive = np.random.choice([True, False], 1, p=[0.5, 0.5])[0]
-				second_agent_goal = first_agent_goal
-				second_random_index = first_random_index
-				if not is_same_goal:
-					second_random_index = np.random.choice([i for i in range(len(gc_goal_set)) if i != first_random_index])
-					assert first_random_index != second_random_index
-				second_agent_goal = gc_goal_set[second_random_index]
-				if not is_same_goal: check_diff_goals(first_agent_goal, second_agent_goal)
-				second_trace_percentage = first_trace_percentage
-				second_observation = []
-				second_agent_kwargs = {
-					"action_selection_method": observation_creation_method,
-					"percentage": second_trace_percentage,
-					"is_consecutive": second_is_consecutive,
-					"save_fig": False
-				}
-				while second_observation == []:
-					if env_prop.use_goal_directed_problem() == True: second_agent_kwargs["goal_directed_problem"] = second_agent_goal
-					else: second_agent_kwargs["goal_directed_goal"] = second_agent_goal
-					second_observation = agents[0].agent.generate_partial_observation(**second_agent_kwargs)
-				second_observation = agents[0].agent.simplify_observation(second_observation)
-			else:
-				is_same_goal = (np.random.choice([1, 0], 1, p=[1/max(len(agents), 6), 1 - 1/max(len(agents), 6)]))[0]
-				first_is_consecutive = np.random.choice([True, False], 1, p=[0.5, 0.5])[0]
-				first_agent = np.random.choice(agents)
-				first_trace_percentage = random.choice([0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
-				first_observation = first_agent.agent.generate_partial_observation(action_selection_method=observation_creation_method, percentage=first_trace_percentage, is_consecutive=first_is_consecutive, save_fig=False, random_optimalism=True)
-				first_observation = first_agent.agent.simplify_observation(first_observation)
-				
-				second_agent = first_agent
-				if not is_same_goal:
-					second_agent = np.random.choice([agent for agent in agents if agent != first_agent])
-					assert second_agent != first_agent
-				second_is_consecutive = np.random.choice([True, False], 1, p=[0.5, 0.5])[0]
-				second_trace_percentage = first_trace_percentage
-				second_observation = second_agent.agent.generate_partial_observation(action_selection_method=observation_creation_method, percentage=second_trace_percentage, is_consecutive=second_is_consecutive, save_fig=False, random_optimalism=True)
-				second_observation = second_agent.agent.simplify_observation(second_observation)
-				if is_same_goal:
-					observations_distance = measure_average_sequence_distance(first_observation, second_observation) # for debugging mate
-			all_samples.append((
-				[torch.tensor(observation, dtype=torch.float32) for observation in first_observation],
-				[torch.tensor(observation, dtype=torch.float32) for observation in second_observation],
-				torch.tensor(is_same_goal, dtype=torch.float32)))
-			# all_samples.append((first_observation, second_observation, torch.tensor(is_same_goal, dtype=torch.float32)))
-			if i % 1000 == 0:
-				print(f'generated {i} samples')
-
-		total_samples = len(all_samples)
-		train_size = int(0.8 * total_samples)
-		train_samples = all_samples[:train_size]
-		dev_samples = all_samples[train_size:]
-		with open(dataset_train_path, 'wb') as train_file:
-			dill.dump(train_samples, train_file)
-		with open(dataset_dev_path, 'wb') as dev_file:
-			dill.dump(dev_samples, dev_file)
-
-	return train_samples, dev_samples
-
-	

gr_libs/recognizer/utils/__init__.py

@@ -1 +0,0 @@
-from .format import recognizer_str_to_obj

gr_libs/recognizer/utils/format.py

@@ -1,13 +0,0 @@
-from gr_libs.recognizer.graml.graml_recognizer import GCGraml, ExpertBasedGraml, MCTSBasedGraml
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql, Draco, GCDraco
-
-def recognizer_str_to_obj(recognizer_str: str):
-    recognizer_map = {
-        "GCGraml": GCGraml,
-        "ExpertBasedGraml": ExpertBasedGraml,
-        "MCTSBasedGraml": MCTSBasedGraml,
-        "Graql": Graql,
-        "Draco": Draco,
-        "GCDraco": GCDraco
-    }
-    return recognizer_map.get(recognizer_str)

gr_libs-0.1.7.post0.dist-info/RECORD

@@ -1,67 +0,0 @@
-evaluation/analyze_results_cross_alg_cross_domain.py,sha256=s_DDh4rNfRnvQ0PDa2d5411jYOa7CaI1YeB8Dpup7QU,9803
-evaluation/create_minigrid_map_image.py,sha256=jaSW3n3tY222iFUeAMqedBP9cvD88GCzPrQ6_XHv5oQ,1242
-evaluation/file_system.py,sha256=SSYnj8QGFkq-8V_0s7x2MWbD88aFaoFY4Ogc_Pt8m6U,1601
-evaluation/generate_experiments_results.py,sha256=oMFt2-TX7g3O6aBflFtQ5q0PT6sngEb8104kpPVMi0s,4051
-evaluation/generate_experiments_results_new_ver1.py,sha256=P9gz3xa0DoRRMQ16GQL3_wVSDYUfh8oZ3BCIUjphKaM,8909
-evaluation/generate_experiments_results_new_ver2.py,sha256=jeKj_wgdM50o2vi8WZI-s3GbsQdsjultHX-8H4Xvus4,12276
-evaluation/generate_task_specific_statistics_plots.py,sha256=rBsqaMe2irP_Cfo-icwIg4_dsleFjEH6eiQCcUBj6WU,15286
-evaluation/get_plans_images.py,sha256=BT-bGWuOPUAYpZVDwk7YMRBLdgKaDbNOBjMrtcl1Vjk,2346
-evaluation/increasing_and_decreasing_.py,sha256=fu1hkEjhOQC3jEsjiS7emW_UPRpVFCaae0d0E2MGZqI,2991
-gr_libs/__init__.py,sha256=WlSRpZIpz5GxLNk96nhympbk3Z5nsMiSOyiAWj17S88,280
-gr_libs/_version.py,sha256=Zy3HQFB_Viry2Rl81-7LPU4kL2FTQegnwLvl0VxTs3E,526
-gr_libs/environment/__init__.py,sha256=KlRp3qdgxEmej31zDoDsYPwbcAqyDglx6x0mH0KRmHU,1032
-gr_libs/environment/environment.py,sha256=d6ZbiAQ4H1aLrUFI8sm0BN9DVW3JtzpkodSi_70Z_PY,6780
-gr_libs/environment/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/environment/utils/utils.py,sha256=4yM3s30KjyuEmWR8UuICE5rR03zsLi3tzqNDvBkdPcU,537
-gr_libs/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/metrics/metrics.py,sha256=4bnvs5suv-QrK9i1NuOzkE_E8uIzS1nlEazNDRXvZGs,8700
-gr_libs/ml/__init__.py,sha256=jrjxYqvSRgWwFWw7XQP9DzOwvmprMZ2umwT7t-DYtDU,233
-gr_libs/ml/agent.py,sha256=DSnK8nRx9SS76fAOZZEEvA68_meLjzm9lfQpMUXmGQU,1957
-gr_libs/ml/consts.py,sha256=mrbZk8n6QoGzLGaKmaxq4QlAsBbk4fhkCgXLuO9jXKw,365
-gr_libs/ml/base/__init__.py,sha256=MfIYhl_UqH8H7YoTCih8wBFA_gpTOUFq8Ph0_Nq0XQk,68
-gr_libs/ml/base/rl_agent.py,sha256=u9rnb-ma9iDM5b_BlwjcTJGSFezIGrxXINw6b-Dbl8s,1598
-gr_libs/ml/neural/__init__.py,sha256=g-0D5oFX8W52To4OR8vO8kDoBLSxAupVqwcQw8XjT5E,180
-gr_libs/ml/neural/deep_rl_learner.py,sha256=b41_b4GVlYqxhjrr1_YMcGdU9iwcMXsf3zH8D2kEucs,20659
-gr_libs/ml/neural/utils/__init__.py,sha256=bJgPfRnmfDQxdnb0OyRGwzgebEc1PnlO7-GpqszPBcc,106
-gr_libs/ml/neural/utils/dictlist.py,sha256=WpHfdWpVZ_T3PcSnOQUC--ro_tsS0dvam2WG3LcsHDw,1039
-gr_libs/ml/neural/utils/penv.py,sha256=R1uW8sePQqvTlJjpAuMx16eDU6TuGAjQF3hTR1QasMo,1862
-gr_libs/ml/planner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/ml/planner/mcts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/ml/planner/mcts/mcts_model.py,sha256=N4B2SRWAySW7sJ1JIIkKHbzpxMYo2GcuaSB-eauJmBg,21068
-gr_libs/ml/planner/mcts/utils/__init__.py,sha256=8OE_XolCHiWIZZwS23lqLaLd72tsHwO8cQRRToTC0Lk,45
-gr_libs/ml/planner/mcts/utils/node.py,sha256=WXXaEjfU857yIBF8gKVjr0ZGmU2Du9s1d-dBcA4QS10,1220
-gr_libs/ml/planner/mcts/utils/tree.py,sha256=mLtLtPoqoU0eauNEExY94px5mdbmH-HCsYAYQDZqioI,3382
-gr_libs/ml/sequential/__init__.py,sha256=rusN4ahTvAeAq1Saz6qS_9HEU7WuXDJu2zwhc9WUEYQ,61
-gr_libs/ml/sequential/lstm_model.py,sha256=Vzm-C1URR84PGNEecj69GUtn3ZmOVyh1BAY6CUnfL1Q,8978
-gr_libs/ml/tabular/__init__.py,sha256=jAfjfTFZLLlVm1KUiJdxdnaNGFp1J2KBU89q_vvradM,177
-gr_libs/ml/tabular/state.py,sha256=8xroKF3y3nRX0LK1QX5fRT2PS2WmvcDPp0UvPFdSx2A,733
-gr_libs/ml/tabular/tabular_q_learner.py,sha256=5QU9ZWC-Cu5jxv5K1TohoRjQrRDhCgTs1Mt18cqM_Sc,18970
-gr_libs/ml/tabular/tabular_rl_agent.py,sha256=7w8PYbKi8QgxHJyECWU_rURtT89spg0tHIMI1cDwYc8,3764
-gr_libs/ml/utils/__init__.py,sha256=qH3pcnem5Z6rkQ4RTZi47AXJRe1RkFEST_-DrBmfWcM,258
-gr_libs/ml/utils/env.py,sha256=AWVN0OXYmFU-J3FUiwvEAIY93Suf1oL6VNcxtyWJraM,171
-gr_libs/ml/utils/format.py,sha256=nu7RzVwn_raG_fqqmnqlJgUjtA0yzKztkB3a5QZnRYo,3071
-gr_libs/ml/utils/math.py,sha256=n62zssVOLHnUb4dPofAoFhoLOKl5n_xBzaKQOUQBoNc,440
-gr_libs/ml/utils/other.py,sha256=HKUfeLBbd4DgJxSTs3ya9KQ85Acx4TjycRrtGD9WQ3s,505
-gr_libs/ml/utils/storage.py,sha256=52wR2pgFmcCOhqbu5Km3tegjAmtI1Fb4HYAVUnUubZk,4626
-gr_libs/problems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/problems/consts.py,sha256=ON7yfKTAKETg7i3okDYuOzEU7KWvynyubl0m7TlU6Hs,38808
-gr_libs/recognizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/recognizer/recognizer.py,sha256=ZrApJVdBQxKRYhhDiWLCNGmlxgi674nwgb30BgVggC8,1705
-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=84GdfohC2dZoNH_QEo7GpSt8nZWdfqSRKCTY99X_iME,5215
-gr_libs/recognizer/graml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gr_libs/recognizer/graml/gr_dataset.py,sha256=lG6m3ulxFELpH1oURnlcmNDWOrxyuzvlAR28ZTqB7L8,7224
-gr_libs/recognizer/graml/graml_recognizer.py,sha256=1xLl1gHj3JxWhHtV9h3SvsW7oJdxsQQV0F-VLtlTmKQ,15911
-gr_libs/recognizer/utils/__init__.py,sha256=ewSroxL7aATvvm-Xzc1_-61mP2LU2U28YaOEqvVVDB0,41
-gr_libs/recognizer/utils/format.py,sha256=e0AnqtPeYoJsV9Z7cEBpgbzTM0hLNxFIjn07fQ3YbQw,492
-tests/test_graml.py,sha256=ZJB2jqtf4Q2-KZredkJq90teqmHBIvigCAQpvR5G110,559
-tests/test_graql.py,sha256=-onMi13e2wStOmB5bYv2f3Ita3QFFiw416XMBkby0OI,141
-tutorials/graml_minigrid_tutorial.py,sha256=ONvxFi79R7d8dcd6gy083Z_yy9A2flhGTDIDRxurdx8,1782
-tutorials/graml_panda_tutorial.py,sha256=wtv_lsw0vsU7j45GKeWecTfE7jzfh4iVGEVnQyaWthM,2063
-tutorials/graml_parking_tutorial.py,sha256=M6bt1WQOOgn8_CRyG2kjxF14PMeyXVAWRDq1ZRwGTXo,1808
-tutorials/graml_point_maze_tutorial.py,sha256=mYq3IxYbf9jidq-4VdT3MdStV80Q5lytFv6Xzzn22Ys,1835
-tutorials/graql_minigrid_tutorial.py,sha256=Jb0TCUhiZQkFeafJWUTPnCISd4FKfPrqP-xfHiqCGKE,1635
-gr_libs-0.1.7.post0.dist-info/METADATA,sha256=aS7y9Nl1JErXYdpAHstuQP_W1QMcKMbGet6IfxfJ_Do,9620
-gr_libs-0.1.7.post0.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-gr_libs-0.1.7.post0.dist-info/top_level.txt,sha256=fJQF8Q8Dfh_D3pA2mhNodazNjzW6b3oWfnx6Jdo-pBU,35
-gr_libs-0.1.7.post0.dist-info/RECORD,,

gr_libs-0.1.7.post0.dist-info/top_level.txt

@@ -1,4 +0,0 @@
-evaluation
-gr_libs
-tests
-tutorials

tutorials/graml_minigrid_tutorial.py

@@ -1,34 +0,0 @@
-from gr_libs.environment.environment import MINIGRID, 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 ExpertBasedGraml
-
-def run_graml_minigrid_tutorial():
-    recognizer = ExpertBasedGraml(
-        domain_name=MINIGRID,
-        env_name="MiniGrid-SimpleCrossingS13N4"
-    )
-
-    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)])
-
-    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 GRAML: {closest_goal}\nactual goal actor aimed towards: (11, 1)")
-
-if __name__ == "__main__":
-    run_graml_minigrid_tutorial()

tutorials/graml_panda_tutorial.py

@@ -1,41 +0,0 @@
-
-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.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
-
-def run_graml_panda_tutorial():
-    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]")
-
-if __name__ == "__main__":
-    run_graml_panda_tutorial()

tutorials/graml_parking_tutorial.py

@@ -1,39 +0,0 @@
-
-from stable_baselines3 import PPO, SAC, TD3
-from gr_libs.environment.environment import PARKING, 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
-import gr_libs.environment.environment
-
-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.goals_adaptation_phase(
-        dynamic_goals = ["1", "11", "21"]
-        # no need for expert sequence generation since GCRL is used
-    )
-
-    # 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", 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-11-v0").str_to_goal(), 0.5)
-    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: 11")
-
-if __name__ == "__main__":
-    run_graml_parking_tutorial()

tutorials/graml_point_maze_tutorial.py

@@ -1,39 +0,0 @@
-
-from stable_baselines3 import SAC, TD3
-from gr_libs.environment.environment import POINT_MAZE, PointMazeProperty
-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
-
-def run_graml_point_maze_tutorial():
-    recognizer = ExpertBasedGraml(
-        domain_name=POINT_MAZE,
-        env_name="PointMaze-FourRoomsEnvDense-11x11"
-    )
-
-    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)]
-    )
-
-    recognizer.goals_adaptation_phase(
-        dynamic_goals = [(4,4), (7,3), (3,7)],
-        dynamic_train_configs=[(SAC, 200000) for _ in range(3)] # for expert sequence generation.
-    )
-
-    # TD3 is different from recognizer and expert algorithms, which are SAC #
-    actor = DeepRLAgent(domain_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, PointMazeProperty("PointMaze-FourRoomsEnvDense-11x11-Goal-4x4").str_to_goal(), 0.5)
-    print(f"closest_goal returned by GRAML: {closest_goal}\nactual goal actor aimed towards: (4, 4)")
-
-if __name__ == "__main__":
-    run_graml_point_maze_tutorial()

tutorials/graql_minigrid_tutorial.py

@@ -1,34 +0,0 @@
-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
-
-def run_graql_minigrid_tutorial():
-    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)")
-    return closest_goal, (11,1)
-
-if __name__ == "__main__":
-    run_graql_minigrid_tutorial()