def __init__(self, domain : Domain, turn_reward=-1, success_reward=20, logger : DiasysLogger = DiasysLogger()): assert turn_reward <= 0.0, 'the turn reward should be negative' self.domain = domain self.turn_reward = turn_reward self.success_reward = success_reward self.logger = logger
def __init__(self, subgraphs, in_module, out_module, logger: DiasysLogger = DiasysLogger()): domains = [graph.domain.get_domain_name() for graph in subgraphs] super(HandcraftedMetapolicy, self).__init__(domains, None, logger=logger) self.subgraphs = subgraphs self.active_domains = domains self.input_module = in_module self.output_module = out_module self.rewrite = False self.offers = {} # track offers made for active domains
def __init__(self, domain=None, subgraph=None, logger: DiasysLogger = DiasysLogger()): super(HandcraftedBST, self).__init__(domain, subgraph, logger=logger) # Informables and Requestables are extracted and provided with # probabilities e.g. state['beliefs']['food']['italian'] = 0.0 self.inform_scores = {} self.request_slots = {} self.primary_key = domain.get_primary_key()
def __init__(self, *modules, domain=None, logger: DiasysLogger = DiasysLogger()): self.domain = domain self.logger = logger self.modules = modules self.is_training = False self.num_dialogs = 0 self.num_turns = 0
def __init__(self, domain: Domain, turn_reward=-1, success_reward=20, logger: DiasysLogger = DiasysLogger()): super(ObjectiveReachedEvaluator, self).__init__(domain) assert turn_reward <= 0.0, 'the turn reward should be negative' self.domain = domain self.turn_reward = turn_reward self.success_reward = success_reward self.logger = logger
def __init__(self, domain: Domain, subgraph: dict = None, template_file: str = None, logger: DiasysLogger = DiasysLogger(), template_file_german: str = None, language: Language = None): """Constructor mainly extracts methods and rules from the template file""" super(HandcraftedNLG, self).__init__(domain, subgraph, logger=logger) self.language = language if language else Language.ENGLISH self.template_english = template_file # TODO: at some point if we expand languages, maybe make kwargs? --LV self.template_german = template_file_german self.domain = domain self.template_filename = None self.templates = None
def __init__(self, domain: JSONLookupDomain = None, logger: DiasysLogger = DiasysLogger()): """ Initializes the policy Arguments: domain (JSONLookupDomain): the domain that the affective policy should operate in """ self.first_turn = True Service.__init__(self, domain=domain) self.logger = logger
def __init__(self, domain: Domain, sub_topic_domains: Dict[str, str] = {}, template_file: str = None, logger: DiasysLogger = DiasysLogger(), template_file_german: str = None, language: Language = None): """Constructor mainly extracts methods and rules from the template file""" HandcraftedNLG.__init__(self, domain, template_file=None, logger=DiasysLogger(), template_file_german=None, language=None, sub_topic_domains=sub_topic_domains) # class_int_mapping = {0: b'no_bc', 1: b'assessment', 2: b'continuer'} self.backchannels = { 0: [''], 1: ['Okay. ', 'Yeah. '], 2: ['Um-hum. ', 'Uh-huh. '] }
def __init__(self, domain: Domain, sub_topic_domains={}, template_file: str = None, logger: DiasysLogger = DiasysLogger(), template_file_german: str = None, emotions: List[str] = [], debug_logger = None): """Constructor mainly extracts methods and rules from the template file""" Service.__init__(self, domain=domain, sub_topic_domains=sub_topic_domains, debug_logger=debug_logger) self.domain = domain self.template_filename = template_file self.templates = {} self.logger = logger self.emotions = emotions self._initialise_templates()
def __init__(self, domain: JSONLookupDomain, train_error_rate: float, test_error_rate: float, pdf: List[float] = [0.7, 0.3, 0.0], logger: DiasysLogger = DiasysLogger()): super(Noise, self).__init__(domain, logger=logger) self.domain = domain self.train_error_rate = train_error_rate self.test_error_rate = test_error_rate self.backup = train_error_rate, test_error_rate self.pdf = pdf self.pdf_wo_value = [ float(i) / sum(self.pdf[1:]) for i in self.pdf[1:] ]
def __init__(self, domain: JSONLookupDomain, logger: DiasysLogger = DiasysLogger(), max_turns: int = 25): """ Initializes the policy Arguments: domain {domain.jsonlookupdomain.JSONLookupDomain} -- Domain """ self.first_turn = True Service.__init__(self, domain=domain) self.current_suggestions = [] # list of current suggestions self.s_index = 0 # the index in current suggestions for the current system reccomendation self.domain_key = domain.get_primary_key() self.logger = logger self.max_turns = max_turns
def __init__(self, domain: Domain, subgraph: dict = None, use_tensorboard=False, experiment_name: str = '', turn_reward=-1, success_reward=20, logger: DiasysLogger = DiasysLogger(), summary_writer=None): """ Keyword Arguments: use_tensorboard {bool} -- [If true, metrics will be written to tensorboard in a *runs* directory] (default: {False}) experiment_name {str} -- [Name suffix for the log files] (default: {''}) turn_reward {float} -- [Reward for one turn - usually negative to penalize dialog length] (default: {-1}) success_reward {float} -- [Reward of the final transition if the dialog goal was reached] (default: {20}) """ super(PolicyEvaluator, self).__init__(domain) self.logger = logger self.epoch = 0 self.evaluator = ObjectiveReachedEvaluator( domain, turn_reward=turn_reward, success_reward=success_reward, logger=logger) self.writer = summary_writer self.total_train_dialogs = 0 self.total_eval_dialogs = 0 self.epoch_train_dialogs = 0 self.epoch_eval_dialogs = 0 self.train_rewards = [] self.eval_rewards = [] self.train_success = [] self.eval_success = [] self.train_turns = [] self.eval_turns = [] self.is_training = False
def __init__(self, domain: JSONLookupDomain, subgraph=None, logger: DiasysLogger = DiasysLogger()): """ Initializes the policy Arguments: domain {domain.jsonlookupdomain.JSONLookupDomain} -- Domain """ super(HandcraftedPolicy, self).__init__(domain, subgraph=None, logger=logger) self.turn = 0 self.last_action = None self.current_suggestions = [] # list of current suggestions self.s_index = 0 # the index in current suggestions for the current system reccomendation self.domain_key = domain.get_primary_key()
def __init__(self, domain: LookupDomain, \ logger: DiasysLogger = DiasysLogger(), device: str = 'cpu'): """Creates neural networks for semantic parsing and other required utils Args: domain: the QA domain logger: the logger device: PyTorch device name """ Service.__init__(self, domain=domain, debug_logger=logger) self.device = torch.device(device) self.nn_relation = self._load_relation_model() self.nn_entity = self._load_entity_model() self.nn_direction = self._load_direction_model() self.tags = self._load_tag_set() self.max_seq_len = 40 self.embedding_creator = BertEmbedding(max_seq_length=self.max_seq_len)
def __init__(self, domain: JSONLookupDomain = None, subgraph=None, logger: DiasysLogger = DiasysLogger()): super(MLBST, self).__init__(domain, subgraph, logger=logger) self.path_to_data_folder = os.path.join(os.path.realpath(os.curdir), "modules", "bst", "ml") self.primary_key = domain.get_domain_name() self.data_mappings = DSTC2Data( path_to_data_folder=self.path_to_data_folder, preprocess=False, load_train_data=False) self.inf_trackers = {} self.req_trackers = {} for inf_slot in domain.get_informable_slots(): self._load_inf_model(inf_slot) for req_slot in domain.get_requestable_slots(): self._load_req_model(req_slot)
def __init__(self, domain: JSONLookupDomain, logger: DiasysLogger = DiasysLogger(), language: Language = None): """ Loads - domain key - informable slots - requestable slots - domain-independent regular expressions - domain-specific regualer espressions It sets the previous system act to None Args: domain {domain.jsonlookupdomain.JSONLookupDomain} -- Domain """ Service.__init__(self, domain=domain) self.logger = logger self.language = language if language else Language.ENGLISH # Getting domain information self.domain_name = domain.get_domain_name() self.domain_key = domain.get_primary_key() # Getting lists of informable and requestable slots self.USER_INFORMABLE = domain.get_informable_slots() self.USER_REQUESTABLE = domain.get_requestable_slots() # Getting the relative path where regexes are stored self.base_folder = os.path.join(get_root_dir(), 'resources', 'nlu_regexes') # Setting previous system act to None to signal the first turn # self.prev_sys_act = None self.sys_act_info = { 'last_act': None, 'lastInformedPrimKeyVal': None, 'lastRequestSlot': None} self.language = Language.ENGLISH self._initialize()
def __init__(self, domain: Domain, template_file: str = None, sub_topic_domains: Dict[str, str] = {}, logger: DiasysLogger = DiasysLogger(), template_file_german: str = None, language: Language = None): """Constructor mainly extracts methods and rules from the template file""" Service.__init__(self, domain=domain, sub_topic_domains=sub_topic_domains) self.language = language if language else Language.ENGLISH self.template_english = template_file # TODO: at some point if we expand languages, maybe make kwargs? --LV self.template_german = template_file_german self.domain = domain self.template_filename = None self.templates = None self.logger = logger self.language = Language.ENGLISH self._initialise_language(self.language)
def __init__(self, domain: JSONLookupDomain, subgraph=None, logger: DiasysLogger = DiasysLogger(), language: Language = None): """ Loads - domain key - informable slots - requestable slots - domain-independent regular expressions - domain-specific regualer espressions It sets the previous system act to None Args: domain {domain.jsonlookupdomain.JSONLookupDomain} -- Domain subgraph {[type]} -- [see modules.Module] (default: {None}) logger: """ super(HandcraftedNLU, self).__init__(domain, None, logger=logger) self.language = language if language else Language.ENGLISH # Getting domain information self.domain_name = domain.get_domain_name() self.domain_key = domain.get_primary_key() # Getting lists of informable and requestable slots self.USER_INFORMABLE = domain.get_informable_slots() self.USER_REQUESTABLE = domain.get_requestable_slots() # Getting the relative path where regexes are stored self.base_folder = os.path.join(get_root_dir(), 'resources', 'regexes') # Setting previous system act to None to signal the first turn self.prev_sys_act = None
def __init__(self, domain: LookupDomain, logger: DiasysLogger = DiasysLogger()): # only call super class' constructor Service.__init__(self, domain=domain, debug_logger=logger)
def __init__(self, domain: Domain, subgraph: dict = None, logger: DiasysLogger = DiasysLogger()): self.domain = domain self.subgraph = subgraph self.logger = logger self.is_training = False
from services.service import DialogSystem from utils.domain.jsonlookupdomain import JSONLookupDomain from utils.logger import DiasysLogger, LogLevel from services.simulator.emotion_simulator import EmotionSimulator from utils.userstate import EmotionType # load domains lecturers = JSONLookupDomain(name='ImsLecturers', display_name="Lecturers") weather = WeatherDomain() mensa = MensaDomain() # only debug logging conversation_log_dir = "./conversation_logs" os.makedirs(f"./{conversation_log_dir}/", exist_ok=True) logger = DiasysLogger(file_log_lvl=LogLevel.NONE, console_log_lvl=LogLevel.DIALOGS, logfile_basename="full_log") # input modules user_in = ConsoleInput(conversation_log_dir=conversation_log_dir) user_out = ConsoleOutput() recorder = SpeechRecorder(conversation_log_dir=conversation_log_dir) speech_in_decoder = SpeechInputDecoder( conversation_log_dir=conversation_log_dir, use_cuda=False) #RemoteService(identifier="asr") # feature extraction d_tracker = DomainTracker(domains=[lecturers, weather, mensa], greet_on_first_turn=True) speech_in_feature_extractor = SpeechInputFeatureExtractor() speach_feats = SpeechFeatureExtractor()
def __init__(self, domain: JSONLookupDomain, buffer_cls=UniformBuffer, buffer_size=6000, batch_size=64, discount_gamma=0.99, max_turns: int = 25, include_confreq=False, logger: DiasysLogger = DiasysLogger(), include_select: bool = False, device=torch.device('cpu'), obj_evaluator: ObjectiveReachedEvaluator = None): """ Creates state- and action spaces, initializes experience replay buffers. Arguments: domain {domain.jsonlookupdomain.JSONLookupDomain} -- Domain Keyword Arguments: subgraph {[type]} -- [see services.Module] (default: {None}) buffer_cls {services.policy.rl.experience_buffer.Buffer} -- [Experience replay buffer *class*, **not** an instance - will be initialized by this constructor!] (default: {UniformBuffer}) buffer_size {int} -- [see services.policy.rl.experience_buffer. Buffer] (default: {6000}) batch_size {int} -- [see services.policy.rl.experience_buffer. Buffer] (default: {64}) discount_gamma {float} -- [Discount factor] (default: {0.99}) include_confreq {bool} -- [Use confirm_request actions] (default: {False}) """ self.device = device self.sys_state = { "lastInformedPrimKeyVal": None, "lastActionInformNone": False, "offerHappened": False, 'informedPrimKeyValsSinceNone': [] } self.max_turns = max_turns self.logger = logger self.domain = domain # setup evaluator for training self.evaluator = obj_evaluator # ObjectiveReachedEvaluator(domain, logger=logger) self.buffer_size = buffer_size self.batch_size = batch_size self.discount_gamma = discount_gamma self.writer = None # get state size self.state_dim = self.beliefstate_dict_to_vector( BeliefState(domain)._init_beliefstate()).size(1) self.logger.info("state space dim: " + str(self.state_dim)) # get system action list self.actions = [ "inform_byname", # TODO rename to 'bykey' "inform_alternatives", "reqmore" ] # TODO badaction for req_slot in self.domain.get_system_requestable_slots(): self.actions.append('request#' + req_slot) self.actions.append('confirm#' + req_slot) if include_select: self.actions.append('select#' + req_slot) if include_confreq: for conf_slot in self.domain.get_system_requestable_slots(): if not req_slot == conf_slot: # skip case where confirm slot = request slot self.actions.append('confreq#' + conf_slot + '#' + req_slot) self.action_dim = len(self.actions) # don't include closingmsg in learnable actions self.actions.append('closingmsg') # self.actions.append("closingmsg") self.logger.info("action space dim: " + str(self.action_dim)) self.primary_key = self.domain.get_primary_key() # init replay memory self.buffer = buffer_cls(buffer_size, batch_size, self.state_dim, discount_gamma=discount_gamma, device=device) self.sys_state = {} self.last_sys_act = None
def __init__(self, domain: JSONLookupDomain, architecture: NetArchitecture = NetArchitecture.DUELING, hidden_layer_sizes: List[int] = [256, 700, 700], # vanilla architecture shared_layer_sizes: List[int] = [256], value_layer_sizes : List[int] = [300,300], advantage_layer_sizes: List[int] = [400, 400], # dueling architecture lr: float = 0.0001, discount_gamma: float = 0.99, target_update_rate: int = 3, replay_buffer_size: int = 8192, batch_size: int = 64, buffer_cls: Type[Buffer] = NaivePrioritizedBuffer, eps_start: float = 0.3, eps_end: float = 0.0, l2_regularisation: float = 0.0, gradient_clipping: float = 5.0, p_dropout: float = 0.0, training_frequency: int = 2, train_dialogs: int = 1000, include_confreq: bool = False, logger: DiasysLogger = DiasysLogger()): """ Args: target_update_rate: if 1, vanilla dqn update if > 1, double dqn with specified target update rate """ super(DQNPolicy, self).__init__(domain, buffer_cls=buffer_cls, buffer_size=replay_buffer_size, batch_size=batch_size, discount_gamma=discount_gamma, include_confreq=include_confreq, logger=logger) self.training_frequency = training_frequency self.train_dialogs = train_dialogs self.lr = lr self.gradient_clipping = gradient_clipping if gradient_clipping > 0.0: self.logger.info("Gradient Clipping: " + str(gradient_clipping)) self.target_update_rate = target_update_rate self.epsilon_start = eps_start self.epsilon_end = eps_end # Select network architecture if architecture == NetArchitecture.VANILLA: self.logger.info("Architecture: Vanilla") self.model = DQN(self.state_dim, self.action_dim, hidden_layer_sizes=hidden_layer_sizes, dropout_rate=p_dropout) else: self.logger.info("Architecture: Dueling") self.model = DuelingDQN(self.state_dim, self.action_dim, shared_layer_sizes=shared_layer_sizes, value_layer_sizes=value_layer_sizes, advantage_layer_sizes=advantage_layer_sizes, dropout_rate=p_dropout) # Select network update self.target_model = None if target_update_rate > 1: self.logger.info("Update: Double") if architecture == NetArchitecture.VANILLA: self.target_model = copy.deepcopy(self.model) else: self.logger.info("Update: Vanilla") self.optim = optim.Adam(self.model.parameters(), lr=lr, weight_decay=l2_regularisation) self.loss_fun = nn.SmoothL1Loss(reduction='none') #self.loss_fun = nn.MSELoss(reduction='none') self.train_call_count = 0 self.total_train_dialogs = 0 self.epsilon = self.epsilon_start
def __init__(self, domain: Domain, logger: DiasysLogger = DiasysLogger()): super(HandcraftedUserSimulator, self).__init__(domain) # possible system actions self.receive_options = { SysActionType.Welcome: self._receive_welcome, SysActionType.InformByName: self._receive_informbyname, SysActionType.InformByAlternatives: self._receive_informbyalternatives, SysActionType.Request: self._receive_request, SysActionType.Confirm: self._receive_confirm, SysActionType.Select: self._receive_select, SysActionType.RequestMore: self._receive_requestmore, SysActionType.Bad: self._receive_bad, SysActionType.ConfirmRequest: self._receive_confirmrequest } # parse config file self.logger = logger self.config = configparser.ConfigParser(inline_comment_prefixes=('#', ';')) self.config.optionxform = str self.config.read( os.path.join(os.path.abspath(os.path.dirname(__file__)), 'usermodel.cfg')) self.parameters = {} # goal self.parameters['goal'] = {} for key in self.config["goal"]: val = self.config.get("goal", key) self.parameters['goal'][key] = float(val) # usermodel self.parameters['usermodel'] = {} for key in self.config["usermodel"]: val = self.config.get("usermodel", key) if key in ['patience']: # patience will be sampled on begin of each dialog self.parameters['usermodel'][key] = [ int(x) for x in (val.replace(' ', '').strip('[]').split(',')) ] else: if val.startswith("[") and val.endswith("]"): # value is a list to sample the probability from self.parameters['usermodel'][ key] = common.numpy.random.uniform(*[ float(x) for x in val.replace(' ', '').strip( '[]').split(',') ]) else: # value is the probability self.parameters['usermodel'][key] = float(val) # member declarations self.turn = 0 self.domain = domain self.dialog_patience = None self.patience = None self.last_user_actions = None self.last_system_action = None self.excluded_venues = [] # member definitions self.goal = Goal(domain, self.parameters['goal']) self.agenda = Agenda() self.num_actions_next_turn = -1
conversation_log_dir = './conversation_logs' speech_log_dir = None if file_log_lvl == LogLevel.DIALOGS: # log user audio, system audio and complete conversation import time from math import floor print("This Adviser call will log all your interactions to files.\n") if not os.path.exists(f"./{conversation_log_dir}"): os.mkdir(f"./{conversation_log_dir}/") conversation_log_dir = "./" + conversation_log_dir + "/{}/".format( floor(time.time())) os.mkdir(conversation_log_dir) speech_log_dir = conversation_log_dir logger = DiasysLogger(file_log_lvl=file_log_lvl, console_log_lvl=log_lvl, logfile_folder=conversation_log_dir, logfile_basename="full_log") # load domain specific services if 'lecturers' in args.domains: l_domain, l_services = load_lecturers_domain(backchannel=args.bc) domains.append(l_domain) services.extend(l_services) if 'weather' in args.domains: w_domain, w_services = load_weather_domain() domains.append(w_domain) services.extend(w_services) if 'mensa' in args.domains: m_domain, m_services = load_mensa_domain(backchannel=args.bc) domains.append(m_domain) services.extend(m_services)
def __init__(self, domain, logger=DiasysLogger()): # only calls super class' constructor super(VVSNLU, self).__init__(domain, debug_logger=logger)
def __init__(self, domain: Domain, logger: DiasysLogger = DiasysLogger()): super(UserSimulator, self).__init__(domain, logger=logger) self.domain = domain self.goal = None self.turn = None
import torch import torch.optim as optim import torch.nn as nn from tensorboardX import SummaryWriter from modules.policy.policy_rl import RLPolicy from modules.policy.rl.common import DEVICE from modules.policy.rl.experience_buffer import UniformBuffer, NaivePrioritizedBuffer from modules.policy.rl.dqn import DQN, DuelingDQN, NetArchitecture from utils.useract import UserActionType, UserAct from utils.sysact import SysAct, SysActionType from utils.beliefstate import BeliefState from utils.logger import DiasysLogger from utils import Goal, common logger = DiasysLogger() MAX_TURNS = 25 class DQNPolicy(RLPolicy): def __init__( self, domain, architecture: NetArchitecture = NetArchitecture.DUELING, hidden_layer_sizes=[300, 700, 700], # vanilla architecture shared_layer_sizes=[300], value_layer_sizes=[300, 300], advantage_layer_sizes=[400, 400], # dueling architecture lr=0.0001, discount_gamma=0.99,
def __init__(self, domain: LookupDomain, logger: DiasysLogger = DiasysLogger()): # only call super class' constructor HandcraftedPolicy.__init__(self, domain=domain, logger=logger)
from tensorboardX import SummaryWriter from services.policy.rl.experience_buffer import NaivePrioritizedBuffer from services.simulator import HandcraftedUserSimulator from services.policy import DQNPolicy from services.stats.evaluation import PolicyEvaluator super_domain = JSONLookupDomain(name="ImsLecturers") policy = HandcraftedPolicy(domain=super_domain) # Allows you to track training progress using tensorboard summary_writer = SummaryWriter(os.path.join('logs', "tutorial")) # logs summary statistics for each train/test epoch logger = DiasysLogger(console_log_lvl=LogLevel.RESULTS, file_log_lvl=LogLevel.DIALOGS) dialogue_logger = DiasysLogger(name='dialogue_logger', console_log_lvl=LogLevel.ERRORS, file_log_lvl=LogLevel.DIALOGS, logfile_folder='dialogue_history', logfile_basename='history') # Create RL policy instance with parameters used in ADVISER paper policy = DQNPolicy(domain=super_domain, lr=0.0001, eps_start=0.3, gradient_clipping=5.0, buffer_cls=NaivePrioritizedBuffer, replay_buffer_size=8192, shared_layer_sizes=[256], train_dialogs=1000,