def __init__(self,
movie_dict=None,
act_set=None,
slot_set=None,
start_set=None,
params=None):
""" Constructor shared by all user simulators """
self.movie_dict = movie_dict
self.act_set = act_set
self.slot_set = slot_set
self.start_set = start_set
self.max_turn = params['max_turn']
self.slot_err_probability = params['slot_err_probability']
self.slot_err_mode = params['slot_err_mode']
self.intent_err_probability = params['intent_err_probability']
self.simulator_run_mode = params['simulator_run_mode']
self.simulator_act_level = params['simulator_act_level']
self.learning_phase = params['learning_phase']
#TODO: Initialize custom testbed
self.test_bed = TestBed()
def test_load_yaml():
fp = "./cde465.yaml"
tb = TestBed()
conf_dict = tb.load(fp)
# for key, value in conf_dict.items():
# print("%s : %s" % (key, value))
# print(conf_dict)
# print(json.dumps(conf_dict,sort_keys=True,indent=4))
rtn_lst = tb.parse_to_json_tree(conf_dict)
print(rtn_lst)
def setup(self, window_size=20, t_in=2, w=10, h=10, d=1, t_out=1, hidden_layers_sizes=[100], pretrain_step=1):
self.bed = TestBed(window_size=window_size, t_in=t_in, w=w, h=h, d=d, t_out=t_out, hidden_layers_sizes=hidden_layers_sizes)
self.gen = SinGenerator(w=w, h=h, d=1)
# self.gen = RadarGenerator('../data/radar', w=w, h=h, left=0, top=80)
self.vis = Visualizer(w=w, h=h, t_out=t_out)
self.pretrain_step = pretrain_step
# fill the window with data
for i in xrange(window_size):
y = self.gen.next()
self.bed.supply(y)
class Worker(QtCore.QThread):
started = QtCore.Signal()
updated = QtCore.Signal(numpy.ndarray, numpy.ndarray)
stopped = QtCore.Signal()
def __init__(self, parent=None):
super(Worker, self).__init__(parent)
self.bed = None
self.gen = None
self.delay = 1.0
self.stop_flg = False
self.mutex = QtCore.QMutex()
def setup(self, window_size=20, t_in=2, w=10, h=10, d=1, t_out=1, hidden_layers_sizes=[100], pretrain_step=1):
self.bed = TestBed(window_size=window_size, t_in=t_in, w=w, h=h, d=d, t_out=t_out, hidden_layers_sizes=hidden_layers_sizes)
self.gen = SinGenerator(w=w, h=h, d=1)
# self.gen = RadarGenerator('../data/radar', w=w, h=h, left=0, top=80)
self.vis = Visualizer(w=w, h=h, t_out=t_out)
self.pretrain_step = pretrain_step
# fill the window with data
for i in xrange(window_size):
y = self.gen.next()
self.bed.supply(y)
def setGeneratorParams(self, k, n):
pass
def setDelay(self, delay):
self.delay = delay
def setLearningParams(self, params):
self.finetune_epochs = params['finetune_epochs']
self.finetune_lr = params['finetune_lr']
self.finetune_batch_size = params['finetune_batch_size']
self.pretrain_epochs = params['pretrain_epochs']
self.pretrain_lr = params['pretrain_lr']
self.pretrain_batch_size = params['pretrain_batch_size']
def stop(self):
with QtCore.QMutexLocker(self.mutex):
self.stop_flg = True
def run(self):
print("Worker: started")
with QtCore.QMutexLocker(self.mutex):
self.stop_flg = False
self.started.emit()
for i,yt in enumerate(self.gen):
# predict
y_preds = self.bed.predict()
print("{0}: yt={1}, y_pred={2}".format(i, yt, y_preds))
self.bed.supply(yt)
self.vis.append_data(yt, y_preds)
if i % self.pretrain_step == 0 and 0 < self.pretrain_epochs:
# pretrain
avg_cost = self.bed.pretrain(self.pretrain_epochs, learning_rate=self.pretrain_lr, batch_size=self.pretrain_batch_size)
print(" pretrain cost: {0}".format(avg_cost))
pass
# finetune
costs = self.bed.finetune(self.finetune_epochs, learning_rate=self.finetune_lr, batch_size=self.finetune_batch_size)
train_cost, valid_cost, test_cost = costs
print(" train cost: {0}".format(train_cost))
self.vis.append_cost(train_cost, valid_cost, test_cost)
self.updated.emit(yt, y_preds)
time.sleep(self.delay)
if self.stop_flg:
print(' --- iteration end ---')
break
self.stopped.emit()
def run_and_log(benchmark, case_params):
dump_file = '%s/dump-%d.pkl' % (benchmark.trace_dir, os.getpid())
test = TestBed(dump_file, benchmark.tunings, custom_tunings=case_params)
test.run(benchmark.rand_poses,
benchmark.rand_velocities)
class RuleSimulator(UserSimulator):
""" GLEN FUNCTIONS FOR CHANGING USER GOAL RANDOMLY """
test_bed = 0
""" A rule-based user simulator for testing dialog policy """
def __init__(self,
movie_dict=None,
act_set=None,
slot_set=None,
start_set=None,
params=None):
""" Constructor shared by all user simulators """
self.movie_dict = movie_dict
self.act_set = act_set
self.slot_set = slot_set
self.start_set = start_set
self.max_turn = params['max_turn']
self.slot_err_probability = params['slot_err_probability']
self.slot_err_mode = params['slot_err_mode']
self.intent_err_probability = params['intent_err_probability']
self.simulator_run_mode = params['simulator_run_mode']
self.simulator_act_level = params['simulator_act_level']
self.learning_phase = params['learning_phase']
#TODO: Initialize custom testbed
self.test_bed = TestBed()
def initialize_episode(self):
""" Initialize a new episode (dialog)
state['history_slots']: keeps all the informed_slots
state['rest_slots']: keep all the slots (which is still in the stack yet)
"""
self.state = {}
self.state['history_slots'] = {}
self.state['inform_slots'] = {}
self.state['request_slots'] = {}
self.state['rest_slots'] = []
self.state['turn'] = 0
self.episode_over = False
self.dialog_status = dialog_config.NO_OUTCOME_YET
##### testbed setup ####
# self.test_bed.init_stats_dict(3) #--setup in run.py
self.test_bed.collect_stats_flag = True
self.test_bed.goal_change_prob = 0.1
self.test_bed.build_goal_dict(self.start_set)
self.goal = self._sample_goal(self.start_set)
self.goal['request_slots']['ticket'] = 'UNK'
self.constraint_check = dialog_config.CONSTRAINT_CHECK_FAILURE
""" Debug: build a fake goal mannually """
#self.debug_falk_goal()
#TODO: What probability we will randomly change goal
# sample first action
user_action = self._sample_action()
assert (self.episode_over != 1), ' but we just started'
return user_action
def _sample_action(self):
""" randomly sample a start action based on user goal """
self.state['diaact'] = random.choice(
dialog_config.start_dia_acts.keys())
# "sample" informed slots
if len(self.goal['inform_slots']) > 0:
known_slot = random.choice(self.goal['inform_slots'].keys())
self.state['inform_slots'][known_slot] = self.goal['inform_slots'][
known_slot]
if 'moviename' in self.goal['inform_slots'].keys(
): # 'moviename' must appear in the first user turn
self.state['inform_slots']['moviename'] = self.goal[
'inform_slots']['moviename']
for slot in self.goal['inform_slots'].keys():
if known_slot == slot or slot == 'moviename': continue
self.state['rest_slots'].append(slot)
self.state['rest_slots'].extend(self.goal['request_slots'].keys())
# "sample" a requested slot
request_slot_set = list(self.goal['request_slots'].keys())
request_slot_set.remove('ticket')
if len(request_slot_set) > 0:
request_slot = random.choice(request_slot_set)
else:
request_slot = 'ticket'
self.state['request_slots'][request_slot] = 'UNK'
if len(self.state['request_slots']) == 0:
self.state['diaact'] = 'inform'
if (self.state['diaact'] in ['thanks', 'closing']):
self.episode_over = True #episode_over = True
else:
self.episode_over = False #episode_over = False
sample_action = {}
sample_action['diaact'] = self.state['diaact']
sample_action['inform_slots'] = self.state['inform_slots']
sample_action['request_slots'] = self.state['request_slots']
sample_action['turn'] = self.state['turn']
self.add_nl_to_action(sample_action)
return sample_action
def _sample_goal(self, goal_set):
""" sample a user goal """
sample_goal = random.choice(self.start_set[self.learning_phase])
return sample_goal
def corrupt(self, user_action):
""" Randomly corrupt an action with error probs (slot_err_probability and slot_err_mode) on Slot and Intent (intent_err_probability). """
for slot in user_action['inform_slots'].keys():
slot_err_prob_sample = random.random()
if slot_err_prob_sample < self.slot_err_probability: # add noise for slot level
if self.slot_err_mode == 0: # replace the slot_value only
if slot in self.movie_dict.keys():
user_action['inform_slots'][slot] = random.choice(
self.movie_dict[slot])
elif self.slot_err_mode == 1: # combined
slot_err_random = random.random()
if slot_err_random <= 0.33:
if slot in self.movie_dict.keys():
user_action['inform_slots'][slot] = random.choice(
self.movie_dict[slot])
elif slot_err_random > 0.33 and slot_err_random <= 0.66:
del user_action['inform_slots'][slot]
random_slot = random.choice(self.movie_dict.keys())
user_action[random_slot] = random.choice(
self.movie_dict[random_slot])
else:
del user_action['inform_slots'][slot]
elif self.slot_err_mode == 2: #replace slot and its values
del user_action['inform_slots'][slot]
random_slot = random.choice(self.movie_dict.keys())
user_action[random_slot] = random.choice(
self.movie_dict[random_slot])
elif self.slot_err_mode == 3: # delete the slot
del user_action['inform_slots'][slot]
intent_err_sample = random.random()
if intent_err_sample < self.intent_err_probability: # add noise for intent level
user_action['diaact'] = random.choice(self.act_set.keys())
def debug_falk_goal(self):
""" Debug function: build a fake goal mannually (Can be moved in future) """
self.goal['inform_slots'].clear()
#self.goal['inform_slots']['city'] = 'seattle'
self.goal['inform_slots']['numberofpeople'] = '2'
#self.goal['inform_slots']['theater'] = 'amc pacific place 11 theater'
#self.goal['inform_slots']['starttime'] = '10:00 pm'
#self.goal['inform_slots']['date'] = 'tomorrow'
self.goal['inform_slots']['moviename'] = 'zoology'
self.goal['inform_slots']['distanceconstraints'] = 'close to 95833'
self.goal['request_slots'].clear()
self.goal['request_slots']['ticket'] = 'UNK'
self.goal['request_slots']['theater'] = 'UNK'
self.goal['request_slots']['starttime'] = 'UNK'
self.goal['request_slots']['date'] = 'UNK'
def next(self, system_action):
""" Generate next User Action based on last System Action """
self.state['turn'] += 2
self.episode_over = False
self.dialog_status = dialog_config.NO_OUTCOME_YET
sys_act = system_action['diaact']
if (self.max_turn > 0 and self.state['turn'] > self.max_turn):
self.dialog_status = dialog_config.FAILED_DIALOG
self.episode_over = True
self.state['diaact'] = "closing"
else:
self.state['history_slots'].update(self.state['inform_slots'])
self.state['inform_slots'].clear()
if sys_act == "inform":
self.response_inform(system_action)
elif sys_act == "multiple_choice":
self.response_multiple_choice(system_action)
elif sys_act == "request":
self.response_request(system_action)
elif sys_act == "thanks":
self.response_thanks(system_action)
elif sys_act == "confirm_answer":
self.response_confirm_answer(system_action)
elif sys_act == "closing":
self.episode_over = True
self.state['diaact'] = "thanks"
self.corrupt(self.state)
response_action = {}
response_action['diaact'] = self.state['diaact']
response_action['inform_slots'] = self.state['inform_slots']
response_action['request_slots'] = self.state['request_slots']
response_action['turn'] = self.state['turn']
response_action['nl'] = ""
# add NL to dia_act
self.add_nl_to_action(response_action)
return response_action, self.episode_over, self.dialog_status
def response_confirm_answer(self, system_action):
""" Response for Confirm_Answer (System Action) """
if len(self.state['rest_slots']) > 0:
request_slot = random.choice(self.state['rest_slots'])
if request_slot in self.goal['request_slots'].keys():
self.state['diaact'] = "request"
self.state['request_slots'][request_slot] = "UNK"
elif request_slot in self.goal['inform_slots'].keys():
self.state['diaact'] = "inform"
self.state['inform_slots'][request_slot] = self.goal[
'inform_slots'][request_slot]
if request_slot in self.state['rest_slots']:
self.state['rest_slots'].remove(request_slot)
else:
self.state['diaact'] = "thanks"
def response_thanks(self, system_action):
""" Response for Thanks (System Action) """
self.episode_over = True
self.dialog_status = dialog_config.SUCCESS_DIALOG
request_slot_set = copy.deepcopy(self.state['request_slots'].keys())
if 'ticket' in request_slot_set:
request_slot_set.remove('ticket')
rest_slot_set = copy.deepcopy(self.state['rest_slots'])
if 'ticket' in rest_slot_set:
rest_slot_set.remove('ticket')
if len(request_slot_set) > 0 or len(rest_slot_set) > 0:
self.dialog_status = dialog_config.FAILED_DIALOG
for info_slot in self.state['history_slots'].keys():
if self.state['history_slots'][
info_slot] == dialog_config.NO_VALUE_MATCH:
self.dialog_status = dialog_config.FAILED_DIALOG
if info_slot in self.goal['inform_slots'].keys():
if self.state['history_slots'][info_slot] != self.goal[
'inform_slots'][info_slot]:
self.dialog_status = dialog_config.FAILED_DIALOG
if 'ticket' in system_action['inform_slots'].keys():
if system_action['inform_slots'][
'ticket'] == dialog_config.NO_VALUE_MATCH:
self.dialog_status = dialog_config.FAILED_DIALOG
if self.constraint_check == dialog_config.CONSTRAINT_CHECK_FAILURE:
self.dialog_status = dialog_config.FAILED_DIALOG
def response_request(self, system_action):
""" Response for Request (System Action) """
if len(system_action['request_slots'].keys()) > 0:
slot = system_action['request_slots'].keys()[0] # only one slot
if slot in self.goal['inform_slots'].keys(
): # request slot in user's constraints #and slot not in self.state['request_slots'].keys():
if (self.test_bed.collect_stats_flag == True):
self.test_bed.collect_event_stats(0)
#TODO: Chance to change goal here -- check if in history slots
# self.event_rand_slot_change(self.goal_change_prob, slot)
self.state['inform_slots'][slot] = self.goal['inform_slots'][
slot]
#TODO: Potentially go back and change an inform from an old slot -- overrides above line of code
self.state, self.goal = self.test_bed.event_rand_slot_change(
self.test_bed.prob_list[0], self.state, self.goal)
#TODO: Added to set slot to either old or new slot - should really only be one
slot = list(self.state['inform_slots'].keys())[0]
self.state['diaact'] = "inform"
if slot in self.state['rest_slots']:
self.state['rest_slots'].remove(slot)
if slot in self.state['request_slots'].keys():
del self.state['request_slots'][slot]
self.state['request_slots'].clear()
elif slot in self.goal['request_slots'].keys(
) and slot not in self.state[
'rest_slots'] and slot in self.state['history_slots'].keys(
): # the requested slot not in goal informs, the requested slot has been answered
if (self.test_bed.collect_stats_flag == True):
self.test_bed.collect_event_stats(1)
self.state, self.goal = self.test_bed.event_rand_slot_change(
self.test_bed.prob_list[1], self.state, self.goal)
#TODO: Chance to change goal here
# self.event_rand_slot_change(self.goal_change_prob, slot)
self.state['inform_slots'][slot] = self.state['history_slots'][
slot]
self.state['request_slots'].clear()
self.state['diaact'] = "inform"
elif slot in self.goal['request_slots'].keys(
) and slot in self.state[
'rest_slots']: # request slot in user's goal's request slots, and not answered yet
#TODO: Match to rule 0 from maxbren code
if (self.test_bed.collect_stats_flag == True):
self.test_bed.collect_event_stats(2)
self.state, self.goal = self.test_bed.event_rand_slot_change(
self.test_bed.prob_list[2], self.state, self.goal)
self.state['diaact'] = "request" # "confirm_question"
self.state['request_slots'][slot] = "UNK"
########################################################################
# Inform the rest of informable slots
########################################################################
for info_slot in self.state['rest_slots']:
if info_slot in self.goal['inform_slots'].keys():
self.state['inform_slots'][info_slot] = self.goal[
'inform_slots'][info_slot]
for info_slot in self.state['inform_slots'].keys():
if info_slot in self.state['rest_slots']:
self.state['rest_slots'].remove(info_slot)
else:
if len(self.state['request_slots']) == 0 and len(
self.state['rest_slots']) == 0:
self.state['diaact'] = "thanks"
else:
self.state['diaact'] = "inform"
self.state['inform_slots'][slot] = dialog_config.I_DO_NOT_CARE
else: # this case should not appear
if len(self.state['rest_slots']) > 0:
random_slot = random.choice(self.state['rest_slots'])
if random_slot in self.goal['inform_slots'].keys():
self.state['inform_slots'][random_slot] = self.goal[
'inform_slots'][random_slot]
self.state['rest_slots'].remove(random_slot)
self.state['diaact'] = "inform"
elif random_slot in self.goal['request_slots'].keys():
self.state['request_slots'][random_slot] = self.goal[
'request_slots'][random_slot]
self.state['diaact'] = "request"
def response_multiple_choice(self, system_action):
""" Response for Multiple_Choice (System Action) """
slot = system_action['inform_slots'].keys()[0]
if slot in self.goal['inform_slots'].keys():
self.state['inform_slots'][slot] = self.goal['inform_slots'][slot]
elif slot in self.goal['request_slots'].keys():
self.state['inform_slots'][slot] = random.choice(
system_action['inform_slots'][slot])
self.state['diaact'] = "inform"
if slot in self.state['rest_slots']:
self.state['rest_slots'].remove(slot)
if slot in self.state['request_slots'].keys():
del self.state['request_slots'][slot]
def response_inform(self, system_action):
""" Response for Inform (System Action) """
if 'taskcomplete' in system_action['inform_slots'].keys(
): # check all the constraints from agents with user goal
self.state['diaact'] = "thanks"
#if 'ticket' in self.state['rest_slots']: self.state['request_slots']['ticket'] = 'UNK'
self.constraint_check = dialog_config.CONSTRAINT_CHECK_SUCCESS
if system_action['inform_slots'][
'taskcomplete'] == dialog_config.NO_VALUE_MATCH:
self.state['history_slots'][
'ticket'] = dialog_config.NO_VALUE_MATCH
if 'ticket' in self.state['rest_slots']:
self.state['rest_slots'].remove('ticket')
if 'ticket' in self.state['request_slots'].keys():
del self.state['request_slots']['ticket']
for slot in self.goal['inform_slots'].keys():
#TODO: Potential goal change here? How will DST react?
#Can we respond with
# Deny, if the answers from agent can not meet the constraints of user
if slot not in system_action['inform_slots'].keys() or (
self.goal['inform_slots'][slot].lower() !=
system_action['inform_slots'][slot].lower()):
self.state['diaact'] = "deny"
self.state['request_slots'].clear()
self.state['inform_slots'].clear()
self.constraint_check = dialog_config.CONSTRAINT_CHECK_FAILURE
break
else:
for slot in system_action['inform_slots'].keys():
self.state['history_slots'][slot] = system_action[
'inform_slots'][slot]
if slot in self.goal['inform_slots'].keys(
): #if agent inform slot key is in my inform slots
if system_action['inform_slots'][slot] == self.goal[
'inform_slots'][
slot]: #if system value matches my inform value
if slot in self.state['rest_slots']:
self.state['rest_slots'].remove(
slot) # remove from rest slots
if len(self.state['request_slots']
) > 0: # if there are request slots left
self.state['diaact'] = "request"
elif len(self.state['rest_slots']) > 0:
rest_slot_set = copy.deepcopy(
self.state['rest_slots'])
if 'ticket' in rest_slot_set:
rest_slot_set.remove('ticket')
if len(rest_slot_set) > 0:
inform_slot = random.choice(
rest_slot_set) # self.state['rest_slots']
if inform_slot in self.goal[
'inform_slots'].keys():
self.state['inform_slots'][
inform_slot] = self.goal[
'inform_slots'][inform_slot]
self.state['diaact'] = "inform"
self.state['rest_slots'].remove(
inform_slot)
elif inform_slot in self.goal[
'request_slots'].keys():
self.state['request_slots'][
inform_slot] = 'UNK'
self.state['diaact'] = "request"
else:
self.state['request_slots']['ticket'] = 'UNK'
self.state['diaact'] = "request"
else: # how to reply here?
self.state[
'diaact'] = "thanks" # replies "closing"? or replies "confirm_answer"
else: # != value Should we deny here or ?
########################################################################
# TODO When agent informs(slot=value), where the value is different with the constraint in user goal, Should we deny or just inform the correct value?
########################################################################
self.state['diaact'] = "inform"
self.state['inform_slots'][slot] = self.goal[
'inform_slots'][slot]
if slot in self.state['rest_slots']:
self.state['rest_slots'].remove(slot)
else:
if slot in self.state['rest_slots']:
self.state['rest_slots'].remove(slot)
if slot in self.state['request_slots'].keys():
del self.state['request_slots'][slot]
if len(self.state['request_slots']) > 0:
request_set = list(self.state['request_slots'].keys())
if 'ticket' in request_set:
request_set.remove('ticket')
if len(request_set) > 0:
request_slot = random.choice(request_set)
else:
request_slot = 'ticket'
self.state['request_slots'][request_slot] = "UNK"
self.state['diaact'] = "request"
elif len(self.state['rest_slots']) > 0:
rest_slot_set = copy.deepcopy(self.state['rest_slots'])
if 'ticket' in rest_slot_set:
rest_slot_set.remove('ticket')
if len(rest_slot_set) > 0:
inform_slot = random.choice(
rest_slot_set) #self.state['rest_slots']
if inform_slot in self.goal['inform_slots'].keys():
self.state['inform_slots'][
inform_slot] = self.goal['inform_slots'][
inform_slot]
self.state['diaact'] = "inform"
self.state['rest_slots'].remove(inform_slot)
if 'ticket' in self.state['rest_slots']:
self.state['request_slots'][
'ticket'] = 'UNK'
self.state['diaact'] = "request"
elif inform_slot in self.goal[
'request_slots'].keys():
self.state['request_slots'][
inform_slot] = self.goal['request_slots'][
inform_slot]
self.state['diaact'] = "request"
else:
self.state['request_slots']['ticket'] = 'UNK'
self.state['diaact'] = "request"
else:
self.state[
'diaact'] = "thanks" # or replies "confirm_answer"
import cv2
import os
import matplotlib.pyplot as plt
from matplotlib import gridspec
from mpl_toolkits.axes_grid1 import make_axes_locatable
import numpy as np
import tkinter as tk
from tkinter import ttk
import tkinter.filedialog
from PIL import ImageTk
from PIL import Image
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from testbed import TestBed
TestBed.init("tyger.jpg");
image = TestBed.image;
if(__name__=="__main__"):
TestBed.root = tk.Tk();
TestBed.root.minsize(TestBed.ROOT_WIDTH,TestBed.ROOT_HEIGHT);
TestBed.scale_var = tk.DoubleVar();
scale = ttk.Scale(TestBed.root,
variable=TestBed.scale_var,
from_=100,
to_=1,
orient=tk.HORIZONTAL,
command=TestBed.onSliderChanged,
