upload files

data.zip

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

database.py

@@ -0,0 +1,125 @@
+import json
+import os
+import random
+from fuzzywuzzy import fuzz
+from itertools import chain
+from zipfile import ZipFile
+from copy import deepcopy
+from convlab.util.unified_datasets_util import BaseDatabase, download_unified_datasets
+
+
+class Database(BaseDatabase):
+    def __init__(self):
+        """extract data.zip and load the database."""
+        data_path = download_unified_datasets('multiwoz21', 'data.zip', os.path.dirname(os.path.abspath(__file__)))
+        archive = ZipFile(data_path)
+        self.domains = ['restaurant', 'hotel', 'attraction', 'train', 'hospital', 'police']
+        self.dbs = {}
+        for domain in self.domains:
+            with archive.open('data/{}_db.json'.format(domain)) as f:
+                self.dbs[domain] = json.loads(f.read())
+        # add some missing information
+        self.dbs['taxi'] = {
+            "taxi_colors": ["black","white","red","yellow","blue","grey"],
+            "taxi_types":  ["toyota","skoda","bmw","honda","ford","audi","lexus","volvo","volkswagen","tesla"],
+            "taxi_phone": ["^[0-9]{10}$"]
+        }
+        self.dbs['police'][0]['postcode'] = "cb11jg"
+        for entity in self.dbs['hospital']:
+            entity['postcode'] = "cb20qq"
+            entity['address'] = "Hills Rd, Cambridge"
+
+        self.slot2dbattr = {
+            'open hours': 'openhours',
+            'price range': 'pricerange',
+            'arrive by': 'arriveBy',
+            'leave at': 'leaveAt',
+            'train id': 'trainID'
+        }
+
+    def query(self, domain: str, state: dict, topk: int, ignore_open=False, soft_contraints=(), fuzzy_match_ratio=60) -> list:
+        """
+        return a list of topk entities (dict containing slot-value pairs) for a given domain based on the dialogue state.
+        :param state: support two formats: 1) [[slot,value], [slot,value]...]; 2) {domain: {slot: value, slot: value...}} (the same as belief state)
+        """
+        if isinstance(state, dict):
+            assert domain in state, print(f"domain {domain} not in state {state}")
+            state = state[domain].items()
+        # query the db
+        if domain == 'taxi':
+            return [{'taxi_colors': random.choice(self.dbs[domain]['taxi_colors']),
+            'taxi_types': random.choice(self.dbs[domain]['taxi_types']),
+            'taxi_phone': ''.join([str(random.randint(1, 9)) for _ in range(11)])}]
+        if domain == 'police':
+            return deepcopy(self.dbs['police'])
+        if domain == 'hospital':
+            department = None
+            for key, val in state:
+                if key == 'department':
+                    department = val
+            if not department:
+                for key, val in soft_contraints:
+                    if key == 'department':
+                        department = val
+            if not department:
+                return deepcopy(self.dbs['hospital'])
+            else:
+                return [deepcopy(x) for x in self.dbs['hospital'] if x['department'].lower() == department.strip().lower()]
+        state = list(map(lambda ele: (self.slot2dbattr.get(ele[0], ele[0]), ele[1]) if not(ele[0] == 'area' and ele[1] == 'center') else ('area', 'centre'), state))
+        soft_contraints = list(map(lambda ele: (self.slot2dbattr.get(ele[0], ele[0]), ele[1]) if not(ele[0] == 'area' and ele[1] == 'center') else ('area', 'centre'), soft_contraints))
+
+        found = []
+        for i, record in enumerate(self.dbs[domain]):
+            constraints_iterator = zip(state, [False] * len(state))
+            soft_contraints_iterator = zip(soft_contraints, [True] * len(soft_contraints))
+            for (key, val), fuzzy_match in chain(constraints_iterator, soft_contraints_iterator):
+                if val in ["", "dont care", 'not mentioned', "don't care", "dontcare", "do n't care", "do not care"]:
+                    pass
+                else:
+                    try:
+                        if key not in record:
+                            continue
+                        if key == 'leaveAt':
+                            val1 = int(val.split(':')[0]) * 100 + int(val.split(':')[1])
+                            val2 = int(record['leaveAt'].split(':')[0]) * 100 + int(record['leaveAt'].split(':')[1])
+                            if val1 > val2:
+                                break
+                        elif key == 'arriveBy':
+                            val1 = int(val.split(':')[0]) * 100 + int(val.split(':')[1])
+                            val2 = int(record['arriveBy'].split(':')[0]) * 100 + int(record['arriveBy'].split(':')[1])
+                            if val1 < val2:
+                                break
+                        # elif ignore_open and key in ['destination', 'departure', 'name']:
+                        elif ignore_open and key in ['destination', 'departure']:
+                            continue
+                        elif record[key].strip() == '?':
+                            # '?' matches any constraint
+                            continue
+                        else:
+                            if not fuzzy_match:
+                                if val.strip().lower() != record[key].strip().lower():
+                                    break
+                            else:
+                                if fuzz.partial_ratio(val.strip().lower(), record[key].strip().lower()) < fuzzy_match_ratio:
+                                    break
+                    except:
+                        continue
+            else:
+                res = deepcopy(record)
+                res['Ref'] = '{0:08d}'.format(i)
+                found.append(res)
+                if len(found) == topk:
+                    return found
+        return found
+
+
+if __name__ == '__main__':
+    db = Database()
+    assert issubclass(Database, BaseDatabase)
+    assert isinstance(db, BaseDatabase)
+    # both calls will be ok
+    res1 = db.query("restaurant", [['price range', 'expensive']], topk=3)
+    res2 = db.query("restaurant", {'restaurant':{'price range': 'expensive'}}, topk=3)
+    assert res1 == res2
+    print(res1, len(res1))
+    # print(db.query("hotel", [['price range', 'moderate'], ['stars','4'], ['type', 'guesthouse'], ['internet', 'yes'], ['parking', 'no'], ['area', 'east']]))

preprocess.py

@@ -0,0 +1,1303 @@
+import copy
+import re
+from zipfile import ZipFile, ZIP_DEFLATED
+from shutil import copy2, rmtree
+import json
+import os
+import random
+from tqdm import tqdm
+from collections import Counter
+from pprint import pprint
+from nltk.tokenize import TreebankWordTokenizer, PunktSentenceTokenizer
+
+ontology = {
+    "domains": {  # descriptions are adapted from multiwoz22, but is_categorical may be different
+        "attraction": {
+            "description": "find an attraction",
+            "slots": {
+                "area": {
+                    "description": "area to search for attractions",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "centre",
+                        "east",
+                        "north",
+                        "south",
+                        "west"
+                    ]
+                },
+                "name": {
+                    "description": "name of the attraction",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "type": {
+                    "description": "type of the attraction",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "architecture",
+                        "boat",
+                        "cinema",
+                        "college",
+                        "concerthall",
+                        "entertainment",
+                        "museum",
+                        "multiple sports",
+                        "nightclub",
+                        "park",
+                        "swimmingpool",
+                        "theatre"
+                    ]
+                },
+                "entrance fee": {
+                    "description": "how much is the entrance fee",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "open hours": {
+                    "description": "open hours of the attraction",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "address": {
+                    "description": "address of the attraction",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "phone": {
+                    "description": "phone number of the attraction",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "postcode": {
+                    "description": "postcode of the attraction",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "choice": {
+                    "description": "number of attractions that meet the requirement",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "hotel": {
+            "description": "find and book a hotel",
+            "slots": {
+                "internet": {
+                    "description": "whether the hotel has internet",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "free",
+                        "no",
+                        "yes"
+                    ]
+                },
+                "parking": {
+                    "description": "whether the hotel has parking",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "free",
+                        "no",
+                        "yes"
+                    ]
+                },
+                "area": {
+                    "description": "area or place of the hotel",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "centre",
+                        "east",
+                        "north",
+                        "south",
+                        "west"
+                    ]
+                },
+                "stars": {
+                    "description": "star rating of the hotel",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "0",
+                        "1",
+                        "2",
+                        "3",
+                        "4",
+                        "5"
+                    ]
+                },
+                "price range": {
+                    "description": "price budget of the hotel",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "expensive",
+                        "cheap",
+                        "moderate"
+                    ]
+                },
+                "type": {
+                    "description": "what is the type of the hotel",
+                    "is_categorical": False,
+                    "possible_values": [
+                        "guesthouse",
+                        "hotel"
+                    ]
+                },
+                "name": {
+                    "description": "name of the hotel",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "book people": {
+                    "description": "number of people for the hotel booking",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "book stay": {
+                    "description": "length of stay at the hotel",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "book day": {
+                    "description": "day of the hotel booking",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "monday",
+                        "tuesday",
+                        "wednesday",
+                        "thursday",
+                        "friday",
+                        "saturday",
+                        "sunday"
+                    ]
+                },
+                "phone": {
+                    "description": "phone number of the hotel",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "postcode": {
+                    "description": "postcode of the hotel",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "address": {
+                    "description": "address of the hotel",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "ref": {
+                    "description": "reference number of the hotel booking",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "choice": {
+                    "description": "number of hotels that meet the requirement",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "taxi": {
+            "description": "rent taxi to travel",
+            "slots": {
+                "destination": {
+                    "description": "destination of taxi",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "departure": {
+                    "description": "departure location of taxi",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "leave at": {
+                    "description": "leaving time of taxi",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "arrive by": {
+                    "description": "arrival time of taxi",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "phone": {
+                    "description": "phone number of the taxi",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "type": {
+                    "description": "car type of the taxi",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "restaurant": {
+            "description": "find and book a restaurant",
+            "slots": {
+                "price range": {
+                    "description": "price budget for the restaurant",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "cheap",
+                        "expensive",
+                        "moderate"
+                    ]
+                },
+                "area": {
+                    "description": "area or place of the restaurant",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "centre",
+                        "east",
+                        "north",
+                        "south",
+                        "west"
+                    ]
+                },
+                "food": {
+                    "description": "the cuisine of the restaurant",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "name": {
+                    "description": "name of the restaurant",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "address": {
+                    "description": "address of the restaurant",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "postcode": {
+                    "description": "postcode of the restaurant",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "phone": {
+                    "description": "phone number of the restaurant",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "book people": {
+                    "description": "number of people for the restaurant booking",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "book time": {
+                    "description": "time of the restaurant booking",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "book day": {
+                    "description": "day of the restaurant booking",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "monday",
+                        "tuesday",
+                        "wednesday",
+                        "thursday",
+                        "friday",
+                        "saturday",
+                        "sunday"
+                    ]
+                },
+                "ref": {
+                    "description": "reference number of the restaurant booking",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "choice": {
+                    "description": "number of restaurants that meet the requirement",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "train": {
+            "description": "find a train to travel",
+            "slots": {
+                "destination": {
+                    "description": "destination of the train",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "arrive by": {
+                    "description": "arrival time of the train",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "departure": {
+                    "description": "departure location of the train",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "leave at": {
+                    "description": "leaving time for the train",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "duration": {
+                    "description": "duration of the travel",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "book people": {
+                    "description": "number of people booking for train",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "day": {
+                    "description": "day of the train",
+                    "is_categorical": True,
+                    "possible_values": [
+                        "monday",
+                        "tuesday",
+                        "wednesday",
+                        "thursday",
+                        "friday",
+                        "saturday",
+                        "sunday"
+                    ]
+                },
+                "ref": {
+                    "description": "reference number of the train booking",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "price": {
+                    "description": "price of the train ticket",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "train id": {
+                    "description": "id of the train",
+                    "is_categorical": False
+                },
+                "choice": {
+                    "description": "number of trains that meet the requirement",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "police": {
+            "description": "find a police station for help",
+            "slots": {
+                "name": {
+                    "description": "name of the police station",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "address": {
+                    "description": "address of the police station",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "postcode": {
+                    "description": "postcode of the police station",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "phone": {
+                    "description": "phone number of the police station",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "hospital": {
+            "description": "find a hospital for help",
+            "slots": {
+                "department": {
+                    "description": "specific department of the hospital",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "address": {
+                    "description": "address of the hospital",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "phone": {
+                    "description": "phone number of the hospital",
+                    "is_categorical": False,
+                    "possible_values": []
+                },
+                "postcode": {
+                    "description": "postcode of the hospital",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+            }
+        },
+        "general": {
+            "description": "general domain without slots",
+            "slots": {}
+        }
+    },
+    "intents": {
+        "inform": {
+            "description": "inform the value of a slot"
+        },
+        "request": {
+            "description": "ask for the value of a slot"
+        },
+        "nobook": {
+            "description": "inform the user that the booking is failed"
+        },
+        "reqmore": {
+            "description": "ask the user for more instructions"
+        },
+        "book": {
+            "description": "book something for the user"
+        },
+        "bye": {
+            "description": "say goodbye to the user and end the conversation"
+        },
+        "thank": {
+            "description": "thanks for the help"
+        },
+        "welcome": {
+            "description": "you're welcome"
+        },
+        "greet": {
+            "description": "express greeting"
+        },
+        "recommend": {
+            "description": "recommend a choice to the user"
+        },
+        "select": {
+            "description": "provide several choices for the user"
+        },
+        "offerbook": {
+            "description": "ask the user if he or she needs booking"
+        },
+        "offerbooked": {
+            "description": "provide information about the booking"
+        },
+        "nooffer": {
+            "description": "inform the user that there is no result satisfies user requirements"
+        }
+    },
+    "state": {
+        "attraction": {
+            "type": "",
+            "name": "",
+            "area": ""
+        },
+        "hotel": {
+            "name": "",
+            "area": "",
+            "parking": "",
+            "price range": "",
+            "stars": "",
+            "internet": "",
+            "type": "",
+            "book stay": "",
+            "book day": "",
+            "book people": ""
+        },
+        "restaurant": {
+            "food": "",
+            "price range": "",
+            "name": "",
+            "area": "",
+            "book time": "",
+            "book day": "",
+            "book people": ""
+        },
+        "taxi": {
+            "leave at": "",
+            "destination": "",
+            "departure": "",
+            "arrive by": ""
+        },
+        "train": {
+            "leave at": "",
+            "destination": "",
+            "day": "",
+            "arrive by": "",
+            "departure": "",
+            "book people": ""
+        },
+        "hospital": {
+            "department": ""
+        }
+    },
+    "dialogue_acts": {
+        "categorical": {},
+        "non-categorical": {},
+        "binary": {}
+    }
+}
+
+slot_name_map = {
+    'addr': "address",
+    'post': "postcode",
+    'pricerange': "price range",
+    'arrive': "arrive by",
+    'arriveby': "arrive by",
+    'leave': "leave at",
+    'leaveat': "leave at",
+    'depart': "departure",
+    'dest': "destination",
+    'fee': "entrance fee",
+    'open': 'open hours',
+    'car': "type",
+    'car type': "type",
+    'ticket': 'price',
+    'trainid': 'train id',
+    'id': 'train id',
+    'people': 'book people',
+    'stay': 'book stay',
+    'none': '',
+    'attraction': {
+        'price': 'entrance fee'
+    },
+    'hospital': {},
+    'hotel': {
+        'day': 'book day', 'price': "price range"
+    },
+    'restaurant': {
+        'day': 'book day', 'time': 'book time', 'price': "price range"
+    },
+    'taxi': {
+        'time': 'leave at',
+        'pickup time': 'leave at',
+        'leaving time': 'leave at',
+        'leaving': 'leave at',
+        'arrival time': 'arrive by',
+        'arriving': 'arrive by',
+        'car': "type",
+        'car type': "type"
+    },
+    'train': {
+        'day': 'day', 'time': "duration"
+    },
+    'police': {},
+    'booking': {}
+}
+
+reverse_da_slot_name_map = {
+    'address': 'Addr',
+    'postcode': 'Post',
+    'price range': 'Price',
+    'arrive by': 'Arrive',
+    'leave at': 'Leave',
+    'departure': 'Depart',
+    'destination': 'Dest',
+    'entrance fee': 'Fee',
+    'open hours': 'Open',
+    'price': 'Ticket',
+    'train id': 'Id',
+    'book people': 'People',
+    'book stay': 'Stay',
+    'book day': 'Day',
+    'book time': 'Time',
+    'duration': 'Time',
+    'taxi': {
+        'type': 'Car',
+        'phone': 'Phone'
+    }
+}
+
+digit2word = {
+    '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five',
+    '6': 'six', '7': 'seven', '8': 'eight', '9': 'nine', '10': 'ten'
+}
+
+cnt_domain_slot = Counter()
+
+
+class BookingActRemapper:
+
+    def __init__(self, ontology):
+        self.ontology = ontology
+        self.reset()
+
+    def reset(self):
+        self.current_domains_user = []
+        self.current_domains_system = []
+        self.booked_domains = []
+
+    def retrieve_current_domain_from_user(self, turn_id, ori_dialog):
+        prev_user_turn = ori_dialog[turn_id - 1]
+
+        dialog_acts = prev_user_turn.get('dialog_act', [])
+        keyword_domains_user = get_keyword_domains(prev_user_turn)
+        current_domains_temp = get_current_domains_from_act(dialog_acts)
+        self.current_domains_user = current_domains_temp if current_domains_temp else self.current_domains_user
+        next_user_domains = get_next_user_act_domains(ori_dialog, turn_id)
+
+        return keyword_domains_user, next_user_domains
+
+    def retrieve_current_domain_from_system(self, turn_id, ori_dialog):
+
+        system_turn = ori_dialog[turn_id]
+        dialog_acts = system_turn.get('dialog_act', [])
+        keyword_domains_system = get_keyword_domains(system_turn)
+        current_domains_temp = get_current_domains_from_act(dialog_acts)
+        self.current_domains_system = current_domains_temp if current_domains_temp else self.current_domains_system
+        booked_domain_current = self.check_domain_booked(system_turn)
+
+        return keyword_domains_system, booked_domain_current
+
+    def remap(self, turn_id, ori_dialog):
+
+        keyword_domains_user, next_user_domains = self.retrieve_current_domain_from_user(turn_id, ori_dialog)
+        keyword_domains_system, booked_domain_current = self.retrieve_current_domain_from_system(turn_id, ori_dialog)
+
+        # only need to remap if there is a dialog action labelled
+        dialog_acts = ori_dialog[turn_id].get('dialog_act', [])
+        spans = ori_dialog[turn_id].get('span_info', [])
+        if dialog_acts:
+
+            flattened_acts = flatten_acts(dialog_acts)
+            flattened_spans = flatten_span_acts(spans)
+            remapped_acts, error_local = remap_acts(flattened_acts, self.current_domains_user,
+                                                    booked_domain_current, keyword_domains_user,
+                                                    keyword_domains_system, self.current_domains_system,
+                                                    next_user_domains, self.ontology)
+
+            remapped_spans, _ = remap_acts(flattened_spans, self.current_domains_user,
+                                               booked_domain_current, keyword_domains_user,
+                                               keyword_domains_system, self.current_domains_system,
+                                               next_user_domains, self.ontology)
+
+            deflattened_remapped_acts = deflat_acts(remapped_acts)
+            deflattened_remapped_spans = deflat_span_acts(remapped_spans)
+
+            return deflattened_remapped_acts, deflattened_remapped_spans
+        else:
+            return dialog_acts, spans
+
+    def check_domain_booked(self, turn):
+
+        booked_domain_current = None
+        for domain in turn['metadata']:
+            if turn['metadata'][domain]["book"]["booked"] and domain not in self.booked_domains:
+                booked_domain_current = domain.capitalize()
+                self.booked_domains.append(domain)
+        return booked_domain_current
+
+def infer_booking_target_domain(slot_raw: str, value: str, cur_domains: list):
+    """
+    Decide which concrete domain a stray 'Booking-*' act should map to, based on slot semantics
+    and currently active dialogue domains. Then validate via normalize_domain_slot_value.
+    """
+    s = (slot_raw or "").lower().strip()
+
+    # Heuristic candidate orders by slot semantics
+    if s in {"time", "book time"}:
+        base_order = ["restaurant", "train", "taxi", "hotel"]
+    elif s in {"stay", "book stay"}:
+        base_order = ["hotel"]
+    elif s in {"day", "book day"}:
+        base_order = ["hotel", "restaurant", "train"]
+    elif s in {"people", "book people"}:
+        base_order = ["hotel", "restaurant", "train"]
+    elif s in {"ref", "reference", "reference number"}:
+        base_order = ["train", "restaurant", "hotel", "taxi"]
+    else:
+        base_order = ["hotel", "restaurant", "train", "taxi"]
+
+    # Prefer already active domains, then the rest
+    ordered = [d for d in base_order if d in cur_domains] + [d for d in base_order if d not in cur_domains]
+
+    # Try to validate against ontology via normalize_domain_slot_value
+    for d in ordered:
+        try:
+            dom, slot, val = normalize_domain_slot_value(d, slot_raw, value)
+            return dom, slot, val
+        except Exception:
+            continue
+
+    # Nothing validated — surface a clear error
+    raise Exception(f"booking-slot '{slot_raw}' could not be mapped to a concrete domain")
+
+
+def load_id_list(base_dir: str, base_name: str) -> set:
+    """
+    Try several filename variants in `base_dir`:
+      base_name.txt, base_name.json, base_name  (no extension).
+    TXT is parsed as whitespace-separated IDs.
+    JSON may be a list of IDs or a dict containing a common split key.
+    """
+    candidates = [
+        os.path.join(base_dir, base_name + ".txt"),
+        os.path.join(base_dir, base_name + ".json"),
+        os.path.join(base_dir, base_name),
+    ]
+    for path in candidates:
+        if os.path.isfile(path):
+            if path.endswith(".txt") or "." not in os.path.basename(path):
+                with open(path, "r", encoding="utf-8") as f:
+                    return set(f.read().split())
+            else:  # JSON
+                with open(path, "r", encoding="utf-8") as f:
+                    obj = json.load(f)
+                if isinstance(obj, list):
+                    return set(obj)
+                if isinstance(obj, dict):
+                    # try common keys seen in different releases
+                    for k in ("val", "valid", "validation", "dev", "test", "valList", "valListFile"):
+                        if k in obj and isinstance(obj[k], list):
+                            return set(obj[k])
+                raise ValueError(f"Unrecognized JSON structure in {path}")
+    raise FileNotFoundError(f"No split file variants found for {base_name} in {base_dir}")
+
+def _resolve_booking_target(cur_domains):
+    """Pick a deterministic target domain for stray 'booking' acts."""
+    for d in ('hotel', 'restaurant', 'train', 'taxi'):
+        if d in cur_domains:
+            return d
+    return 'hotel'  # final fallback
+
+def get_keyword_domains(turn):
+    keyword_domains = []
+    text = turn['text']
+    for d in ["Hotel", "Restaurant", "Train"]:
+        if d.lower() in text.lower():
+            keyword_domains.append(d)
+    return keyword_domains
+
+
+def get_current_domains_from_act(dialog_acts):
+
+    current_domains_temp = []
+    for dom_int in dialog_acts:
+        domain, intent = dom_int.split('-')
+        if domain in ["general", "Booking"]:
+            continue
+        if domain not in current_domains_temp:
+            current_domains_temp.append(domain)
+
+    return current_domains_temp
+
+
+def get_next_user_act_domains(ori_dialog, turn_id):
+    domains = []
+    try:
+        next_user_act = ori_dialog[turn_id + 1]['dialog_act']
+        domains = get_current_domains_from_act(next_user_act)
+    except:
+        # will fail if system act is the last act of the dialogue
+        pass
+    return domains
+
+
+def flatten_acts(dialog_acts):
+    flattened_acts = []
+    for dom_int in dialog_acts:
+        domain, intent = dom_int.split('-')
+        for slot_value in dialog_acts[dom_int]:
+            slot = slot_value[0]
+            value = slot_value[1]
+            flattened_acts.append((domain, intent, slot, value))
+
+    return flattened_acts
+
+
+def flatten_span_acts(span_acts):
+
+    flattened_acts = []
+    for span_act in span_acts:
+        domain, intent = span_act[0].split("-")
+        flattened_acts.append((domain, intent, span_act[1], span_act[2:]))
+    return flattened_acts
+
+
+def deflat_acts(flattened_acts):
+
+    dialog_acts = dict()
+
+    for act in flattened_acts:
+        domain, intent, slot, value = act
+        if f"{domain}-{intent}" not in dialog_acts.keys():
+            dialog_acts[f"{domain}-{intent}"] = [[slot, value]]
+        else:
+            dialog_acts[f"{domain}-{intent}"].append([slot, value])
+
+    return dialog_acts
+
+
+def deflat_span_acts(flattened_acts):
+
+    dialog_span_acts = []
+    for act in flattened_acts:
+        domain, intent, slot, value = act
+        if value == 'none':
+            continue
+        new_act = [f"{domain}-{intent}", slot]
+        new_act.extend(value)
+        dialog_span_acts.append(new_act)
+
+    return dialog_span_acts
+
+
+def remap_acts(flattened_acts, current_domains, booked_domain=None, keyword_domains_user=None,
+               keyword_domains_system=None, current_domain_system=None, next_user_domain=None, ontology=None):
+
+    # We now look for all cases that can happen: Booking domain, Booking within a domain or taxi-inform-car for booking
+    error = 0
+    remapped_acts = []
+
+    # if there is more than one current domain or none at all, we try to get booked domain differently
+    if len(current_domains) != 1 and booked_domain:
+        current_domains = [booked_domain]
+    elif len(current_domains) != 1 and len(keyword_domains_user) == 1:
+        current_domains = keyword_domains_user
+    elif len(current_domains) != 1 and len(keyword_domains_system) == 1:
+        current_domains = keyword_domains_system
+    elif len(current_domains) != 1 and len(current_domain_system) == 1:
+        current_domains = current_domain_system
+    elif len(current_domains) != 1 and len(next_user_domain) == 1:
+        current_domains = next_user_domain
+
+    for act in flattened_acts:
+        try:
+            domain, intent, slot, value = act
+            if f"{domain}-{intent}-{slot}" == "Booking-Book-Ref":
+                # We need to remap that booking act now
+                potential_domain = current_domains[0]
+                remapped_acts.append((potential_domain, "Book", "none", "none"))
+                if ontology_check(potential_domain, slot, ontology):
+                    remapped_acts.append((potential_domain, "Inform", "Ref", value))
+            elif domain == "Booking" and intent == "Book" and slot != "Ref":
+                # the book intent is here actually an inform intent according to the data
+                potential_domain = current_domains[0]
+                if ontology_check(potential_domain, slot, ontology):
+                    remapped_acts.append((potential_domain, "Inform", slot, value))
+            elif domain == "Booking" and intent == "Inform":
+                # the inform intent is here actually a request intent according to the data
+                potential_domain = current_domains[0]
+                if ontology_check(potential_domain, slot, ontology):
+                    remapped_acts.append((potential_domain, "OfferBook", slot, value))
+            elif domain == "Booking" and intent in ["NoBook", "Request"]:
+                potential_domain = current_domains[0]
+                if ontology_check(potential_domain, slot, ontology):
+                    remapped_acts.append((potential_domain, intent, slot, value))
+            elif f"{domain}-{intent}-{slot}" == "Taxi-Inform-Car":
+                # taxi-inform-car actually triggers the booking and informs on a car
+                remapped_acts.append((domain, "Book", "none", "none"))
+                remapped_acts.append((domain, intent, slot, value))
+            elif f"{domain}-{intent}-{slot}" in ["Train-Inform-Ref", "Train-OfferBooked-Ref"]:
+                # train-inform/offerbooked-ref actually triggers the booking and informs on the reference number
+                remapped_acts.append((domain, "Book", "none", "none"))
+                remapped_acts.append((domain, "Inform", slot, value))
+            elif domain == "Train" and intent == "OfferBooked" and slot != "Ref":
+                # this is actually an inform act
+                remapped_acts.append((domain, "Inform", slot, value))
+            else:
+                remapped_acts.append(act)
+        except Exception as e:
+            print("Error detected:", e)
+            error += 1
+
+    return remapped_acts, error
+
+
+def ontology_check(domain_, slot_, init_ontology):
+
+    domain = domain_.lower()
+    slot = slot_.lower()
+    if slot not in init_ontology['domains'][domain]['slots']:
+        if slot in slot_name_map:
+            slot = slot_name_map[slot]
+        elif slot in slot_name_map[domain]:
+            slot = slot_name_map[domain][slot]
+    return slot in init_ontology['domains'][domain]['slots']
+
+
+def reverse_da(dialogue_acts):
+    global reverse_da_slot_name_map
+    das = {}
+    for da_type in dialogue_acts:
+        for da in dialogue_acts[da_type]:
+            intent, domain, slot, value = da['intent'], da['domain'], da['slot'], da.get('value', '')
+            if domain == 'general':
+                Domain_Intent = '-'.join([domain, intent])
+            elif intent == 'nooffer':
+                Domain_Intent = '-'.join([domain.capitalize(), 'NoOffer'])
+            elif intent == 'nobook':
+                Domain_Intent = '-'.join([domain.capitalize(), 'NoBook'])
+            elif intent == 'offerbook':
+                Domain_Intent = '-'.join([domain.capitalize(), 'OfferBook'])
+            else:
+                Domain_Intent = '-'.join([domain.capitalize(), intent.capitalize()])
+            das.setdefault(Domain_Intent, [])
+            if slot in reverse_da_slot_name_map:
+                Slot = reverse_da_slot_name_map[slot]
+            elif domain in reverse_da_slot_name_map and slot in reverse_da_slot_name_map[domain]:
+                Slot = reverse_da_slot_name_map[domain][slot]
+            else:
+                Slot = slot.capitalize()
+            if value == '':
+                if intent == 'request':
+                    value = '?'
+                else:
+                    value = 'none'
+            if Slot == '':
+                Slot = 'none'
+            das[Domain_Intent].append([Slot, value])
+    return das
+
+
+def normalize_domain_slot_value(domain, slot, value):
+    global ontology, slot_name_map
+    domain = domain.lower()
+    slot = slot.lower()
+    value = value.strip()
+    if value in ['do nt care', "do n't care"]:
+        value = 'dontcare'
+    if value in ['?', 'none', 'not mentioned']:
+        value = ""
+    if domain not in ontology['domains']:
+        raise Exception(f'{domain} not in ontology')
+    if slot not in ontology['domains'][domain]['slots']:
+        if slot in slot_name_map:
+            slot = slot_name_map[slot]
+        elif slot in slot_name_map[domain]:
+            slot = slot_name_map[domain][slot]
+        else:
+            raise Exception(f'{domain}-{slot} not in ontology')
+    assert slot == '' or slot in ontology['domains'][domain]['slots'], f'{(domain, slot, value)} not in ontology'
+    return domain, slot, value
+
+
+def convert_da(da_dict, utt, sent_tokenizer, word_tokenizer):
+    '''
+    convert multiwoz dialogue acts to required format
+    :param da_dict: dict[(intent, domain, slot, value)] = [word_start, word_end]
+    :param utt: user or system utt
+    '''
+    global ontology, digit2word, cnt_domain_slot
+
+    converted_da = {
+        'categorical': [],
+        'non-categorical': [],
+        'binary': []
+    }
+    sentences = sent_tokenizer.tokenize(utt)
+    sent_spans = sent_tokenizer.span_tokenize(utt)
+    tokens = [token for sent in sentences for token in word_tokenizer.tokenize(sent)]
+    token_spans = [(sent_span[0] + token_span[0], sent_span[0] + token_span[1]) for sent, sent_span in
+                   zip(sentences, sent_spans) for token_span in word_tokenizer.span_tokenize(sent)]
+    # assert len(tokens) == len(token_spans)
+    # for token, span in zip(tokens, token_spans):
+    #     if utt[span[0]:span[1]] != '"':
+    #         assert utt[span[0]:span[1]] == token
+
+    for (intent, domain, slot, value), span in da_dict.items():
+        if intent == 'request' or slot == '' or value == '':
+            # binary dialog acts
+            assert value == ''
+            converted_da['binary'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': slot
+            })
+        elif ontology['domains'][domain]['slots'][slot]['is_categorical']:
+            # categorical dialog acts
+            converted_da['categorical'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': slot,
+                'value': value
+            })
+        else:
+            # non-categorical dialog acts
+            converted_da['non-categorical'].append({
+                'intent': intent,
+                'domain': domain,
+                'slot': slot,
+                'value': value
+            })
+            # correct some value and try to give char level span
+            match = False
+            value = value.lower()
+            if span and span[0] <= span[1]:
+                # use original span annotation, but tokenizations are different
+                start_word, end_word = span
+                if end_word >= len(tokens):
+                    # due to different tokenization, sometimes will out of index
+                    delta = end_word - len(tokens) + 1
+                    start_word -= delta
+                    end_word -= delta
+                start_char, end_char = token_spans[start_word][0], token_spans[end_word][1]
+                value_span = utt[start_char:end_char].lower()
+                match = True
+                if value_span == value:
+                    cnt_domain_slot['span match'] += 1
+                elif value.isdigit() and value in digit2word and digit2word[value] == value_span:
+                    # !!!CHANGE VALUE: value is digit but value span is word
+                    cnt_domain_slot['digit value match'] += 1
+                elif ''.join(value.split()) == ''.join(value_span.split()):
+                    # !!!CHANGE VALUE: equal when remove blank
+                    cnt_domain_slot['remove blank'] += 1
+                elif value in value_span:
+                    # value in value_span
+                    start_char += value_span.index(value)
+                    end_char = start_char + len(value)
+                    assert utt[start_char:end_char].lower() == value, f'{[value, utt[start_char:end_char], utt]}'
+                    cnt_domain_slot['value in span'] += 1
+                elif ':' in value and value == '0' + value_span:
+                    # !!!CHANGE VALUE: time x:xx == 0x:xx
+                    cnt_domain_slot['x:xx == 0x:xx'] += 1
+                else:
+                    # span mismatch, search near 1-2 words
+                    for window in range(1, 3):
+                        start = max(0, start_word - window)
+                        end = min(len(token_spans) - 1, end_word + window)
+                        large_span = utt[token_spans[start][0]:token_spans[end][1]].lower()
+                        if value in large_span:
+                            start_char = token_spans[start][0] + large_span.index(value)
+                            end_char = start_char + len(value)
+                            assert utt[
+                                   start_char:end_char].lower() == value, f'{[value, utt[start_char:end_char], utt]}'
+                            cnt_domain_slot[f'window={window}'] += 1
+                            break
+                    else:
+                        # still not found
+                        match = False
+
+            if match:
+                converted_da['non-categorical'][-1]['value'] = utt[start_char:end_char]
+                converted_da['non-categorical'][-1]['start'] = start_char
+                converted_da['non-categorical'][-1]['end'] = end_char
+                cnt_domain_slot['have span'] += 1
+            else:
+                cnt_domain_slot['no span'] += 1
+    return converted_da
+
+
+def preprocess():
+    original_data_dir = 'MultiWOZ2_3'
+    new_data_dir = 'data'
+
+    if not os.path.exists(original_data_dir):
+        original_data_zip = 'MultiWOZ2_3.zip'
+        if not os.path.exists(original_data_zip):
+            raise FileNotFoundError(
+                f'cannot find original data {original_data_zip} in multiwoz21/, should manually download MultiWOZ_2.1.zip from https://github.com/budzianowski/multiwoz/blob/master/data/MultiWOZ_2.1.zip')
+        else:
+            archive = ZipFile(original_data_zip)
+            archive.extractall()
+
+    os.makedirs(new_data_dir, exist_ok=True)
+    for filename in os.listdir(original_data_dir):
+        if 'db' in filename:
+            copy2(f'{original_data_dir}/{filename}', new_data_dir)
+
+    # Load core data
+    with open(f'{original_data_dir}/data.json', 'r', encoding='utf-8') as f:
+        original_data = json.load(f)
+    global ontology, cnt_domain_slot
+
+    try:
+        val_list = load_id_list(original_data_dir, "valListFile")
+        test_list = load_id_list(original_data_dir, "testListFile")
+    except FileNotFoundError:
+        all_ids = list(original_data.keys())
+        rng = random.Random(42)
+        rng.shuffle(all_ids)
+        n = len(all_ids)
+        n_val = max(1, n // 10)
+        n_test = max(1, n // 10)
+        val_list = set(all_ids[:n_val])
+        test_list = set(all_ids[n_val:n_val + n_test])
+
+    dataset = 'multiwoz23'
+    splits = ['train', 'validation', 'test']
+    dialogues_by_split = {split: [] for split in splits}
+    sent_tokenizer = PunktSentenceTokenizer()
+    word_tokenizer = TreebankWordTokenizer()
+    booking_remapper = BookingActRemapper(ontology)
+    for ori_dialog_id, ori_dialog in tqdm(original_data.items()):
+        if ori_dialog_id in val_list:
+            split = 'validation'
+        elif ori_dialog_id in test_list:
+            split = 'test'
+        else:
+            split = 'train'
+        dialogue_id = f'{dataset}-{split}-{len(dialogues_by_split[split])}'
+
+        # get user goal and involved domains
+        cur_domains = []
+        goal = {
+            'description': '. '.join(ori_dialog['goal']['message']),
+            'inform': {},
+            'request': {}
+        }
+        for k, v in ori_dialog['goal'].items():
+            if len(v) != 0 and k in ontology['domains']:
+                cur_domains.append(k)
+                goal['inform'][k] = {}
+                goal['request'][k] = {}
+                for attr in ['fail_info', 'info', 'fail_book', 'book']:
+                    if attr in v:
+                        for slot, value in v[attr].items():
+                            if 'invalid' in slot:
+                                continue
+                            domain, slot, value = normalize_domain_slot_value(k, slot, value)
+                            if slot in goal['inform'][domain]:
+                                goal['inform'][domain][slot] += '|' + value
+                            else:
+                                goal['inform'][domain][slot] = value
+                if 'reqt' in v:
+                    for slot in v['reqt']:
+                        domain, slot, _ = normalize_domain_slot_value(k, slot, '')
+                        goal['request'][domain][slot] = ''
+
+        dialogue = {
+            'dataset': dataset,
+            'data_split': split,
+            'dialogue_id': dialogue_id,
+            'original_id': ori_dialog_id,
+            'domains': cur_domains,  # will be updated by dialog_acts and state
+            'goal': goal,
+            'turns': []
+        }
+
+        booking_remapper.reset()
+        belief_domains = ['attraction', 'restaurant', 'train', 'hotel', 'taxi', 'hospital']
+        entity_booked_dict = dict((domain, False) for domain in belief_domains)
+        for turn_id, turn in enumerate(ori_dialog['log']):
+            # correct some grammar errors in the text, mainly following `tokenization.md` in MultiWOZ_2.1
+            text = turn['text']
+            text = re.sub(" Im ", " I'm ", text)
+            text = re.sub(" im ", " i'm ", text)
+            text = re.sub(r"^Im ", "I'm ", text)
+            text = re.sub(r"^im ", "i'm ", text)
+            text = re.sub("theres", "there's", text)
+            text = re.sub("dont", "don't", text)
+            text = re.sub("whats", "what's", text)
+            text = re.sub('thats', "that's", text)
+            utt = text
+            speaker = 'user' if turn_id % 2 == 0 else 'system'
+
+            das = turn.get('dialog_act', [])
+            spans = turn.get('span_info', [])
+
+            if speaker == 'system':
+                das, spans = booking_remapper.remap(turn_id, ori_dialog['log'])
+
+            da_dict = {}
+            # transform DA (robust to raw 'Booking-*' that slipped through)
+            for Domain_Intent in das:
+                domain, intent = Domain_Intent.lower().split('-')
+                assert intent in ontology['intents'], f'{ori_dialog_id}:{turn_id}:da\t{intent} not in ontology'
+                for Slot, value in das[Domain_Intent]:
+                    if domain == 'booking':
+                        # infer the correct concrete domain from the slot/value, then validate
+                        dom_, slot_, val_ = infer_booking_target_domain(Slot, value, cur_domains)
+                        target_domain = dom_
+                    else:
+                        dom_, slot_, val_ = normalize_domain_slot_value(domain, Slot, value)
+                        target_domain = dom_
+
+                    if target_domain not in cur_domains:
+                        cur_domains.append(target_domain)
+
+                    da_dict[(intent, target_domain, slot_, val_,)] = []
+
+            # transform SPANs (also robust to 'Booking-*' and backfills missing DAs)
+            for span in spans:
+                Domain_Intent, Slot, value, start_word, end_word = span
+                domain, intent = Domain_Intent.lower().split('-')
+
+                if domain == 'booking':
+                    dom_, slot_, val_ = infer_booking_target_domain(Slot, value, cur_domains)
+                else:
+                    dom_, slot_, val_ = normalize_domain_slot_value(domain, Slot, value)
+
+                # ensure target domain is tracked
+                if dom_ not in cur_domains:
+                    cur_domains.append(dom_)
+
+                key = (intent, dom_, slot_, val_)
+                # If the DA loop didn’t produce this entry (annotation mismatch/legacy alias), backfill it.
+                if key not in da_dict:
+                    da_dict[key] = []  # no word-span yet; we’re about to set it
+
+                da_dict[key] = [start_word, end_word]
+
+            dialogue_acts = convert_da(da_dict, utt, sent_tokenizer, word_tokenizer)
+
+            # reverse_das = reverse_da(dialogue_acts)
+            # das_list = sorted([(Domain_Intent, Slot, ''.join(value.split()).lower()) for Domain_Intent in das for Slot, value in das[Domain_Intent]])
+            # reverse_das_list = sorted([(Domain_Intent, Slot, ''.join(value.split()).lower()) for Domain_Intent in reverse_das for Slot, value in reverse_das[Domain_Intent]])
+            # if das_list != reverse_das_list:
+            #     print(das_list)
+            #     print(reverse_das_list)
+            #     print()
+            #     print()
+
+            dialogue['turns'].append({
+                'speaker': speaker,
+                'utterance': utt,
+                'utt_idx': turn_id,
+                '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 == 'system':
+                # add state to last user turn
+                # add empty db_results
+                turn_state = turn['metadata']
+                cur_state = copy.deepcopy(ontology['state'])
+                booked = {}
+                for domain in turn_state:
+                    if domain not in cur_state:
+                        continue
+                    for subdomain in ['semi', 'book']:
+                        for slot, value in turn_state[domain][subdomain].items():
+                            if slot == 'ticket':
+                                continue
+                            elif slot == 'booked':
+                                assert domain in ontology['domains']
+                                booked[domain] = value
+                                continue
+                            _, slot, value = normalize_domain_slot_value(domain, slot, value)
+                            cur_state[domain][slot] = value
+                dialogue['turns'][-2]['state'] = cur_state
+                entity_booked_dict, booked = fix_entity_booked_info(entity_booked_dict, booked)
+                dialogue['turns'][-1]['booked'] = booked
+        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(original_data_dir)
+    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()