Datasets:
Tasks:
Text2Text Generation
Languages:
English
Multilinguality:
monolingual
Size Categories:
100K<n<1M
Language Creators:
found
Annotations Creators:
no-annotation
Source Datasets:
original
ArXiv:
License:
# coding=utf-8 | |
# Copyright 2020 Facebook, Inc. and the HuggingFace Datasets Authors. | |
# | |
# Licensed under the Apache License, Version 2.0 (the "License"); | |
# you may not use this file except in compliance with the License. | |
# You may obtain a copy of the License at | |
# | |
# http://www.apache.org/licenses/LICENSE-2.0 | |
# | |
# Unless required by applicable law or agreed to in writing, software | |
# distributed under the License is distributed on an "AS IS" BASIS, | |
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
# See the License for the specific language governing permissions and | |
# limitations under the License. | |
# Lint as: python3 | |
"""ELI5: Long Form Question Answering dataset""" | |
import bz2 | |
import io | |
import json | |
import lzma | |
import os | |
import re | |
from os.path import isfile | |
from os.path import join as pjoin | |
from time import time | |
import datasets | |
from datasets.exceptions import DefunctDatasetError | |
logger = datasets.logging.get_logger(__name__) | |
_SUB_REDDITS = ["explainlikeimfive", "askscience", "AskHistorians"] | |
_REDDIT_URL = "https://files.pushshift.io/reddit/" | |
# pylint: disable=line-too-long | |
_URL_REGEX = r"""(?i)\b((?:https?:(?:/{1,3}|[a-z0-9%])|[a-z0-9.\-]+[.](?:com|net|org|edu|gov|mil|aero|asia|biz|cat|coop|info|int|jobs|mobi|museum|name|post|pro|tel|travel|xxx|ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co|cr|cs|cu|cv|cx|cy|cz|dd|de|dj|dk|dm|do|dz|ec|ee|eg|eh|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|il|im|in|io|iq|ir|is|it|je|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mm|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|Ja|sk|sl|sm|sn|so|sr|ss|st|su|sv|sx|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|yu|za|zm|zw)/)(?:[^\s()<>{}\[\]]+|\([^\s()]*?\([^\s()]+\)[^\s()]*?\)|\([^\s]+?\))+(?:\([^\s()]*?\([^\s()]+\)[^\s()]*?\)|\([^\s]+?\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’])|(?:(?<!@)[a-z0-9]+(?:[.\-][a-z0-9]+)*[.](?:com|net|org|edu|gov|mil|aero|asia|biz|cat|coop|info|int|jobs|mobi|museum|name|post|pro|tel|travel|xxx|ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co|cr|cs|cu|cv|cx|cy|cz|dd|de|dj|dk|dm|do|dz|ec|ee|eg|eh|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|il|im|in|io|iq|ir|is|it|je|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mm|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|Ja|sk|sl|sm|sn|so|sr|ss|st|su|sv|sx|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|yu|za|zm|zw)\b/?(?!@)))""" | |
# pylint: enable=line-too-long | |
_HTML_PAIRS = [ | |
("&", " & "), | |
(""", ' " '), | |
("&apos", " ' "), | |
(">", " > "), | |
("<", " < "), | |
] | |
# removes URLs (kept in separate list) | |
def _extract_urls_from_text(stp): | |
url_list = list(set(re.findall(_URL_REGEX, stp))) | |
for i, url in enumerate(url_list): | |
stp = stp.replace(url, "_URL_%d_" % (i,)) | |
for a, b in _HTML_PAIRS: | |
stp = stp.replace(a, b) | |
return (stp, url_list) | |
# collects URLs for monthly dumps, has to be robust to file type changes | |
def _gather_dump_urls(base_url, mode, dl_manager): | |
from bs4 import BeautifulSoup | |
page_path = dl_manager.download(_REDDIT_URL + mode) | |
page_f = open(page_path, encoding="utf-8") | |
page_content = page_f.read() | |
page_f.close() | |
soup = BeautifulSoup(page_content, "lxml") | |
files = [it for it in soup.find_all(attrs={"class": "file"})] | |
f_urls = [ | |
tg.find_all(lambda x: x.has_attr("href"))[0]["href"] | |
for tg in files | |
if len(tg.find_all(lambda x: x.has_attr("href"))) > 0 | |
] | |
date_to_url = {} | |
for url_st in f_urls: | |
ls = re.findall(r"20[0-9]{2}-[0-9]{2}", url_st) | |
if len(ls) > 0: | |
yr, mt = ls[0].split("-") | |
date_to_url[(int(yr), int(mt))] = base_url + mode + url_st[1:] | |
return date_to_url | |
# select valid top-level comments | |
def _valid_line(dct, mode): | |
top_level = (mode == "submissions") or ( | |
len(dct["body"].split()) > 2 | |
and not dct["body"].startswith("Your submission has been removed") | |
and dct["author"] != "AutoModerator" | |
and dct["parent_id"] == dct["link_id"] | |
) | |
res = dct.get("num_comments", 1) > 0 and dct.get("score", 0) and dct.get("score", 0) >= 2 and top_level | |
return res | |
def _open_compressed_file(f_name, f_type): | |
import zstandard as zstd | |
fh = None | |
if f_type == "xz": | |
f = lzma.open(f_name, "rt") | |
elif f_type == "bz2": | |
f = bz2.open(f_name, "rt") | |
elif f_type == "zst": | |
fh = open(f_name, "rb") | |
dctx = zstd.ZstdDecompressor() | |
stream_reader = dctx.stream_reader(fh) | |
f = io.TextIOWrapper(stream_reader, encoding="utf-8") | |
else: | |
raise NotImplementedError | |
return f, fh | |
# download a file, extract posts from desired subreddit, then remove from disk | |
def _download_and_select_lines(dl_manager, f_url, mode, st_time): | |
# download and pre-process original posts | |
logger.info(f"downloading {f_url} {time() - st_time:.2f}") | |
f_downloaded_path = dl_manager.download(f_url) | |
logger.info(f"decompressing and filtering {f_url} {time() - st_time:.2f}") | |
f, fh = _open_compressed_file(f_downloaded_path, f_url.split(".")[-1]) | |
lines = dict([(name, []) for name in _SUB_REDDITS]) | |
for line in f: | |
line_dct = json.loads(line) | |
if any([line_dct.get("subreddit", "") == name for name in _SUB_REDDITS]): | |
lines[line_dct["subreddit"]] += [line_dct] | |
f.close() | |
if f_url.split(".")[-1] == "zst": | |
fh.close() | |
os.remove(f_downloaded_path) | |
os.remove(f_downloaded_path + ".json") | |
os.remove(f_downloaded_path + ".lock") | |
logger.info("tokenizing and selecting {f_url} {time() - st_time:.2f}") | |
processed_items = dict([(name, []) for name in _SUB_REDDITS]) | |
if mode == "submissions": | |
key_list = ["id", "score", "url", "title", "selftext", "subreddit"] | |
else: | |
key_list = ["id", "link_id", "parent_id", "score", "body"] | |
for name in _SUB_REDDITS: | |
for line in lines[name]: | |
if _valid_line(line, mode): | |
reddit_res = {} | |
for k in key_list: | |
if k in ["title", "selftext", "body"]: | |
reddit_res[k] = _extract_urls_from_text(line[k]) | |
else: | |
reddit_res[k] = line[k] | |
processed_items[name] += [reddit_res] | |
logger.info(f"Total found {sum([len(ls) for ls in processed_items.values()])} {mode} {time() - st_time:.2f}") | |
return processed_items | |
# post-process ELI5 questions and de-duplicate answers | |
def _post_process(reddit_dct, name=""): | |
# remove the ELI5 at the start of explainlikeimfive questions | |
start_re = re.compile(r"""\A[\[|\(]?[ ]?eli[5f][ ]?[\]|\)]?[]?[:,]?""", re.IGNORECASE) | |
if name == "explainlikeimfive": | |
title, uls = reddit_dct["title"] | |
title = start_re.sub("", title.strip()).strip() | |
reddit_dct["title"] = [title, uls] | |
# dedupe and filter comments | |
comments = [ | |
c | |
for i, c in enumerate(reddit_dct["comments"]) | |
if len(c["body"][0].split()) >= 8 and c["id"] not in [x["id"] for x in reddit_dct["comments"][:i]] | |
] | |
comments = sorted(comments, key=lambda c: (c["score"], len(c["body"][0].split()), c["id"]), reverse=True) | |
reddit_dct["comments"] = comments | |
return reddit_dct | |
def _download_and_filter_reddit(dl_manager, start_year=2011, start_month=7, end_year=2019, end_month=7): | |
# collect submissions and comments monthly URLs | |
date_to_url_submissions = _gather_dump_urls(_REDDIT_URL, "submissions", dl_manager) | |
date_to_url_comments = _gather_dump_urls(_REDDIT_URL, "comments", dl_manager) | |
# download, filter, process, remove | |
st_time = time() | |
qa_dict = dict([(name, {}) for name in _SUB_REDDITS]) | |
# first download all questions | |
for year in range(start_year, end_year + 1): | |
start_mth = start_month if year == start_year else 1 | |
end_mth = end_month if year == end_year else 12 | |
months = range(start_mth, end_mth + 1) | |
for month in months: | |
if (year, month) in date_to_url_submissions: | |
f_url = date_to_url_submissions[(year, month)] | |
processed_submissions = _download_and_select_lines(dl_manager, f_url, "submissions", st_time) | |
for name in _SUB_REDDITS: | |
for dct in processed_submissions[name]: | |
qa_dict[name][dct["id"]] = dct | |
else: | |
logger.info(f"Could not find submissions dump file for year {year:4d} month {month:2d}") | |
# then all answers | |
for year in range(start_year, end_year + 1): | |
start_mth = start_month if year == start_year else 1 | |
end_mth = end_month if year == end_year else 12 | |
months = range(start_mth, end_mth + 1) | |
for month in months: | |
if (year, month) in date_to_url_comments: | |
f_url = date_to_url_comments[(year, month)] | |
processed_comments = _download_and_select_lines(dl_manager, f_url, "comments", st_time) | |
# merge submissions and comments | |
for name in _SUB_REDDITS: | |
merged_comments = 0 | |
for dct in processed_comments[name]: | |
did = dct["parent_id"].split("_")[-1] | |
if did in qa_dict[name]: | |
merged_comments += 1 | |
qa_dict[name][did]["comments"] = qa_dict[name][did].get("comments", []) + [dct] | |
else: | |
logger.info(f"Could not find comments dump file for year {year:4d} month {month:2d}") | |
# then post-process | |
res = {} | |
for name in _SUB_REDDITS: | |
qa_dct_list = [(k, _post_process(rdct, name)) for k, rdct in qa_dict[name].items() if "comments" in rdct] | |
qa_dct_list = [x for x in qa_dct_list if len(x[1]["comments"]) > 0 and name in x[1]["url"]] | |
res[name] = dict(qa_dct_list[:]) | |
return res | |
_DESCRIPTION = """\ | |
Explain Like I'm 5 long form QA dataset | |
""" | |
_CITATION = """\ | |
@inproceedings{DBLP:conf/acl/FanJPGWA19, | |
author = {Angela Fan and | |
Yacine Jernite and | |
Ethan Perez and | |
David Grangier and | |
Jason Weston and | |
Michael Auli}, | |
editor = {Anna Korhonen and | |
David R. Traum and | |
Lluis Marquez}, | |
title = {{ELI5:} Long Form Question Answering}, | |
booktitle = {Proceedings of the 57th Conference of the Association for Computational | |
Linguistics, {ACL} 2019, Florence, Italy, July 28- August 2, 2019, | |
Volume 1: Long Papers}, | |
pages = {3558--3567}, | |
publisher = {Association for Computational Linguistics}, | |
year = {2019}, | |
url = {https://doi.org/10.18653/v1/p19-1346}, | |
doi = {10.18653/v1/p19-1346}, | |
} | |
""" | |
class Eli5Config(datasets.BuilderConfig): | |
"""BuilderConfig for ExplainLikeImFive.""" | |
def __init__(self, **kwargs): | |
"""BuilderConfig for ExplainLikeImFive. | |
Args: | |
**kwargs: keyword arguments forwarded to super. | |
""" | |
super(Eli5Config, self).__init__(**kwargs) | |
class Eli5(datasets.GeneratorBasedBuilder): | |
"""ELI5: Explain Like I'm Five long form question answering dataset.""" | |
BUILDER_CONFIG_CLASS = Eli5Config | |
_DATA_SPLIT_URL = "https://s3.amazonaws.com/datasets.huggingface.co/nlp/datasets/eli5/reddit_data_split.json" | |
BUILDER_CONFIGS = [ | |
Eli5Config(name="LFQA_reddit", version=datasets.Version("1.0.0"), description="long from QA subreddits"), | |
] | |
test_dummy_data = False | |
def _info(self): | |
raise DefunctDatasetError( | |
"Dataset 'eli5' is defunct and no longer accessible due to unavailability of the source data" | |
) | |
return datasets.DatasetInfo( | |
description=_DESCRIPTION, | |
features=datasets.Features( | |
{ | |
"q_id": datasets.Value("string"), | |
"title": datasets.Value("string"), | |
"selftext": datasets.Value("string"), | |
"document": datasets.Value("string"), | |
"subreddit": datasets.Value("string"), | |
"answers": datasets.features.Sequence( | |
{ | |
"a_id": datasets.Value("string"), | |
"text": datasets.Value("string"), | |
"score": datasets.Value("int32"), | |
} | |
), | |
"title_urls": datasets.features.Sequence(datasets.Value("string")), | |
"selftext_urls": datasets.features.Sequence(datasets.Value("string")), | |
"answers_urls": datasets.features.Sequence(datasets.Value("string")), | |
} | |
), | |
supervised_keys=None, | |
homepage="https://facebookresearch.github.io/ELI5/explore.html", | |
citation=_CITATION, | |
) | |
def _split_generators(self, dl_manager): | |
qa_data_file = pjoin( | |
self._cache_dir_root, self._relative_data_dir(with_version=False), "reddit_downloaded_qa_lists.json" | |
) | |
if isfile(qa_data_file): | |
logger.info("loading pre-computed QA list") | |
self.filtered_reddit = json.load(open(qa_data_file)) | |
else: | |
self.filtered_reddit = _download_and_filter_reddit( | |
dl_manager, start_year=2011, start_month=7, end_year=2019, end_month=7 | |
) | |
logger.info("saving pre-computed QA list") | |
json.dump(self.filtered_reddit, open(qa_data_file, "w")) | |
# download data splits from AWS | |
fpath_splits = dl_manager.download(self._DATA_SPLIT_URL) | |
self.data_split = json.load(open(fpath_splits)) | |
return [ | |
datasets.SplitGenerator( | |
name=datasets.Split("train_eli5"), | |
gen_kwargs={"split": "train", "subreddit_name": "explainlikeimfive"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("validation_eli5"), | |
gen_kwargs={"split": "validation", "subreddit_name": "explainlikeimfive"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("test_eli5"), | |
gen_kwargs={"split": "test", "subreddit_name": "explainlikeimfive"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("train_asks"), | |
gen_kwargs={"split": "train", "subreddit_name": "askscience"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("validation_asks"), | |
gen_kwargs={"split": "validation", "subreddit_name": "askscience"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("test_asks"), | |
gen_kwargs={"split": "test", "subreddit_name": "askscience"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("train_askh"), | |
gen_kwargs={"split": "train", "subreddit_name": "AskHistorians"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("validation_askh"), | |
gen_kwargs={"split": "validation", "subreddit_name": "AskHistorians"}, | |
), | |
datasets.SplitGenerator( | |
name=datasets.Split("test_askh"), | |
gen_kwargs={"split": "test", "subreddit_name": "AskHistorians"}, | |
), | |
] | |
def _generate_examples(self, split, subreddit_name): | |
logger.info(f"generating examples from = {subreddit_name}, {split} set") | |
if split in self.data_split.get(subreddit_name, []): | |
id_list = self.data_split[subreddit_name][split] | |
data = [ | |
self.filtered_reddit[subreddit_name][q_id] | |
for q_id in id_list | |
if q_id in self.filtered_reddit[subreddit_name] | |
] | |
elif split == "train": | |
data = [ | |
self.filtered_reddit[subreddit_name][q_id] | |
for subreddit_name in self.filtered_reddit | |
for q_id in self.filtered_reddit[subreddit_name] | |
] | |
else: | |
data = [] | |
for example in data: | |
id_ = example["id"] | |
title = example["title"][0] | |
title_urls = example["title"][1] | |
selftext = example["selftext"][0] | |
selftext_urls = example["selftext"][1] | |
answer_scores = [ans["score"] for ans in example["comments"]] | |
answer_ids = [ans["id"] for ans in example["comments"]] | |
# flatten list of URL mappings | |
url_maps = [(ul, i, j) for i, ans in enumerate(example["comments"]) for j, ul in enumerate(ans["body"][1])] | |
answers_urls = [ul for ul, _, _ in url_maps] | |
map_url_indices = dict([((i, j), k) for k, (_, i, j) in enumerate(url_maps)]) | |
answer_texts = [] | |
for i, ans in enumerate(example["comments"]): | |
txt = ans["body"][0] | |
for j, _ in enumerate(ans["body"][1]): | |
txt = txt.replace(f"_URL_{j}_", f"_URL_{map_url_indices[(i, j)]}_") | |
answer_texts += [txt.strip()] | |
yield id_, { | |
"q_id": id_, | |
"title": title, | |
"selftext": selftext, | |
"document": "", | |
"subreddit": example.get("subreddit", subreddit_name), | |
"answers": {"a_id": answer_ids, "text": answer_texts, "score": answer_scores}, | |
"title_urls": title_urls, | |
"selftext_urls": selftext_urls, | |
"answers_urls": answers_urls, | |
} | |