diff --git "a/code/preprocess_data_TOD.py" "b/code/preprocess_data_TOD.py" new file mode 100644--- /dev/null +++ "b/code/preprocess_data_TOD.py" @@ -0,0 +1,3078 @@ +""" + Copyright (c) 2023, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: Apache License 2.0 + For full license text, see the LICENSE file in the repo root or https://www.apache.org/licenses/LICENSE-2.0 +""" + +#!/usr/bin/env python3 +# +import random +import sys, os, pdb +import json, math +import shutil, errno +from tqdm import tqdm +import pandas as pd +from collections import defaultdict +from utils.domain_mapping import generate_prompt +from utils.constant import * + +random.seed(42) + +class PreProcessData(object): + """docstring for PreProcessData""" + def __init__(self): + super(PreProcessData, self).__init__() + self.data_dir = "/path/to/where/the/raw/dataset/is" + self.save_dir = "/path/to/store/the/processed/dataset/" # e.g. ./data/processed/Task-Oriented + + + def _load_json(self, path=None): + if path is None or not os.path.exists(path): + raise IOError('File does not exist: %s' % path) + with open(path) as df: + data = json.loads(df.read()) + return data + + + def _load_txt(self, path=None, split_tok="\n"): + if path is None or not os.path.exists(path): + raise IOError('File does not exist: %s' % path) + with open(path) as df: + data = df.read().strip().split(split_tok) + return data + + + def _load_csv(self, path=None, sep="\t"): + if path is None or not os.path.exists(path): + raise IOError('File does not exist: %s' % path) + with open(path) as df: + data = pd.read_csv(df, sep=sep) + return data + + + def _load_dir_json(self, dir_path=None): + if dir_path is None or not os.path.exists(dir_path): return None + total_data = [] # assume data is a list of dialogs + for filename in sorted(os.listdir(dir_path)): + if filename in ["schema.json"]: continue + if not filename.endswith(".json"): continue + file_path = os.path.join(dir_path, filename) + data = self._load_json(path=file_path) + if type(data) == list: + for item in data: + item["filename"] = filename.split(".json")[0] + total_data.extend(data) + else: # assume is a dict + data["filename"] = filename.split(".json")[0] + total_data.append(data) + return total_data + + + def _load_dir_txt(self, dir_path=None, file_type="txt"): + if dir_path is None or not os.path.exists(dir_path): return None + total_data = [] # assume data is a list of dialogs + for filename in sorted(os.listdir(dir_path)): + if not filename.endswith(file_type): continue + file_path = os.path.join(dir_path, filename) + data = self._load_txt(path=file_path) + if type(data) == list: + total_data.extend(data) + else: + total_data.append(data) + return total_data + + + def _load_dir_tsv(self, dir_path=None, sep="\t"): + if dir_path is None or not os.path.exists(dir_path): return None + total_data = None + for filename in sorted(os.listdir(dir_path)): + file_path = os.path.join(dir_path, filename) + data = self._load_csv(path=file_path, sep=sep) + data["filename"] = filename.split(".tsv")[0] + total_data = pd.concat([total_data, data], ignore_index=True) + return total_data + + + def _save_json(self, data, path): + with open(path, "w") as tf: + json.dump(data, tf, indent=4) + + + def init_dial(self, dial_idx=0): + dial = { + ORI_DIAL_ID: "", + DIAL_IDX: dial_idx, + ORI_DIAL_INFO: {}, + LOG: [], + EK_ORI: { + TOD_EK:{}, + DST_EK:{}, + INTENT_EK:{}, + }, + EK: "", + EK_DST: "", + EK_INTENT: "", + PROMPT: [], + } + return dial + + + def init_turn(self, turn_id=1, dial_hist=[]): + turn = { + TURN_ID: turn_id, + USR_UTT: "", + SYS_UTT: "", + DIAL_HIST: " ".join(dial_hist), + ORI_USR_ANN: {}, + ORI_SYS_ANN: {}, + DST: "", + DST_ACC: "", + } + return turn + + + def save_dial(self, data, data_name="", file_idx=0, mode="train"): + save_name = f"dialogues_{file_idx}.json" + folder_path = os.path.join(self.save_dir, data_name, mode) + if not os.path.exists(folder_path): os.makedirs(folder_path) + path = os.path.join(folder_path, save_name) + self._save_json(data, path) + + # pdb.set_trace() + + + def copy_general(self, src, dst): + try: + shutil.copytree(src, dst, dirs_exist_ok=True) + except OSError as exc: # python >2.5 + if exc.errno in (errno.ENOTDIR, errno.EINVAL): + shutil.copy(src, dst) + else: raise + + + def copy_related_files(self, data_name, exp_list=[], extra_dir=""): + source_dir = os.path.join(self.data_dir, data_name, extra_dir) + target_dir = os.path.join(self.save_dir, data_name) + for filename in os.listdir(source_dir): + source_path = os.path.join(source_dir, filename) + target_path = os.path.join(target_dir, filename) + if filename in exp_list: continue + self.copy_general(source_path, target_path) + + + def save_original_examples(self, examples, data_name): + """ + save 5 original data points just for reference and check + data would be a list of length 5, each entry is a dialog + in the form of dictionary + """ + path = os.path.join(self.save_dir, data_name, "original_examples.json") + self._save_json(examples, path) + print("original examples saved") + + + def save_converted_examples(self, data_name): + """ + extract the first 5 examples from the train set of the + already processed data, just for reference and check + """ + data = self._load_json(os.path.join(self.save_dir, data_name, "train/dialogues_1.json")) + examples = {key: data[key] for key in list(data.keys())[:5]} + self._save_json(examples, os.path.join(self.save_dir, data_name, "converted_examples.json")) + print("converted examples saved") + + + def filter_cand(self, cand_list, constraints): + """ + pop up cands that satisfy constraints + cand_list = [ + { + attribute1: ..., + attribute2: ..., + ... + }, + ... + ] + constraints = [ + { + attribute1: ..., + attributei: ..., + } + ] + constraints[i].keys() is a subset of cand_list[k].keys() + """ + satisfy_results = [] + for cand in cand_list: + for constraint in constraints: + flag = 1 # flag for marking whether constraint is satisfied + for key_ in constraint: + # if key_ == "category" and (key_ not in cand or key_ not in constraint): + # pdb.set_trace() + if key_ not in cand: continue + if cand[key_] != constraint[key_]: + flag = 0 + break + if flag: + satisfy_results.append(cand) + break + for cand in satisfy_results: + cand_list.remove(cand) + return satisfy_results, cand_list + + + def kvret(self): + """ + system or user side might have consecutive turns""" + data_name, exp_list = "KVRET", [] + # slot type belonging to each doamin + dom_slot = { + "schedule": {_key:[] for _key in ["event","time","data","party","room","agenda"]}, + "weather": {_key:[] for _key in ["location","weekly_time","temperature","weather_attribute"]}, + "navigate": {_key:[] for _key in ["traffic_info","poi_type","poi","distance"]}, + } + schema = self._load_json(os.path.join(self.data_dir, data_name, "kvret_entities.json")) + for slot in schema: + for domain in dom_slot: + if slot in dom_slot[domain]: + dom_slot[domain][slot] = schema[slot] + for mode in ["train", "val", "test"]: + real_name = f"kvret_{mode}_public.json" if mode != "val" else "kvret_dev_public.json" + path = os.path.join(self.data_dir, data_name, real_name) + exp_list.append(real_name) + + data = self._load_json(path) + new_data = {} + file_idx = 1 + + for dial_idx, dial in enumerate(data): + domain = dial["scenario"]["task"]["intent"] + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial["scenario"]['uuid'] + new_dial[ORI_DIAL_INFO] = { + "scenario" : dial["scenario"] + } + dial_hist, result_list, dst_dict = [], [], {} + usr_utts, sys_utts, turn_id = [], [], 2 + new_turn = self.init_turn() + for idx, turn in enumerate(dial["dialogue"]): + utt = turn["data"]["utterance"] + if turn["turn"] == "driver": + if idx and dial["dialogue"][idx - 1]["turn"] == "assistant": + # wrap previous turn + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = sys_utts[-1] if sys_utts else " ".join(sys_utts) + new_dial[LOG].append(new_turn) + dial_hist.append(f" {new_turn[USR_UTT]}") + dial_hist.append(f" {new_turn[SYS_UTT]}") + + # new turn start from user + new_turn = self.init_turn(turn_id=turn_id) + turn_id += 1 + usr_utts, sys_utts = [], [] + new_turn[DIAL_HIST] = " ".join(dial_hist) + # # include user utterance into dialog history + # dial_hist.append(f" {utt}") + + if utt in usr_utts: continue + usr_utts.append(utt) + # other annotation for user side + for key in turn["data"]: + if key == "utterance": continue + new_turn[ORI_USR_ANN][key] = turn["data"][key] + + if turn["turn"] == "assistant": + # new_turn[SYS_UTT] = utt + if utt in sys_utts: continue + sys_utts.append(utt) + # include system response into dialog history + # dial_hist.append(f" {utt}") + # other annotation for system side + for key in turn["data"]: + if key == "utterance": continue + new_turn[ORI_SYS_ANN][key] = turn["data"][key] + # adding dst output + # if "slots" not in turn["data"]: continue # checked + new_turn[DST] = ", ".join([f"{domain} {slot} {value}" for slot, value in turn["data"]["slots"].items()]) + # adding accumulated dst output + if domain not in dst_dict: dst_dict[domain] = {} + dst_dict[domain].update(turn["data"]["slots"]) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + if "slots" in turn and "poi" in turn["slots"]: + result_list.append(turn["slots"]["poi"]) + elif "slots" in turn and "event" in turn["slots"]: + result_list.append(turn["slots"]["event"]) + + if usr_utts or sys_utts: + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = sys_utts[-1] if sys_utts else " ".join(sys_utts) + new_dial[LOG].append(new_turn) + + + # adding metadata for TOD task + new_dial[EK_ORI][TOD_EK][domain] = [] + if dial["scenario"]["kb"]["items"] is not None: + cand_list = dial["scenario"]["kb"]["items"] + for result in dial["scenario"]["kb"]["items"]: + if "poi" in result and result["poi"] in result_list: + new_dial[EK_ORI][TOD_EK][domain].append(result) + cand_list.remove(result) + elif "event" in result and result["event"] in result_list: + new_dial[EK_ORI][TOD_EK][domain].append(result) + cand_list.remove(result) + if len(dial["scenario"]["kb"]["items"]) < TOD_LENGTH: + new_dial[EK_ORI][TOD_EK][domain].extend(cand_list) + else: + new_dial[EK_ORI][TOD_EK][domain].extend(random.choices(cand_list, k=(TOD_LENGTH-len(result_list)))) + # adding ek for DST task + new_dial[EK_ORI][DST_EK] = dom_slot[domain] + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = [domain] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + print(f"finishing processing {len(data)} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def woz(self): + # dialog ends on the user side + # first system response recorded in the second turn + data_name, exp_list = "WOZ2_0", [] + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + del otgy["request"] + + for mode in ["train", "val", "test"]: + real_name = f"{mode}_en.json" if mode != "val" else "valid_en.json" + path = os.path.join(self.data_dir, data_name, real_name) + exp_list.append(real_name) + + data = self._load_json(path) + new_data = {} + file_idx = 1 + + for dial_idx, dial in enumerate(data): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['dialogue_idx'] + dial_hist, dst_dict = [], {} + new_turn = self.init_turn(turn_id=1) + for idx, turn in enumerate(dial["dialogue"]): + usr_utt, sys_utt = turn["transcript"], turn["system_transcript"] + + if sys_utt: + new_turn[ORI_SYS_ANN]["system_acts"] = turn["system_acts"] + new_turn[SYS_UTT] = sys_utt + dial_hist.append(f" {sys_utt}") + new_dial[LOG].append(new_turn) + # reset new turn for next + new_turn = self.init_turn(turn_id=idx+1) + new_turn[DIAL_HIST] = " ".join(dial_hist) + + # dst output + # if "turn_label" not in turn: pdb.set_trace() # checked + slot_list = [] + for slot in turn["turn_label"]: + if slot[0] == "request": continue + slot_type = "_".join(slot[0].split()) + slot_list.append(f"restaurant {slot_type} {slot[1]}") + new_turn[DST] = ", ".join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + + + new_turn[USR_UTT] = usr_utt + dial_hist.append(f" {usr_utt}") + for key in turn: + if key.startswith("system"): continue + new_turn[ORI_USR_ANN][key] = turn[key] + # append the last turn with no system response + new_dial[LOG].append(new_turn) + + # adding ek for DST task + new_dial[EK_ORI][DST_EK] = {"restaurant" : otgy} + for slot in new_dial[EK_ORI][DST_EK]["restaurant"]: + if len(new_dial[EK_ORI][DST_EK]["restaurant"][slot]) > 2*DST_LENGTH: + new_dial[EK_ORI][DST_EK]["restaurant"][slot] = random.choices(otgy[slot], k=DST_LENGTH) + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = ["restaurant"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def sgd(self): + data_name, exp_list = "SGD", [] + for mode in ["train", "val", "test"]: + real_name = mode if mode != "val" else "dev" + dir_path = os.path.join(self.data_dir, data_name, real_name) + exp_list.append(real_name) + + data = self._load_dir_json(dir_path) + schema = self._load_json(os.path.join(self.data_dir, data_name, real_name, "schema.json")) + new_data = {} + file_idx = 1 + + for dial_idx, dial in (enumerate(data)): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['dialogue_id'] + new_dial[ORI_DIAL_INFO]["services"] = dial["services"] + + dial_hist, result_list, cand_list = [], {}, {} + for idx, turn in enumerate(dial["turns"]): + utt = turn["utterance"] + if turn["speaker"] == "USER": + # new turn start from user + new_turn = self.init_turn(turn_id=idx//2+1) + new_turn[USR_UTT] = utt + new_turn[DIAL_HIST] = " ".join(dial_hist) + # include user utterance into dialog history + dial_hist.append(f" {utt}") + # other annotation for user side + new_turn[ORI_USR_ANN]["frames"] = turn["frames"] + # add dst output + slot_list = [] + for frame in turn["frames"]: + if not frame["slots"]: continue + for slot in frame["slots"]: + slot_list.append(frame["service"] +" "+ slot["slot"] +" "+ turn["utterance"][slot["start"]: slot["exclusive_end"]]) + new_turn[DST] = DST_SPLIT.join(slot_list) + # add accu dst output + slot_list = [] + for frame in turn["frames"]: + if not frame["state"]: continue + for slot_type, slot_values in frame["state"]["slot_values"].items(): + slot_list.append(frame["service"]+" "+slot_type+" "+slot_values[0]) + new_turn[DST_ACC] = DST_SPLIT.join(slot_list) + # dialog ends at user side + if idx == len(dial["turns"]) - 1: + new_dial[LOG].append(new_turn) + + if turn["speaker"] == "SYSTEM": + new_turn[SYS_UTT] = utt + # include system response into dialog history + dial_hist.append(f" {utt}") + # other annotation for system side + new_turn[ORI_SYS_ANN]["frames"] = turn["frames"] + # turn must end at assistant side + new_dial[LOG].append(new_turn) + + for frame in turn["frames"]: + if "service_results" in frame: + domain = frame["service"] + # # # accumulate db results + if domain not in cand_list: + cand_list[domain] = [] + cand_list[domain].extend(frame["service_results"]) + # # # accumulate offered results + if domain not in result_list: + result_list[domain] = [] + result_list[domain].append(frame["service_call"]["parameters"]) + # adding EK for TOD + for domain in cand_list: + new_dial[EK_ORI][TOD_EK][domain] = [] + satisfied_cand, unsatisfied_cand = self.filter_cand(cand_list[domain], result_list[domain]) + if len(satisfied_cand)+len(unsatisfied_cand) < TOD_LENGTH: + new_dial[EK_ORI][TOD_EK][domain] = satisfied_cand + unsatisfied_cand + else: + new_dial[EK_ORI][TOD_EK][domain] = satisfied_cand + new_dial[EK_ORI][TOD_EK][domain].extend(random.choices(unsatisfied_cand, k=(TOD_LENGTH-len(satisfied_cand)))) + # adding EK for DST + for domain in dial["services"]: + new_dial[EK_ORI][DST_EK][domain] = {} + for service in schema: + if service["service_name"] != domain: continue + for slot in service["slots"]: + if not slot["possible_values"]: continue + new_dial[EK_ORI][DST_EK][domain][slot["name"]] = slot["possible_values"] + # adding EK for Intent + for domain in dial["services"]: + new_dial[EK_ORI][INTENT_EK][domain] = [] + for service in schema: + if service["service_name"] != domain: continue + for intent in service["intents"]: + new_dial[EK_ORI][INTENT_EK][domain].append(intent["name"]) + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = [domain.lower().split("_")[0] for domain in dial["services"]] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + print(f"finishing processing {dial_idx+1} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + for mode in ["train", "dev", "test"]: + source_path = os.path.join(self.data_dir, data_name, mode, "schema.json") + target_dir = os.path.join(self.save_dir, data_name, mode) + shutil.copy(source_path, target_dir) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def bitod(self): + data_name, exp_list = "BiTOD", [] + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + for mode in ["train", "val", "test"]: + real_name = f"{mode}_en.json" if mode != "val" else "valid_en.json" + path = os.path.join(self.data_dir, data_name, real_name) + exp_list.append(real_name) + + data = self._load_json(path) + new_data, file_idx, dial_idx = {}, 1, 1 + + for dial_id in data: + new_dial_id = f"{data_name}--{mode}--{dial_idx}" + new_dial = self.init_dial(dial_idx=dial_idx) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial_id + new_dial[ORI_DIAL_INFO]["Scenario"] = data[dial_id]["Scenario"] + domains = [] + for intent in data[dial_id]["Scenario"]["User_Goal"]: + domains.append(intent.split("_")[0]) + domains = list(set(domains)) + dial_hist, idx = [], 0 + dst_dict = {} + for turn in data[dial_id]["Events"]: + if "Text" not in turn: continue + utt = turn["Text"] + if turn["Agent"] == "User": + idx += 1 + # new turn start from user + new_turn = self.init_turn(turn_id=idx) + new_turn[USR_UTT] = utt + new_turn[DIAL_HIST] = " ".join(dial_hist) + # include user utterance into dialog history + dial_hist.append(f" {utt}") + # adding dst output + # if "active_intent" not in turn: pdb.set_trace() #checked + domain = turn["active_intent"].split("_")[0] + if domain == "chat": + new_turn[DST] = "" + else: + slot_list = [] + for act in turn["Actions"]: + if act["act"] != "inform": continue + slot_type = act["slot"] + slot_values = act["value"] + slot_list.append(f"{domain} {slot_type} {slot_values[0]}") + new_turn[DST] = ", ".join(slot_list) + + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + # adding intent prediction output + new_turn[INTENT] = turn["active_intent"] + # other annotation for user side + for key in turn: + if key == "Text": continue + new_turn[ORI_USR_ANN][key] = turn[key] + + if turn["Agent"] == "Wizard": + new_turn[SYS_UTT] = utt + # include system response into dialog history + dial_hist.append(f" {utt}") + # other annotation for system side + for key in turn: + if key == "Text": continue + new_turn[ORI_SYS_ANN][key] = turn[key] + # turn must end at assistant side + new_dial[LOG].append(new_turn) + # adding EK for Intent Prediction + new_dial[EK_ORI][INTENT_EK] = {} + for domain in domains: + if domain not in otgy: + pdb.set_trace() + if "intents" not in otgy[domain]: + pdb.set_trace() + new_dial[EK_ORI][INTENT_EK][domain] = otgy[domain]["intents"] + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {} + for domain in domains: + new_dial[EK_ORI][DST_EK][domain] = otgy[domain]["slots"] + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > 2*DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy[domain]["slots"][slot], k=DST_LENGTH) + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx) % 1000 == 0 or dial_idx == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + dial_idx += 1 + + if mode == "train": self.save_original_examples([data[key] for key in list(data.keys())[:5]], data_name) + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def metalwoz(self): + """ + system side starts first + """ + data_name, exp_list = "MetaLWOZ", [] + for mode in ["train", "test"]: + if mode == "train": + real_name = "dialogues" + exp_list.append(real_name) + else: + real_name = "MetalWOZ-Test-v1/dstc8_metalwoz_heldout/dialogues" + exp_list.append("MetalWOZ-Test-v1") + dir_path = os.path.join(self.data_dir, data_name, real_name) + + data = self._load_dir_txt(dir_path) + new_data = {} + file_idx = 1 + for dial_idx, dial_str in enumerate(data): + dial = json.loads(dial_str) + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['id'] + for key in dial: + if key in ["turns"]: continue + new_dial[ORI_DIAL_INFO][key] = dial[key] + + dial_hist, new_turn = [], self.init_turn(turn_id=1) + for idx, utt in enumerate(dial["turns"]): + if not idx: continue + if idx % 2 == 0: + # the first turn start from system + new_turn[SYS_UTT] = utt + # turn must end at assistant side + new_dial[LOG].append(new_turn) + # include system response into dialog history + dial_hist.append(f" {utt}") + else: + # a new turn (except the first) start from user + new_turn = self.init_turn(turn_id=(idx+1)//2) + new_turn[USR_UTT] = utt + new_turn[DIAL_HIST] = " ".join(dial_hist) + # include user utterance into dialog history + dial_hist.append(f" {utt}") + # dialog ends at user side + if idx == len(dial["turns"]) - 1: + new_dial[LOG].append(new_turn) + + # adding prompt for each dialog + domains = [dial["domain"].lower()] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx == len(data)-1: + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def star(self): + """ + 1. No train/val/test split is availble + 2. Agents in this dataset includes "User", "UserGuide", "Wizard" and "KnowledgeBase" + """ + data_name, exp_list = "STAR", [] + for mode in ["train"]: + dir_path = os.path.join(self.data_dir, data_name, "dialogues") + exp_list.append("dialogues") + data = self._load_dir_json(dir_path) + data.sort(key=lambda x:x["DialogueID"]) + new_data = {} + file_idx = 1 + + for dial_idx, dial in enumerate(data): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['DialogueID'] + for key in dial: + if key == "Events": continue + new_dial[ORI_DIAL_INFO][key] = dial[key] + + dial_hist, turn_id = [], 1 + for idx, turn in enumerate(dial["Events"]): + # ignore "userguide" and "knowledgebase" + if turn["Agent"] not in ["User", "Wizard"] or \ + turn["Action"] not in ["utter", "pick_suggestion"]: continue + utt = turn["Text"] + if turn["Agent"] == "User": + # new turn start from user + new_turn = self.init_turn(turn_id=turn_id) + new_turn[USR_UTT] = utt + new_turn[DIAL_HIST] = " ".join(dial_hist) + # include user utterance into dialog history + dial_hist.append(f" {utt}") + # other annotation for user side + for key in turn: + if key == "Text": continue + new_turn[ORI_USR_ANN][key] = turn[key] + # dialog ends at user side + if idx == len(dial["Events"]) - 1: + new_dial[LOG].append(new_turn) + + if turn["Agent"] == "Wizard": + new_turn[SYS_UTT] = utt + # include system response into dialog history + dial_hist.append(f" {utt}") + # other annotation for system side + for key in turn: + if key == "Text": continue + new_turn[ORI_SYS_ANN][key] = turn[key] + # turn must end at assistant side + new_dial[LOG].append(new_turn) + turn_id += 1 + + # adding prompt for each dialog + domains = dial["Scenario"]["Domains"] + if domains == [None]: + domains = [dial["Scenario"]["WizardCapabilities"][0]["Task"]] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def taskmaster1(self): + data_name = "Taskmaster1" + path = os.path.join(self.data_dir, data_name, "self-dialogs.json") + data = self._load_json(path) + # data.extend(self._load_json(os.path.join(self.data_dir, data_name, "woz-dialogs.json"))) + exp_list = ["self-dialogs.json"] + split_id, new_data, file_idx, finish_flag, dial_idx = {}, {}, {}, {}, {} + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + for mode in ["train", "val", "test"]: + real_name = f"{mode}.csv" if mode != "val" else "dev.csv" + idx_path = os.path.join(self.data_dir, data_name, "train-dev-test", real_name) + split_id[mode] = self._load_txt(idx_path, split_tok=",\n") + new_data[mode], file_idx[mode], finish_flag[mode], dial_idx[mode] = {}, 1, 0, 1 + + for dial in data: + new_dial = self.init_dial() # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['conversation_id'] + new_dial[ORI_DIAL_INFO]["instruction_id"] = dial["instruction_id"] + dial_hist, dst_dict = [], {} + domain = dial["instruction_id"].split("-")[0] + usr_utts, sys_utts, turn_id = [], [], 2 + new_turn = self.init_turn() + for idx, turn in enumerate(dial["utterances"]): + utt = turn["text"] + if turn["speaker"] == "USER": # user side + if idx and dial["utterances"][idx-1]["speaker"] == "ASSISTANT": + # wrap up the previous turn + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = " ".join(sys_utts) + if usr_utts and sys_utts: + new_dial[LOG].append(new_turn) + dial_hist.append(f" {new_turn[USR_UTT]}") + dial_hist.append(f" {new_turn[SYS_UTT]}") + # initialize a new turn + new_turn = self.init_turn(turn_id=turn_id) + new_turn[DIAL_HIST] = " ".join(dial_hist) + turn_id += 1 + usr_utts, sys_utts = [], [] + usr_utts.append(utt) + # dial_hist.append(f" {utt}") + new_turn[ORI_USR_ANN]['speaker'] = turn["speaker"] + slot_list = [] + if "segments" in turn: + new_turn[ORI_USR_ANN]['speaker'] = turn["segments"] + # add output for dst task (only accumulated dst provided) + for segment in turn["segments"]: + slot_value = segment["text"].replace(",","") + if len(segment["annotations"][0]["name"].split(".")) == 2: + slot_type = segment["annotations"][0]["name"].split(".")[1] + else: + slot1, dom = segment["annotations"][0]["name"].split(".")[1], segment["annotations"][0]["name"].split(".")[2] + if dom == domain: + slot_type = slot1 + else: + slot_type = f"{dom}_{slot1}" + slot_list.append(f"{domain} {slot_type} {slot_value}") + new_turn[DST] = ", ".join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + + else: # system side + if idx == 0 : continue + sys_utts.append(utt) + # new_turn[SYS_UTT] = utt + # dial_hist.append(f" {utt}") + new_turn[ORI_SYS_ANN]['speaker'] = turn["speaker"] + new_turn[ORI_SYS_ANN]['segments'] = [] + if "segments" in turn: + new_turn[ORI_SYS_ANN]['segments'] = turn["segments"] + new_turn[EK] = self.dict_to_str(new_turn[ORI_SYS_ANN]["segments"]) + new_turn[EK_ORI] = new_turn[ORI_SYS_ANN]["segments"] + if idx+1 == len(dial["utterances"]) and usr_utts and sys_utts: + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = " ".join(sys_utts) + new_dial[LOG].append(new_turn) + turn_id += 1 + usr_utts, sys_utts = [], [] + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy["slots"][domain]} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["slots"][domain][slot], k=DST_LENGTH//2) + + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = [domain] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + + mode = "train" + for mode_option in ["val", "test"]: + if dial["conversation_id"] in split_id[mode_option]: + mode = mode_option + new_dial_id = f"{data_name}--{mode}--{dial_idx[mode]}" + new_dial[DIAL_IDX] = dial_idx[mode] + dial_idx[mode] += 1 + new_data[mode][new_dial_id] = new_dial + if not new_dial[LOG]: + pdb.set_trace() + if len(new_data[mode]) == 1000: + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + new_data[mode] = {} # reset + file_idx[mode] += 1 + finish_flag[mode] = 1 + else: + finish_flag[mode] = 0 + + # if there are some unsaved dialogs left, save it now + for mode in ["train", "val", "test"]: + if not finish_flag[mode]: + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + print(f"finishing processing {dial_idx[mode]} dialogs for {mode} set ...") + + self.save_original_examples(data[:5], data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def taskmaster2(self): + """ + user/system side utterances are separated into sentences + """ + data_name = "Taskmaster2" + dir_path, exp_list = os.path.join(self.data_dir, data_name, "data"), ["data"] + data = self._load_dir_json(dir_path) + new_data, file_idx, mode = {}, 1, "train" + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + + for dial_idx, dial in enumerate(data): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['conversation_id'] + # if new_dial[ORI_DIAL_ID] == "dlg-bcc6972e-13e0-4c70-b703-8197ebfb388b": + # pdb.set_trace() + new_dial[ORI_DIAL_INFO]["instruction_id"] = dial["instruction_id"] + + domain = dial["instruction_id"].split("-")[0] + dial_hist, turn_id, usr_utt_list, sys_utt_list, dst_dict = [], 1, [], [], {} + for idx, turn in enumerate(dial["utterances"]): + if turn["speaker"] == "USER": + # finish previous turn + if sys_utt_list: + new_turn[SYS_UTT] = " ".join(sys_utt_list) + dial_hist.append(" " + new_turn[SYS_UTT]) + new_turn[EK_ORI] = new_turn[ORI_SYS_ANN]['segments'] if 'segments' in new_turn[ORI_SYS_ANN] else [] + new_turn[EK] = self.dict_to_str(new_turn[EK_ORI]) + new_dial[LOG].append(new_turn) + turn_id += 1 + sys_utt_list = [] + if not usr_utt_list: + # initialize a new turn for the following + new_turn = self.init_turn(turn_id=turn_id) + new_turn[DIAL_HIST] = " ".join(dial_hist) + + usr_utt_list.append(turn["text"]) + new_turn[ORI_USR_ANN]['speaker'] = turn["speaker"] + slot_list = [] + if "segments" in turn: + if "segments" not in new_turn[ORI_USR_ANN]: + new_turn[ORI_USR_ANN]['segments'] = [] + new_turn[ORI_USR_ANN]['segments'].extend(turn["segments"]) + # add output for dst task (only accumulated dst provided) + for segment in turn["segments"]: + slot_value = segment["text"].replace(",","") + if len(segment["annotations"][0]["name"].split(".")) == 2: + slot_type = segment["annotations"][0]["name"].split(".")[1] + else: + slot1, dom = segment["annotations"][0]["name"].split(".")[1], segment["annotations"][0]["name"].split(".")[2] + if dom == domain: + slot_type = slot1 + else: + slot_type = f"{dom}_{slot1}" + slot_list.append(f"{domain} {slot_type} {slot_value}") + new_turn[DST] = ", ".join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + + if turn["speaker"] == "ASSISTANT": # system side + # process previous user side utt + if usr_utt_list: # process only for the first system side turn + new_turn[USR_UTT] = " ".join(usr_utt_list) + dial_hist.append(" " + new_turn[USR_UTT]) + usr_utt_list = [] + if not dial_hist: # skip for the first turn + continue + + # record system side info + sys_utt_list.append(turn["text"]) + new_turn[ORI_SYS_ANN]["speaker"] = turn["speaker"] + if "segments" not in new_turn[ORI_SYS_ANN]: + new_turn[ORI_SYS_ANN]['segments'] = [] + if "segments" in turn: + new_turn[ORI_SYS_ANN]['segments'].extend(turn["segments"]) + + if usr_utt_list: + new_turn[USR_UTT] = " ".join(usr_utt_list) + if sys_utt_list: + new_turn[SYS_UTT] = " ".join(sys_utt_list) + new_turn[EK_ORI] = new_turn[ORI_SYS_ANN]["segments"] + new_turn[EK] = self.dict_to_str(new_turn[EK_ORI]) + new_dial[LOG].append(new_turn) + + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy["slots"][domain]} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["slots"][domain][slot], k=DST_LENGTH//2) + + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = [dial["filename"]] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_original_examples(data[:5], data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def taskmaster3(self): + """ + for set split + # some id exist in more than one set + # some id does not exist in any set + # almost all val dialog exists in train split set + # therefore we set up val and test set first, and dump all left to train + # Since val and test only have 3 / 1 unique dialog + # we set test val with a size of 2000 + # and consider the rest dialogs as train data""" + data_name = "Taskmaster3" + dir_path = os.path.join(self.data_dir, data_name, "data") + data = self._load_dir_json(dir_path) + exp_list = ["data", "splits"] + split_id, new_data, file_idx, finish_flag, dial_idx = {}, {}, {}, {}, {} + otgy = self._load_json(os.path.join(self.data_dir, data_name, "otgy.json")) + + for mode in ["train", "val", "test"]: + real_name = mode if mode != "val" else "dev" + split_dir = os.path.join(self.data_dir, data_name, "splits", real_name) + split_file = self._load_dir_txt(dir_path=split_dir, file_type="tsv") + split_id[mode] = [] + for line in split_file: + split_id[mode].append(line.split()[-1]) + new_data[mode], file_idx[mode], finish_flag[mode], dial_idx[mode] = {}, 1, 0, 1 + + for dial in tqdm(data): + new_dial = self.init_dial() # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['conversation_id'] + domain = "movie" + for key in ["vertical", "scenario", "instructions"]: + new_dial[ORI_DIAL_INFO][key] = dial[key] + dial_hist, dst_dict = [], {} + usr_utts, sys_utts, turn_id = [], [], 2 + new_turn = self.init_turn() + for idx, turn in enumerate(dial["utterances"]): + utt = turn["text"] + if turn["speaker"] == "user": + if idx and dial["utterances"][idx-1]["speaker"] == "assistant": + # wrap up the previous turn + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = " ".join(sys_utts) + if usr_utts and sys_utts: + new_dial[LOG].append(new_turn) + dial_hist.append(f" {new_turn[USR_UTT]}") + dial_hist.append(f" {new_turn[SYS_UTT]}") + # initialize a new turn + new_turn = self.init_turn(turn_id=turn_id) + new_turn[DIAL_HIST] = " ".join(dial_hist) + turn_id += 1 + usr_utts, sys_utts = [], [] + usr_utts.append(utt) + for key in turn: + if key in ["text", "speaker", "index"]: continue + new_turn[ORI_USR_ANN][key] = turn[key] + # dial_hist.append(f" {utt}") + + slot_list = [] + if "segments" in turn: + # add output for dst task (only accumulated dst provided) + for segment in turn["segments"]: + slot_value = segment["text"].replace(",","") # remove ",", because we use "," to separate slot triplet + if len(segment["annotations"][0]["name"].split(".")) == 1: + slot_type = segment["annotations"][0]["name"] + else: + slot1, dom = segment["annotations"][0]["name"].split(".")[0], segment["annotations"][0]["name"].split(".")[1] + if dom == domain: + slot_type = slot1 + else: + slot_type = f"{dom}_{slot1}" + slot_list.append(f"{domain} {slot_type} {slot_value}") + new_turn[DST] = ", ".join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + + else: # system side + if idx == 0 : continue + sys_utts.append(utt) + # new_turn[SYS_UTT] = utt + # dial_hist.append(f" {utt}") + new_turn[ORI_SYS_ANN]["segments"] = [] + if "segments" in turn: + new_turn[ORI_SYS_ANN]["segments"] = turn["segments"] + new_turn[EK] = self.dict_to_str(new_turn[ORI_SYS_ANN]["segments"]) + new_turn[EK_ORI] = new_turn[ORI_SYS_ANN]["segments"] + + if idx+1 == len(dial["utterances"]) and usr_utts and sys_utts: + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = " ".join(sys_utts) + new_dial[LOG].append(new_turn) + turn_id += 1 + usr_utts, sys_utts = [], [] + + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy["slots"][domain]} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["slots"][domain][slot], k=DST_LENGTH//2) + + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = ["movie"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + + if dial["conversation_id"] in split_id["val"] and \ + dial["conversation_id"] not in split_id["train"]: + mode = "val" + elif dial["conversation_id"] in split_id["test"] and \ + dial["conversation_id"] not in split_id["train"]: + mode = "test" + elif dial["conversation_id"] in split_id["val"] and dial_idx["val"] < 2000: + mode = "val" + elif dial["conversation_id"] in split_id["test"] and dial_idx["test"] < 2000: + mode = "test" + else: + mode = "train" + new_dial_id = f"{data_name}--{mode}--{dial_idx[mode]}" + new_dial[DIAL_IDX] = dial_idx[mode] + dial_idx[mode] += 1 + new_data[mode][new_dial_id] = new_dial + if len(new_data[mode]) == 1000: + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + new_data[mode] = {} # reset + file_idx[mode] += 1 + finish_flag[mode] = 1 + else: + finish_flag[mode] = 0 + + + # if there are some unsaved dialogs left, save it now + for mode in ["train", "val", "test"]: + if not finish_flag[mode]: + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + + print(f"finishing processing {dial_idx[mode]} dialogs for {mode} set ...") + self.save_original_examples(data[:5], data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def simjoint(self): + """ + original turn format leads by system side + """ + for data_name in ["SimJointMovie", "SimJointRestaurant"]: + exp_list = [] + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + domain = "movie" if data_name == "SimJointMovie" else "restaurant" + for mode in ["train", "val", "test"]: + real_name = f"{mode}.json" if mode != "val" else "dev.json" + path = os.path.join(self.data_dir, data_name, real_name) + exp_list.append(real_name) + + data = self._load_json(path) + new_data = {} + file_idx = 1 + + for dial_idx, dial in enumerate(data): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial["dialogue_id"] + dial_hist, dst_dict = [], {} + for idx, turn in enumerate(dial["turns"]): + if "system_utterance" in turn: + new_turn[SYS_UTT] = turn["system_utterance"]["text"] + for key in ["system_acts", "system_utterance"]: + new_turn[ORI_SYS_ANN][key] = turn[key] + dial_hist.append(" " + new_turn[SYS_UTT]) + new_dial[LOG].append(new_turn) + + if "user_utterance" in turn: + new_turn = self.init_turn(turn_id=idx+1) + new_turn[USR_UTT] = turn["user_utterance"]["text"] + new_turn[DIAL_HIST] = " ".join(dial_hist) + for key in ["dialogue_state", "user_acts", "user_intents", "user_utterance"]: + if key in turn: + new_turn[ORI_USR_ANN][key] = turn[key] + # adding dst output + slot_list = [] + for slot in turn["user_utterance"]["slots"]: + slot_type = slot["slot"] + slot_value = " ".join(turn["user_utterance"]["tokens"][slot["start"]:slot["exclusive_end"]]) + slot_list.append(f"{domain} {slot_type} {slot_value}") + new_turn[DST] = ", ".join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + # adding intent prediction output + # if len(turn["user_acts"]) > 1: pdb.set_trace() # checked: yes + intent_list = [intent["type"] for intent in turn["user_acts"]] + new_turn[INTENT] = ", ".join(intent_list) + dial_hist.append(" " + new_turn[USR_UTT]) + if not new_turn[SYS_UTT]: + new_dial[LOG].append(new_turn) + + # adding EK for Intent Prediction + new_dial[EK_ORI][INTENT_EK] = {domain:otgy["intents"]} + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy["slots"]} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > 2*DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["slots"][slot], k=DST_LENGTH) + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = [domain] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + + print(f"finishing processing {len(data)} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def simjointgen(self): + """ + original turn format leads by system side + but our format should end by system side + """ + data_name = "SimJointGEN" + exp_list = ["data"] + otgy = self._load_json(os.path.join(self.data_dir, data_name, "data/db.json")) + domain = "movie" + for mode in ["train", "val", "test"]: + real_name = f"{mode}.json" if mode != "val" else "dev.json" + path = os.path.join(self.data_dir, data_name, "data", real_name) + + data = self._load_json(path) + new_data = {} + file_idx = 1 + + for dial_idx, dial in tqdm(enumerate(data)): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial["dialogue_id"] + dial_hist, prev_slot_list = [], [] + + # init the first turn, which would contain only system utt + new_turn = self.init_turn(turn_id=1) + for idx, turn in enumerate(dial["turns"]): + if "system_utterance" in turn: # turn ends at system side + new_turn[SYS_UTT] = turn["system_utterance"] + new_turn[ORI_SYS_ANN]["system_acts"] = turn["system_acts"] + dial_hist.append(" " + new_turn[SYS_UTT]) + dial_hist.append(" " + new_turn[USR_UTT]) + new_dial[LOG].append(new_turn) + + if "user_utterance" in turn: # turn starts at user side + new_turn = self.init_turn(turn_id=idx+2) + new_turn[USR_UTT] = turn["user_utterance"] + new_turn[DIAL_HIST] = " ".join(dial_hist) + for key in ["dialogue_state", "database_state"]: + if key in turn: + new_turn[ORI_USR_ANN][key] = turn[key] + # add output for accumulated dst task (only accumulated dst provided) + slot_list = [] + for slot_type, slot_value in turn["dialogue_state"].items(): + slot_list.append(f"{domain} {slot_type} {slot_value}") + new_turn[DST_ACC] = ", ".join(slot_list) + # add output for current turn dst task + current_slot_list = [] + for slot_type, slot_value in turn["dialogue_state"].items(): + slot = f"{domain} {slot_type} {slot_value}" + if slot in prev_slot_list: continue + current_slot_list.append(slot) + new_turn[DST] = ", ".join(current_slot_list) + prev_slot_list = current_slot_list + + if not new_turn[SYS_UTT]: + new_dial[LOG].append(new_turn) + + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > 2*DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy[slot], k=DST_LENGTH) + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = ["movie"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + + print(f"finishing processing {len(data)} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + self.copy_general(os.path.join(self.data_dir, data_name, "data", "db.json"), os.path.join(self.save_dir, data_name, "db.json")) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def muldogo(self): + """ + raw data in ./data/unannotated/${domain}.tsv in format of: + conversationId,turnNumber,utteranceId,utterance,authorRole + acs-31971762-f14e-4d55-b909-0370f6e4db19-1,0,acs-2571cf40-4e39-46b6-940c-7b8cce559bae,HI GOOD MORNING,customer + split and annotation in ./data/paper_splits/splits_annotated_at_turn_level/${domain}/[train/dev/test].tsv in format of: + conversationId turnNumber utteranceId utterance slot-labels intent + 31971762-f14e-4d55-b909-0370f6e4db19 0 31971762-f14e-4d55-b909-0370f6e4db190 hi good morning O O O openinggreeting + + 1. conversationId in raw has prefix (acs-) and suffix (-1/-2) + 2. user/system turn can be consecutive + 3. not all data have been annotated + 4. split in sentence level is different from that in turn level. use turn level split for now + """ + data_name = "MulDoGO" + dir_dial = os.path.join(self.data_dir, data_name, "data/unannotated") + dir_split = os.path.join(self.data_dir, data_name, "data/paper_splits/splits_annotated_at_turn_level") + data = self._load_dir_tsv(dir_dial, sep=",") + split_annotation, new_data, file_idx, finish_flag, dial_idx = {}, {}, {}, {}, {} + exp_list = ["data"] + + for mode in ["train", "val", "test"]: + real_name = mode if mode != "val" else "dev" + split_annotation[mode] = None + for domain in sorted(os.listdir(dir_split)): + split_file = self._load_csv(os.path.join(dir_split, domain, f"{real_name}.tsv")) + split_file["domain"] = domain + split_annotation[mode] = pd.concat([split_annotation[mode], split_file], ignore_index=True) + new_data[mode], file_idx[mode], finish_flag[mode], dial_idx[mode] = {}, 1, 0, 1 + + new_dial = None + for idx, turn in tqdm(data.iterrows()): + if turn.conversationId.endswith("2"): continue # repeated conversation + dial_id = turn.conversationId[:-2] + if dial_id.startswith("acs-"): dial_id = dial_id[4:] + # init a new dial for the current and following turns + if new_dial is None: + annotate_flag = 0 + for mode in ["val", "test", "train"]: + if dial_id in split_annotation[mode]['conversationId'].values: + annotate_flag = 1 + index = split_annotation[mode][split_annotation[mode]['conversationId']==dial_id].index[0] + domain_ = split_annotation[mode]["domain"][index] + # pdb.set_trace() + break + new_dial_id = f"{data_name}--{mode}--{dial_idx[mode]}" + new_dial = self.init_dial(dial_idx=dial_idx[mode]) + new_dial[ORI_DIAL_ID] = dial_id + new_dial[ORI_DIAL_INFO]["domain"] = domain_ + turn_id, dial_hist = 1, [] + new_turn = self.init_turn(turn_id=turn_id) + + # continue extending the current dial + if turn.authorRole == "customer": + # adding utterances + new_turn[USR_UTT] += f" {turn.utterance}" + new_turn[USR_UTT] = new_turn[USR_UTT].strip() + # adding annotation for turn level + if annotate_flag: + utt_id = f"{dial_id}{turn.turnNumber}" + row = split_annotation[mode][split_annotation[mode]["utteranceId"]==utt_id] + # pdb.set_trace() + new_turn[ORI_USR_ANN]["slot-labels"] = row["slot-labels"].tolist() + new_turn[ORI_USR_ANN]["intent"] = row["intent"].values.tolist() + + elif turn.authorRole == "agent": + # no annotation on system side + new_turn[SYS_UTT] += f" {turn.utterance}" + new_turn[SYS_UTT] = new_turn[SYS_UTT].strip() + + # wrap up turn + if idx == len(data)-1 or data.authorRole[idx+1] != "agent": + new_dial[LOG].append(new_turn) + turn_id += 1 + dial_hist.append(" " + new_turn[USR_UTT]) + dial_hist.append(" " + new_turn[SYS_UTT]) + new_turn = self.init_turn(turn_id=turn_id) + new_turn[DIAL_HIST] = " ".join(dial_hist) + + # wrap up dial (add new dial to new data) + if idx == len(data)-1 or dial_id not in data.conversationId[idx+1]: + # adding prompt for each dialog + domains = [turn["filename"]] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + if new_dial[LOG]: + new_data[mode][new_dial_id] = new_dial + dial_idx[mode] += 1 + new_dial = None + + if len(new_data[mode]) == 1000: + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + new_data[mode] = {} # reset + file_idx[mode] += 1 + finish_flag[mode] = 1 + else: + finish_flag[mode] = 0 + + # if there are some unsaved dialogs left, save it now + for mode in ["train", "val", "test"]: + if not finish_flag[mode]: + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + print(f"finishing processing {dial_idx[mode]} dialogs for {mode} set ...") + + self.save_original_examples(data[:6].to_string(index=False).split('\n'), data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def casino(self): + """ + 1. operation like "Submit-Deal","Accept-Deal" and "Reject-Deal" inlcuded in the "chat-log" + we move them to dialog-level annotation: new_dial[ORI_DIAL_INFO]["result"] = [turn1, turn2, ...] + 2. no user/system but mturk_agent_1/2, and either might start the dialog. Therefore, we consider + whoever starts the dialog as user. + 3. no consecutive turn from the same side + 4. xxx-Deal can happens during the dialog + """ + data_name = "CaSiNo" + exp_list = ["data"] + dir_data = os.path.join(self.data_dir, data_name, "data/split") + for mode in ["train", "val", "test"]: + real_name = mode if mode != "val" else "valid" + data = self._load_json(os.path.join(dir_data, f"casino_{real_name}.json")) + new_data, file_idx = {}, 1 + for dial_idx, dial in tqdm(enumerate(data)): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial["dialogue_id"] + new_dial[ORI_DIAL_INFO]["participant_info"] = dial["participant_info"] + new_dial[ORI_DIAL_INFO]["annotations"] = dial["annotations"] + new_dial[ORI_DIAL_INFO]["results"] = [] + dial_hist = [] + speaker_user = dial["chat_logs"][0]["id"] + new_turn = self.init_turn() + usr_utts, sys_utts, turn_id = [], [], 2 + + for idx, turn in enumerate(dial["chat_logs"]): + # skip those negotiation decision turns + if turn["text"].endswith("-Deal"): + new_dial[ORI_DIAL_INFO]["results"].append(turn) + continue + if turn["id"] == speaker_user: + if sys_utts: + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = " ".join(sys_utts) + new_dial[LOG].append(new_turn) + dial_hist.append(" " + new_turn[USR_UTT]) + dial_hist.append(" " + new_turn[SYS_UTT]) + new_turn = self.init_turn(turn_id=turn_id) + new_turn[DIAL_HIST] = " ".join(dial_hist) + turn_id += 1 + usr_utts, sys_utts = [], [] + + # if not usr_utts: + # new_turn = self.init_turn(turn_id=turn_id, dial_hist=dial_hist) + usr_utts.append(turn["text"]) + # new_turn[USR_UTT] = turn["text"] + new_turn[ORI_USR_ANN] = turn["task_data"] + new_turn[ORI_USR_ANN]["speakere"] = turn["id"] + else: + sys_utts.append(turn["text"]) + new_turn[ORI_SYS_ANN] = turn["task_data"] + new_turn[ORI_SYS_ANN]["speaker"] = turn["id"] + + if usr_utts or sys_utts: + new_turn[USR_UTT] = " ".join(usr_utts) + new_turn[SYS_UTT] = " ".join(sys_utts) + new_dial[LOG].append(new_turn) + usr_utts, sys_utts = [], [] + + # adding prompt for each dialog + domains = ["negotiate"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def airdialogue(self): + """ + both user and system can end a dialog. we ignore the last utt if user ends a dialog. + system side can start a dialog, ignore it + """ + data_name = "AirDialogue" + exp_list = ["airdialogue"] + dir_path = os.path.join(self.data_dir, data_name, "airdialogue") + for mode in ["val", "train"]: + real_name = mode if mode != "val" else "dev" + data = self._load_txt(os.path.join(dir_path, f"{real_name}_data.json")) + database = self._load_txt(os.path.join(dir_path, f"{real_name}_kb.json")) + new_data, file_idx = {}, 1 + + for dial_idx, dial in tqdm(enumerate(data)): + dial = json.loads(dial) + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + for key in dial: + if key == "dialogue": continue + new_dial[ORI_DIAL_INFO][key] = dial[key] + dial_hist, turn_id = [], 1 + for idx, turn in enumerate(dial["dialogue"]): + speaker, utt = turn.split(": ")[0], ": ".join(turn.split(": ")[1:]) + if idx == 0 and speaker == "agent": continue + if speaker == "customer": + new_turn = self.init_turn(turn_id=turn_id, dial_hist=dial_hist) + new_turn[USR_UTT] = utt + elif speaker == "agent": + new_turn[SYS_UTT] = utt + new_dial[LOG].append(new_turn) + dial_hist.append(" " + new_turn[USR_UTT]) + dial_hist.append(" " + new_turn[SYS_UTT]) + turn_id += 1 + + target_fligt_num_list, cands = new_dial[ORI_DIAL_INFO]["action"]["flight"], [] + ek = json.loads(database[dial_idx]) + for flight in ek["kb"]: + if flight["flight_number"] in target_fligt_num_list: + cands.append(flight) + while len(cands) < TOD_LENGTH: + cand = random.choice(ek["kb"]) + if cand not in cands: + cands.append(cand) + new_dial[EK_ORI][TOD_EK]["flight"] = cands + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = ["flight"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + self.copy_general(os.path.join(self.data_dir, data_name, "airdialogue", "train_kb.json"), os.path.join(self.save_dir, data_name, "train_kb.json")) + self.copy_general(os.path.join(self.data_dir, data_name, "airdialogue", "dev_kb.json"), os.path.join(self.save_dir, data_name, "val_kb.json")) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def msdc(self): + """ + 1. raw data is not standardized with error: + pandas.errors.ParserError: Error tokenizing data. C error: Expected 10 fields in line 23317, saw 11 + therefore process as txt file + + 2. agent might have consecutive utt at the end of dialog + """ + data_name = "MS-DC" + mode, new_data, file_idx, new_dial, dial_idx = "train", {}, 1, None, 1 + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + + for filename in os.listdir(os.path.join(self.data_dir, data_name)): + domain = filename.split("_")[0] + data = self._load_txt(os.path.join(self.data_dir, data_name, filename))[1:] + + for idx, row in tqdm(enumerate(data)): + [dial_id, turn_id, timestamp, speaker, utt], act = row.strip().split("\t")[:5], row.strip().split("\t")[5:] + if new_dial is None: + # init dialog + new_dial_id = f"{data_name}--{mode}--{dial_idx}" + new_dial = self.init_dial(dial_idx=dial_idx) + new_dial[ORI_DIAL_ID] = dial_id + new_dial[ORI_DIAL_INFO]["domain"] = domain + dst_dict = {} + # init turn + turn_idx, prev_speaker, dial_hist = 1, None, [] + new_turn = self.init_turn(turn_id=turn_idx) + new_turn[ORI_USR_ANN]["act"] = [] + new_turn[ORI_SYS_ANN]["act"] = [] + + # continue extending the current dial + if speaker == "user": + # adding utterances + new_turn[USR_UTT] += f" {utt}" + new_turn[USR_UTT] = new_turn[USR_UTT].strip() + new_turn[ORI_USR_ANN]["act"].extend(act) + + elif speaker == "agent": + # no annotation on system side + new_turn[SYS_UTT] += f" {utt}" + new_turn[SYS_UTT] = new_turn[SYS_UTT].strip() + new_turn[ORI_SYS_ANN]["act"].extend(act) + + # wrap up turn + if idx == len(data)-1 or data[idx+1].split("\t")[3] != "agent": + # adding output for dst task + slot_list = [] + for act in new_turn[ORI_USR_ANN]["act"]: + if act.split("(")[0] not in ["inform", "request"]: continue + slots = act.split("(")[1][:-1].replace("?",";").replace("==","=").replace(",",";c").replace("||",";") + if slots.startswith("mc_list"): continue + for slot in slots.split(";"): + if slot == "pickup_location_city=West Roxburystate=MA": + slot_list.append(f"{domain} pickup_location_city West Roxbury") + slot_list.append(f"{domain} state MA") + continue + if slot == "date=Apr 2ndstarttime=1pm": + slot_list.append(f"{domain} date Apr 2nd") + slot_list.append(f"{domain} starttime 1pm") + continue + if slot == "numberofpeople=2date=tomorrow night": + slot_list.append(f"{domain} numberofpeople 2") + slot_list.append(f"{domain} date tomorrow night") + continue + if slot == "city=Washington DCtheater=a regular": + slot_list.append(f"{domain} city Washington DC") + slot_list.append(f"{domain} theater a regular") + continue + if "=" in slot: + slot_type = slot.split("=")[0].strip() + slot_value = "=".join(slot.split("=")[1:]) + slot_value = slot_value.replace("\\","").replace("{{","{").strip() + if not slot_value: continue + if slot_type in ["result","closing","greeting"]: continue + if slot_type in ["cstate", "ccity", "cdate", "cnumberofpeople", "cstarttime", "cpickup_location_city"]: slot_type = slot_type[1:] + slot_list.append(f"{domain} {slot_type} {slot_value}") + new_turn[DST] = ", ".join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + # adding output for intents task + new_turn[INTENT] = ", ".join([act.split("(")[0] for act in new_turn[ORI_USR_ANN]["act"]]) + new_dial[LOG].append(new_turn) + turn_idx += 1 + dial_hist.append(" " + new_turn[USR_UTT]) + dial_hist.append(" " + new_turn[SYS_UTT]) + new_turn = self.init_turn(turn_id=turn_idx) + new_turn[DIAL_HIST] = " ".join(dial_hist) + new_turn[ORI_USR_ANN]["act"] = [] + new_turn[ORI_SYS_ANN]["act"] = [] + + # wrap up dial (add new dial to new data) + if idx == len(data)-1 or dial_id != data[idx+1].split("\t")[0]: + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy["slots"][domain]} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > 2*DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["slots"][domain][slot], k=DST_LENGTH) + # adding EK for Intent task + new_dial[EK_ORI][INTENT_EK] = {domain: otgy["intents"][domain]} + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + + # adding prompt for each dialog + domains = [domain] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + new_dial = None + dial_idx += 1 + + if (dial_idx-1) % 1000 == 0 or dial_idx == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_original_examples(data[:50], data_name) + self.save_converted_examples(data_name) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def abcd(self): + """ + 1. consecutive turns exist, with repeated annotation + 2. conversation starts from agent. Therefore, no user utt is included in the first turn + "dialog history": " Hello. How can i help you today?", + """ + data_name = "ABCD" + data = self._load_json(os.path.join(self.data_dir, data_name, "data/abcd_v1.1.json")) + new_data, file_idx, exp_list = {}, {}, ["abcd_v1.1.json"] + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + + for real_name, split_data in data.items(): + mode = real_name if real_name != "dev" else "val" + new_data[mode] = {} + file_idx[mode] = 1 + + for dial_idx, dial in tqdm(enumerate(split_data)): + # init dialog + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) + new_dial[ORI_DIAL_ID] = dial["convo_id"] + new_dial[ORI_DIAL_INFO] = dial["scenario"] + # init the first turn + turn_idx, prev_speaker, dial_hist = 1, None, [] + new_turn = self.init_turn(turn_id=turn_idx) + new_turn[ORI_USR_ANN]["delexed"], new_turn[ORI_SYS_ANN]["delexed"] = [], [] + domain = dial["scenario"]["flow"] + dst_dict = {} + for idx, [speaker, utt] in enumerate(dial["original"]): + # continue extending the current dial + if speaker == "customer": + # adding utterances + new_turn[USR_UTT] += f" {utt}" + new_turn[USR_UTT] = new_turn[USR_UTT].strip() + new_turn[ORI_USR_ANN]["delexed"].append(dial["delexed"][idx]) + slot_list = [] + if "<" in dial["delexed"][idx]["text"]: + slot_val_list = self.compare_delex(utt, dial["delexed"][idx]["text"]) + for [slot_value, slot_type] in slot_val_list: + if not slot_type.startswith("<") and not slot_type.endswith(">"): continue + slot_type = slot_type.split(">")[0].split("<")[-1] + slot_list.append(f"{domain} {slot_type} {slot_value}") + new_turn[DST] = ", ".join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) + + + if speaker == "agent": + # no annotation on system side + new_turn[SYS_UTT] += f" {utt}" + new_turn[SYS_UTT] = new_turn[SYS_UTT].strip() + new_turn[ORI_SYS_ANN]["delexed"].append(dial["delexed"][idx]) + + # wrap up turn + if idx == len(dial["original"])-1 or dial["original"][idx+1][0] != "agent": + new_dial[LOG].append(new_turn) + turn_idx += 1 + if new_turn[USR_UTT]: + dial_hist.append(" " + new_turn[USR_UTT]) + dial_hist.append(" " + new_turn[SYS_UTT]) + new_turn = self.init_turn(turn_id=turn_idx) + new_turn[DIAL_HIST] = " ".join(dial_hist) + new_turn[ORI_USR_ANN]["delexed"], new_turn[ORI_SYS_ANN]["delexed"] = [], [] + + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy["slots"][domain]} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > 2*DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["slots"][domain][slot], k=DST_LENGTH) + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = [dial["scenario"]["flow"]] + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[mode][new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(split_data): + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + new_data[mode] = {} # reset + file_idx[mode] += 1 + + if mode == "train": self.save_original_examples(split_data[:5], data_name) + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list, "data") + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def salesbot(self): + """ + chitchat+top, no user/system + no ek + """ + data_name = "SalesBot" + data = self._load_dir_json(os.path.join(self.data_dir, data_name, "data/dialogues")) + mode, new_data, file_idx, exp_list = "train", {}, 1, ["data"] + for dial_idx, dial in tqdm(enumerate(data)): + # init dialog + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) + new_dial[ORI_DIAL_ID] = dial["id"] + new_dial[ORI_DIAL_INFO]["intent"] = dial["intent"] + new_dial[ORI_DIAL_INFO]["transition_candidates"] = dial["transition_candidates"] + dial_hist = [] + for turn_idx, utt in enumerate(dial["dialog"]): + if turn_idx%2==0: + new_turn = self.init_turn(turn_id=turn_idx//2+1) + finish_turn_flag = 0 + new_turn[DIAL_HIST] = " ".join(dial_hist) + new_turn[USR_UTT] = utt + else: + new_turn[SYS_UTT] = utt + new_dial[LOG].append(new_turn) + finish_turn_flag = 1 + dial_hist.append(" " + new_turn[USR_UTT]) + dial_hist.append(" " + new_turn[SYS_UTT]) + + if not finish_turn_flag: + new_dial[LOG].append(new_turn) + # adding prompt for each dialog + domains = dial["intent"]["type"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_original_examples(data[:5], data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list, "data") + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def craigslist(self): + """ + 1. dialog acts of the last two turns could be "offer" and "accept/reject" ("message" for usual cases) + since outcome has already been included in dial["outcome"], therefore we skip all turns withour action "message" + 2. no consecutive turns + 3. no user/system. we consider the agent who starts the conversation as user (seller/buyer might exchange over dialogs) + 4. action space: ["accept", "reject", "quit", "message", "offer"] + """ + + data_name = "CraigslistBargains" + exp_list = [] + for mode in ["train", "val", "test"]: + data = self._load_json(os.path.join(self.data_dir, data_name, f"{mode}.json")) + new_data, file_idx = {}, 1 + exp_list.append(f"{mode}.json") + dial_idx = 1 + + for dial in (data): + # init dialog + new_dial = self.init_dial(dial_idx=dial_idx) + new_dial[ORI_DIAL_ID] = dial["uuid"] + for key in dial: + if key in ["uuid", "events"]: continue + new_dial[ORI_DIAL_INFO][key] = dial[key] + dial_hist, turn_id = [], 1 + for idx, turn in enumerate(dial["events"]): + if turn["action"] != "message": continue + turn["data"] = turn["data"].replace("\\","") + turn_id += 1 + if turn_id%2==0: + new_turn = self.init_turn(turn_id=turn_id//2) + finish_turn_flag = 0 + new_turn[DIAL_HIST] = " ".join(dial_hist) + new_turn[USR_UTT] = turn["data"] + for key in turn: + if key == "data": continue + new_turn[ORI_USR_ANN][key] = turn[key] + else: + new_turn[SYS_UTT] = turn["data"] + for key in turn: + if key == "data": continue + new_turn[ORI_USR_ANN][key] = turn[key] + new_dial[LOG].append(new_turn) + finish_turn_flag = 1 + dial_hist.append(" " + new_turn[USR_UTT]) + dial_hist.append(" " + new_turn[SYS_UTT]) + if not finish_turn_flag and idx+1 == len(dial["events"]): + new_dial[LOG].append(new_turn) + + # adding prompt for each dialog + domains = ["bargain"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + if new_dial[LOG]: + new_dial[DIAL_IDX] = dial_idx + new_dial_id = f"{data_name}--{mode}--{dial_idx}" + new_data[new_dial_id] = new_dial + dial_idx += 1 + if (dial_idx-1) % 1000 == 0 or dial_idx == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def frames(self): + data_name = "FRAMES" + otgy = self._load_json(os.path.join(self.save_dir, data_name, "otgy.json")) + exp_list = [] + for mode in ['train', 'test']: + data = self._load_json(os.path.join(self.data_dir, data_name, f"{mode}_dials.json")) + new_data, file_idx = {}, 1 + for dial_idx, dial in tqdm(enumerate(data["dialogues"])): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) + new_dial[ORI_DIAL_ID] = dial["dialogue_id"] + new_dial[ORI_DIAL_INFO]["scenario"] = dial["scenario"] + domain = dial["scenario"]["task"] + + utterances = dial["utterances"] + # There are formats such as ,...,,...,...,... + user_uttr = "" + sys_uttr = "" + dialog_history = "" + user_da_label = "" # dialog acts + sys_da_label = "" + sys_slots_values = {} + uttr_index = 0 + turn_index = 1 + mentioned_slots = { + "dst_city": set(), + "or_city": set(), + } + dst_dict = {} + while uttr_index < len(utterances): + while uttr_index < len(utterances) and utterances[uttr_index]["speaker"] == "USR": + user_uttr += " " + utterances[uttr_index]["text"] + user_uttr = user_uttr.strip() + + # Keep the latest + user_da_label = utterances[uttr_index]["da_label"] + + uttr_index += 1 + + while uttr_index < len(utterances) and utterances[uttr_index]["speaker"] == "SYS": + sys_uttr += " " + utterances[uttr_index]["text"] + sys_uttr = sys_uttr.strip() + + # Keep the latest + sys_da_label = utterances[uttr_index]["da_label"] + sys_slots_values = utterances[uttr_index]["slots"] + + uttr_index += 1 + + # converted "null", i.e., no dialog act labels, to "" + if sys_da_label == "null": + sys_da_label = "" + + turn_log = {} + turn_log["turn id"] = turn_index + turn_log["user utterance"] = user_uttr + turn_log["system response"] = sys_uttr + turn_log["dialog history"] = dialog_history + turn_log["original user side information"] = {} + turn_log["original system side information"] = {} + + turn_log["original user side information"]["da_label"] = user_da_label + turn_log["original system side information"]["da_label"] = sys_da_label + turn_log["original system side information"]["slots"] = sys_slots_values + # adding output for intent task + turn_log[INTENT] = user_da_label + # adding output for dst task + slot_list = [] + for slot_type, slot_value in sys_slots_values.items(): + slot_list.append(f"{domain} {slot_type} {slot_value}") + turn_log[DST] = DST_SPLIT.join(slot_list) + # accumulate dst output + dst_dict = self.update_with_slot_list(dst_dict, slot_list) + turn_log[DST_ACC] = self.dst_dict_to_str(dst_dict) + new_dial['log'].append(turn_log) + + dialog_history += " " + user_uttr + " " + sys_uttr + dialog_history = dialog_history.strip() + + user_uttr = "" + sys_uttr = "" + user_da_label = "" + sys_da_label = "" + sys_slots_values = {} + + turn_index += 1 + if "dst_city" in sys_slots_values: + mentioned_slots["dst_city"].add(sys_slots_values["dst_city"]) + if "or_city" in sys_slots_values: + mentioned_slots["or_city"].add(sys_slots_values["or_city"]) + + # adding EK for TOD task + if len(dial["scenario"]["items"]) <= TOD_LENGTH: + new_dial[EK_ORI][TOD_EK]["travel"] = dial["scenario"]["items"] + else: + # select the dialog-mentioned item first and then random select the rest + cands = [] + for item in dial["scenario"]["items"]: + if item["trip"]["or_city"] in mentioned_slots["or_city"] and \ + item["hotel"]["dst_city"] in mentioned_slots["dst_city"]: + cands.append(item) + while len(cands) < TOD_LENGTH: + cand = random.choice(dial["scenario"]["items"]) + if cand not in cands: + cands.append(cand) + new_dial[EK_ORI][TOD_EK]["travel"] = cands + # adding EK for DST task + new_dial[EK_ORI][DST_EK] = {domain: otgy["slots"][domain]} + for slot in new_dial[EK_ORI][DST_EK][domain]: + if len(new_dial[EK_ORI][DST_EK][domain][slot]) > 2*DST_LENGTH: + new_dial[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["slots"][domain][slot], k=DST_LENGTH) + # adding EK for Intent task + new_dial[EK_ORI][INTENT_EK] = {domain: otgy["intents"][domain]} + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = ["trip"] + new_dial[PROMPT] = generate_prompt(data_name, domains) + + new_data[new_dial_id] = new_dial + + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data["dialogues"]): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data["dialogues"][:5], data_name) + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def dstc2(self): + data_name = "DSTC2-Clean" + otgy = self._load_json(os.path.join(self.data_dir, data_name, "ontology_en.json")) + del otgy["informable"]["request"] + exp_list = [] + domain = "restaurant" + for mode in ["train", "test", "val"]: + real_name = f"{mode}_en.json" if mode!="val" else "valid_en.json" + new_data, file_idx = {}, 1 + f_text = self._load_json(os.path.join(self.data_dir, data_name, real_name)) + for index, text in enumerate(f_text): + dialog = self.init_dial(dial_idx=index+1) + # dialog = defaultdict(list) + dialog[ORI_DIAL_ID] = "" + dialog[DIAL_IDX] = index + 1 + dialog[ORI_DIAL_INFO] = defaultdict(list) + dialog_history = "" + turn_index = 1 + new_dial_id = f"{data_name}--{mode}--{index+1}" + + messages = text['dialogue'] + for uttr_index, utterance in enumerate(messages): + if uttr_index == 0: + sys_uttr = utterance["system_transcript"] + + turn_log = self.save_info_to_dict(turn_index, "", sys_uttr, dialog_history) + turn_log[ORI_SYS_ANN]["system_acts"] = utterance["system_acts"] + + dialog['log'].append(turn_log) + + dialog_history = " " + sys_uttr + user_uttr = utterance["transcript"] + user_turn_label = utterance["turn_label"] + user_asr = utterance["asr"] + + else: + sys_uttr = utterance["system_transcript"] + + turn_log = self.save_info_to_dict(turn_index, user_uttr, sys_uttr, dialog_history) + + turn_log[ORI_USR_ANN]["turn_label"] = user_turn_label + turn_log[ORI_USR_ANN]["asr"] = user_asr + turn_log[ORI_SYS_ANN]["system_acts"] = utterance["system_acts"] + + # adding output for dst task + # if user_turn_label: + slot_list = [] + for [slot_type, slot_value] in user_turn_label: + slot_list.append(f"{domain} {slot_type} {slot_value}") + turn_log[DST] = ", ".join(slot_list) + + dialog['log'].append(turn_log) + + dialog_history += " " + user_uttr + " " + sys_uttr + user_uttr = utterance["transcript"] + user_turn_label = utterance["turn_label"] + user_asr = utterance["asr"] + + if uttr_index + 1 == len(messages): + turn_log = self.save_info_to_dict(turn_index + 1, user_uttr, "", dialog_history) + + turn_log[ORI_USR_ANN]["turn_label"] = user_turn_label + turn_log[ORI_USR_ANN]["asr"] = user_asr + turn_log[ORI_SYS_ANN]["system_acts"] = utterance["system_acts"] + + # adding output for dst task + # if user_turn_label: + slot_list = [] + for [slot_type, slot_value] in user_turn_label: + slot_list.append(f"{domain} {slot_type} {slot_value}") + turn_log[DST] = ", ".join(slot_list) + dialog['log'].append(turn_log) + + turn_index += 1 + + # adding EK for DST task + dialog[EK_ORI][DST_EK] = {domain: otgy["informable"]} + for slot in dialog[EK_ORI][DST_EK][domain]: + if len(dialog[EK_ORI][DST_EK][domain][slot]) > 2*DST_LENGTH: + dialog[EK_ORI][DST_EK][domain][slot] = random.choices(otgy["informable"][slot], k=DST_LENGTH) + + # turn the external knowledge into a flat string + dialog[EK] = self.dict_to_str(dialog[EK_ORI][TOD_EK]) + dialog[EK_DST] = self.dict_to_str(dialog[EK_ORI][DST_EK]) + dialog[EK_INTENT] = self.dict_to_str(dialog[EK_ORI][INTENT_EK]) + + # adding prompt for each dialog + domains = ["restaurant"] + dialog[PROMPT] = generate_prompt(data_name, domains) + + new_data[new_dial_id] = dialog + # Save every 1000 dialogs to a file + if (index + 1) % 1000 == 0 or (index + 1) == len(f_text): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(f_text[:5], data_name) + print(f"finishing processing {index} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def multiwoz_hdsa(self): + data_name, exp_list = "HDSA-Dialog", [] + for mode in ["train", "val", "test"]: + dir_path = os.path.join(self.data_dir, data_name, f"data/{mode}.json") + data = self._load_json(dir_path) + new_data = {} + file_idx = 1 + + for dial_idx, dial in tqdm(enumerate(data)): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial["file"] + + dial_hist, result_list, cand_list = [], {}, {} + for idx, turn in enumerate(dial["info"]): + new_turn = self.init_turn(turn_id=idx+1) + new_turn[USR_UTT] = turn["user"] + new_turn[SYS_UTT] = turn["sys"] + new_turn[DIAL_HIST] = " ".join(dial_hist) + # include user utterance into dialog history + dial_hist.append(f" {new_turn[USR_UTT]}") + dial_hist.append(f" {new_turn[SYS_UTT]}") + for key_ in turn.keys(): + if key_ in ["user", "sys"]: continue + elif key_ in ["sys_orig", "source", "KB", "act"]: + new_turn[ORI_SYS_ANN][key_] = turn[key_] + else: + new_turn[ORI_USR_ANN][key_] = turn[key_] + new_dial[LOG].append(new_turn) + + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data[:5], data_name) + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + # self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def multiwoz22(self): + data_name, exp_list = "MULTIWOZ2_2", [] + for mode in ["train", "val", "test"]: + real_name = mode if mode != "val" else "dev" + data = self._load_dir_json(os.path.join(self.data_dir, data_name, real_name)) + data_21 = self._load_json(os.path.join(self.data_dir, "MULTIWOZ2_1", f"{mode}_dials.json")) + otgy = self.multiwoz_dst_otgy() + intents = self._load_json(os.path.join(self.data_dir, "MultiWOZ_2.1", "intents.json" )) + exp_list.append(real_name) + new_data = {} + file_idx = 1 + turn_num = 0 + for dial_idx, dial in tqdm(enumerate(data)): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['dialogue_id'] + new_dial[ORI_DIAL_INFO]["services"] = dial["services"] + + dial_hist, prev_dst_set = [], set() + for idx, turn in enumerate(dial["turns"]): + utt = turn["utterance"] + if turn["speaker"] == "USER": + # new turn start from user + new_turn = self.init_turn(turn_id=idx//2+1) + new_turn[USR_UTT] = utt + new_turn[DIAL_HIST] = " ".join(dial_hist) + # include user utterance into dialog history + dial_hist.append(f" {utt}") + # other annotation for user side + new_turn[ORI_USR_ANN]["frames"] = turn["frames"] + # add dst output + slot_list = [] + # # only for the current turn and non-categorical slots + # for frame in turn["frames"]: + # if not frame["slots"]: continue + # for slot in frame["slots"]: + # dom, slot_type = slot["slot"].split("-") + # value = slot["value"] if type(slot["value"]) == str else slot["value"][0] + # slot_list.append(f"{dom} {slot_type} {value}") + # used for accumulated slots + for frame in turn["frames"]: + if not frame["state"]["slot_values"]: continue + for slot, value in frame["state"]["slot_values"].items(): + dom, slot_type = slot.split("-") + value = value[0] if type(value) == list else value + slot_list.append(f"{dom} {slot_type} {value}") + new_turn[DST_ACC] = DST_SPLIT.join(slot_list) + # compute the non-accumulated slots + new_turn[DST] = DST_SPLIT.join(list(set(slot_list).difference(prev_dst_set))) + prev_dst_set = set(slot_list) + # add intent output + intent_list = [] + for frame in turn["frames"]: + if frame["state"]["active_intent"] != "NONE": + intent_list.append(frame["state"]["active_intent"]) + new_turn[INTENT] = ", ".join(intent_list) + + # dialog ends at user side + if idx == len(dial["turns"]) - 1: + new_dial[LOG].append(new_turn) + + if turn["speaker"] == "SYSTEM": + new_turn[SYS_UTT] = utt + # include system response into dialog history + dial_hist.append(f" {utt}") + # turn must end at assistant side + new_dial[LOG].append(new_turn) + turn_num += 1 + goal = data_21[dial["dialogue_id"]]["goal"] + # get active domains + domains = [] + for dom in MULTIWOZ_DOMAINS: + if goal[dom]: domains.append(dom) + # adding EK for TOD + for dom in ["restaurant", "hotel", "attraction", "train"]: + if not goal[dom]: continue + constraint = [goal[dom]["info"]] + db = self._load_json(os.path.join(self.data_dir, data_name, f"db/{dom}_db.json")) + + new_dial[EK_ORI][TOD_EK][dom] = [] + satisfied_cand, unsatisfied_cand = self.filter_cand(db, constraint) + if len(satisfied_cand)+len(unsatisfied_cand) < TOD_LENGTH: + new_dial[EK_ORI][TOD_EK][dom] = satisfied_cand + unsatisfied_cand + else: + new_dial[EK_ORI][TOD_EK][dom] = satisfied_cand + new_dial[EK_ORI][TOD_EK][dom].extend(random.choices(unsatisfied_cand, k=(TOD_LENGTH-len(satisfied_cand)))) + # adding EK for DST + for dom in domains: + if dom not in otgy: continue + if dom not in new_dial[EK_ORI][DST_EK]: new_dial[EK_ORI][DST_EK][dom] = {} + for slot_type in otgy[dom]: + new_dial[EK_ORI][DST_EK][dom][slot_type] = random.choices(otgy[dom][slot_type], k=DST_LENGTH) + # adding EK for Intent + for dom in domains+["booking", "general"]: + if dom not in intents: continue + new_dial[EK_ORI][INTENT_EK][dom] = intents[dom] + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog + domains = dial["services"] # some dial["services"] are not annotated + new_dial[PROMPT] = generate_prompt(data_name, domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + print(f"Processing {mode} data with {dial_idx} dialogs i.e. {turn_num} turns ... " ) + if mode == "train": self.save_original_examples(data[:5], data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def mudoco(self): + def save_info_to_dict(turn_index, user_uttr, sys_uttr, dialog_history): + turn_log = defaultdict(list) + turn_log["turn id"] = turn_index + turn_log["user utterance"] = user_uttr + turn_log["system response"] = sys_uttr + + turn_log["dialog history"] = dialog_history + turn_log["original user side information"] = defaultdict(list) + turn_log["original system side information"] = defaultdict(list) + return turn_log + + data_name = "MuDoCo" + exp_list = [] + # combine dialog from each domain + data = defaultdict(list) + domains = ["calling", "messaging", "music", "news", "reminders", "weather"] + for domain in domains: + domain_data = self._load_json(os.path.join(self.data_dir, data_name, f"mudoco_{domain}.json")) + exp_list.append(f"mudoco_{domain}.json") + for dial_id in domain_data["dialogs"]: + domain_data["dialogs"][dial_id]["domain"] = domain + data.update(domain_data["dialogs"]) + # split dialogs into train/val/test set + f_text = defaultdict(list) + for dialog_id in data: + mode = data[dialog_id]["split"] + if mode == "eval": + mode = "val" + f_text[mode].append([dialog_id, data[dialog_id]]) + + for mode in ["train", "val", "test"]: + # out_folder_path = os.path.join(folder_path + '_PROCESSED', out_dataset_name, attribute) + data = defaultdict(list) + file_idx = 1 + for dial_idx, (dialog_id, text) in enumerate(f_text[mode]): + dialog = self.init_dial() + dialog[ORI_DIAL_ID] = dialog_id + dialog[DIAL_IDX] = dial_idx + 1 + dialog[ORI_DIAL_INFO] = { + "split": text["split"], + "domain": text["domain"], + } + + dialog_history = "" + turn_index = 1 + for uttr_index, utterance in enumerate(text["turns"]): + if uttr_index %2 == 0: + user_uttr = utterance["utterance"] + user_name_entities = utterance["named_entities"] + user_references = utterance["references"] + user_links = utterance["links"] + elif uttr_index %2 == 1: + sys_uttr = utterance["utterance"] + sys_name_entities = utterance["named_entities"] + sys_references = utterance["references"] + sys_links = utterance["links"] + + new_turn = self.init_turn(turn_id=turn_index, dial_hist=[dialog_history]) + new_turn[USR_UTT] = user_uttr + new_turn[SYS_UTT] = sys_uttr + # turn_log = save_info_to_dict(turn_index, user_uttr, sys_uttr, dialog_history) + + new_turn[ORI_USR_ANN]["name_entities"] = user_name_entities + new_turn[ORI_USR_ANN]["references"] = user_references + new_turn[ORI_USR_ANN]["links"] = user_links + new_turn[ORI_SYS_ANN]["name_entities"] = sys_name_entities + new_turn[ORI_SYS_ANN]["references"] = sys_references + new_turn[ORI_SYS_ANN]["links"] = sys_links + dialog['log'].append(new_turn) + dialog_history += " " + user_uttr + " " + sys_uttr + turn_index += 1 + + if uttr_index %2 == 0 and (uttr_index + 1) == len(text): + new_turn = self.init_turn(turn_id=turn_index, dial_hist=[dialog_history]) + new_turn[USR_UTT] = user_uttr + new_turn[SYS_UTT] = "" + # turn_log = save_info_to_dict(turn_index, user_uttr, "", dialog_history) + + new_turn[ORI_USR_ANN]["name_entities"] = user_name_entities + new_turn[ORI_USR_ANN]["references"] = user_references + new_turn[ORI_USR_ANN]["links"] = user_links + + dialog['log'].append(new_turn) + + dial_id = f"{data_name}--{mode}--{dial_idx+1}" + data[dial_id] = dialog + + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(f_text[mode]): + self.save_dial(data, data_name=data_name, file_idx=file_idx, mode=mode) + data = defaultdict(list) # reset + file_idx += 1 + + if mode == "train": self.save_original_examples(data["dialogues"][:5], data_name) + print(f"finishing processing {dial_idx} dialogs for {mode} set ...") + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def ketod(self): + """ + This dataset is build based on SGD, focusing on enrich system response with knowledge + therefore, we igore the DST and INTENT task, since the annotation would be exactly same as SGD + we replace utt with utt_enrich if it exists, otherwise keep the same + we add turn-level ek for enriched knowledge + the entity query usually expose the ground-truth item + so it might not be necessary to add noisy items""" + data_name = "KETOD" + exp_list = [] + for mode in ["train", "val", "test"]: + real_name = "dev" if mode == "val" else mode + data = self._load_json(os.path.join(self.data_dir, data_name, f"{real_name}.json")) + new_data, file_idx = {}, 1 + for dial_idx, dial in (enumerate(data)): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['dialogue_id'] + # new_dial[ORI_DIAL_INFO]["services"] = dial["services"] + domains = [] + + dial_hist, result_list, cand_list = [], {}, {} + for idx, turn in enumerate(dial["turns"]): + utt = turn["utterance"] + if turn["speaker"] == "USER": + # new turn start from user + new_turn = self.init_turn(turn_id=idx//2+1) + new_turn[EK_ORI] = {TOD_EK:{}} + new_turn[EK] = "" + new_turn[USR_UTT] = utt + new_turn[DIAL_HIST] = " ".join(dial_hist) + # include user utterance into dialog history + dial_hist.append(f" {utt}") + # other annotation for user side + new_turn[ORI_USR_ANN]["frames"] = turn["frames"] + new_turn[ORI_USR_ANN]["enrich"] = turn["frames"] + # dialog ends at user side + if idx == len(dial["turns"]) - 1: + new_dial[LOG].append(new_turn) + for frame in turn["frames"]: + if frame["service"] not in domains: domains.append(frame["service"]) + + if turn["speaker"] == "SYSTEM": + if turn["enrich"]: + new_turn[SYS_UTT] = turn["enriched_utter"] + new_turn[ORI_SYS_ANN]["original_utt"] = utt + new_turn[ORI_SYS_ANN]["entity_query"] = turn["entity_query"] + new_turn[ORI_SYS_ANN]["kg_snippets"] = turn["kg_snippets"] + new_turn[ORI_SYS_ANN]["kg_snippets_text"] = turn["kg_snippets_text"] + new_turn[EK_ORI][TOD_EK]["entity_query"] = turn["entity_query"] + new_turn[EK_ORI][TOD_EK]["kg_snippets_text"] = turn["kg_snippets_text"] + new_turn[EK] = self.dict_to_str(new_turn[EK_ORI][TOD_EK]) + else: + new_turn[SYS_UTT] = utt + # include system response into dialog history + dial_hist.append(f" {utt}") + # other annotation for system side + new_turn[ORI_SYS_ANN]["frames"] = turn["frames"] + # turn must end at assistant side + new_dial[LOG].append(new_turn) + + for frame in turn["frames"]: + if "service_results" in frame: + domain = frame["service"] + # # # accumulate db results + if domain not in cand_list: + cand_list[domain] = [] + cand_list[domain].extend(frame["service_results"]) + # # # accumulate offered results + if domain not in result_list: + result_list[domain] = [] + result_list[domain].append(frame["service_call"]["parameters"]) + # adding EK for TOD + for domain in cand_list: + new_dial[EK_ORI][TOD_EK][domain] = [] + satisfied_cand, unsatisfied_cand = self.filter_cand(cand_list[domain], result_list[domain]) + if len(satisfied_cand)+len(unsatisfied_cand) < TOD_LENGTH: + new_dial[EK_ORI][TOD_EK][domain] = satisfied_cand + unsatisfied_cand + else: + new_dial[EK_ORI][TOD_EK][domain] = satisfied_cand + new_dial[EK_ORI][TOD_EK][domain].extend(random.choices(unsatisfied_cand, k=(TOD_LENGTH-len(satisfied_cand)))) + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + # adding prompt for each dialog + domains = [domain.lower().split("_")[0] for domain in domains] + new_dial[PROMPT] = generate_prompt("SGD", domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + print(f"Processing {mode} data with {dial_idx} dialogs ... " ) + if mode == "train": self.save_original_examples(data[:5], data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def task2dial(self): + data_name = "Task2Dial" + mode = "train" + from datasets import load_dataset + data = load_dataset("cstrathe435/Task2Dial") + for dial in data: + pdb.set_trace() + pass + + + def gecor(self): + """ + constructed based on CamRest676 + [{"dial":[{}, ...]},...] + also, since annotation are the same as camrest676 + we do not care about the DST or INTENT tasks""" + data_name = "GECOR" + exp_list = [] + for filename in os.listdir(os.path.join(self.data_dir, data_name)): + if filename in ["LICENSE", "readme.txt"]: continue + exp_list.append(filename) + + data = self._load_json(os.path.join(self.data_dir, data_name, "CamRest676_for_coreference_and_ellipsis_resolution/CamRest676_annotated.json")) + schema = self._load_json(os.path.join(self.data_dir, data_name, "CamRest676_for_coreference_and_ellipsis_resolution/CamRestOTGY.json")) + db = self._load_json(os.path.join(self.data_dir, data_name, "CamRest676_for_coreference_and_ellipsis_resolution/CamRestDB.json")) + mode = "train" + new_data, file_idx = {}, 1 + for dial_idx, dial in tqdm(enumerate(data)): + new_dial_id = f"{data_name}--{mode}--{dial_idx+1}" + new_dial = self.init_dial(dial_idx=dial_idx+1) # idx starts from 1 + new_dial[ORI_DIAL_ID] = dial['dialogue_id'] + new_dial[ORI_DIAL_INFO]["finished"] = dial['finished'] + new_dial[ORI_DIAL_INFO]["goal"] = dial['goal'] + dial_hist = [] + for turn in dial["dial"]: + new_turn = self.init_turn(turn_id=turn["turn"]) + new_turn[USR_UTT] = turn["usr"]["transcript"] + new_turn[SYS_UTT] = turn["sys"]["sent"] + new_turn[DIAL_HIST] = " ".join(dial_hist) + for key_ in turn["usr"]: + if key_ == "transcript": continue + new_turn[ORI_USR_ANN][key_] = turn["usr"][key_] + new_turn[ORI_SYS_ANN]["DA"] = turn["sys"]["DA"] + dial_hist.append(f" {new_turn[USR_UTT]}") + dial_hist.append(f" {new_turn[SYS_UTT]}") + new_dial[LOG].append(new_turn) + + # adding EK for TOD + constraint = [{cons[0]:cons[1] for cons in dial['goal']["constraints"]}] + new_dial[EK_ORI][TOD_EK] = [] + satisfied_cand, unsatisfied_cand = self.filter_cand(db, constraint) + if len(satisfied_cand)+len(unsatisfied_cand) < TOD_LENGTH: + new_dial[EK_ORI][TOD_EK] = satisfied_cand + unsatisfied_cand + else: + new_dial[EK_ORI][TOD_EK] = satisfied_cand + new_dial[EK_ORI][TOD_EK].extend(random.choices(unsatisfied_cand, k=(TOD_LENGTH-len(satisfied_cand)))) + + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + # adding prompt for each dialog, since camrest676 is only about restaurant, we use... + domains = ["restaurant"] + new_dial[PROMPT] = generate_prompt("MULTIWOZ2_2", domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx+1) % 1000 == 0 or dial_idx+1 == len(data): + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + + print(f"Processing {mode} data with {dial_idx+1} dialogs ... " ) + if mode == "train": self.save_original_examples(data[:5], data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def disamb(self): + """ + a variant of multiwoz22, though in format of multiwoz21""" + data_name = "Disambiguation" + exp_list = [] + for filename in os.listdir(os.path.join(self.data_dir, data_name)): + if not filename.startswith("data_aug"):continue + exp_list.append(filename) + otgy = self.multiwoz_dst_otgy() + intents = self._load_json(os.path.join(self.data_dir, "MultiWOZ_2.1", "intents.json" )) + for mode in ["train", "val", "test"]: + data = self._load_json(os.path.join(self.data_dir, data_name, f"data_aug_{mode}.json")) + new_data, dial_idx, file_idx = {}, 1, 1 + for dial_id, dial in tqdm(data.items()): + + new_dial_id = f"{data_name}--{mode}--{dial_idx}" + new_dial = self.init_dial(dial_idx=dial_idx) # idx starts from 1, set this when checking its source + new_dial[ORI_DIAL_ID] = dial_id + new_dial[ORI_DIAL_INFO]["goal"] = dial['goal'] + dial_hist = [] + # """ + # note: these five dialogs do not contain any annotation + # for user side, including span_info or dialog acts + # therefore, we exclude these five dialogs since slot-->ek-->utt + # """ + if dial_id in ["pmul4707.json", "pmul2245.json", "pmul4776.json", "pmul3872.json", "pmul4859.json"]: continue + for turn_num in range(math.ceil(len(dial["log"]) / 2)): + # # # turn number + usr_turn = dial["log"][turn_num*2] + sys_turn = dial["log"][turn_num*2+1] + + new_turn = self.init_turn(turn_id=turn_num+1) + new_turn[USR_UTT] = usr_turn["text"] + new_turn[SYS_UTT] = sys_turn["text"] + new_turn[DIAL_HIST] = " ".join(dial_hist) + dial_hist.append(f" {new_turn[USR_UTT]}") + dial_hist.append(f" {new_turn[SYS_UTT]}") + for key_ in ["metadata", "dialog_act", "span_info"]: + # other annotation for user side + if key_ in usr_turn: + new_turn[ORI_USR_ANN][key_] = usr_turn[key_] + # other annotation for system side + if key_ in sys_turn: + new_turn[ORI_SYS_ANN][key_] = sys_turn[key_] + + # used for accumulated slots, extracted based on "metadata", only in system side (turn_num * 2 + 1) + slot_list_acc = [] + for dom, slot in sys_turn["metadata"].items(): + for slot_type, slot_val in slot["book"].items(): + if not slot_val or slot_type == "booked" or slot_val == "not mentioned": continue + slot_list_acc.append(f"{dom} {slot_type} {slot_val[0]}") + for slot_type, slot_val in slot["semi"].items(): + if not slot_val or slot_val == "not mentioned": continue + slot_list_acc.append(f"{dom} {slot_type} {slot_val[0]}") + new_turn[DST_ACC] = DST_SPLIT.join(slot_list_acc).lower() + # compute the non-accumulated slots + slot_list = [] + for act in usr_turn["dialog_act"]: + if not act.endswith("inform"): continue + for slot_type, slot_val in usr_turn["dialog_act"][act]: + dom = act.split("-")[0] + slot_type = slot_type + slot_list.append(f"{dom} {slot_type} {slot_val}") + new_turn[DST] = DST_SPLIT.join(slot_list).lower() + # add intent output + new_turn[INTENT] = ", ".join(list(usr_turn["dialog_act"].keys())).lower() + new_dial[LOG].append(new_turn) + + # get active domains + domains = [] + for dom in MULTIWOZ_DOMAINS: + if dial["goal"][dom]: domains.append(dom) + # adding EK for TOD + goal = dial['goal'] + for dom in ["restaurant", "hotel", "attraction", "train"]: + if not goal[dom]: continue + constraint = [goal[dom]["info"]] + db = self._load_json(os.path.join(self.data_dir, "MultiWOZ_2.1", f"{dom}_db.json")) + + new_dial[EK_ORI][TOD_EK][dom] = [] + satisfied_cand, unsatisfied_cand = self.filter_cand(db, constraint) + if len(satisfied_cand)+len(unsatisfied_cand) < TOD_LENGTH: + new_dial[EK_ORI][TOD_EK][dom] = satisfied_cand + unsatisfied_cand + else: + new_dial[EK_ORI][TOD_EK][dom] = satisfied_cand + new_dial[EK_ORI][TOD_EK][dom].extend(random.choices(unsatisfied_cand, k=(TOD_LENGTH-len(satisfied_cand)))) + # adding EK for DST + for dom in domains: + if dom not in otgy: continue + if dom not in new_dial[EK_ORI][DST_EK]: new_dial[EK_ORI][DST_EK][dom] = {} + for slot_type in otgy[dom]: + new_dial[EK_ORI][DST_EK][dom][slot_type] = random.choices(otgy[dom][slot_type], k=DST_LENGTH) + # adding EK for Intent + for dom in domains+["booking", "general"]: + if dom not in intents: continue + new_dial[EK_ORI][INTENT_EK][dom] = intents[dom] + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + # adding prompt for each dialog, since camrest676 is only about restaurant, we use... + domains = [] + for dom in MULTIWOZ_DOMAINS: + if dial["goal"][dom]: domains.append(dom) + new_dial[PROMPT] = generate_prompt("MULTIWOZ2_2", domains) + # finish and wrap the current dialog + new_data[new_dial_id] = new_dial + if (dial_idx) % 1000 == 0: + self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + new_data = {} # reset + file_idx += 1 + dial_idx += 1 + + if len(new_data) > 0: self.save_dial(new_data, data_name=data_name, file_idx=file_idx, mode=mode) + print(f"Processing {mode} data with {dial_idx-1} dialogs ... " ) + if mode=="train":self.save_original_examples({k:data[k] for k in list(data.keys())[:5]}, data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + + def multiwoz21(self): + data_name, exp_list = "MultiWOZ_2.1", ["data.json"] + MULTIWOZ_DOMAINS = ["taxi", "police", "hospital", "hotel","attraction","train","restaurant"] + data = self._load_json(os.path.join(self.data_dir, data_name, "data.json")) + val_list = self._load_txt(os.path.join(self.data_dir, data_name, "valListFile.txt")) + test_list = self._load_txt(os.path.join(self.data_dir, data_name, "testListFile.txt")) + otgy = self.multiwoz_dst_otgy() + intents = self._load_json(os.path.join(self.data_dir, "MultiWOZ_2.1", "intents.json" )) + new_data = {"train":{}, "val":{}, "test":{}} + dial_idx = {"train":1, "val":1, "test":1} + file_idx = {"train":1, "val":1, "test":1} + for dial_id, dial in tqdm(data.items()): + if dial_id in test_list: + mode = "test" + elif dial_id in val_list: + mode = "val" + else: + mode = "train" + + new_dial_id = f"{data_name}--{mode}--{dial_idx[mode]}" + new_dial = self.init_dial(dial_idx=dial_idx[mode]) # idx starts from 1, set this when checking its source + new_dial[ORI_DIAL_ID] = dial_id + new_dial[ORI_DIAL_INFO]["goal"] = dial['goal'] + dial_hist = [] + # """ + # note: these five dialogs do not contain any annotation + # for user side, including span_info or dialog acts + # therefore, we exclude these five dialogs since slot-->ek-->utt + # """ + if dial_id in ["PMUL4707.json", "PMUL2245.json", "PMUL4776.json", + "PMUL3872.json", "PMUL4859.json"]: + continue + for turn_num in range(math.ceil(len(dial["log"]) / 2)): + # # # turn number + usr_turn = dial["log"][turn_num*2] + sys_turn = dial["log"][turn_num*2+1] + + new_turn = self.init_turn(turn_id=turn_num+1) + new_turn[USR_UTT] = usr_turn["text"] + new_turn[SYS_UTT] = sys_turn["text"] + new_turn[DIAL_HIST] = " ".join(dial_hist) + dial_hist.append(f" {new_turn[USR_UTT]}") + dial_hist.append(f" {new_turn[SYS_UTT]}") + for key_ in ["metadata", "dialog_act", "span_info"]: + # other annotation for user side + if key_ in usr_turn: + new_turn[ORI_USR_ANN][key_] = usr_turn[key_] + # other annotation for system side + if key_ in sys_turn: + new_turn[ORI_SYS_ANN][key_] = sys_turn[key_] + + # used for accumulated slots, extracted based on "metadata", only in system side (turn_num * 2 + 1) + slot_list_acc = [] + for dom, slot in sys_turn["metadata"].items(): + for slot_type, slot_val in slot["book"].items(): + if not slot_val or slot_type == "booked" or slot_val == "not mentioned": continue + slot_list_acc.append(f"{dom} {slot_type} {slot_val}") + + for slot_type, slot_val in slot["semi"].items(): + if not slot_val or slot_val == "not mentioned": continue + slot_list_acc.append(f"{dom} {slot_type} {slot_val}") + new_turn[DST_ACC] = DST_SPLIT.join(slot_list_acc).lower() + # compute the non-accumulated slots + slot_list = [] + for act in usr_turn["dialog_act"]: + if not act.endswith("Inform"): continue + for slot_type, slot_val in usr_turn["dialog_act"][act]: + dom = act.split("-")[0] + slot_type = slot_type + slot_list.append(f"{dom} {slot_type} {slot_val}") + new_turn[DST] = DST_SPLIT.join(slot_list).lower() + # add intent output + new_turn[INTENT] = ", ".join(list(usr_turn["dialog_act"].keys())).lower() + + new_dial[LOG].append(new_turn) + + # get active domains + domains = [] + for dom in MULTIWOZ_DOMAINS: + if dial["goal"][dom]: domains.append(dom) + # adding EK for TOD + for dom in ["restaurant", "hotel", "attraction", "train"]: + if not dial["goal"][dom]: continue + constraint = [dial['goal'][dom]["info"]] + db = self._load_json(os.path.join(self.data_dir, data_name, f"{dom}_db.json")) + new_dial[EK_ORI][TOD_EK][dom] = [] + satisfied_cand, unsatisfied_cand = self.filter_cand(db, constraint) + if len(satisfied_cand)+len(unsatisfied_cand) < TOD_LENGTH: + new_dial[EK_ORI][TOD_EK][dom] = satisfied_cand + unsatisfied_cand + else: + new_dial[EK_ORI][TOD_EK][dom] = satisfied_cand + new_dial[EK_ORI][TOD_EK][dom].extend(random.choices(unsatisfied_cand, k=(TOD_LENGTH-len(satisfied_cand)))) + # adding EK for DST + for dom in domains: + if dom not in otgy: continue + if dom not in new_dial[EK_ORI][DST_EK]: new_dial[EK_ORI][DST_EK][dom] = {} + for slot_type in otgy[dom]: + new_dial[EK_ORI][DST_EK][dom][slot_type] = random.choices(otgy[dom][slot_type], k=DST_LENGTH) + # adding EK for Intent + for dom in domains+["booking", "general"]: + if dom not in intents: continue + new_dial[EK_ORI][INTENT_EK][dom] = intents[dom] + # turn the external knowledge into a flat string + new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) + new_dial[EK_DST] = self.dict_to_str(new_dial[EK_ORI][DST_EK]) + new_dial[EK_INTENT] = self.dict_to_str(new_dial[EK_ORI][INTENT_EK]) + # adding prompt for each dialog, since camrest676 is only about restaurant, we use... + new_dial[PROMPT] = generate_prompt("MULTIWOZ2_2", domains) + # finish and wrap the current dialog + new_data[mode][new_dial_id] = new_dial + if (dial_idx[mode]) % 1000 == 0: + # pdb.set_trace() + self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + new_data[mode] = {} # reset + file_idx[mode] += 1 + if file_idx[mode]>100: pdb.set_trace() + dial_idx[mode] += 1 + for mode in ["train", "test", "val"]: + if len(new_data[mode]) > 0: self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) + print(f"Processing {mode} data with {dial_idx[mode]-1} dialogs ... " ) + self.save_original_examples({k:data[k] for k in list(data.keys())[:5]}, data_name) + self.save_converted_examples(data_name) + self.copy_related_files(data_name, exp_list) + print("*"*10, f"finishing processing dataset {data_name}", "*"*10) + + def multiwoz21_trade(self): + pass + + + def run_all(self): + # self.kvret() # 800 tod+dst + # self.woz() # dst + # self.sgd() # 16k tod+dst+intent + # self.bitod() + # self.metalwoz() + # self.star() + # self.taskmaster1() # 643 dst only + # self.taskmaster2() # 981 dst only + self.taskmaster3() # 1167 dst only + # self.simjoint() # dst + # self.simjointgen() # dst + # self.muldogo() + # self.casino() + # self.airdialogue() # 1595 + # self.msdc() # 759 dst+intent + # self.abcd() # 8034 dst + # self.salesbot() + # self.craigslist() + # self.frames() # 2000 tod+dst+intent + # self.dstc2() + # self.multiwoz_hdsa() + # self.multiwoz22() + # self.mudoco() + # self.ketod() + # self.task2dial() + # self.gecor() + # self.disamb() + # self.multiwoz21() + pass + + def multiwoz_dst_otgy(self): + """ + transfer the ontology file in multiwoz from format: + {domain-semi/book-slot_type:[slot_value, ...],} + into + {domain:{slot_type:[slot_value, ...],}""" + otgy_ori = self._load_json(os.path.join(self.data_dir, "MultiWOZ_2.1/ontology.json")) + otgy = {} + for dom_slot in otgy_ori: + dom, _, slot_type = dom_slot.split("-") + if dom not in otgy: otgy[dom] = {} + otgy[dom][slot_type] = otgy_ori[dom_slot] + return otgy + + def save_info_to_dict(self, turn_index, user_uttr, sys_uttr, dialog_history): + turn_log = self.init_turn(turn_id=turn_index, dial_hist=dialog_history) + turn_log[TURN_ID] = turn_index + turn_log[USR_UTT] = user_uttr + turn_log[SYS_UTT] = sys_uttr + turn_log[DIAL_HIST] = dialog_history + return turn_log + + + def compare_delex(self, utt_ori, utt_delex): + """ + original: Yes my order id is 4870952797 + delexicalized: yes my order id is + assuming delexicalized token is only of length 1 + """ + utt_ori = utt_ori.lower().replace(",", " , ").replace(". ", " . ").replace(":", " : ").replace(" ", " ").replace(" | ", " and ").split() + utt_delex = utt_delex.replace(",", " , ").replace(". ", " . ").replace(":", " : ").replace(" ", " ").replace(" | ", " and ").split() + utt_ori = [slot_value.strip(",.$?\"\\()") for slot_value in utt_ori] + utt_delex = [slot_type.strip(",.$?\"\\0()") for slot_type in utt_delex] + pointer_ori_start, pointer_ori_end, pointer_delex = 0, 0, 0 + result = [] + while pointer_ori_start < len(utt_ori): + if utt_ori[pointer_ori_start] == utt_delex[pointer_delex]: # not slot, continue + pointer_ori_start += 1 + pointer_delex += 1 + elif pointer_delex == len(utt_delex) - 1: # the last token + result.append([" ".join(utt_ori[pointer_ori_start:]), utt_delex[pointer_delex]]) + break + else: + for pointer_delex_end in range(pointer_delex+1,len(utt_delex)): + if not (utt_delex[pointer_delex_end].startswith("<") or utt_delex[pointer_delex_end].endswith(">")): + break + flag = 0 + for pointer_ori_end in range(pointer_ori_start+1, len(utt_ori)): + if utt_ori[pointer_ori_end] == utt_delex[pointer_delex_end]: + result.extend(self.match(utt_ori[pointer_ori_start:pointer_ori_end], utt_delex[pointer_delex:pointer_delex_end])) + pointer_ori_start = pointer_ori_end + 1 + pointer_delex += 2 + flag = 1 + break + if not flag: + result.extend(self.match(utt_ori[pointer_ori_start:], utt_delex[pointer_delex:])) + break + return result + + + def match(self, list_ori, list_delex): + if len(list_delex) == 0: + return [] + elif len(list_delex) == 1: # only one slot + return [[" ".join(list_ori), " ".join(list_delex)]] + elif len(list_ori) == len(list_delex): # slot has only length 1 + return [[list_ori[i], list_delex[i]] for i in range(len(list_delex))] + elif len(list_ori) < len(list_delex): # something wrong with annotation + return [] + else: # multiple, length-variant slots + if "" in list_delex: + i_delex = list_delex.index("") + for i_ori, value in enumerate(list_ori): + if "@" in value: + break + result = self.match(list_ori[:i_ori], list_delex[:i_delex]) + result.append([value, ""]) + # pdb.set_trace() + if i_ori < len(list_ori) - 1: + result.extend(self.match(list_ori[i_ori+1:], list_delex[i_delex+1:])) + return result + elif list_delex[0] in ["", "", "", ""]: + result = [[list_ori[0], list_delex[0]]] + result.extend(self.match(list_ori[1:], list_delex[1:])) + return result + elif list_delex[-1] in ["", "", "", ""]: + result = [[list_ori[-1], list_delex[-1]]] + result.extend(self.match(list_ori[:-1], list_delex[:-1])) + return result + else: + # return [[" ".join(list_ori), " ".join(list_delex)]] + return [] + + + def copy_example(self): + source_dir = self.save_dir + target_dir = "/home/qkun/projs/TOD-Project/Datasets/Task-Oriented_PROCESSED/" + file_list = ["converted_examples.json", "original_examples.json", "readme.txt", "LICENSE"] + for dir_name in sorted(os.listdir(source_dir)): + if os.path.isfile(os.path.join(source_dir, dir_name)): continue + if not os.path.exists(os.path.join(target_dir, dir_name)): os.makedirs(os.path.join(target_dir, dir_name)) + for filename in file_list: + source_path = os.path.join(source_dir, dir_name, filename) + target_path = os.path.join(target_dir, dir_name, filename) + if not os.path.exists(source_path): continue + shutil.copy(source_path, target_path) + + + def dict_to_str(self, ek_ori): + """ + turn non-flat external knowledge into string + original format: + "metadata":{ + domain: [ + { + attr1: value1, + attr2: value2, + ... + }, + ... + ] + } + output format: + ( metadata : ( domain : ( attr1 : value1 | attr2 : value2 | ... ) | ( ... ) | ... )) + """ + ek = str(ek_ori).replace("'"," ").replace(", "," | ") + ek = ek.replace("{","(").replace("}",")").replace("[","(").replace("]",")") + ek = ek.replace(" ", " ") + return ek + + + def dst_dict_to_str(self, dst_dict): + """ + use a dict to store updated dst state, and now conver it into string for generation + """ + slot_list = [] + for domain in dst_dict: + for slot, value in dst_dict[domain].items(): + slot_list.append(f"{domain} {slot} {value.strip()}") + return ", ".join(slot_list) + + + def update_with_slot_list(self, dst_dict, slot_list): + """ + assuming using a dict to store updated dst state, now update the dict with slot_list + """ + for slot in slot_list: + if len(slot.split()) < 2: + pdb.set_trace() + domain, slot_type, slot_value = slot.split()[0], slot.split()[1], " ".join(slot.split()[2:]) + if domain not in dst_dict: + dst_dict[domain] = {} + dst_dict[domain][slot_type] = slot_value + return dst_dict + + + def examine(self): + for data_name in sorted(os.listdir(self.save_dir)): + if data_name in ["AirDialogue"]: continue + print(f"Loading {data_name} ...") + if os.path.isfile(os.path.join(self.save_dir, data_name)): continue + for filename in os.listdir(os.path.join(self.save_dir, data_name, "train")): + if not filename.startswith("dialog"): continue + idx = 1 + data = self._load_json(os.path.join(self.save_dir, data_name, "train", filename)) + for dial_id, dial in data.items(): + if not dial_id.endswith(str(idx)) and idx != 1000: + print(data_name, filename, dial_id, idx) + pdb.set_trace() + idx += 1 + # for idx, turn in enumerate(dial[LOG]): + # if idx + 1 != turn[TURN_ID]: + # print(data_name, dial_id) + + +def main(): + preprocess = PreProcessData() + preprocess.run_all() + preprocess.copy_example() + # preprocess.examine() + +if __name__ == '__main__': + main()