Upload with huggingface_hub

README.md

@@ -0,0 +1,65 @@
+# Dataset Card for SGD-X v5
+
+- **Repository:** https://github.com/google-research-datasets/dstc8-schema-guided-dialogue/tree/master/sgd_x
+- **Paper:** https://arxiv.org/pdf/2110.06800.pdf
+- **Leaderboard:** None
+- **Who transforms the dataset:** Qi Zhu(zhuq96 at gmail dot com)
+
+### Dataset Summary
+
+The **Schema-Guided Dialogue (SGD)** dataset consists of over 20k annotated multi-domain, task-oriented conversations between a human and a virtual assistant. These conversations involve interactions with services and APIs spanning 20 domains, such as banks, events, media, calendar, travel, and weather. For most of these domains, the dataset contains multiple different APIs, many of which have overlapping functionalities but different interfaces, which reflects common real-world scenarios. The wide range of available annotations can be used for intent prediction, slot filling, dialogue state tracking, policy imitation learning, language generation, and user simulation learning, among other tasks for developing large-scale virtual assistants. Additionally, the dataset contains unseen domains and services in the evaluation set to quantify the performance in zero-shot or few-shot settings.
+
+The **SGD-X** dataset consists of 5 linguistic variants of every schema in the original SGD dataset. Linguistic variants were written by hundreds of paid crowd-workers. In the SGD-X directory, v1 represents the variant closest to the original schemas and v5 the farthest in terms of linguistic distance. To evaluate model performance on SGD-X schemas, dialogues must be converted using the script generate_sgdx_dialogues.py.
+
+- **How to get the transformed data from original data:** 
+  - Download [dstc8-schema-guided-dialogue-master.zip](https://github.com/google-research-datasets/dstc8-schema-guided-dialogue/archive/refs/heads/master.zip).
+  - Modified `sgd_x/generate_sgdx_dialogues.py` as https://github.com/google-research-datasets/dstc8-schema-guided-dialogue/issues/57
+  - Run `python -m sgd_x.generate_sgdx_dialogues` under `dstc8-schema-guided-dialogue-master` dir which need tensorflow installed.
+  - Run `python preprocess.py` in the current directory.
+- **Main changes of the transformation:**
+  - Lower case original `act` as `intent`.
+  - Add `count` slot for each domain, non-categorical, find span by text matching.
+  - Categorize `dialogue acts` according to the `intent`.
+  - Concatenate multiple values using `|`.
+  - Retain `active_intent`, `requested_slots`, `service_call`.
+- **Annotations:**
+  - dialogue acts, state, db_results, service_call, active_intent, requested_slots.
+
+### Supported Tasks and Leaderboards
+
+NLU, DST, Policy, NLG, E2E
+
+### Languages
+
+English
+
+### 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      |       16142 |       329964 |     20.44 |         9.75 |          1.84 |                     100 | -                      |                            100 |                               100 |
+| validation |        2482 |        48726 |     19.63 |         9.66 |          1.84 |                     100 | -                      |                            100 |                               100 |
+| test       |        4201 |        84594 |     20.14 |        10.4  |          2.02 |                     100 | -                      |                            100 |                               100 |
+| all        |       22825 |       463284 |     20.3  |         9.86 |          1.87 |                     100 | -                      |                            100 |                               100 |
+
+45 domains: ['Banks_15', 'Buses_15', 'Buses_25', 'Calendar_15', 'Events_15', 'Events_25', 'Flights_15', 'Flights_25', 'Homes_15', 'Hotels_15', 'Hotels_25', 'Hotels_35', 'Media_15', 'Movies_15', 'Music_15', 'Music_25', 'RentalCars_15', 'RentalCars_25', 'Restaurants_15', 'RideSharing_15', 'RideSharing_25', 'Services_15', 'Services_25', 'Services_35', 'Travel_15', 'Weather_15', 'Alarm_15', 'Banks_25', 'Flights_35', 'Hotels_45', 'Media_25', 'Movies_25', 'Restaurants_25', 'Services_45', 'Buses_35', 'Events_35', 'Flights_45', 'Homes_25', 'Media_35', 'Messaging_15', 'Movies_35', 'Music_35', 'Payment_15', 'RentalCars_35', 'Trains_15']
+- **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
+
+```
+@inproceedings{lee2022sgd,
+  title={SGD-X: A Benchmark for Robust Generalization in Schema-Guided Dialogue Systems},
+  author={Lee, Harrison and Gupta, Raghav and Rastogi, Abhinav and Cao, Yuan and Zhang, Bin and Wu, Yonghui},
+  booktitle={Proceedings of the AAAI Conference on Artificial Intelligence},
+  volume={36},
+  number={10},
+  pages={10938--10946},
+  year={2022}
+}
+```
+
+### Licensing Information
+
+[**CC BY-SA 4.0**](https://creativecommons.org/licenses/by-sa/4.0/)

data.zip

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

preprocess.py

@@ -0,0 +1,358 @@
+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/sgd_x/data/v5'
+    dataset_name = 'sgd5'
+    new_data_dir = 'data'
+
+    if not os.path.exists(original_data_dir):
+        raise FileNotFoundError(f'cannot find original data {original_data_dir}, should manually download dstc8-schema-guided-dialogue-master.zip from https://github.com/google-research-datasets/dstc8-schema-guided-dialogue and run `python3 -m sgd_x.generate_sgdx_dialogues`')
+    
+    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']
+    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
+                    prev_state = {}
+                    for domain in dialogue['domains']:
+                        prev_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, print(slot, action, d['dialogue_id'], utt_idx)
+                                    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
+                                    assert domain in ontology['domains'], print(ontology['domains'])
+                                    assert slot in ontology['domains'][domain]['slots'], print(slot, action, d['dialogue_id'], utt_idx)
+                                    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(prev_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 in state[domain]:
+                                    if slot in frame['state']['slot_values']:
+                                        value_list = frame['state']['slot_values'][slot]
+                                        state[domain][slot] = value_list[0]
+                                        for value in value_list[1:]:
+                                            state[domain][slot] += '|' + value
+                                    else:
+                                        state[domain][slot] = ''
+                            prev_state = state
+                            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()