|
""" |
|
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 |
|
""" |
|
|
|
|
|
|
|
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/" |
|
|
|
|
|
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 = [] |
|
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: |
|
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 = [] |
|
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) |
|
|
|
|
|
|
|
|
|
def copy_general(self, src, dst): |
|
try: |
|
shutil.copytree(src, dst, dirs_exist_ok=True) |
|
except OSError as exc: |
|
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 |
|
for key_ in constraint: |
|
|
|
|
|
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", [] |
|
|
|
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) |
|
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": |
|
|
|
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"<USER> {new_turn[USR_UTT]}") |
|
dial_hist.append(f"<SYSTEM> {new_turn[SYS_UTT]}") |
|
|
|
|
|
new_turn = self.init_turn(turn_id=turn_id) |
|
turn_id += 1 |
|
usr_utts, sys_utts = [], [] |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
|
|
|
|
if utt in usr_utts: continue |
|
usr_utts.append(utt) |
|
|
|
for key in turn["data"]: |
|
if key == "utterance": continue |
|
new_turn[ORI_USR_ANN][key] = turn["data"][key] |
|
|
|
if turn["turn"] == "assistant": |
|
|
|
if utt in sys_utts: continue |
|
sys_utts.append(utt) |
|
|
|
|
|
|
|
for key in turn["data"]: |
|
if key == "utterance": continue |
|
new_turn[ORI_SYS_ANN][key] = turn["data"][key] |
|
|
|
|
|
new_turn[DST] = ", ".join([f"{domain} {slot} {value}" for slot, value in turn["data"]["slots"].items()]) |
|
|
|
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) |
|
|
|
|
|
|
|
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)))) |
|
|
|
new_dial[EK_ORI][DST_EK] = dom_slot[domain] |
|
|
|
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]) |
|
|
|
domains = [domain] |
|
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 = {} |
|
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): |
|
|
|
|
|
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) |
|
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"<SYSTEM> {sys_utt}") |
|
new_dial[LOG].append(new_turn) |
|
|
|
new_turn = self.init_turn(turn_id=idx+1) |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
|
|
|
|
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) |
|
|
|
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"<USER> {usr_utt}") |
|
for key in turn: |
|
if key.startswith("system"): continue |
|
new_turn[ORI_USR_ANN][key] = turn[key] |
|
|
|
new_dial[LOG].append(new_turn) |
|
|
|
|
|
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) |
|
|
|
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]) |
|
|
|
domains = ["restaurant"] |
|
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 = {} |
|
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) |
|
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 = self.init_turn(turn_id=idx//2+1) |
|
new_turn[USR_UTT] = utt |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
dial_hist.append(f"<USER> {utt}") |
|
|
|
new_turn[ORI_USR_ANN]["frames"] = turn["frames"] |
|
|
|
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) |
|
|
|
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) |
|
|
|
if idx == len(dial["turns"]) - 1: |
|
new_dial[LOG].append(new_turn) |
|
|
|
if turn["speaker"] == "SYSTEM": |
|
new_turn[SYS_UTT] = utt |
|
|
|
dial_hist.append(f"<SYSTEM> {utt}") |
|
|
|
new_turn[ORI_SYS_ANN]["frames"] = turn["frames"] |
|
|
|
new_dial[LOG].append(new_turn) |
|
|
|
for frame in turn["frames"]: |
|
if "service_results" in frame: |
|
domain = frame["service"] |
|
|
|
if domain not in cand_list: |
|
cand_list[domain] = [] |
|
cand_list[domain].extend(frame["service_results"]) |
|
|
|
if domain not in result_list: |
|
result_list[domain] = [] |
|
result_list[domain].append(frame["service_call"]["parameters"]) |
|
|
|
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)))) |
|
|
|
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"] |
|
|
|
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"]) |
|
|
|
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]) |
|
|
|
domains = [domain.lower().split("_")[0] for domain in dial["services"]] |
|
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 = {} |
|
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) |
|
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 = self.init_turn(turn_id=idx) |
|
new_turn[USR_UTT] = utt |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
dial_hist.append(f"<USER> {utt}") |
|
|
|
|
|
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) |
|
|
|
|
|
dst_dict = self.update_with_slot_list(dst_dict, slot_list) |
|
new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) |
|
|
|
new_turn[INTENT] = turn["active_intent"] |
|
|
|
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 |
|
|
|
dial_hist.append(f"<SYSTEM> {utt}") |
|
|
|
for key in turn: |
|
if key == "Text": continue |
|
new_turn[ORI_SYS_ANN][key] = turn[key] |
|
|
|
new_dial[LOG].append(new_turn) |
|
|
|
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"] |
|
|
|
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) |
|
|
|
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]) |
|
|
|
new_dial[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
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 = {} |
|
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) |
|
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: |
|
|
|
new_turn[SYS_UTT] = utt |
|
|
|
new_dial[LOG].append(new_turn) |
|
|
|
dial_hist.append(f"<SYSTEM> {utt}") |
|
else: |
|
|
|
new_turn = self.init_turn(turn_id=(idx+1)//2) |
|
new_turn[USR_UTT] = utt |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
dial_hist.append(f"<USER> {utt}") |
|
|
|
if idx == len(dial["turns"]) - 1: |
|
new_dial[LOG].append(new_turn) |
|
|
|
|
|
domains = [dial["domain"].lower()] |
|
new_dial[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
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 = {} |
|
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) |
|
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"]): |
|
|
|
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 = self.init_turn(turn_id=turn_id) |
|
new_turn[USR_UTT] = utt |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
dial_hist.append(f"<USER> {utt}") |
|
|
|
for key in turn: |
|
if key == "Text": continue |
|
new_turn[ORI_USR_ANN][key] = turn[key] |
|
|
|
if idx == len(dial["Events"]) - 1: |
|
new_dial[LOG].append(new_turn) |
|
|
|
if turn["Agent"] == "Wizard": |
|
new_turn[SYS_UTT] = utt |
|
|
|
dial_hist.append(f"<SYSTEM> {utt}") |
|
|
|
for key in turn: |
|
if key == "Text": continue |
|
new_turn[ORI_SYS_ANN][key] = turn[key] |
|
|
|
new_dial[LOG].append(new_turn) |
|
turn_id += 1 |
|
|
|
|
|
domains = dial["Scenario"]["Domains"] |
|
if domains == [None]: |
|
domains = [dial["Scenario"]["WizardCapabilities"][0]["Task"]] |
|
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 = {} |
|
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) |
|
|
|
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() |
|
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": |
|
if idx and dial["utterances"][idx-1]["speaker"] == "ASSISTANT": |
|
|
|
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"<USER> {new_turn[USR_UTT]}") |
|
dial_hist.append(f"<SYSTEM> {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 = [], [] |
|
usr_utts.append(utt) |
|
|
|
new_turn[ORI_USR_ANN]['speaker'] = turn["speaker"] |
|
slot_list = [] |
|
if "segments" in turn: |
|
new_turn[ORI_USR_ANN]['speaker'] = turn["segments"] |
|
|
|
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) |
|
|
|
dst_dict = self.update_with_slot_list(dst_dict, slot_list) |
|
new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) |
|
|
|
else: |
|
if idx == 0 : continue |
|
sys_utts.append(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 = [], [] |
|
|
|
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) |
|
|
|
|
|
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]) |
|
|
|
domains = [domain] |
|
new_dial[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
|
|
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] = {} |
|
file_idx[mode] += 1 |
|
finish_flag[mode] = 1 |
|
else: |
|
finish_flag[mode] = 0 |
|
|
|
|
|
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) |
|
new_dial[ORI_DIAL_ID] = dial['conversation_id'] |
|
|
|
|
|
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": |
|
|
|
if sys_utt_list: |
|
new_turn[SYS_UTT] = " ".join(sys_utt_list) |
|
dial_hist.append("<SYSTEM> " + 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: |
|
|
|
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"]) |
|
|
|
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) |
|
|
|
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": |
|
|
|
if usr_utt_list: |
|
new_turn[USR_UTT] = " ".join(usr_utt_list) |
|
dial_hist.append("<USER> " + new_turn[USR_UTT]) |
|
usr_utt_list = [] |
|
if not dial_hist: |
|
continue |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
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]) |
|
|
|
domains = [dial["filename"]] |
|
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 = {} |
|
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() |
|
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": |
|
|
|
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"<USER> {new_turn[USR_UTT]}") |
|
dial_hist.append(f"<SYSTEM> {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 = [], [] |
|
usr_utts.append(utt) |
|
for key in turn: |
|
if key in ["text", "speaker", "index"]: continue |
|
new_turn[ORI_USR_ANN][key] = turn[key] |
|
|
|
|
|
slot_list = [] |
|
if "segments" in turn: |
|
|
|
for segment in turn["segments"]: |
|
slot_value = segment["text"].replace(",","") |
|
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) |
|
|
|
dst_dict = self.update_with_slot_list(dst_dict, slot_list) |
|
new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) |
|
|
|
else: |
|
if idx == 0 : continue |
|
sys_utts.append(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 = [], [] |
|
|
|
|
|
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) |
|
|
|
|
|
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]) |
|
|
|
domains = ["movie"] |
|
new_dial[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
|
|
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] = {} |
|
file_idx[mode] += 1 |
|
finish_flag[mode] = 1 |
|
else: |
|
finish_flag[mode] = 0 |
|
|
|
|
|
|
|
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) |
|
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("<SYSTEM> " + 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] |
|
|
|
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) |
|
|
|
dst_dict = self.update_with_slot_list(dst_dict, slot_list) |
|
new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) |
|
|
|
|
|
intent_list = [intent["type"] for intent in turn["user_acts"]] |
|
new_turn[INTENT] = ", ".join(intent_list) |
|
dial_hist.append("<USER> " + new_turn[USR_UTT]) |
|
if not new_turn[SYS_UTT]: |
|
new_dial[LOG].append(new_turn) |
|
|
|
|
|
new_dial[EK_ORI][INTENT_EK] = {domain:otgy["intents"]} |
|
|
|
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) |
|
|
|
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]) |
|
|
|
domains = [domain] |
|
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 = {} |
|
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) |
|
new_dial[ORI_DIAL_ID] = dial["dialogue_id"] |
|
dial_hist, prev_slot_list = [], [] |
|
|
|
|
|
new_turn = self.init_turn(turn_id=1) |
|
for idx, turn in enumerate(dial["turns"]): |
|
if "system_utterance" in turn: |
|
new_turn[SYS_UTT] = turn["system_utterance"] |
|
new_turn[ORI_SYS_ANN]["system_acts"] = turn["system_acts"] |
|
dial_hist.append("<SYSTEM> " + new_turn[SYS_UTT]) |
|
dial_hist.append("<USER> " + new_turn[USR_UTT]) |
|
new_dial[LOG].append(new_turn) |
|
|
|
if "user_utterance" in turn: |
|
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] |
|
|
|
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) |
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
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]) |
|
|
|
domains = ["movie"] |
|
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 = {} |
|
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 <CONV>31971762-f14e-4d55-b909-0370f6e4db19<TURN>0 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 |
|
dial_id = turn.conversationId[:-2] |
|
if dial_id.startswith("acs-"): dial_id = dial_id[4:] |
|
|
|
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] |
|
|
|
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) |
|
|
|
|
|
if turn.authorRole == "customer": |
|
|
|
new_turn[USR_UTT] += f" {turn.utterance}" |
|
new_turn[USR_UTT] = new_turn[USR_UTT].strip() |
|
|
|
if annotate_flag: |
|
utt_id = f"<CONV>{dial_id}<TURN>{turn.turnNumber}" |
|
row = split_annotation[mode][split_annotation[mode]["utteranceId"]==utt_id] |
|
|
|
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": |
|
|
|
new_turn[SYS_UTT] += f" {turn.utterance}" |
|
new_turn[SYS_UTT] = new_turn[SYS_UTT].strip() |
|
|
|
|
|
if idx == len(data)-1 or data.authorRole[idx+1] != "agent": |
|
new_dial[LOG].append(new_turn) |
|
turn_id += 1 |
|
dial_hist.append("<USER> " + new_turn[USR_UTT]) |
|
dial_hist.append("<SYSTEM> " + new_turn[SYS_UTT]) |
|
new_turn = self.init_turn(turn_id=turn_id) |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
|
|
if idx == len(data)-1 or dial_id not in data.conversationId[idx+1]: |
|
|
|
domains = [turn["filename"]] |
|
new_dial[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
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] = {} |
|
file_idx[mode] += 1 |
|
finish_flag[mode] = 1 |
|
else: |
|
finish_flag[mode] = 0 |
|
|
|
|
|
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) |
|
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"]): |
|
|
|
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("<USER> " + new_turn[USR_UTT]) |
|
dial_hist.append("<SYSTEM> " + 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 = [], [] |
|
|
|
|
|
|
|
usr_utts.append(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 = [], [] |
|
|
|
|
|
domains = ["negotiate"] |
|
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 = {} |
|
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) |
|
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("<USER> " + new_turn[USR_UTT]) |
|
dial_hist.append("<SYSTEM> " + 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 |
|
|
|
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]) |
|
|
|
domains = ["flight"] |
|
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 = {} |
|
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: |
|
|
|
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 = {} |
|
|
|
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"] = [] |
|
|
|
|
|
if speaker == "user": |
|
|
|
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": |
|
|
|
new_turn[SYS_UTT] += f" {utt}" |
|
new_turn[SYS_UTT] = new_turn[SYS_UTT].strip() |
|
new_turn[ORI_SYS_ANN]["act"].extend(act) |
|
|
|
|
|
if idx == len(data)-1 or data[idx+1].split("\t")[3] != "agent": |
|
|
|
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) |
|
|
|
dst_dict = self.update_with_slot_list(dst_dict, slot_list) |
|
new_turn[DST_ACC] = self.dst_dict_to_str(dst_dict) |
|
|
|
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("<USER> " + new_turn[USR_UTT]) |
|
dial_hist.append("<SYSTEM> " + 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"] = [] |
|
|
|
|
|
if idx == len(data)-1 or dial_id != data[idx+1].split("\t")[0]: |
|
|
|
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) |
|
|
|
new_dial[EK_ORI][INTENT_EK] = {domain: otgy["intents"][domain]} |
|
|
|
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]) |
|
|
|
|
|
domains = [domain] |
|
new_dial[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
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 = {} |
|
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": "<USER> <SYSTEM> 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)): |
|
|
|
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"] |
|
|
|
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"]): |
|
|
|
if speaker == "customer": |
|
|
|
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) |
|
|
|
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": |
|
|
|
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]) |
|
|
|
|
|
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("<USER> " + new_turn[USR_UTT]) |
|
dial_hist.append("<SYSTEM> " + 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"] = [], [] |
|
|
|
|
|
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) |
|
|
|
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]) |
|
|
|
domains = [dial["scenario"]["flow"]] |
|
new_dial[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
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] = {} |
|
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)): |
|
|
|
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("<USER> " + new_turn[USR_UTT]) |
|
dial_hist.append("<SYSTEM> " + new_turn[SYS_UTT]) |
|
|
|
if not finish_turn_flag: |
|
new_dial[LOG].append(new_turn) |
|
|
|
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 = {} |
|
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): |
|
|
|
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("<USER> " + new_turn[USR_UTT]) |
|
dial_hist.append("<SYSTEM> " + new_turn[SYS_UTT]) |
|
if not finish_turn_flag and idx+1 == len(dial["events"]): |
|
new_dial[LOG].append(new_turn) |
|
|
|
|
|
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 = {} |
|
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"] |
|
|
|
user_uttr = "" |
|
sys_uttr = "" |
|
dialog_history = "" |
|
user_da_label = "" |
|
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() |
|
|
|
|
|
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() |
|
|
|
|
|
sys_da_label = utterances[uttr_index]["da_label"] |
|
sys_slots_values = utterances[uttr_index]["slots"] |
|
|
|
uttr_index += 1 |
|
|
|
|
|
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 |
|
|
|
turn_log[INTENT] = user_da_label |
|
|
|
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) |
|
|
|
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> " + user_uttr + " <SYSTEM> " + 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"]) |
|
|
|
|
|
if len(dial["scenario"]["items"]) <= TOD_LENGTH: |
|
new_dial[EK_ORI][TOD_EK]["travel"] = dial["scenario"]["items"] |
|
else: |
|
|
|
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 |
|
|
|
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) |
|
|
|
new_dial[EK_ORI][INTENT_EK] = {domain: otgy["intents"][domain]} |
|
|
|
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]) |
|
|
|
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 = {} |
|
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[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> " + 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"] |
|
|
|
|
|
|
|
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> " + user_uttr + " <SYSTEM> " + 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"] |
|
|
|
|
|
|
|
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 |
|
|
|
|
|
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) |
|
|
|
|
|
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]) |
|
|
|
|
|
domains = ["restaurant"] |
|
dialog[PROMPT] = generate_prompt(data_name, domains) |
|
|
|
new_data[new_dial_id] = dialog |
|
|
|
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 = {} |
|
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) |
|
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) |
|
|
|
dial_hist.append(f"<USER> {new_turn[USR_UTT]}") |
|
dial_hist.append(f"<SYSTEM> {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) |
|
|
|
|
|
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 = {} |
|
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) |
|
|
|
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) |
|
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 = self.init_turn(turn_id=idx//2+1) |
|
new_turn[USR_UTT] = utt |
|
new_turn[DIAL_HIST] = " ".join(dial_hist) |
|
|
|
dial_hist.append(f"<USER> {utt}") |
|
|
|
new_turn[ORI_USR_ANN]["frames"] = turn["frames"] |
|
|
|
slot_list = [] |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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) |
|
|
|
new_turn[DST] = DST_SPLIT.join(list(set(slot_list).difference(prev_dst_set))) |
|
prev_dst_set = set(slot_list) |
|
|
|
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) |
|
|
|
|
|
if idx == len(dial["turns"]) - 1: |
|
new_dial[LOG].append(new_turn) |
|
|
|
if turn["speaker"] == "SYSTEM": |
|
new_turn[SYS_UTT] = utt |
|
|
|
dial_hist.append(f"<SYSTEM> {utt}") |
|
|
|
new_dial[LOG].append(new_turn) |
|
turn_num += 1 |
|
goal = data_21[dial["dialogue_id"]]["goal"] |
|
|
|
domains = [] |
|
for dom in MULTIWOZ_DOMAINS: |
|
if goal[dom]: domains.append(dom) |
|
|
|
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)))) |
|
|
|
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) |
|
|
|
for dom in domains+["booking", "general"]: |
|
if dom not in intents: continue |
|
new_dial[EK_ORI][INTENT_EK][dom] = intents[dom] |
|
|
|
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]) |
|
|
|
domains = dial["services"] |
|
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 = {} |
|
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 = [] |
|
|
|
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"]) |
|
|
|
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"]: |
|
|
|
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 |
|
|
|
|
|
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 += " <USR> " + user_uttr + " <SYS> " + 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] = "" |
|
|
|
|
|
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) |
|
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) |
|
new_dial[ORI_DIAL_ID] = dial['dialogue_id'] |
|
|
|
domains = [] |
|
|
|
dial_hist, result_list, cand_list = [], {}, {} |
|
for idx, turn in enumerate(dial["turns"]): |
|
utt = turn["utterance"] |
|
if turn["speaker"] == "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) |
|
|
|
dial_hist.append(f"<USER> {utt}") |
|
|
|
new_turn[ORI_USR_ANN]["frames"] = turn["frames"] |
|
new_turn[ORI_USR_ANN]["enrich"] = turn["frames"] |
|
|
|
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 |
|
|
|
dial_hist.append(f"<SYSTEM> {utt}") |
|
|
|
new_turn[ORI_SYS_ANN]["frames"] = turn["frames"] |
|
|
|
new_dial[LOG].append(new_turn) |
|
|
|
for frame in turn["frames"]: |
|
if "service_results" in frame: |
|
domain = frame["service"] |
|
|
|
if domain not in cand_list: |
|
cand_list[domain] = [] |
|
cand_list[domain].extend(frame["service_results"]) |
|
|
|
if domain not in result_list: |
|
result_list[domain] = [] |
|
result_list[domain].append(frame["service_call"]["parameters"]) |
|
|
|
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)))) |
|
|
|
new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) |
|
|
|
domains = [domain.lower().split("_")[0] for domain in domains] |
|
new_dial[PROMPT] = generate_prompt("SGD", 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 = {} |
|
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) |
|
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"<USER> {new_turn[USR_UTT]}") |
|
dial_hist.append(f"<SYSTEM> {new_turn[SYS_UTT]}") |
|
new_dial[LOG].append(new_turn) |
|
|
|
|
|
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)))) |
|
|
|
|
|
new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) |
|
|
|
domains = ["restaurant"] |
|
new_dial[PROMPT] = generate_prompt("MULTIWOZ2_2", 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 = {} |
|
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) |
|
new_dial[ORI_DIAL_ID] = dial_id |
|
new_dial[ORI_DIAL_INFO]["goal"] = dial['goal'] |
|
dial_hist = [] |
|
|
|
|
|
|
|
|
|
|
|
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)): |
|
|
|
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"<USER> {new_turn[USR_UTT]}") |
|
dial_hist.append(f"<SYSTEM> {new_turn[SYS_UTT]}") |
|
for key_ in ["metadata", "dialog_act", "span_info"]: |
|
|
|
if key_ in usr_turn: |
|
new_turn[ORI_USR_ANN][key_] = usr_turn[key_] |
|
|
|
if key_ in sys_turn: |
|
new_turn[ORI_SYS_ANN][key_] = sys_turn[key_] |
|
|
|
|
|
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() |
|
|
|
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() |
|
|
|
new_turn[INTENT] = ", ".join(list(usr_turn["dialog_act"].keys())).lower() |
|
new_dial[LOG].append(new_turn) |
|
|
|
|
|
domains = [] |
|
for dom in MULTIWOZ_DOMAINS: |
|
if dial["goal"][dom]: domains.append(dom) |
|
|
|
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)))) |
|
|
|
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) |
|
|
|
for dom in domains+["booking", "general"]: |
|
if dom not in intents: continue |
|
new_dial[EK_ORI][INTENT_EK][dom] = intents[dom] |
|
|
|
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]) |
|
|
|
|
|
new_dial[EK] = self.dict_to_str(new_dial[EK_ORI][TOD_EK]) |
|
|
|
domains = [] |
|
for dom in MULTIWOZ_DOMAINS: |
|
if dial["goal"][dom]: domains.append(dom) |
|
new_dial[PROMPT] = generate_prompt("MULTIWOZ2_2", domains) |
|
|
|
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 = {} |
|
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]) |
|
new_dial[ORI_DIAL_ID] = dial_id |
|
new_dial[ORI_DIAL_INFO]["goal"] = dial['goal'] |
|
dial_hist = [] |
|
|
|
|
|
|
|
|
|
|
|
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)): |
|
|
|
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"<USER> {new_turn[USR_UTT]}") |
|
dial_hist.append(f"<SYSTEM> {new_turn[SYS_UTT]}") |
|
for key_ in ["metadata", "dialog_act", "span_info"]: |
|
|
|
if key_ in usr_turn: |
|
new_turn[ORI_USR_ANN][key_] = usr_turn[key_] |
|
|
|
if key_ in sys_turn: |
|
new_turn[ORI_SYS_ANN][key_] = sys_turn[key_] |
|
|
|
|
|
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() |
|
|
|
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() |
|
|
|
new_turn[INTENT] = ", ".join(list(usr_turn["dialog_act"].keys())).lower() |
|
|
|
new_dial[LOG].append(new_turn) |
|
|
|
|
|
domains = [] |
|
for dom in MULTIWOZ_DOMAINS: |
|
if dial["goal"][dom]: domains.append(dom) |
|
|
|
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)))) |
|
|
|
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) |
|
|
|
for dom in domains+["booking", "general"]: |
|
if dom not in intents: continue |
|
new_dial[EK_ORI][INTENT_EK][dom] = intents[dom] |
|
|
|
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]) |
|
|
|
new_dial[PROMPT] = generate_prompt("MULTIWOZ2_2", domains) |
|
|
|
new_data[mode][new_dial_id] = new_dial |
|
if (dial_idx[mode]) % 1000 == 0: |
|
|
|
self.save_dial(new_data[mode], data_name=data_name, file_idx=file_idx[mode], mode=mode) |
|
new_data[mode] = {} |
|
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.taskmaster3() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 <order_id> |
|
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]: |
|
pointer_ori_start += 1 |
|
pointer_delex += 1 |
|
elif pointer_delex == len(utt_delex) - 1: |
|
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: |
|
return [[" ".join(list_ori), " ".join(list_delex)]] |
|
elif len(list_ori) == len(list_delex): |
|
return [[list_ori[i], list_delex[i]] for i in range(len(list_delex))] |
|
elif len(list_ori) < len(list_delex): |
|
return [] |
|
else: |
|
if "<email>" in list_delex: |
|
i_delex = list_delex.index("<email>") |
|
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, "<email>"]) |
|
|
|
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 ["<amount>", "<username>", "<zip_code>", "<order_id>"]: |
|
result = [[list_ori[0], list_delex[0]]] |
|
result.extend(self.match(list_ori[1:], list_delex[1:])) |
|
return result |
|
elif list_delex[-1] in ["<amount>", "<username>", "<zip_code>", "<order_id>"]: |
|
result = [[list_ori[-1], list_delex[-1]]] |
|
result.extend(self.match(list_ori[:-1], list_delex[:-1])) |
|
return result |
|
else: |
|
|
|
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 |
|
|
|
|
|
|
|
|
|
|
|
def main(): |
|
preprocess = PreProcessData() |
|
preprocess.run_all() |
|
preprocess.copy_example() |
|
|
|
|
|
if __name__ == '__main__': |
|
main() |
|
|