Upload 6 files

README.md

@@ -1,3 +1,61 @@
----
-license: apache-2.0
----
+# Dataset Card for CrossWOZ
+
+- **Repository:** https://github.com/thu-coai/CrossWOZ
+- **Paper:** https://aclanthology.org/2020.tacl-1.19/
+- **Leaderboard:** None
+- **Who transforms the dataset:** Qi Zhu(zhuq96 at gmail dot com)
+
+### Dataset Summary
+
+CrossWOZ is the first large-scale Chinese Cross-Domain Wizard-of-Oz task-oriented dataset. It contains 6K dialogue sessions and 102K utterances for 5 domains, including hotel, restaurant, attraction, metro, and taxi. Moreover, the corpus contains rich annotation of dialogue states and dialogue acts at both user and system sides. We also provide a user simulator and several benchmark models for pipelined taskoriented dialogue systems, which will facilitate researchers to compare and evaluate their models on this corpus.
+
+- **How to get the transformed data from original data:** 
+  - Run `python preprocess.py` in the current directory. Need `../../crosswoz/` as the original data.
+- **Main changes of the transformation:**
+  - Add simple description for domains, slots, and intents.
+  - switch intent&domain of `General` dialog acts => domain == 'General' and intent in ['thank','bye','greet','welcome']
+  - Binary dialog acts include: 1) domain == 'General'; 2) intent in ['NoOffer', 'Request', 'Select']; 3) slot in ['酒店设施']
+  - Categorical dialog acts include: slot in ['酒店类型', '车型', '车牌']
+  - Non-categorical dialogue acts: others. assert intent in ['Inform', 'Recommend'] and slot != 'none' and value != 'none'
+  - Transform original user goal to list of `{domain: {'inform': {slot: [value, mentioned/not mentioned]}, 'request': {slot: [value, mentioned/not mentioned]}}}`, stored as `user_state` of user turns.
+  - Transform `sys_state_init` (first API call of system turns) without `selectedResults` as belief state in user turns.
+  - Transform `sys_state` (last API call of system turns) to `db_query` with domain states that contain non-empty `selectedResults`. The `selectedResults` are saved as `db_results`. Both stored in system turns.
+- **Annotations:**
+  - user goal, user state, dialogue acts, state, db query, db results.
+  - Multiple values in state are separated by spaces, meaning all constraints should be satisfied.
+
+### Supported Tasks and Leaderboards
+
+NLU, DST, Policy, NLG, E2E, User simulator
+
+### Languages
+
+Chinese
+
+### Data Splits
+
+| split      |   dialogues |   utterances |   avg_utt |   avg_tokens |   avg_domains |   cat slot match(state) | cat slot match(goal)   |   cat slot match(dialogue act) |   non-cat slot span(dialogue act) |
+|------------|-------------|--------------|-----------|--------------|---------------|-------------------------|------------------------|--------------------------------|-----------------------------------|
+| train      |        5010 |        84660 |     16.9  |        20.55 |          3.02 |                   99.67 | -                      |                            100 |                             94.39 |
+| validation |         500 |         8458 |     16.92 |        20.53 |          3.04 |                   99.62 | -                      |                            100 |                             94.36 |
+| test       |         500 |         8476 |     16.95 |        20.51 |          3.08 |                   99.61 | -                      |                            100 |                             94.85 |
+| all        |        6010 |       101594 |     16.9  |        20.54 |          3.03 |                   99.66 | -                      |                            100 |                             94.43 |
+
+6 domains: ['景点', '餐馆', '酒店', '地铁', '出租', 'General']
+- **cat slot match**: how many values of categorical slots are in the possible values of ontology in percentage.
+- **non-cat slot span**: how many values of non-categorical slots have span annotation in percentage.
+
+### Citation
+
+```
+@article{zhu2020crosswoz,
+  author = {Qi Zhu and Kaili Huang and Zheng Zhang and Xiaoyan Zhu and Minlie Huang},
+  title = {Cross{WOZ}: A Large-Scale Chinese Cross-Domain Task-Oriented Dialogue Dataset},
+  journal = {Transactions of the Association for Computational Linguistics},
+  year = {2020}
+}
+```
+
+### Licensing Information
+
+Apache License, Version 2.0

data.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddc310bba9fada91f266bd455d50b064ec897f069b960c6ca63447cefb8355bb
+size 15918515

database.py

@@ -0,0 +1,239 @@
+"""Modifed from https://github.com/thu-coai/CrossWOZ/blob/master/convlab2/util/crosswoz/dbquery.py"""
+import json
+import os
+import re
+from zipfile import ZipFile
+
+from convlab.util.unified_datasets_util import (BaseDatabase,
+                                                download_unified_datasets)
+
+
+def contains(arr, s):
+    return not len(tuple(filter(lambda item: (not (item.find(s) < 0)), arr)))
+
+class Database(BaseDatabase):
+    def __init__(self):
+        """extract data.zip and load the database."""
+        data_path = download_unified_datasets('crosswoz', 'data.zip', os.path.dirname(os.path.abspath(__file__)))
+        archive = ZipFile(data_path)
+        self.domains = ['景点', '餐馆', '酒店', '地铁', '出租']
+        domain2eng = {'景点': 'attraction', '餐馆': 'restaurant', '酒店': 'hotel', '地铁': 'metro'}
+        self.data = {}
+        for domain in self.domains[:-1]:
+            with archive.open('data/{}_db.json'.format(domain2eng[domain])) as f:
+                self.data[domain] = json.loads(f.read())
+        
+        self.schema = {
+            '景点': {
+                '名称': {'params': None},
+                '门票': {'type': 'between', 'params': [None, None]},
+                '游玩时间': {'params': None},
+                '评分': {'type': 'between', 'params': [None, None]},
+                '周边景点': {'type': 'in', 'params': None},
+                '周边餐馆': {'type': 'in', 'params': None},
+                '周边酒店': {'type': 'in', 'params': None},
+            },
+            '餐馆': {
+                '名称': {'params': None},
+                '推荐菜': {'type': 'multiple_in', 'params': None},
+                '人均消费': {'type': 'between', 'params': [None, None]},
+                '评分': {'type': 'between', 'params': [None, None]},
+                '周边景点': {'type': 'in', 'params': None},
+                '周边餐馆': {'type': 'in', 'params': None},
+                '周边酒店': {'type': 'in', 'params': None}
+            },
+            '酒店': {
+                '名称': {'params': None},
+                '酒店类型': {'params': None},
+                '酒店设施': {'type': 'multiple_in', 'params': None},
+                '价格': {'type': 'between', 'params': [None, None]},
+                '评分': {'type': 'between', 'params': [None, None]},
+                '周边景点': {'type': 'in', 'params': None},
+                '周边餐馆': {'type': 'in', 'params': None},
+                '周边酒店': {'type': 'in', 'params': None}
+            },
+            '地铁': {
+                '起点': {'params': None},
+                '终点': {'params': None},
+            },
+            '出租': {
+                '起点': {'params': None},
+                '终点': {'params': None},
+            }
+        }
+
+    def query(self, domain: str, state: dict, topk: int) -> list:
+        """
+        return a list of topk entities (dict containing slot-value pairs) for a given domain based on the dialogue state.
+        query database using belief state, return list of entities, same format as database
+        :param state: belief state of the format {domain: {slot: value}}
+        :param domain: maintain by DST, current query domain
+        :param topk: max number of entities
+        :return: list of entities
+        """
+        if not domain:
+            return []
+        cur_query_form = {}
+        for slot, value in state[domain].items():
+            if not value:
+                continue
+            if slot == '出发地':
+                slot = '起点'
+            elif slot == '目的地':
+                slot = '终点'
+            if slot == '名称':
+                # DONE: if name is specified, ignore other constraints
+                cur_query_form = {'名称': value}
+                break
+            elif slot == '评分':
+                if re.match('(\d\.\d|\d)', value):
+                    if re.match('\d\.\d', value):
+                        score = float(re.match('\d\.\d', value)[0])
+                    else:
+                        score = int(re.match('\d', value)[0])
+                    cur_query_form[slot] = [score, None]
+                # else:
+                #     assert 0, value
+            elif slot in ['门票', '人均消费', '价格']:
+                low, high = None, None
+                if re.match('(\d+)-(\d+)', value):
+                    low = int(re.match('(\d+)-(\d+)', value)[1])
+                    high = int(re.match('(\d+)-(\d+)', value)[2])
+                elif re.match('\d+', value):
+                    if '以上' in value:
+                        low = int(re.match('\d+', value)[0])
+                    elif '以下' in value:
+                        high = int(re.match('\d+', value)[0])
+                    else:
+                        low = high = int(re.match('\d+', value)[0])
+                elif slot == '门票':
+                    if value == '免费':
+                        low = high = 0
+                    elif value == '不免费':
+                        low = 1
+                    else:
+                        print(value)
+                        # assert 0
+                cur_query_form[slot] = [low, high]
+            else:
+                cur_query_form[slot] = value
+        cur_res = self.query_schema(field=domain, args=cur_query_form)
+        if domain == '出租':
+            res = [cur_res]
+        elif domain == '地铁':
+            res = []
+            for r in cur_res:
+                if not res and '起点' in r[0]:
+                    res.append(r)
+                    break
+            for r in cur_res:
+                if '终点' in r[0]:
+                    res.append(r)
+                    break
+        else:
+            res = cur_res
+
+        return res[:topk]
+    
+    def query_schema(self, field, args):
+        if not field in self.schema:
+            raise Exception('Unknown field %s' % field)
+        if not isinstance(args, dict):
+            raise Exception('`args` must be dict')
+        db = self.data.get(field)
+        plan = self.schema[field]
+        for key, value in args.items():
+            if not key in plan:
+                raise Exception('Unknown key %s' % key)
+            value_type = plan[key].get('type')
+            if value_type == 'between':
+                if not value[0] is None:
+                    plan[key]['params'][0] = float(value[0])
+                if not value[1] is None:
+                    plan[key]['params'][1] = float(value[1])
+            else:
+                if not isinstance(value, str):
+                    raise Exception('Value for `%s` must be string' % key)
+                plan[key]['params'] = value
+        if field in ['地铁', '出租']:
+            s = plan['起点']['params']
+            e = plan['终点']['params']
+            if not s or not e:
+                return []
+            if field == '出租':
+                return [
+                    '出租 (%s - %s)' % (s, e), {
+                        '领域': '出租',
+                        '车型': '#CX',
+                        '车牌': '#CP'
+                    }
+                ]
+            else:
+                def func1(item):
+                    if item[0].find(s) >= 0:
+                        return ['(起点) %s' % item[0], item[1]]
+
+                def func2(item):
+                    if item[0].find(e) >= 0:
+                        return ['(终点) %s' % item[0], item[1]]
+                    return None
+
+                return list(filter(lambda item: not item is None, list(map(func1, db)))) + list(
+                    filter(lambda item: not item is None, list(map(func2, db))))
+
+        def func3(item):
+            details = item[1]
+            for key, val in args.items():
+                val = details.get(key)
+                absence = val is None
+                options = plan[key]
+                if options.get('type') == 'between':
+                    L = options['params'][0]
+                    R = options['params'][1]
+                    if not L is None:
+                        if absence:
+                            return False
+                    else:
+                        L = float('-inf')
+                    if not R is None:
+                        if absence:
+                            return False
+                    else:
+                        R = float('inf')
+                    if L > val or val > R:
+                        return False
+                elif options.get('type') == 'in':
+                    s = options['params']
+                    if not s is None:
+                        if absence:
+                            return False
+                        if contains(val, s):
+                            return False
+                elif options.get('type') == 'multiple_in':
+                    s = options['params']
+                    if not s is None:
+                        if absence:
+                            return False
+                        sarr = list(filter(lambda t: bool(t), s.split(' ')))
+                        if len(list(filter(lambda t: contains(val, t), sarr))):
+                            return False
+                else:
+                    s = options['params']
+                    if not s is None:
+                        if absence:
+                            return False
+                        if val.find(s) < 0:
+                            return False
+            return True
+
+        return [x[1] for x in filter(func3, db)]
+
+
+if __name__ == '__main__':
+    db = Database()
+    assert issubclass(Database, BaseDatabase)
+    assert isinstance(db, BaseDatabase)
+    res = db.query("餐馆", {"餐馆":{'评分':'4.5以上'}}, topk=3)
+    from pprint import pprint
+    pprint(res)
+    print(len(res))

preprocess.py

@@ -0,0 +1,535 @@
+import copy
+import json
+import os
+import re
+from collections import Counter
+from pprint import pprint
+from shutil import copy2, rmtree
+from zipfile import ZIP_DEFLATED, ZipFile
+
+from tqdm import tqdm
+
+ontology = {
+    "domains": {
+        "景点": {
+            "description": "查找景点",
+            "slots": {
+                "名称": {
+                    "description": "景点名称",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "门票": {
+                    "description": "景点门票价格",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "游玩时间": {
+                    "description": "景点游玩时间",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "评分": {
+                    "description": "景点评分",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "地址": {
+                    "description": "景点地址",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "电话": {
+                    "description": "景点电话",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边景点": {
+                    "description": "景点周边景点",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边餐馆": {
+                    "description": "景点周边餐馆",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边酒店": {
+                    "description": "景点周边酒店",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "餐馆": {
+            "description": "查找餐馆",
+            "slots": {
+                "名称": {
+                    "description": "餐馆名称",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "推荐菜": {
+                    "description": "餐馆推荐菜",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "人均消费": {
+                    "description": "餐馆人均消费",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "评分": {
+                    "description": "餐馆评分",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "地址": {
+                    "description": "餐馆地址",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "电话": {
+                    "description": "餐馆电话",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "营业时间": {
+                    "description": "餐馆营业时间",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边景点": {
+                    "description": "餐馆周边景点",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边餐馆": {
+                    "description": "餐馆周边餐馆",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边酒店": {
+                    "description": "餐馆周边酒店",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "酒店": {
+            "description": "查找酒店",
+            "slots": {
+                "名称": {
+                    "description": "酒店名称",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "酒店类型": {
+                    "description": "酒店类型",
+                    "is_categorical": True,
+                    "possible_values": [
+                        '高档型', '豪华型', '经济型', '舒适型'
+                    ]
+                },
+                "酒店设施": {
+                    "description": "酒店设施",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "价格": {
+                    "description": "酒店价格",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "评分": {
+                    "description": "酒店评分",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "地址": {
+                    "description": "酒店地址",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "电话": {
+                    "description": "酒店电话",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边景点": {
+                    "description": "酒店周边景点",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边餐馆": {
+                    "description": "酒店周边餐馆",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "周边酒店": {
+                    "description": "酒店周边酒店",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "地铁": {
+            "description": "乘坐地铁从某地到某地",
+            "slots": {
+                "出发地": {
+                    "description": "地铁出发地",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "目的地": {
+                    "description": "地铁目的地",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "出发地附近地铁站": {
+                    "description": "出发地附近地铁站",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "目的地附近地铁站": {
+                    "description": "目的地附近地铁站",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "出租": {
+            "description": "乘坐出租车从某地到某地",
+            "slots": {
+                "出发地": {
+                    "description": "出租出发地",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "目的地": {
+                    "description": "出租目的地",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "车型": {
+                    "description": "出租车车型",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "#CX"
+                    ]
+                },
+                "车牌": {
+                    "description": "出租车车牌",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "#CP"
+                    ]
+                }
+            }
+        },
+        "General": {
+            "description": "通用领域",
+            "slots": {}
+        }
+    },
+    "intents": {
+        "Inform": {
+            "description": "告知相关属性"
+        },
+        "Request": {
+            "description": "询问相关属性"
+        },
+        "Recommend": {
+            "description": "推荐搜索结果"
+        },
+        "Select": {
+            "description": "在附近搜索"
+        },
+        "NoOffer": {
+            "description": "未找到符合用户要求的结果"
+        },
+        "bye": {
+            "description": "再见"
+        },
+        "thank": {
+            "description": "感谢"
+        },
+        "welcome": {
+            "description": "不客气"
+        },
+        "greet": {
+            "description": "打招呼"
+        },
+    },
+    "state": {
+        "景点": {
+            "名称": "",
+            "门票": "",
+            "游玩时间": "",
+            "评分": "",
+            "周边景点": "",
+            "周边餐馆": "",
+            "周边酒店": "",
+        },
+        "餐馆": {
+            "名称": "",
+            "推荐菜": "",
+            "人均消费": "",
+            "评分": "",
+            "周边景点": "",
+            "周边餐馆": "",
+            "周边酒店": "",
+        },
+        "酒店": {
+            "名称": "",
+            "酒店类型": "",
+            "酒店设施": "",
+            "价格": "",
+            "评分": "",
+            "周边景点": "",
+            "周边餐馆": "",
+            "周边酒店": "",
+        },
+        "地铁": {
+            "出发地": "",
+            "目的地": "",
+        },
+        "出租": {
+            "出发地": "",
+            "目的地": "",
+        }
+    },
+    "dialogue_acts": {
+        "categorical": {},
+        "non-categorical": {},
+        "binary": {}
+    }
+}
+
+cnt_domain_slot = Counter()
+
+def convert_da(da_list, utt):
+    '''
+    convert dialogue acts to required format
+    :param da_dict: list of (intent, domain, slot, value)
+    :param utt: user or system utt
+    '''
+    global ontology, cnt_domain_slot
+
+    converted_da = {
+        'categorical': [],
+        'non-categorical': [],
+        'binary': []
+    }
+
+    for intent, domain, slot, value in da_list:
+        # if intent in ['Inform', 'Recommend']:
+        if intent == 'NoOffer':
+            assert slot == 'none' and value == 'none'
+            converted_da['binary'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': ''
+            })
+        elif intent == 'General':
+            # intent=General, domain=thank/bye/greet/welcome
+            assert slot == 'none' and value == 'none'
+            converted_da['binary'].append({
+                'intent': domain,
+                'domain': intent,
+                'slot': ''
+            })
+        elif intent == 'Request':
+            assert value == '' and slot != 'none'
+            converted_da['binary'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': slot
+            })
+        elif '酒店设施' in slot:
+            converted_da['binary'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': f"{slot}-{value}"
+            })
+        elif intent == 'Select':
+            assert slot == '源领域'
+            converted_da['binary'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': f"{slot}-{value}"
+            })
+        elif slot in ['酒店类型', '车型', '车牌']:
+            assert intent in ['Inform', 'Recommend']
+            assert slot != 'none' and value != 'none'
+            converted_da['categorical'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': slot,
+                'value': value
+            })
+        else:
+            assert intent in ['Inform', 'Recommend']
+            assert slot != 'none' and value != 'none'
+            matches = utt.count(value)
+            if matches == 1:
+                start = utt.index(value)
+                end = start + len(value)
+                
+                converted_da['non-categorical'].append({
+                    'intent': intent,
+                    'domain': domain,
+                    'slot': slot,
+                    'value': value,
+                    'start': start,
+                    'end': end
+                })
+                cnt_domain_slot['have span'] += 1
+            else:
+                # can not find span
+                converted_da['non-categorical'].append({
+                    'intent': intent,
+                    'domain': domain,
+                    'slot': slot,
+                    'value': value
+                })
+                cnt_domain_slot['no span'] += 1
+            # cnt_domain_slot.setdefault(f'{domain}-{slot}', set())
+            # cnt_domain_slot[f'{domain}-{slot}'].add(value)
+        
+    return converted_da
+
+def transform_user_state(user_state):
+    goal = []
+    for subgoal in user_state:
+        gid, domain, slot, value, mentioned = subgoal
+        if len(value) != 0:
+            t = 'inform'
+        else:
+            t = 'request'
+        if len(goal) < gid:
+            goal.append({domain: {'inform': {}, 'request': {}}})
+        goal[gid-1][domain][t][slot] = [value, 'mentioned' if mentioned else 'not mentioned']
+    return goal
+
+
+def preprocess():
+    original_data_dir = '../../crosswoz'
+    new_data_dir = 'data'
+
+    os.makedirs(new_data_dir, exist_ok=True)
+    for filename in os.listdir(os.path.join(original_data_dir,'database')):
+        copy2(f'{original_data_dir}/database/{filename}', new_data_dir)
+
+    global ontology
+
+    dataset = 'crosswoz'
+    splits = ['train', 'validation', 'test']
+    dialogues_by_split = {split: [] for split in splits}
+    for split in ['train', 'val', 'test']:
+        data = json.load(ZipFile(os.path.join(original_data_dir, f'{split}.json.zip'), 'r').open(f'{split}.json'))
+        if split == 'val':
+            split = 'validation'
+    
+        for ori_dialog_id, ori_dialog in data.items():
+            if ori_dialog_id in ['10550', '11724']:
+                # skip error dialog
+                continue
+            dialogue_id = f'{dataset}-{split}-{len(dialogues_by_split[split])}'
+
+            # get user goal and involved domains
+            goal = {'inform': {}, 'request': {}}
+            goal["description"] = '\n'.join(ori_dialog["task description"])
+            cur_domains = [x[1] for i, x in enumerate(ori_dialog['goal']) if i == 0 or ori_dialog['goal'][i-1][1] != x[1]]
+
+            dialogue = {
+                'dataset': dataset,
+                'data_split': split,
+                'dialogue_id': dialogue_id,
+                'original_id': ori_dialog_id,
+                'domains': cur_domains,
+                'goal': goal,
+                'user_state_init': transform_user_state(ori_dialog['goal']),
+                'type': ori_dialog['type'],
+                'turns': [],
+                'user_state_final': transform_user_state(ori_dialog['final_goal'])
+            }
+
+            for turn_id, turn in enumerate(ori_dialog['messages']):
+                if ori_dialog_id == '2660' and turn_id in [8,9]:
+                    # skip error turns
+                    continue
+                elif ori_dialog_id == '7467' and turn_id in [14,15]:
+                    # skip error turns
+                    continue
+                elif ori_dialog_id == '11726' and turn_id in [4,5]:
+                    # skip error turns
+                    continue
+                speaker = 'user' if turn['role'] == 'usr' else 'system'
+                utt = turn['content']
+
+                das = turn['dialog_act']
+
+                dialogue_acts = convert_da(das, utt)
+
+                dialogue['turns'].append({
+                    'speaker': speaker,
+                    'utterance': utt,
+                    'utt_idx': len(dialogue['turns']),
+                    'dialogue_acts': dialogue_acts,
+                })
+
+                # add to dialogue_acts dictionary in the ontology
+                for da_type in dialogue_acts:
+                    das = dialogue_acts[da_type]
+                    for da in das:
+                        ontology["dialogue_acts"][da_type].setdefault((da['intent'], da['domain'], da['slot']), {})
+                        ontology["dialogue_acts"][da_type][(da['intent'], da['domain'], da['slot'])][speaker] = True
+
+                if speaker == 'user':
+                    dialogue['turns'][-1]['user_state'] = transform_user_state(turn['user_state'])
+                else:
+                    # add state to last user turn
+                    belief_state = turn['sys_state_init']
+                    for domain in belief_state:
+                        belief_state[domain].pop('selectedResults')
+                    dialogue['turns'][-2]['state'] = belief_state
+                    db_query = turn['sys_state']
+                    db_results = {}
+                    for domain in list(db_query.keys()):
+                        db_res = db_query[domain].pop('selectedResults')
+                        if len(db_res) > 0:
+                            db_results[domain] = [{'名称': x} for x in db_res]
+                        else:
+                            db_query.pop(domain)
+                    dialogue['turns'][-1]['db_query'] = db_query
+                    dialogue['turns'][-1]['db_results'] = db_results
+            dialogues_by_split[split].append(dialogue)
+    pprint(cnt_domain_slot.most_common())
+    dialogues = []
+    for split in splits:
+        dialogues += dialogues_by_split[split]
+    for da_type in ontology['dialogue_acts']:
+        ontology["dialogue_acts"][da_type] = sorted([str(
+            {'user': speakers.get('user', False), 'system': speakers.get('system', False), 'intent': da[0],
+             'domain': da[1], 'slot': da[2]}) for da, speakers in ontology["dialogue_acts"][da_type].items()])
+    json.dump(dialogues[:10], open(f'dummy_data.json', 'w', encoding='utf-8'), indent=2, ensure_ascii=False)
+    json.dump(ontology, open(f'{new_data_dir}/ontology.json', 'w', encoding='utf-8'), indent=2, ensure_ascii=False)
+    json.dump(dialogues, open(f'{new_data_dir}/dialogues.json', 'w', encoding='utf-8'), indent=2, ensure_ascii=False)
+    with ZipFile('data.zip', 'w', ZIP_DEFLATED) as zf:
+        for filename in os.listdir(new_data_dir):
+            zf.write(f'{new_data_dir}/{filename}')
+    rmtree(new_data_dir)
+    return dialogues, ontology
+
+
+def fix_entity_booked_info(entity_booked_dict, booked):
+    for domain in entity_booked_dict:
+        if not entity_booked_dict[domain] and booked[domain]:
+            entity_booked_dict[domain] = True
+            booked[domain] = []
+    return entity_booked_dict, booked
+
+
+if __name__ == '__main__':
+    preprocess()