Emulated-Inc/reading-comprehension-training-pool

Reading comprehension training pool

Public reading comprehension questions from six datasets, each a question about a passage with an answer that is a span of it, a number or a date, read at the pinned revisions named below and laid out twice. Train on either layer or on both.

pool.jsonl

Every source rewritten into one shape, 310728 rows, one JSON object per line, with these fields.

Field	What it holds
id	a row identifier unique within this file
passage	the text the question is about, as its source publishes it
question	the question
answers	the question's annotations, each a list of the spans it names
answer_type	span, spans, number, date or yes_no
source	the name of the source directory the row came from
source_repo, source_revision	where the row was read and at what revision
source_subset, source_split, source_id	where the row sits in that set
provenance_class	how the row came to exist
licence	the licence of the source it came from

answers holds the question's annotations, each a list of the spans it names, and every row of this layer holds exactly one, since no source here publishes more than one annotation for its training split. An annotation with several spans is one answer naming several things, which the discrete-reasoning source asks for in about six percent of its questions (two players, three groups) and the coreference source in about a tenth. Rows are deduplicated across sources on the question together with its passage, keeping the first source that carries it in the order of the sections below. The file is written one source after another in that same order, so a sequential read of its first rows trains on one source. Most rows share their passage with other rows of the same source, every source but one asking several questions of each passage (124341 distinct passages carry the rows), so a held-out split should be cut on the passage rather than on the row. A row whose annotators left no usable answer is not in this layer and is still in the raw one.

sources/

The same data untouched, 326089 rows, one directory per source, holding the files at the paths, in the format and with the fields its own publisher uses. Three sources are parquet as published on the Hugging Face Hub and three are the release json as published from their own bucket. Nothing here was renamed, reshaped, reordered or deduplicated. Use this layer if you want a field the rewritten one drops, such as the character offset of an answer inside its passage, the supporting sentences of a multi-paragraph question or the dialogue structure of the conversational source.

The sources

sources/drop

Crowdworker-written questions over Wikipedia paragraphs, mostly match reports and history articles, whose answers need counting, sorting, comparison or arithmetic over what the paragraph states rather than a phrase copied out of it. From the release at https://ai2-public- datasets.s3.amazonaws.com/drop/drop_dataset.zip, sha256 39d2278a29fd729de301b111a45f434c24834f40df8f4ff116d864589e3249d6, files drop_dataset/drop_dataset_train.json. 35072 rows here, of which 34553 also appear in pool.jsonl. Provenance class human, licence cc-by-sa-4.0. Its own fields are one entry per passage keyed by its id, holding passage, wiki_url and qa_pairs, each pair with question, query_id and answer, the answer as number, date with day, month and year, and spans.

Worth knowing. The authors' own release, read from the archive they publish, in the shape their official scorer is defined on. A training question carries exactly one annotation, its primary one, since the release validates only the development split, and an answer naming several things is one annotation with several spans. A date is written day, month, year as the official scorer writes it. The Hub copy ucinlp/drop was not used because it flattens a question's spans into one list, so a two-span answer cannot be told apart from two annotators who each named one thing. Only the training split of this source is here.

sources/squad

Crowdworker-written questions over Wikipedia paragraphs, each answered by a span of the paragraph, the set most extractive reading comprehension work is measured on. From rajpurkar/squad at revision 7b6d24c440a36b6815f21b70d25016731768db1f, files plain_text/train-00000-of-00001.parquet. 87295 rows here, of which 87099 also appear in pool.jsonl. Provenance class human, licence cc-by-sa-4.0. Its own fields are id, title, context, question, and answers with parallel text and answer_start.

Worth knowing. Version 1.1, so every question is answerable. The questions are mostly lexical matching rather than reasoning, which is the gap that questions requiring discrete reasoning over a passage were written to expose.

sources/hotpot_qa

Crowdworker-written questions that need two Wikipedia paragraphs to answer, in the distractor setting, where each question is given its two supporting paragraphs and eight retrieved decoys, with a short span or a yes or no as the answer. From hotpotqa/hotpot_qa at revision 1908d6afbbead072334abe2965f91bd2709910ab, files distractor/train-00000-of-00002.parquet, distractor/train-00001-of-00002.parquet. 90011 rows here, of which 90011 also appear in pool.jsonl. Provenance class human, licence cc-by-sa-4.0. Its own fields are id, question, answer, type, level, supporting_facts with parallel title and sent_id lists, and context with parallel title and sentences lists.

Worth knowing. The passage of a row is ten paragraphs, about a thousand words, several times the length of every other source here, and six percent of its answers are the word yes or the word no rather than a span.

sources/quac

A teacher and a student in conversation about a section of a Wikipedia article, where the student cannot see the section and every answer is a span of it or the marker that the section does not say. From the release at https://s3.amazonaws.com/my89public/quac/train_v0.2.json, sha256 ff5cca5a2e4b4d1cb5b5ced68b9fce88394ef6d93117426d6d4baafbcc05c56a, files train_v0.2.json. 83430 rows here, of which 68800 also appear in pool.jsonl. Provenance class human, licence mit. Its own fields are data, each entry a dialogue with title, section_title, background and one paragraph holding context, id and qas, each question carrying followup, yesno, answers and orig_answer.

Worth knowing. Its answers are sentence-length spans rather than the short phrases every other source carries, and a question only means anything after the questions before it, so the rewritten rows carry the earlier turns in front of the question, one per line as Q: and A: with the question itself last, and a turn the annotators marked as not answerable keeps its CANNOTANSWER marker in that history, so about a third of the questions contain the word, and every passage of this source ends with that same word because the source appends it to each dialogue's text. The answer length is worth filtering on. The published copy on the Hub is a loading script with no data in it, so the release file is fetched from its own bucket and pinned by sha256.

sources/quoref

Crowdworker-written questions over Wikipedia paragraphs that cannot be answered without resolving who or what a pronoun refers to, by the group that built the discrete reasoning source above, in the same file format, with answers that may name several spans. From the release at https://quoref-dataset.s3-us-west-2.amazonaws.com/train_and_dev/quoref-train-dev-v0.1.zip, sha256 aacde0863c04ba6e9ab46995ea844a5b0c6cea58a77ab6fd86a128e33a3ad8fb, files quoref-train- dev-v0.1/quoref-train-v0.1.json. 19357 rows here, of which 19341 also appear in pool.jsonl. Provenance class human, licence cc-by-4.0. Its own fields are data, each entry a title, a url and paragraphs, each paragraph a context, a context_id and qas with a question, an id and answers holding text and answer_start.

Worth knowing. The train and dev split only, the test set is not published. The Hub copy is a loading script with no data in it, so the release archive is fetched from its own bucket and pinned by sha256.

sources/ropes

Questions that apply a passage of background knowledge, taken from science texts and Wikipedia, to a short situation a crowdworker wrote, with the answer a span of one of the two. From allenai/ropes at revision d59f1e2ee2b423d7c6ba71edd47fceb4158b07dd, files plain_text/train-00000-of-00001.parquet. 10924 rows here, of which 10924 also appear in pool.jsonl. Provenance class human, licence cc-by-4.0. Its own fields are id, background, situation, question, and answers with a text list.

Worth knowing. The background paragraph is reused across many situations, so its rows are far from independent, and at about eleven thousand questions it is the smallest source here.

Provenance and licences

Every row was written by a person. All six sources are questions written by crowdworkers about published text, which is the provenance class human. Nothing in the pool was generated by a model.

The pool as a whole is offered under cc-by-sa-4.0, which is the most restrictive term its sources compose to. The sources themselves are cc-by-sa-4.0 for drop, squad and hotpot_qa, mit for quac and cc-by-4.0 for quoref and ropes. Each rewritten row carries its own in the licence field and each directory under sources/ is one source, so a subset under a single licence can be selected. The passages are drawn from Wikipedia and remain under its own terms, and attribution for the share-alike sources goes to the groups that built them.

Filtering

Two filters ran before publication and nothing else did. A slice of rows was withheld from this pool, and a row was removed from both layers alike when its passage was one of the withheld passages (1157 rows) and when its question and passage read as one text shared a run of eight words with a withheld row (42100 rows). The withheld rows are not distributed here. Nothing else was filtered: no topic, no difficulty and no answer type was selected for or against, and the second filter is blunt on passages of this length, so it took more rows than the first by a wide margin.