def generate_places(): streets = file_to_list('street') cities = file_to_list('city') cities.extend(file_to_list('borough')) states = file_to_list('state') num = len(streets) city_num = sample_from_list(cities, num, True) state_num = sample_from_list(states, num, True) final = [s + '\t' + c + '\t'+ st for s, c, st in zip(streets, city_num, state_num)] pdb.set_trace() list_to_file(final, 'places.txt')
def _get_random_slot_value(self, slot): '''Get a random value for the given slot.''' values = [] tables_fields = self._get_slot_mapping(slot) for tbf in tables_fields:#sample a value of each table which the slot is connected if iscallable(tbf):#slot have values generated dynamic from one or several funs v = sample_from_list(tbf(self.goal, slot)) values.append(v) else: tb, f = tbf row = self._get_random_row(tb) values.append(self.db.get_row_field_value(tb, row, f)) return sample_from_list(values)#take one in the sampled values
def test_random_dialogues(user): metadata = get_metadata() for i in range(100): print '=======================Dialogue %i============================'%(i+1) user.new_dialogue() print 'Goal:', user.goal print '-'*60 goal_des = metadata['goals'][user.goal['task']] ordered_acts = goal_des['acts'] slots = goal_des['slots'] for acts in ordered_acts: da = DialogueAct() for act in acts.split('&'): act_des = metadata['act_definitions'][act] slot = None if act_des['slot_included']: slot = sample_from_list(slots) value = None if act_des['value_included']: if slot not in user.goal.keys(): for s in get_equivalent_slots(goal_des, slot): if s in user.goal.keys(): slot = s break if slot in user.goal.keys(): if sample_a_prob(0.5): value = user.goal[slot] else: value = 'lct' else: value = 'lct' item = DialogueActItem(act, slot, value) da.append(item) print 'sys_da:\t\t', da user.da_in(da) da = user.da_out() print 'user_da:\t', da[0] if len(da[0])==0: raise RuntimeError('User simulator doesnt reply anything!!') pdb.set_trace()
def infer_info(self, goal): ds = None accepted_slots = None self.goal = copy.deepcopy(goal) # retrieve the slot variables from_city_val = self.get_accepted_mpv(ds, 'from_city', accepted_slots) from_borough_val = self.get_accepted_mpv(ds, 'from_borough', accepted_slots) from_stop_val = self.get_accepted_mpv(ds, 'from_stop', accepted_slots) from_street_val = self.get_accepted_mpv(ds, 'from_street', accepted_slots) from_street2_val = self.get_accepted_mpv(ds, 'from_street2', accepted_slots) to_city_val = self.get_accepted_mpv(ds, 'to_city', accepted_slots) to_borough_val = self.get_accepted_mpv(ds, 'to_borough', accepted_slots) to_stop_val = self.get_accepted_mpv(ds, 'to_stop', accepted_slots) to_street_val = self.get_accepted_mpv(ds, 'to_street', accepted_slots) to_street2_val = self.get_accepted_mpv(ds, 'to_street2', accepted_slots) vehicle_val = self.get_accepted_mpv(ds, 'vehicle', accepted_slots) max_transfers_val = self.get_accepted_mpv(ds, 'num_transfers', accepted_slots) # infer cities based on stops from_cities, to_cities = None, None if from_stop_val != 'none' and from_city_val == 'none': from_cities = self.ontology.get_compatible_vals('stop_city', from_stop_val) if len(from_cities) == 1: from_city_val = from_cities.pop() elif len(from_cities)>1: from_city_val = sample_from_list(from_cities) #if from_city_val != 'none': self.goal['from_city']= from_city_val if to_stop_val != 'none' and to_city_val == 'none': to_cities = self.ontology.get_compatible_vals('stop_city', to_stop_val) if len(to_cities) == 1: to_city_val = to_cities.pop() elif len(to_cities)>1: to_city_val = sample_from_list(to_cities) #if to_city_val != 'none': self.goal['to_city']= to_city_val # infer cities based on street from_cities_st, to_cities_st = None, None if from_street_val != 'none' and from_city_val == 'none': from_cities_st = self.ontology.get_compatible_vals('street_city', from_street_val) if len(from_cities_st) == 1: from_city_val = from_cities_st.pop() elif len(from_cities_st)>1: from_city_val = sample_from_list(from_cities_st) #if from_city_val != 'none': self.goal['from_city']= from_city_val if to_street_val != 'none' and to_city_val == 'none': to_cities_st = self.ontology.get_compatible_vals('street_city', to_stop_val) if len(to_cities_st) == 1: to_city_val = to_cities_st.pop() elif len(to_cities_st)>1: to_city_val = sample_from_list(to_cities_st) #if to_city_val != 'none': self.goal['to_city']= to_city_val # infer boroughs based on stops from_boroughs, to_boroughs = None, None if from_stop_val != 'none' and from_borough_val == 'none': from_boroughs = self.ontology.get_compatible_vals('stop_borough', from_stop_val) if len(from_boroughs) == 1: from_borough_val = from_boroughs.pop() elif len(from_boroughs)>1: from_borough_val = sample_from_list(from_boroughs) #if from_borough_val != 'none': self.goal['from_borough']= from_borough_val if to_stop_val != 'none' and to_borough_val == 'none': to_boroughs = self.ontology.get_compatible_vals('stop_borough', to_stop_val) if len(to_boroughs) == 1: to_borough_val = to_boroughs.pop() elif len(to_boroughs)>1: to_borough_val = sample_from_list(to_boroughs) #if to_borough_val != 'none': self.goal['to_borough']= to_borough_val # infer boroughs based on streets from_boroughs_st, to_boroughs_st = None, None if to_street_val != 'none' and to_borough_val == 'none': to_boroughs_st = self.ontology.get_compatible_vals('street_borough', to_street_val) if len(to_boroughs_st) == 1: to_borough_val = to_boroughs_st.pop() elif len(to_boroughs_st)>1: to_borough_val = sample_from_list(to_boroughs_st) #if to_borough_val != 'none': self.goal['to_borough']= to_borough_val if from_street_val != 'none' and from_borough_val == 'none': from_boroughs_st = self.ontology.get_compatible_vals('street_borough', from_street_val) if len(from_boroughs_st) == 1: from_borough_val = from_boroughs_st.pop() elif len(from_boroughs_st)>1: from_borough_val= sample_from_list(from_boroughs_st) #if from_borough_val!= 'none': self.goal['from_borough']= from_borough_val ''' #set 'none' for slot which could find info in database present I don't know val = 'none' if 'from_borough' not in self.goal and ('from_stop' in self.goal or 'from_street' in self.goal): self.goal['from_borough'] = val if 'to_borough' not in self.goal and ('to_stop' in self.goal or 'to_street' in self.goal): self.goal['to_borough'] = val if 'from_city' not in self.goal: self.goal['from_city'] = val if 'to_city' not in self.goal: self.goal['to_city'] = val ''' return self.goal
def alternative_value_fun(): '''A generator for a slot during conversation''' a = ['next', 'prev', 'last', '1', '2', '3', '4', 'next hour'] return sample_from_list(a)