def __init__(self, domainString): #DomainUtils() instance, which accesses ontology and database. self.domainUtil = DomainUtils.DomainUtils(domainString=domainString) configs = [] # self.reward_every_turn = True # if Settings.config.has_option("eval", "rewardeveryturn"): # configs.append('rewardeveryturn') # self.reward_every_turn = Settings.config.getboolean('eval', 'rewardeveryturn') self.reward_venue_recommended = 100 if Settings.config.has_option('eval', 'rewardvenuerecommended'): configs.append('rewardvenuerecommended') self.reward_venue_recommended = Settings.config.getint('eval', 'rewardvenuerecommended') self.penalise_all_turns = False if Settings.config.has_option('eval', 'penaliseallturns'): configs.append('penaliseallturns') self.penalise_all_turns = Settings.config.getboolean('eval', 'penaliseallturns') self.wrong_venue_penalty = 4 if Settings.config.has_option('eval', 'wrongvenuepenalty'): configs.append('wrongvenuepenalty') self.wrong_venue_penalty = Settings.config.getint('eval', 'wrongvenuepenalty') self.not_mentioned_value_penalty = 4 if Settings.config.has_option('eval', 'notmentionedvaluepenalty'): configs.append('notmentionedvaluepenalty') self.not_mentioned_value_penalty = Settings.config.getint('eval', 'notmentionedvaluepenalty') self.restart() if Settings.config.has_section('eval'): for opt in Settings.config.options('eval'): if opt not in configs and opt not in Settings.config.defaults(): logger.error('Invalid config: '+opt)
def __init__(self, domainString): domainUtil = DomainUtils.DomainUtils(domainString) self.generator = GoalGenerator(domainUtil) self.goal = None self.prev_goal = None self.hdcSim = UMHdcSim.UMHdcSim(domainUtil) self.lastUserAct = None self.lastSysAct = None
def __init__(self, domainString): self.domainUtil = DomainUtils.DomainUtils(domainString) self.CONFUSE_TYPE = 0.2 self.CONFUSE_SLOT = 0.3 self.CONFUSE_VALUE = 0.5 self.newUserActs = [ 'hello', 'thankyou', 'ack', 'bye', 'inform', 'request', 'reqalts', 'reqmore', 'confirm', 'affirm', 'negate', 'deny', 'repeat', 'null' ] self.nNewUserActs = len(self.newUserActs)
def create_domain_dependent_regex(self): """Can overwrite any of the regular expressions set in RegexSemI.RegexParser.init_regular_expressions(). This doesn't deal with slot,value (ie domain dependent) semantics. For those you need to handcraft the _decode_[inform,request,confirm] etc. """ # REDEFINES OF BASIC SEMANTIC ACTS (ie those other than inform, request): (likely nothing needs to be done here) #eg: self.rHELLO = "anion" domain_util = DomainUtils.DomainUtils(domainString=self.domainTag, rootIn=self.repoRoot) self.USER_REQUESTABLE = domain_util.ontology["requestable"] self.USER_INFORMABLE = domain_util.ontology["system_requestable"] self.domains_type = domain_util.ontology["type"] # DOMAIN DEPENDENT SEMANTICS: self.slot_vocab = {} # FIXME: define slot specific language - for requests #------------------------------------------------------------------------------------------- self.slot_vocab["warranty"] = "(warranty)" self.slot_vocab["design"] = "(design)" self.slot_vocab["display"] = "(display)" self.slot_vocab["graphadaptor"] = "(graphadaptor)" self.slot_vocab["sysmemory"] = "(sysmemory)" self.slot_vocab["processor"] = "(processor)" self.slot_vocab["processorclass"] = "(processorclass)" self.slot_vocab["platform"] = "(platform)" self.slot_vocab["utility"] = "(utility)" self.slot_vocab["price"] = "(price|cost|expense)(?!(\ ?range))" self.slot_vocab["pricerange"] = "(price\ ?range)" self.slot_vocab["dimension"] = "(size|dimension)" self.slot_vocab["weight"] = "(weight)(?!(\ ?range))" self.slot_vocab["weightrange"] = "(weight|weight\ ?range)" self.slot_vocab[ "batteryrating"] = "(battery|battery\ ?rating|rating\ of\ the\ (laptops\ )*battery)" self.slot_vocab[ "isforbusinesscomputing"] = "(business\ computing|gaming|fun|games|work|play)" self.slot_vocab["drive"] = "(drive|hard\ *drive)(?!(\ ?range))" self.slot_vocab["driverange"] = "(hard\ *)*drive(\ ?range)" self.slot_vocab["name"] = "(name)" self.slot_vocab["family"] = "(family|class)" #------------------------------------------------------------------------------------------- # Generate regular expressions for requests: self._set_request_regex() # Generate regular expressions for informs: self.slot_values = dict.fromkeys(self.USER_INFORMABLE) for slot in self.slot_values.keys(): self.slot_values[slot] = { value: "(" + str(value) + ")" for value in domain_util.ontology["informable"][slot] } # FIXME: many value have synonyms -- deal with this here: self._set_value_synonyms() # At end of file - this can grow very long self._set_inform_regex()
def bootup(self, domainString, previousDomainString=None, episodeNum=1): """ """ # also fire up the DMUtils - pass the slots too below... domain_utils = DomainUtils.DomainUtils(domainString=domainString) self.domainManagers[domainString] = DMan.DMan(domainUtil=domain_utils) self.domainManagers[domainString].restart() self.operatingDomain = domainString self.startLearningEpisode(episodeNum) # and note that this domain is now involved in current dialog: self.in_present_dialog.append(domainString) return self._conditionally_init_new_domains_belief( previousDomainString)
def create_domain_dependent_regex(self): """Can overwrite any of the regular expressions set in RegexSemI.RegexParser.init_regular_expressions(). This doesn't deal with slot,value (ie domain dependent) semantics. For those you need to handcraft the _decode_[inform,request,confirm] etc. """ # REDEFINES OF BASIC SEMANTIC ACTS (ie those other than inform, request): (likely nothing needs to be done here) #eg: self.rHELLO = "anion" domain_util = DomainUtils.DomainUtils(domainString=self.domainTag, rootIn=self.repoRoot) self.USER_REQUESTABLE = domain_util.ontology["requestable"] self.USER_INFORMABLE = domain_util.ontology["system_requestable"] self.domains_type = domain_util.ontology["type"] # DOMAIN DEPENDENT SEMANTICS: self.slot_vocab= {} # FIXME: define slot specific language - for requests #------------------------------------------------------------------------------------------- exit("below are the slots for the domain - fix up self.slot_vocab below")
def create_domain_dependent_regex(self): """Can overwrite any of the regular expressions set in RegexSemI.RegexParser.init_regular_expressions(). This doesn't deal with slot,value (ie domain dependent) semantics. For those you need to handcraft the _decode_[inform,request,confirm] etc. """ # REDEFINES OF BASIC SEMANTIC ACTS (ie those other than inform, request): (likely nothing needs to be done here) #eg: self.rHELLO = "anion" domain_util = DomainUtils.DomainUtils(domainString=self.domainTag, rootIn=self.repoRoot) self.USER_REQUESTABLE = domain_util.ontology["requestable"] self.USER_INFORMABLE = domain_util.ontology["system_requestable"] self.domains_type = domain_util.ontology["type"] # DOMAIN DEPENDENT SEMANTICS: self.slot_vocab = {} # FIXME: define slot specific language - for requests #------------------------------------------------------------------------------------------- self.slot_vocab["price"] = "(price|cost|expense)(?!(\ ?range))" self.slot_vocab["pricerange"] = "(price\ ?range)" self.slot_vocab["accessories"] = "(extras|accessories)" self.slot_vocab["power"] = "(power)" self.slot_vocab["pixels"] = "(pixels)" self.slot_vocab["audio"] = "(audio|sound)" self.slot_vocab["cabinet"] = "(cabinet)" self.slot_vocab["eco"] = "((eco|environment(al)*)\ rating)" self.slot_vocab["screensizerange"] = "(screen\ ?size)(?!(\ ?range))" self.slot_vocab["screensize"] = "(screen\ ?size))" self.slot_vocab["hdmi"] = "(hdmi)" self.slot_vocab["usb"] = "(usb)" self.slot_vocab["name"] = "(name)" self.slot_vocab["series"] = "(series|family|class)" #------------------------------------------------------------------------------------------- # Generate regular expressions for requests: self._set_request_regex() # Generate regular expressions for informs: self.slot_values = dict.fromkeys(self.USER_INFORMABLE) for slot in self.slot_values.keys(): self.slot_values[slot] = { value: "(" + str(value) + ")" for value in domain_util.ontology["informable"][slot] } # FIXME: many value have synonyms -- deal with this here: self._set_value_synonyms() # At end of file - this can grow very long self._set_inform_regex()
def create_domain_dependent_regex(self): """Can overwrite any of the regular expressions set in RegexSemI.RegexParser.init_regular_expressions(). This doesn't deal with slot,value (ie domain dependent) semantics. For those you need to handcraft the _decode_[inform,request,confirm] etc. """ # REDEFINES OF BASIC SEMANTIC ACTS (ie those other than inform, request): (likely nothing needs to be done here) #eg: self.rHELLO = "anion" domain_util = DomainUtils.DomainUtils(domainString=self.domainTag, rootIn=self.repoRoot) self.USER_REQUESTABLE = domain_util.ontology["requestable"] self.USER_INFORMABLE = domain_util.ontology["system_requestable"] self.domains_type = domain_util.ontology["type"] # DOMAIN DEPENDENT SEMANTICS: self.slot_vocab = {} # FIXME: define slot specific language - for requests #--------------------------------------------------------------------------------------------------- exit("THESE NEED FIXING FOR THIS DOMAIN") self.slot_vocab["addr"] = "(address)" self.slot_vocab["pricerange"] = "(price|cost)(\ ?range)*" self.slot_vocab["area"] = "(area|location)" self.slot_vocab["near"] = "(near)" self.slot_vocab["kind"] = "(kind)" self.slot_vocab["stars"] = "(stars|rating)" self.slot_vocab["phone"] = "(phone(\ number)*)" self.slot_vocab["postcode"] = "(postcode)" self.slot_vocab["hasinternet"] = "(internet)" self.slot_vocab["hasparking"] = "(parking|car(\ ?park))" self.slot_vocab["name"] = "(name)" #--------------------------------------------------------------------------------------------------- # Generate regular expressions for requests: self._set_request_regex() # Generate regular expressions for informs: self.slot_values = dict.fromkeys(self.USER_INFORMABLE) for slot in self.slot_values.keys(): self.slot_values[slot] = { value: "(" + str(value) + ")" for value in domain_util.ontology["informable"][slot] } # FIXME: many value have synonyms -- deal with this here: self._set_value_synonyms() # At end of file - this can grow very long self._set_inform_regex()