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()
