def load_mensa_domain(backchannel: bool = False):
from examples.webapi.mensa import MensaDomain, MensaNLU
from services.policy.policy_api import HandcraftedPolicy as PolicyAPI
mensa = MensaDomain()
mensa_nlu = MensaNLU(domain=mensa)
mensa_bst = HandcraftedBST(domain=mensa)
mensa_policy = PolicyAPI(domain=mensa)
mensa_nlg = load_nlg(backchannel=backchannel, domain=mensa)
return mensa, [mensa_nlu, mensa_bst, mensa_policy, mensa_nlg]
def load_weather_domain():
from examples.webapi.weather import WeatherNLU, WeatherNLG, WeatherDomain
from services.policy.policy_api import HandcraftedPolicy as PolicyAPI
weather = WeatherDomain()
weather_nlu = WeatherNLU(domain=weather)
weather_nlg = WeatherNLG(domain=weather)
weather_bst = HandcraftedBST(domain=weather)
weather_policy = PolicyAPI(domain=weather)
return weather, [weather_nlu, weather_nlg, weather_bst, weather_policy]
def load_lecturers_domain(backchannel: bool = False):
from utils.domain.jsonlookupdomain import JSONLookupDomain
from services.nlu.nlu import HandcraftedNLU
from services.nlg.nlg import HandcraftedNLG
from services.policy import HandcraftedPolicy
domain = JSONLookupDomain('ImsLecturers', display_name="Lecturers")
lect_nlu = HandcraftedNLU(domain=domain)
lect_bst = HandcraftedBST(domain=domain)
lect_policy = HandcraftedPolicy(domain=domain)
lect_nlg = load_nlg(backchannel=backchannel, domain=domain)
return domain, [lect_nlu, lect_bst, lect_policy, lect_nlg]
# feature processing
engagement = EngagementTracker()
emotion = EmotionRecognition()
ust = HandcraftedUST()
affective_policy = EmotionPolicy()
# lecturer specific modules
lect_nlu = HandcraftedNLU(domain=lecturers)
# lect_nlg = HandcraftedEmotionNLG(domain=lecturers, sub_topic_domains={'sys_emotion': '', 'sys_engagement': ''},
# emotions=["Happy", "Angry", "Sad"])
lect_nlg = BackchannelHandcraftedNLG(domain=lecturers,
sub_topic_domains={'predicted_BC': ''})
lect_policy = HandcraftedPolicy(domain=lecturers)
lect_bst = HandcraftedBST(domain=lecturers)
# weather specific modules
weather_nlu = WeatherNLU(domain=weather)
weather_nlg = WeatherNLG(domain=weather)
weather_bst = HandcraftedBST(domain=weather)
weather_policy = PolicyAPI(domain=weather)
backchanneler = AcousticBackchanneller()
# install node modules if missing
webui_folder = os.path.abspath(
os.path.join(os.path.dirname(os.path.abspath(__file__)), "tools", "webui"))
if not os.path.isdir(os.path.join(webui_folder, 'node_modules')):
print("INFO: Couldn't find node dependencies - trying to install...")
subprocess.run(["npm", "install"], cwd=webui_folder, capture_output=True)
def train(domain_name: str, log_to_file: bool, seed: int, train_epochs: int, train_dialogs: int,
eval_dialogs: int, max_turns: int, train_error_rate: float, test_error_rate: float,
lr: float, eps_start: float, grad_clipping: float, buffer_classname: str,
buffer_size: int, use_tensorboard: bool):
"""
Training loop for the RL policy, for information on the parameters, look at the descriptions
of commandline arguments in the "if main" below
"""
seed = seed if seed != -1 else None
common.init_random(seed=seed)
file_log_lvl = LogLevel.DIALOGS if log_to_file else LogLevel.NONE
logger = DiasysLogger(console_log_lvl=LogLevel.RESULTS, file_log_lvl=file_log_lvl)
summary_writer = SummaryWriter(log_dir='logs') if use_tensorboard else None
if buffer_classname == "prioritized":
buffer_cls = NaivePrioritizedBuffer
elif buffer_classname == "uniform":
buffer_cls = UniformBuffer
domain = JSONLookupDomain(name=domain_name)
bst = HandcraftedBST(domain=domain, logger=logger)
user = HandcraftedUserSimulator(domain, logger=logger)
# noise = SimpleNoise(domain=domain, train_error_rate=train_error_rate,
# test_error_rate=test_error_rate, logger=logger)
policy = DQNPolicy(domain=domain, lr=lr, eps_start=eps_start,
gradient_clipping=grad_clipping, buffer_cls=buffer_cls,
replay_buffer_size=buffer_size, train_dialogs=train_dialogs,
logger=logger, summary_writer=summary_writer)
evaluator = PolicyEvaluator(domain=domain, use_tensorboard=use_tensorboard,
experiment_name=domain_name, logger=logger,
summary_writer=summary_writer)
ds = DialogSystem(services=[user, bst, policy, evaluator], protocol='tcp')
# ds.draw_system_graph()
error_free = ds.is_error_free_messaging_pipeline()
if not error_free:
ds.print_inconsistencies()
for j in range(train_epochs):
# START TRAIN EPOCH
evaluator.train()
policy.train()
evaluator.start_epoch()
for episode in range(train_dialogs):
if episode % 100 == 0:
print("DIALOG", episode)
logger.dialog_turn("\n\n!!!!!!!!!!!!!!!! NEW DIALOG !!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n")
ds.run_dialog(start_signals={f'user_acts/{domain.get_domain_name()}': []})
evaluator.end_epoch()
policy.save()
# START EVAL EPOCH
evaluator.eval()
policy.eval()
evaluator.start_epoch()
for episode in range(eval_dialogs):
logger.dialog_turn("\n\n!!!!!!!!!!!!!!!! NEW DIALOG !!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n")
ds.run_dialog(start_signals={f'user_acts/{domain.get_domain_name()}': []})
evaluator.end_epoch()
ds.shutdown()
def bst(domain):
return HandcraftedBST(domain)
user_sim = HandcraftedUserSimulator(domain=super_domain,
logger=dialogue_logger)
evaluator = PolicyEvaluator(domain=super_domain,
use_tensorboard=True,
experiment_name="tutorial",
logger=dialogue_logger,
summary_writer=summary_writer)
# SET CONSTANTS
TRAIN_EPOCHS = 1
TRAIN_EPISODES = 1000
EVAL_EPISODES = 1000
MAX_TURNS = 25
bst = HandcraftedBST(domain=super_domain)
# Choose how many repeated trials
for i in range(1):
common.init_random(
) # add seed here as a parameter to the init_random if wanted
ds = DialogSystem(services=[user_sim, bst, policy, evaluator],
protocol='tcp')
# Start train/eval loop
for j in range(TRAIN_EPOCHS):
# START TRAIN EPOCH
evaluator.train()
policy.train()
evaluator.start_epoch()
for episode in range(TRAIN_EPISODES):
def test_initialize_bst_without_domain():
"""
Tests whether the initialization of a BST without domain executes without errors.
"""
HandcraftedBST()