Add load script and update README

README.md

@@ -1,3 +1,213 @@
 ---
-license: mit
+annotations_creators:
+- machine-generated
+- expert-generated
+language:
+- en
+language_creators:
+- found
+license:
+- mit
+multilinguality:
+- monolingual
+pretty_name: KQA-Pro
+size_categories:
+- 10K<n<100K
+source_datasets:
+- original
+tags:
+- knowledge graph
+- freebase
+task_categories:
+- question-answering
+task_ids:
+- open-domain-qa
 ---
+
+# Dataset Card for [Dataset Name]
+
+## Table of Contents
+- [Table of Contents](#table-of-contents)
+- [Dataset Description](#dataset-description)
+  - [Dataset Summary](#dataset-summary)
+  - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+  - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+  - [Data Splits](#data-splits)
+- [Additional Information](#additional-information)
+  - [How to run SPARQLs and programs](#how-to-run-sparqls-and-programs)
+  - [Knowledge Graph File](#knowledge-graph-file)
+  - [How to Submit to Leaderboard](#how-to-submit-results-of-test-set)
+  - [Licensing Information](#licensing-information)
+  - [Citation Information](#citation-information)
+  - [Contributions](#contributions)
+
+## Dataset Description
+
+- **Homepage:** http://thukeg.gitee.io/kqa-pro/
+- **Repository:** https://github.com/shijx12/KQAPro_Baselines
+- **Paper:** [KQA Pro: A Dataset with Explicit Compositional Programs for Complex Question Answering over Knowledge Base](https://aclanthology.org/2022.acl-long.422/)
+- **Leaderboard:** http://thukeg.gitee.io/kqa-pro/leaderboard.html
+- **Point of Contact:** shijx12 at gmail dot com
+
+### Dataset Summary
+
+KQA Pro is a large-scale dataset of complex question answering over knowledge base. The questions are very diverse and challenging, requiring multiple reasoning capabilities including compositional reasoning, multi-hop reasoning, quantitative comparison, set operations, and etc. Strong supervisions of SPARQL and program are provided for each question.
+
+### Supported Tasks and Leaderboards
+
+It supports knowlege graph based question answering. Specifically, it provides SPARQL and *program* for each question.
+
+### Languages
+
+English
+
+## Dataset Structure
+
+**train.json/val.json**
+```
+[
+    {
+        'question': str,
+        'sparql': str, # executable in our virtuoso engine
+        'program': 
+        [
+            {
+                'function': str,  # function name
+                'dependencies': [int],  # functional inputs, representing indices of the preceding functions
+                'inputs': [str],  # textual inputs
+            }
+        ],
+        'choices': [str],  # 10 answer choices
+        'answer': str,  # golden answer
+    }
+]
+```
+
+**test.json**
+```
+[
+    {
+        'question': str,
+        'choices': [str],  # 10 answer choices
+    }
+]
+```
+
+### Data Splits
+
+train, val, test
+
+
+## Additional Information
+
+### Knowledge Graph File
+
+You can find the knowledge graph file `kb.json` in the original github repository. It comes with the format:
+
+```json
+{
+    'concepts':
+    {
+        '<id>':
+        {
+            'name': str,
+            'instanceOf': ['<id>', '<id>'], # ids of parent concept
+        }
+    },
+    'entities': # excluding concepts
+    {
+        '<id>': 
+        {
+            'name': str,
+            'instanceOf': ['<id>', '<id>'], # ids of parent concept
+            'attributes':
+            [
+                {
+                    'key': str, # attribute key
+                    'value':  # attribute value
+                    {
+                        'type': 'string'/'quantity'/'date'/'year',
+                        'value': float/int/str, # float or int for quantity, int for year, 'yyyy/mm/dd' for date
+                        'unit': str,  # for quantity
+                    },
+                    'qualifiers':
+                    {
+                        '<qk>':  # qualifier key, one key may have multiple corresponding qualifier values
+                        [
+                            {
+                                'type': 'string'/'quantity'/'date'/'year',
+                                'value': float/int/str,
+                                'unit': str,
+                            }, # the format of qualifier value is similar to attribute value
+                        ]
+                    }
+                },
+            ]
+            'relations':
+            [
+                {
+                    'predicate': str,
+                    'object': '<id>', # NOTE: it may be a concept id
+                    'direction': 'forward'/'backward',
+                    'qualifiers':
+                    {
+                        '<qk>':  # qualifier key, one key may have multiple corresponding qualifier values
+                        [
+                            {
+                                'type': 'string'/'quantity'/'date'/'year',
+                                'value': float/int/str,
+                                'unit': str,
+                            }, # the format of qualifier value is similar to attribute value
+                        ]
+                    }
+                },
+            ]
+        }
+    }
+}
+```
+
+
+
+### How to run SPARQLs and programs
+
+We implement multiple baselines in our [codebase](https://github.com/shijx12/KQAPro_Baselines), which includes a supervised SPARQL parser and program parser.
+
+In the SPARQL parser, we implement a query engine based on [Virtuoso](https://github.com/openlink/virtuoso-opensource.git).
+You can install the engine based on our [instructions](https://github.com/shijx12/KQAPro_Baselines/blob/master/SPARQL/README.md), and then feed your predicted SPARQL to get the answer.
+
+In the program parser, we implement a rule-based program executor, which receives a predicted program and returns the answer.
+Detailed introductions of our functions can be found in our [paper](https://arxiv.org/abs/2007.03875).
+
+### How to submit results of test set
+You need to predict answers for all questions of test set and write them in a text file **in order**, one per line.
+Here is an example:
+```
+Tron: Legacy
+Palm Beach County
+1937-03-01
+The Queen
+...
+```
+
+### Licensing Information
+
+MIT License
+
+### Citation Information
+
+If you find our dataset is helpful in your work, please cite us by
+
+```
+@inproceedings{KQAPro,
+  title={{KQA P}ro: A Large Diagnostic Dataset for Complex Question Answering over Knowledge Base},
+  author={Cao, Shulin and Shi, Jiaxin and Pan, Liangming and Nie, Lunyiu and Xiang, Yutong and Hou, Lei and Li, Juanzi and He, Bin and Zhang, Hanwang},
+  booktitle={ACL'22},
+  year={2022}
+}
+```
+
+### Contributions
+
+Thanks to [@happen2me](https://github.com/happen2me) for adding this dataset.

kqa_pro.py

@@ -0,0 +1,126 @@
+"""KQA Pro: A large-scale, diverse, challenging dataset of complex question answering over knowledge base."""
+
+import json
+import os
+
+import datasets
+
+logger = datasets.logging.get_logger(__name__)
+
+_CITATION = """\
+@inproceedings{KQAPro,
+    title={{KQA P}ro: A Large Diagnostic Dataset for Complex Question Answering over Knowledge Base},
+    author={Cao, Shulin and Shi, Jiaxin and Pan, Liangming and Nie, Lunyiu and Xiang, Yutong and Hou, Lei and Li, Juanzi and He, Bin and Zhang, Hanwang},
+    booktitle={ACL'22},
+    year={2022}
+    }
+"""
+
+_DESCRIPTION = """\
+A large-scale, diverse, challenging dataset of complex question answering over knowledge base.
+"""
+
+_URL = "https://thukeg.gitee.io/kqa-pro/"
+_DOWNLOAD_URL = "https://cloud.tsinghua.edu.cn/f/df54ff66d1dc4ca7823e/?dl=1"
+
+_TRAIN_CONFIG_NAME = "train_val"
+_TEST_CONFIG_NAME = "test"
+
+class KQAProConfig(datasets.BuilderConfig):
+    """BuilderConfig for KQA Pro."""
+
+    def __init__(self, **kwargs):
+        """BuilderConfig for KQA Pro.
+        Args:
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super(KQAProConfig, self).__init__(**kwargs)
+
+
+class KQAPro(datasets.GeneratorBasedBuilder):
+    """KQAPro: A large scale knowledge-based question answering dataset."""
+
+    BUILDER_CONFIGS = [
+        KQAProConfig(
+            name=_TRAIN_CONFIG_NAME,
+            description="KQA Pro",
+            data_dir="data"
+        ),
+        KQAProConfig(
+            name=_TEST_CONFIG_NAME,
+            description="KQA Pro",
+            data_dir="data"
+        ),
+    ]
+
+
+    def _info(self):
+        if self.config.name == _TEST_CONFIG_NAME:
+            return datasets.DatasetInfo(
+                description=_DESCRIPTION,
+                features=datasets.Features(
+                    {
+                        "question": datasets.Value("string"),
+                        "choices": datasets.features.Sequence(datasets.Value("string")),
+                    }
+                ),
+                supervised_keys=None,
+                homepage=_URL,
+                citation=_CITATION,
+            )
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "question": datasets.Value("string"),
+                    "sparql": datasets.Value("string"),
+                    "program": datasets.features.Sequence(
+                        {
+                            "function": datasets.Value("string"),
+                            "dependencies":  datasets.features.Sequence(datasets.Value("int32")),
+                            "inputs": datasets.features.Sequence(datasets.Value("string"))
+                        }
+                    ),
+                    "choices": datasets.features.Sequence(datasets.Value("string")),
+                    "answer": datasets.Value("string")
+                }
+            ),
+            # No default supervised_keys (as we have to pass both question
+            # and context as input).
+            supervised_keys=None,
+            homepage=_URL,
+            citation=_CITATION,
+        )
+
+
+    def _split_generators(self, dl_manager):
+        download_dir = dl_manager.download_and_extract(_DOWNLOAD_URL)
+        data_dir = os.path.join(download_dir, self.config.data_dir)
+        downloaded_files = {
+            "train": os.path.join(data_dir, "train.json"),
+            "val": os.path.join(data_dir, "val.json"),
+            "test": os.path.join(data_dir, "test.json")
+        }
+
+        if self.config.name == _TEST_CONFIG_NAME:
+            return [
+                datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={
+                                        "filepath": downloaded_files["test"]})
+            ]
+
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={
+                                    "filepath": downloaded_files["train"]}),
+            datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={
+                                    "filepath": downloaded_files["val"]})
+        ]
+
+
+    def _generate_examples(self, filepath):
+        """This function returns the examples in the raw (text) form."""
+        logger.info("generating examples from = %s", filepath)
+        with open(filepath, encoding="utf-8") as f:
+            kqa = json.load(f)
+            for idx, sample in enumerate(kqa):
+                yield idx, sample