Upload preprocess.py

preprocess.py

@@ -0,0 +1,356 @@
+from zipfile import ZipFile, ZIP_DEFLATED
+import json
+import os
+from pprint import pprint
+from copy import deepcopy
+from collections import Counter
+from tqdm import tqdm
+from shutil import rmtree
+import re
+
+digit2word = {
+    '0': 'zero', '1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five',
+    '6': 'six', '7': 'seven', '8': 'eight', '9': 'nine', '10': 'ten'
+}
+
+match = {
+    '0': 0,
+    '1': 0,
+    '>1': 0,
+}
+
+
+def pharse_in_sen(phrase, sen):
+    '''
+    match value in the sentence
+    :param phrase: str
+    :param sen: str
+    :return: start, end if matched, else None, None
+    '''
+    assert isinstance(phrase, str)
+    pw = '(^|[\s,\.:\?!-])(?P<v>{})([\s,\.:\?!-]|$)'
+    pn = '(^|[\s\?!-]|\D[,\.:])(?P<v>{})($|[\s\?!-]|[,\.:]\D|[,\.:]$)'
+    if phrase.isdigit():
+        pattern = pn
+    else:
+        pattern = pw
+    p = re.compile(pattern.format(re.escape(phrase)), re.I)
+    m = re.search(p, sen)
+    if m:
+        num = len(re.findall(p, sen))
+        if num > 1:
+            match['>1'] += 1
+        else:
+            match['1'] += 1
+        return m.span('v'), num
+    if phrase.isdigit() and phrase in digit2word:
+        phrase = digit2word[phrase]
+        p = re.compile(pw.format(re.escape(phrase)), re.I)
+        m = re.search(p, sen)
+        if m:
+            num = len(re.findall(p, sen))
+            if num > 1:
+                match['>1'] += 1
+            else:
+                match['1'] += 1
+            return m.span('v'), num
+    match['0'] += 1
+    return (None, None), 0
+
+
+def sys_intent():
+    """from original data README.md"""
+    return {
+        "inform": {"description": "Inform the value for a slot to the user."},
+        "request": {"description": "Request the value of a slot from the user."},
+        "confirm": {"description": "Confirm the value of a slot before making a transactional service call."},
+        "offer": {"description": "Offer a certain value for a slot to the user."},
+        "notify_success": {"description": "Inform the user that their request was successful."},
+        "notify_failure": {"description": "Inform the user that their request failed."},
+        "inform_count": {"description": "Inform the number of items found that satisfy the user's request."},
+        "offer_intent": {"description": "Offer a new intent to the user."},
+        "req_more": {"description": "Asking the user if they need anything else."},
+        "goodbye": {"description": "End the dialogue."},
+    }
+
+
+def usr_intent():
+    """from original data README.md"""
+    return {
+        "inform_intent": {"description": "Express the desire to perform a certain task to the system."},
+        "negate_intent": {"description": "Negate the intent which has been offered by the system."},
+        "affirm_intent": {"description": "Agree to the intent which has been offered by the system."},
+        "inform": {"description": "Inform the value of a slot to the system."},
+        "request": {"description": "Request the value of a slot from the system."},
+        "affirm": {"description": "Agree to the system's proposition. "},
+        "negate": {"description": "Deny the system's proposal."},
+        "select": {"description": "Select a result being offered by the system."},
+        "request_alts": {"description": "Ask for more results besides the ones offered by the system."},
+        "thank_you": {"description": "Thank the system."},
+        "goodbye": {"description": "End the dialogue."},
+    }
+
+
+def get_intent():
+    """merge sys & usr intent"""
+    return {
+        "inform": {"description": "Inform the value for a slot."},
+        "request": {"description": "Request the value of a slot."},
+        "confirm": {"description": "Confirm the value of a slot before making a transactional service call."},
+        "offer": {"description": "Offer a certain value for a slot to the user."},
+        "notify_success": {"description": "Inform the user that their request was successful."},
+        "notify_failure": {"description": "Inform the user that their request failed."},
+        "inform_count": {"description": "Inform the number of items found that satisfy the user's request."},
+        "offer_intent": {"description": "Offer a new intent to the user."},
+        "req_more": {"description": "Asking the user if they need anything else."},
+        "goodbye": {"description": "End the dialogue."},
+        "inform_intent": {"description": "Express the desire to perform a certain task to the system."},
+        "negate_intent": {"description": "Negate the intent which has been offered by the system."},
+        "affirm_intent": {"description": "Agree to the intent which has been offered by the system."},
+        "affirm": {"description": "Agree to the system's proposition. "},
+        "negate": {"description": "Deny the system's proposal."},
+        "select": {"description": "Select a result being offered by the system."},
+        "request_alts": {"description": "Ask for more results besides the ones offered by the system."},
+        "thank_you": {"description": "Thank the system."},
+    }
+
+
+def preprocess():
+    original_data_dir = 'dstc8-schema-guided-dialogue-master'
+    new_data_dir = 'data'
+
+    if not os.path.exists(original_data_dir):
+        original_data_zip = 'dstc8-schema-guided-dialogue-master.zip'
+        if not os.path.exists(original_data_zip):
+            raise FileNotFoundError(f'cannot find original data {original_data_zip} in sgd/, should manually download dstc8-schema-guided-dialogue-master.zip from https://github.com/google-research-datasets/dstc8-schema-guided-dialogue')
+        else:
+            archive = ZipFile(original_data_zip)
+            archive.extractall()
+    
+    os.makedirs(new_data_dir, exist_ok=True)
+
+    dialogues = []
+    ontology = {'domains': {},
+                'intents': get_intent(),
+                'state': {},
+                'dialogue_acts': {
+                    "categorical": {},
+                    "non-categorical": {},
+                    "binary": {}
+                }}
+    splits = ['train', 'validation', 'test']
+    dataset_name = 'sgd'
+    for data_split in splits:
+        data_dir = os.path.join(original_data_dir, data_split if data_split != 'validation' else 'dev')
+        # schema => ontology
+        with open(os.path.join(data_dir, 'schema.json')) as f:
+            data = json.load(f)
+            for schema in data:
+                domain = schema['service_name']
+                ontology['domains'].setdefault(domain, {})
+                ontology['domains'][domain]['description'] = schema['description']
+                ontology['domains'][domain].setdefault('slots', {})
+                ontology['domains'][domain]['active_intents'] = schema['intents']
+                ontology['state'].setdefault(domain, {})
+                for slot in schema['slots']:
+                    ontology['domains'][domain]['slots'][slot['name']] = {
+                        "description": slot['description'],
+                        "is_categorical": slot['is_categorical'],
+                        "possible_values": slot['possible_values']
+                    }
+                    ontology['state'][domain][slot['name']] = ''
+                # add 'count' slot
+                ontology['domains'][domain]['slots']['count'] = {
+                    "description": "the number of items found that satisfy the user's request.",
+                    "is_categorical": False,
+                    "possible_values": []
+                }
+
+        # dialog
+        cnt = 0
+        for root, dirs, files in os.walk(data_dir):
+            fs = sorted([x for x in files if 'dialogues' in x])
+            for f in tqdm(fs, desc='processing schema-guided-{}'.format(data_split)):
+                data = json.load(open(os.path.join(data_dir, f)))
+                for d in data:
+                    dialogue = {
+                        "dataset": dataset_name,
+                        "data_split": data_split,
+                        "dialogue_id": f'{dataset_name}-{data_split}-{cnt}',
+                        "original_id": d['dialogue_id'],
+                        "domains": d['services'],
+                        "goal": { # no goal
+                            'description': '',
+                            'inform': {},
+                            'request': {}
+                        },
+                        "turns": []
+                    }
+                    cnt += 1
+                    init_state = {}
+                    for domain in dialogue['domains']:
+                        init_state.setdefault(domain, deepcopy(ontology['state'][domain]))
+
+                    for utt_idx, t in enumerate(d['turns']):
+                        speaker = t['speaker'].lower()
+                        turn = {
+                            'speaker': speaker,
+                            'utterance': t['utterance'],
+                            'utt_idx': utt_idx,
+                            'dialogue_acts': {
+                                'binary': [],
+                                'categorical': [],
+                                'non-categorical': [],
+                            },
+                        }
+                        for frame in t['frames']:
+                            domain = frame['service']
+                            for action in frame['actions']:
+                                intent = action['act'].lower() # lowercase intent
+                                assert intent in ontology['intents'], [intent]
+                                slot = action['slot']
+                                value_list = action['values']
+                                if action['act'] in ['REQ_MORE', 'AFFIRM', 'NEGATE', 'THANK_YOU', 'GOODBYE']:
+                                    # Slot and values are always empty
+                                    assert slot == "" and len(value_list) == 0
+                                    turn['dialogue_acts']['binary'].append({
+                                        "intent": intent,
+                                        "domain": '',
+                                        "slot": ''
+                                    })
+                                elif action['act'] in ['NOTIFY_SUCCESS', 'NOTIFY_FAILURE', 'REQUEST_ALTS', 'AFFIRM_INTENT', 'NEGATE_INTENT']:
+                                    # Slot and values are always empty
+                                    assert slot == "" and len(value_list) == 0
+                                    turn['dialogue_acts']['binary'].append({
+                                        "intent": intent,
+                                        "domain": domain,
+                                        "slot": ''
+                                    })
+                                elif action['act'] in ['OFFER_INTENT', 'INFORM_INTENT']:
+                                    # slot containing the intent being offered.
+                                    assert slot == 'intent' and len(value_list) == 1
+                                    turn['dialogue_acts']['binary'].append({
+                                        "intent": intent,
+                                        "domain": domain,
+                                        "slot": value_list[0]
+                                    })
+                                elif action['act'] in ['REQUEST'] and len(value_list) == 0:
+                                    # always contains a slot, but values are optional.
+                                    assert slot in ontology['domains'][domain]['slots'], f'{domain}-{slot}'
+                                    turn['dialogue_acts']['binary'].append({
+                                        "intent": intent,
+                                        "domain": domain,
+                                        "slot": slot
+                                    })
+                                elif action['act'] in ['SELECT'] and len(value_list) == 0:
+                                    # (slot=='' and len(value_list) == 0) or (slot!='' and len(value_list) > 0)
+                                    assert slot == '', f'{domain}-{slot}-{action}'
+                                    turn['dialogue_acts']['binary'].append({
+                                        "intent": intent,
+                                        "domain": domain,
+                                        "slot": slot
+                                    })
+                                elif action['act'] in ['INFORM_COUNT']:
+                                    # always has "count" as the slot, and a single element in values for the number of results obtained by the system.
+                                    assert slot == 'count' and len(value_list) == 1
+                                    value = value_list[0]
+
+                                    turn['dialogue_acts']['non-categorical'].append({
+                                        "intent": intent,
+                                        "domain": domain,
+                                        "slot": slot,
+                                        "value": value,
+                                    })
+                                    
+                                    # find char span
+                                    (start, end), num = pharse_in_sen(value, t['utterance'])
+                                    assert num > 0, f'{value}-{t["utterance"]}' # {1:20086, 2:341, 3:19}
+                                    assert value.lower() == t['utterance'][start:end].lower() \
+                                                or digit2word[value].lower() == t['utterance'][start:end].lower()
+                                    # first match is always the choice
+                                    turn['dialogue_acts']['non-categorical'][-1].update({
+                                        "value": t['utterance'][start:end], "start": start, "end": end
+                                    })
+                                else:
+                                    # have slot & value
+                                    if ontology['domains'][domain]['slots'][slot]['is_categorical']:
+                                        possible_values = [value.lower() for value in ontology['domains'][domain]['slots'][slot]['possible_values']]
+                                        for value in value_list:
+                                            if value.lower() not in possible_values and value != 'dontcare':
+                                                ontology['domains'][domain]['slots'][slot]['possible_values'].append(value)
+                                                print(f'add value to ontology\t{domain}-{slot}-{value}', possible_values)
+                                            turn['dialogue_acts']['categorical'].append({
+                                                "intent": intent,
+                                                "domain": domain,
+                                                "slot": slot,
+                                                "value": value,
+                                            })
+                                    else:
+                                        # span info in frame['slots']
+                                        for value in value_list:
+                                            for slot_info in frame['slots']:
+                                                start = slot_info['start']
+                                                end = slot_info['exclusive_end']
+                                                if slot_info['slot'] == slot and t['utterance'][start:end].lower() == value.lower():
+                                                    assert t['utterance'][start:end] == value, f'{action}-{slot_info}-{t["utterance"][start:end]}'
+                                                    turn['dialogue_acts']['non-categorical'].append({
+                                                        "intent": intent,
+                                                        "domain": domain,
+                                                        "slot": slot,
+                                                        "value": value,
+                                                        "start": start,
+                                                        "end": end
+                                                    })
+                                                    break
+                                            else:
+                                                assert value == 'dontcare', f'{action}-{slot_info}'
+                                                
+                        if speaker == 'user':
+                            state = deepcopy(init_state)
+                            active_intent = {}
+                            requested_slots = {}
+                            for frame in t['frames']:
+                                domain = frame['service']
+                                active_intent[domain] = frame['state']['active_intent']
+                                requested_slots[domain] = frame['state']['requested_slots']
+                                for slot, value_list in frame['state']['slot_values'].items():
+                                    state[domain][slot] = value_list[0]
+                                    for value in value_list[1:]:
+                                        state[domain][slot] += '|' + value
+                            turn['state'] = state
+                            turn['active_intent'] = active_intent
+                            turn['requested_slots'] = requested_slots
+                        else:
+                            # service_call and service_results
+                            turn['service_call'] = {}
+                            turn['db_results'] = {}
+                            for frame in t['frames']:
+                                if 'service_call' not in frame:
+                                    continue
+                                domain = frame['service']
+                                turn['service_call'][domain] = frame['service_call']
+                                turn['db_results'][domain] = frame['service_results']
+
+                        # add to dialogue_acts dictionary in the ontology
+                        for da_type in turn['dialogue_acts']:
+                            das = turn['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
+                        dialogue['turns'].append(turn)
+                    dialogues.append(dialogue)
+    
+    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
+
+if __name__ == '__main__':
+    preprocess()