def get_param(config, param_name):
param_value = utils.get_param(config, param_name)
if param_value is None:
raise RuntimeError(
"Error: The configuration parameters \'%s\' cannot be undefined." %
param_name)
return param_value
def __init__(self, tasks, num_tasks, export_folder_names, params, target_automata, binary_folder_name):
super().__init__(tasks, num_tasks, export_folder_names, params, target_automata, binary_folder_name)
# reward shaping
self.use_reward_shaping = utils.get_param(params, ISAAlgorithmQRM.USE_REWARD_SHAPING, False)
self.use_reward_shaping_only_when_accepting = utils.get_param(params, ISAAlgorithmQRM.REWARD_SHAPING_ONLY_WHEN_ACCEPTING, True)
self.reward_shaping_method = utils.get_param(params, ISAAlgorithmQRM.REWARD_SHAPING_METHOD, "min_distance")
# attributes of reward function encoded by the automaton
self.reward_on_rejecting_state = utils.get_param(params, ISAAlgorithmQRM.REWARD_ON_REJECTING_STATE, False)
# experience replay
self.experience_replay_buffers = None
if self.use_experience_replay:
self._build_experience_replay_buffers()
# q-tables in the case of tabular QRM and dqn in the case of DQRM
self.q_functions = []
self.target_q_functions = []
self.optimizers = []
self.target_net_update_counter = {}
self._build_q_functions()
def __init__(self, tasks, num_tasks, export_folder_names, params,
target_automata, binary_folder_name):
super().__init__(tasks, num_tasks, export_folder_names, params,
target_automata, binary_folder_name)
# pseudorewards to update the q-functions of the conditions
self.enable_pseudoreward_on_deadend_state = utils.get_param(
params, ISAAlgorithmHRL.ENABLE_PSEUDOREWARD_ON_DEADEND, False)
self.pseudoreward_condition_satisfied = utils.get_param(
params, ISAAlgorithmHRL.PSEUDOREWARD_CONDITION_SATISFIED, 1.0)
self.pseudoreward_after_step = utils.get_param(
params, ISAAlgorithmHRL.PSEUDOREWARD_AFTER_STEP, 0.0)
# policy bank q-function update flags
self.use_num_positive_matchings = utils.get_param(
params, ISAAlgorithmHRL.USE_NUM_POSITIVE_MATCHINGS, True)
self.always_reuse_qfunction = utils.get_param(
params, ISAAlgorithmHRL.ALWAYS_REUSE_QFUNCTION, False)
self.update_all_policy_bank = utils.get_param(
params, ISAAlgorithmHRL.UPDATE_ALL_POLICY_BANK, False)
# option related structures
self.has_terminated = {} # whether the option has terminated
self.selected_option = {} # option currently being executed
self.last_state = {} # state where the option started being executed
self.num_option_steps = {
} # number of steps between the last option initiation and termination
self.option_reward = {}
# q-functions for selecting among options (policies over options)
self.meta_q_functions = []
self.target_meta_q_functions = []
self.target_meta_counters = {}
self.meta_optimizers = {}
self.meta_experience_replay_buffers = None
# q-functions for satisfying a particular condition
self.policy_bank = {}
self.policy_bank_update_counter = {}
self.target_policy_bank = {}
self.target_policy_bank_counter = {}
self.policy_bank_optimizers = {}
self.experience_replay_buffers = None
self._build_q_functions()
self._build_experience_replay_buffers()
valida_telefono
)
from utils.utils import (
load_config,
get_params,
get_param
)
print ("Description: >")
config = load_config('project_params.json')
STACK_NAME = os.environ.get('STACK_NAME')
INSTANCE_ID = get_param(f"/ct-manager/{STACK_NAME}/instance-id")
INSTANCE_ALIAS = get_param(f"/ct-manager/{STACK_NAME}/instance-alias")
SOURCE_PHONE = get_param(f"/ct-manager/{STACK_NAME}/source-phone")
REGION = get_param(f"/ct-manager/{STACK_NAME}/region")
BEEP_PROMPT = get_param(f"/ct-manager/{STACK_NAME}/beep-prompt")
DEFAULT_AGENT =get_param(f"/ct-manager/{STACK_NAME}/default-agent")
PRESIGNED_URL_DURATION = get_param(f"/ct-manager/{STACK_NAME}/presigned-url-duration")
TAGS = config['tags']
SSM_PARAMS = get_params('/ct-manager/{}'.format(STACK_NAME))
assert len(SSM_PARAMS), "No hay parametros previos, asegure de implementar primero el stack base"
def __init__(self, tasks, num_tasks, export_folder_names, params, target_automata, binary_folder_name):
super().__init__(tasks, num_tasks, export_folder_names, params)
self.binary_folder_name = binary_folder_name
self.initial_automaton_mode = utils.get_param(params, ISAAlgorithmBase.INITIAL_AUTOMATON_MODE, "basic")
# interleaved automaton learning params
self.interleaved_automaton_learning = utils.get_param(params, ISAAlgorithmBase.INTERLEAVED_FIELD, False)
self.ilasp_timeout = utils.get_param(params, ISAAlgorithmBase.ILASP_TIMEOUT_FIELD, 120)
self.ilasp_version = utils.get_param(params, ISAAlgorithmBase.ILASP_VERSION_FIELD, "2")
self.ilasp_compute_minimal = utils.get_param(params, ISAAlgorithmBase.ILASP_COMPUTE_MINIMAL, False)
self.num_starting_states = utils.get_param(params, ISAAlgorithmBase.STARTING_NUM_STATES_FIELD, 3)
self.num_automaton_states = self.num_starting_states * np.ones(self.num_domains, dtype=np.int)
self.use_restricted_observables = utils.get_param(params, ISAAlgorithmBase.USE_RESTRICTED_OBSERVABLES, False)
self.max_disjunction_size = utils.get_param(params, ISAAlgorithmBase.MAX_DISJUNCTION_SIZE, 1)
self.max_body_literals = utils.get_param(params, ISAAlgorithmBase.MAX_BODY_LITERALS, 1)
self.learn_acyclic_graph = utils.get_param(params, ISAAlgorithmBase.LEARN_ACYCLIC_GRAPH, False)
self.symmetry_breaking_method = utils.get_param(params, ISAAlgorithmBase.SYMMETRY_BREAKING_METHOD, None)
self.avoid_learning_only_negative = utils.get_param(params, ISAAlgorithmBase.AVOID_LEARNING_ONLY_NEGATIVE, False)
self.prioritize_optimal_solutions = utils.get_param(params, ISAAlgorithmBase.PRIORITIZE_OPTIMAL_SOLUTIONS, False)
self.wait_for_goal_example = utils.get_param(params, ISAAlgorithmBase.WAIT_FOR_GOAL_EXAMPLE, True)
self.has_observed_goal_example = np.zeros(self.num_domains, dtype=np.bool)
# maximum episode annealing parameters
self.use_max_episode_length_annealing = utils.get_param(params, ISAAlgorithmBase.USE_MAX_EPISODE_LENGTH_ANNEALING, False)
self.final_max_episode_length = utils.get_param(params, ISAAlgorithmBase.FINAL_MAX_EPISODE_LENGTH, 100)
if self.use_max_episode_length_annealing:
self.initial_max_episode_length = utils.get_param(params, ISAAlgorithmBase.INITIAL_MAX_EPISODE_LENGTH, 100)
self.max_episode_length = self.initial_max_episode_length
self.max_episode_length_increase_rate = (self.final_max_episode_length - self.max_episode_length) / self.num_episodes
# experience replay
self.use_experience_replay = utils.get_param(params, ISAAlgorithmBase.USE_EXPERIENCE_REPLAY, False) or not self.is_tabular_case
self.experience_replay_buffer_size = utils.get_param(params, ISAAlgorithmBase.EXPERIENCE_REPLAY_BUFFER_SIZE, 50000)
self.experience_replay_batch_size = utils.get_param(params, ISAAlgorithmBase.EXPERIENCE_REPLAY_BATCH_SIZE, 32)
self.experience_replay_start_size = utils.get_param(params, ISAAlgorithmBase.EXPERIENCE_REPLAY_START_SIZE, 1000)
# deep q-learning
self.use_double_dqn = utils.get_param(params, ISAAlgorithmBase.USE_DOUBLE_DQN, True)
self.num_layers = utils.get_param(params, ISAAlgorithmBase.NUM_HIDDEN_LAYERS, 6)
self.num_neurons_per_layer = utils.get_param(params, ISAAlgorithmBase.NUM_NEURONS_PER_LAYER, 64)
self.target_net_update_frequency = utils.get_param(params, ISAAlgorithmBase.TARGET_NET_UPDATE_FREQUENCY, 100)
# set of automata per domain
self.automata = None
self._set_automata(target_automata)
# sets of examples (goal, deadend and incomplete)
self.goal_examples = None
self.dend_examples = None
self.inc_examples = None
self._reset_examples()
# keep track of the number of learnt automata per domain
self.automaton_counters = np.zeros(self.num_domains, dtype=np.int)
self.automaton_learning_episodes = [[] for _ in range(self.num_domains)]
if self.train_model: # if the tasks are learnt, remove previous folders if they exist
utils.rm_dirs(self.get_automaton_task_folders())
utils.rm_dirs(self.get_automaton_solution_folders())
utils.rm_dirs(self.get_automaton_plot_folders())
utils.rm_files(self.get_automaton_learning_episodes_files())
import json
from aws_cdk import (
aws_lambda,
core,
aws_iam,
aws_ssm as ssm,
aws_dynamodb as ddb,
)
from project_config import (PYTHON_LAMBDA_CONFIG, BASE_ENV_VARIABLES,
STACK_NAME)
from utils.utils import (get_param)
tabla_usuarios_ssm = get_param(
f'/ct-manager/{STACK_NAME}/voice-mail-api/users-ddb-table')
class OnCall(core.Construct):
def __init__(self, scope: core.Construct, construct_id: str,
**kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
tabla_usuarios = ddb.Table.from_table_name(
self, "tabla_usr_from_ssm", table_name=tabla_usuarios_ssm)
lambda_router = aws_lambda.Function(
self,
"lambdarouter",
handler="lambda_function.lambda_handler",
code=aws_lambda.Code.asset(
"./lambdas/oncall/contact_router_lambda"),
def __init__(self, tasks, num_tasks, export_folder_names, params):
self.num_domains = len(tasks)
self.num_tasks = num_tasks
self.tasks = tasks
self.export_folder_names = export_folder_names
use_gpu = utils.get_param(params, LearningAlgorithm.USE_GPU, False)
self.device = "cuda" if use_gpu and torch.cuda.is_available(
) else "cpu"
self.debug = utils.get_param(params, LearningAlgorithm.DEBUG, False)
self.train_model = utils.get_param(params,
LearningAlgorithm.TRAIN_MODEL, True)
self.num_episodes = utils.get_param(params,
LearningAlgorithm.NUM_EPISODES,
20000)
self.max_episode_length = utils.get_param(
params, LearningAlgorithm.MAX_EPISODE_LENGTH, 100)
self.learning_rate = utils.get_param(params,
LearningAlgorithm.LEARNING_RATE,
0.1)
self.discount_rate = utils.get_param(params,
LearningAlgorithm.DISCOUNT_RATE,
0.99)
self.is_tabular_case = utils.get_param(
params, LearningAlgorithm.IS_TABULAR_CASE, True)
self.exploration_rate = utils.get_param(
params, LearningAlgorithm.EXPLORATION_RATE, 0.1)
self.use_exploration_rate_annealing = utils.get_param(
params, LearningAlgorithm.USE_EXPLORATION_RATE_ANNEALING, False)
self.final_exploration_rate = utils.get_param(
params, LearningAlgorithm.FINAL_EXPLORATION_RATE, 0.01)
if self.use_exploration_rate_annealing:
self.exploration_rate = utils.get_param(
params, LearningAlgorithm.INITIAL_EXPLORATION_RATE, 1.0)
self.exploration_decay_rate = (
self.exploration_rate -
self.final_exploration_rate) / self.num_episodes
self.greedy_evaluation_enable = utils.get_param(
params, LearningAlgorithm.GREEDY_EVALUATION_ENABLE, True)
self.greedy_evaluation_frequency = utils.get_param(
params, LearningAlgorithm.GREEDY_EVALUATION_FREQUENCY, 1)
self.greedy_evaluation_episodes = utils.get_param(
params, LearningAlgorithm.GREEDY_EVALUATION_EPISODES, 1)
self.use_compressed_traces = utils.get_param(
params, LearningAlgorithm.USE_COMPRESSED_TRACES, True)
self.ignore_empty_observations = utils.get_param(
params, LearningAlgorithm.IGNORE_EMPTY_OBSERVATIONS, False)
# learning progress attributes
self.current_episode = 1
self.current_domain_id = 0
self.current_task_id = 0
self.running_time = 0.0
self.last_timestamp = None
# seed attributes
self.use_seed = utils.get_param(params, LearningAlgorithm.USE_SEED,
False)
self.seed_value = utils.get_param(params, LearningAlgorithm.SEED_VALUE,
None)
self.python_seed_state = None
self.numpy_seed_state = None
self.torch_seed_state = None
if self.use_seed:
self._set_random_seed(
) # need to set these here, especially before creating the model in the subclasses
# checkpoint attributes
self.checkpoint_enable = utils.get_param(
params, LearningAlgorithm.CHECKPOINT_ENABLE, False)
self.checkpoint_folder = utils.get_param(
params, LearningAlgorithm.CHECKPOINT_FOLDER, ".")
self.checkpoint_frequency = utils.get_param(
params, LearningAlgorithm.CHECKPOINT_FREQUENCY, 5)
# logs for the different tasks
self.reward_steps_loggers = []
self.reward_steps_greedy_loggers = []
if self.train_model:
utils.rm_dirs(self.get_reward_episodes_folders())
utils.rm_dirs(self.get_reward_episodes_greedy_folders())
utils.rm_dirs(self.get_models_folders())
utils.rm_files(self.get_running_time_files())