Datasets:
qanta

Languages: English
Multilinguality: monolingual
Size Categories: 100K<n<1M
Language Creators: found
Annotations Creators: machine-generated
Source Datasets: original
License: unknown
qanta / qanta.py
system's picture
system
HF staff
Update files from the datasets library (from 1.6.0)
c990801
"""qanta dataset."""
import json
from typing import List, Tuple
import datasets
_CITATION = """
@article{Rodriguez2019QuizbowlTC,
title={Quizbowl: The Case for Incremental Question Answering},
author={Pedro Rodriguez and Shi Feng and Mohit Iyyer and He He and Jordan L. Boyd-Graber},
journal={ArXiv},
year={2019},
volume={abs/1904.04792}
}
"""
_DESCRIPTION = """
The Qanta dataset is a question answering dataset based on the academic trivia game Quizbowl.
"""
_QANTA_URL = "https://s3-us-west-2.amazonaws.com/pinafore-us-west-2/qanta-jmlr-datasets/qanta.mapped.2018.04.18.json"
_TRICK_URL = "https://s3-us-west-2.amazonaws.com/pinafore-us-west-2/trick-tacl-datasets/qanta.tacl-trick.json"
_VERSION = datasets.Version("2018.04.18")
_FIRST = "first"
_FULL = "full"
_SENTENCES = "sentences"
_RUNS = "runs"
# Order matters, the first one is default
_MODES = [_FULL, _FIRST, _SENTENCES, _RUNS]
_DEFAULT_CHAR_SKIP = 25
class QantaConfig(datasets.BuilderConfig):
"""BuilderConfig for Qanta."""
def __init__(self, mode: str, char_skip: int, **kwargs):
super(QantaConfig, self).__init__(version=_VERSION, **kwargs)
self.mode = mode
self.char_skip = char_skip
def create_char_runs(text: str, char_skip: int) -> List[Tuple[str, int]]:
"""
Returns runs of the question based on skipping char_skip characters at a time. Also returns the indices used
q: name this first united states president.
runs with char_skip=10:
['name this ',
'name this first unit',
'name this first united state p',
'name this first united state president.']
:param char_skip: Number of characters to skip each time
"""
char_indices = list(range(char_skip, len(text) + char_skip, char_skip))
return [(text[:idx], idx) for idx in char_indices]
def with_default(key, lookup, default):
if key in lookup:
value = lookup[key]
if value is None:
return default
else:
return value
else:
return default
def question_to_examples(question, mode: str, char_skip: int):
features = {
"qanta_id": question["qanta_id"],
"proto_id": with_default("proto_id", question, ""),
"qdb_id": with_default("qdb_id", question, -1),
# We refer to the actual answer as page, but this
# may be misleading externally, so rename here to
# be clearer
"page": question["page"],
"answer": question["page"],
"raw_answer": question["answer"],
"dataset": with_default("dataset", question, ""),
"full_question": question["text"],
"first_sentence": question["first_sentence"],
"tokenizations": question["tokenizations"],
"fold": question["fold"],
"gameplay": question["gameplay"],
"category": with_default("category", question, ""),
"subcategory": with_default("subcategory", question, ""),
"tournament": question["tournament"],
"difficulty": with_default("difficulty", question, ""),
"year": question["year"],
"char_idx": -1,
"sentence_idx": -1,
}
if mode == _FULL:
yield {
"text": question["text"],
"id": str(question["qanta_id"]) + "-full",
**features,
}
elif mode == _FIRST:
yield {
"text": question["first_sentence"],
"id": str(question["qanta_id"]) + "-first",
**features,
}
elif mode == _RUNS:
text = question["text"]
for text_run, char_idx in create_char_runs(text, char_skip):
yield {
"text": text_run,
"char_idx": char_idx,
"id": str(question["qanta_id"]) + "-char-" + str(char_idx),
**features,
}
elif mode == _SENTENCES:
for sentence_idx, (start, end) in enumerate(question["tokenizations"]):
sentence = question["text"][start:end]
yield {
"text": sentence,
"sentence_idx": sentence_idx,
"id": str(question["qanta_id"]) + "-sentence-" + str(sentence_idx),
**features,
}
else:
raise ValueError(f"Invalid mode: {mode}")
_FEATURES = {
# Generated ID based modes set, unique
"id": datasets.Value("string"),
# Dataset defined IDs
"qanta_id": datasets.Value("int32"),
"proto_id": datasets.Value("string"),
"qdb_id": datasets.Value("int32"),
"dataset": datasets.Value("string"),
# Inputs
"text": datasets.Value("string"),
"full_question": datasets.Value("string"),
"first_sentence": datasets.Value("string"),
"char_idx": datasets.Value("int32"),
"sentence_idx": datasets.Value("int32"),
# Character indices of sentences: List[Tuple[int, int]]
"tokenizations": datasets.features.Sequence(datasets.features.Sequence(datasets.Value("int32"), length=2)),
# Labels: Number is equal to number of unique pages across all folds
"answer": datasets.Value("string"),
"page": datasets.Value("string"),
"raw_answer": datasets.Value("string"),
# Meta Information
"fold": datasets.Value("string"),
"gameplay": datasets.Value("bool"),
"category": datasets.Value("string"),
"subcategory": datasets.Value("string"),
"tournament": datasets.Value("string"),
"difficulty": datasets.Value("string"),
"year": datasets.Value("int32"),
}
class Qanta(datasets.GeneratorBasedBuilder):
"""The Qanta dataset is a question answering dataset based on the academic trivia game Quizbowl."""
VERSION = _VERSION
BUILDER_CONFIGS = [
QantaConfig(
name=f"mode={mode},char_skip={_DEFAULT_CHAR_SKIP}",
description=f"Question format: {mode}, char_skip: {_DEFAULT_CHAR_SKIP}",
mode=mode,
char_skip=_DEFAULT_CHAR_SKIP,
)
for mode in _MODES
]
def _info(self):
return datasets.DatasetInfo(
# This is the description that will appear on the datasets page.
description=_DESCRIPTION,
# datasets.features.FeatureConnectors
features=datasets.Features(_FEATURES),
# Number of classes is a function of the dataset, ClassLabel doesn't support dynamic
# definition, so have to defer conversion to classes to later, so can't define
# supervied keys
supervised_keys=None,
# Homepage of the dataset for documentation
homepage="http://www.qanta.org/",
citation=_CITATION,
)
def _split_generators(self, dl_manager):
"""Returns SplitGenerators."""
qanta_path = dl_manager.download_and_extract(_QANTA_URL)
trick_path = dl_manager.download_and_extract(_TRICK_URL)
return [
datasets.SplitGenerator(
name=datasets.Split("guesstrain"),
gen_kwargs={
"qanta_filepath": qanta_path,
"trick_filepath": trick_path,
"fold": "guesstrain",
"mode": self.config.mode,
"char_skip": self.config.char_skip,
},
),
datasets.SplitGenerator(
name=datasets.Split("buzztrain"),
gen_kwargs={
"qanta_filepath": qanta_path,
"trick_filepath": trick_path,
"fold": "buzztrain",
"mode": self.config.mode,
"char_skip": self.config.char_skip,
},
),
datasets.SplitGenerator(
name=datasets.Split("guessdev"),
gen_kwargs={
"qanta_filepath": qanta_path,
"trick_filepath": trick_path,
"fold": "guessdev",
"mode": self.config.mode,
"char_skip": self.config.char_skip,
},
),
datasets.SplitGenerator(
name=datasets.Split("buzzdev"),
gen_kwargs={
"qanta_filepath": qanta_path,
"trick_filepath": trick_path,
"fold": "buzzdev",
"mode": self.config.mode,
"char_skip": self.config.char_skip,
},
),
datasets.SplitGenerator(
name=datasets.Split("guesstest"),
gen_kwargs={
"qanta_filepath": qanta_path,
"trick_filepath": trick_path,
"fold": "guesstest",
"mode": self.config.mode,
"char_skip": self.config.char_skip,
},
),
datasets.SplitGenerator(
name=datasets.Split("buzztest"),
gen_kwargs={
"qanta_filepath": qanta_path,
"trick_filepath": trick_path,
"fold": "buzztest",
"mode": self.config.mode,
"char_skip": self.config.char_skip,
},
),
datasets.SplitGenerator(
name=datasets.Split("adversarial"),
gen_kwargs={
"qanta_filepath": qanta_path,
"trick_filepath": trick_path,
"fold": "adversarial",
"mode": self.config.mode,
"char_skip": self.config.char_skip,
},
),
]
def _generate_examples(
self,
qanta_filepath: str,
trick_filepath: str,
fold: str,
mode: str,
char_skip: int,
):
"""Yields examples."""
if mode not in _MODES:
raise ValueError(f"Invalid mode: {mode}")
if fold == "adversarial":
path = trick_filepath
else:
path = qanta_filepath
with open(path, encoding="utf-8") as f:
questions = json.load(f)["questions"]
for q in questions:
if q["page"] is not None and q["fold"] == fold:
for example in question_to_examples(q, mode, char_skip):
yield example["id"], example