_nq.py

import glob
import json
import os
from io import BytesIO

import ijson
import more_itertools
import pandas as pd

import datasets
from datasets import Dataset, DatasetDict, DatasetInfo, Features, Sequence, Value

logger = datasets.logging.get_logger(__name__)
# _URL = "https://www.cs.tau.ac.il/~ohadr/NatQuestions.zip"

# RERANKING_URLS = {
#     "train": "https://dl.fbaipublicfiles.com/dpr/data/retriever/biencoder-nq-train.json.gz",
#     "validation": "https://dl.fbaipublicfiles.com/dpr/data/retriever/biencoder-nq-dev.json.gz",
#     # "test": "https://dl.fbaipublicfiles.com/dpr/data/retriever/nq-test.qa.csv",
# }

from tqdm.auto import tqdm

_CITATION = """ """

_DESCRIPTION = """ """

# def
# def read_glob(paths):
#     paths = glob.glob(paths)
#     data = []
#     for path in paths:
#         with open(path) as f:
#             if path.endswith(".json"):
#                 data.extend(json.load(f))
#             elif path.endswith(".jsonl"):
#                 for line in f:
#                     data.append(json.loads(line))
#     return data


def to_dict_element(el, cols):
    bucked_fields = more_itertools.bucket(cols, key=lambda x: x.split(".")[0])
    final_dict = {}
    for parent_name in list(bucked_fields):

        fields = [y.split(".")[-1] for y in list(bucked_fields[parent_name])]
        if len(fields) == 1 and fields[0] == parent_name:
            final_dict[parent_name] = el[fields[0]]
        else:
            parent_list = []
            zipped_fields = list(zip(*[el[f"{parent_name}.{child}"] for child in fields]))
            for x in zipped_fields:
                parent_list.append({k: v for k, v in zip(fields, x)})
            final_dict[parent_name] = parent_list
    return final_dict


def get_json_dataset(dataset):
    flat_dataset = dataset.flatten()
    json_dataset = dataset_to_json(flat_dataset)
    return [to_dict_element(el, cols=flat_dataset.column_names) for el in json_dataset]


def dataset_to_json(dataset):
    new_str = BytesIO()
    dataset.to_json(new_str)
    new_str.seek(0)
    return [json.loads(line.decode()) for line in new_str]


# inference_features = datasets.Features(
#     {
#         "source": Value(dtype="string"),
#         "meta": {
#             "question": Value(dtype="string"),
#             "text": Value(dtype="string"),
#             "title": Value(dtype="string"),
#             "qid": Value(dtype="string"),
#             "id": Value(dtype="string"),
#         },
#     }
# )


class NatQuestionsConfig(datasets.BuilderConfig):
    """BuilderConfig for NatQuestionsDPR."""

    def __init__(self, features, retriever, feature_format, url, **kwargs):
        """BuilderConfig for NatQuestions.

        Args:
          **kwargs: keyword arguments forwarded to super.
        """
        super(NatQuestionsConfig, self).__init__(**kwargs)
        self.features = features
        self.retriever = retriever
        self.feature_format = feature_format
        self.url = url


RETBM25_RERANKING_URLS = {
    split: f"https://dl.fbaipublicfiles.com/dpr/data/retriever/biencoder-nq-{split}.json.gz"
    for split in ["train", "dev"]
}
RETDPR_RERANKING_URLS = {
    split: f"https://dl.fbaipublicfiles.com/dpr/data/retriever/biencoder-nq-adv-hn-{split}.json.gz"
    for split in ["train"]
}


RETDPR_INF_URLS = {
    split: f"https://dl.fbaipublicfiles.com/dpr/data/retriever_results/single/nq-{split}.json.gz"
    for split in ["train", "dev", "test"]
}

RETBM25_INF_URLS = {
    split:f"https://www.cs.tau.ac.il/~ohadr/nq-{split}.json.gz" for split in ["dev","test"]
    
}
RETBM25_RERANKING_features = Features(
    {
        "dataset": Value(dtype="string"),
        "qid": Value(dtype="string"),
        "question": Value(dtype="string"),
        "answers": Sequence(feature=Value(dtype="string")),
        "positive_ctxs": Sequence(
            feature={
                "title": Value(dtype="string"),
                "text": Value(dtype="string"),
                "score": Value(dtype="float32"),
                #    'title_score': Value(dtype='int32'),
                "passage_id": Value(dtype="string"),
            }
        ),
        # 'negative_ctxs': Sequence(feature={'title': Value(dtype='string'),
        #                                  'text': Value(dtype='string'),
        #                                   'score': Value(dtype='float32'),
        #                                 #    'title_score': Value(dtype='int32'),
        #                                     'passage_id': Value(dtype='string')}),
        "hard_negative_ctxs": Sequence(
            feature={
                "title": Value(dtype="string"),
                "text": Value(dtype="string"),
                "score": Value(dtype="float32"),
                #    'title_score': Value(dtype='int32'),
                "passage_id": Value(dtype="string"),
            }
        ),
    }
)

RETDPR_RERANKING_features = Features(
    {
        "qid": Value(dtype="string"),
        "question": Value(dtype="string"),
        "answers": Sequence(feature=Value(dtype="string")),
        # 'negative_ctxs': Sequence(feature=[]),
        "hard_negative_ctxs": Sequence(
            feature={
                "passage_id": Value(dtype="string"),
                "title": Value(dtype="string"),
                "text": Value(dtype="string"),
                "score": Value(dtype="string"),
                # 'has_answer': Value(dtype='int32')
            }
        ),
        "positive_ctxs": Sequence(
            feature={
                "title": Value(dtype="string"),
                "text": Value(dtype="string"),
                "score": Value(dtype="float32"),
                #    'title_score': Value(dtype='int32'),
                # 'has_answer': Value(dtype='int32'),
                "passage_id": Value(dtype="string"),
            }
        ),
    }
)


RETDPR_INF_features = Features(
    {
        "question": Value(dtype="string"),
        "qid": Value(dtype="string"),
        "answers": Sequence(feature=Value(dtype="string")),
        "ctxs": Sequence(
            feature={
                "id": Value(dtype="string"),
                "title": Value(dtype="string"),
                "text": Value(dtype="string"),
                "score": Value(dtype="float32"),
                # "has_answer": Value(dtype="int32"),
            }
        ),
    }
)
URL_DICT = {"reranking_dprnq":RETDPR_RERANKING_URLS, 
            "reranking_bm25":RETBM25_RERANKING_URLS,
            "inference_dprnq":RETDPR_INF_URLS}

class NatQuestions(datasets.GeneratorBasedBuilder):

    BUILDER_CONFIGS = [
        NatQuestionsConfig(
            name="reranking_dprnq",
            version=datasets.Version("1.0.1", ""),
            description="NatQuestions dataset in DPR format with the dprnq retrieval results",
            features=RETDPR_RERANKING_features,
            retriever="dprnq",
            feature_format="dpr",
            url=URL_DICT,
        ),
        NatQuestionsConfig(
            name="reranking_bm25",
            version=datasets.Version("1.0.1", ""),
            description="NatQuestions dataset in DPR format with the bm25 retrieval results",
            features=RETBM25_RERANKING_features,
            retriever="bm25",
            feature_format="dpr",
            url=URL_DICT,
        ),
        NatQuestionsConfig(
            name="inference_dprnq",
            version=datasets.Version("1.0.1", ""),
            description="NatQuestions dataset in a format accepted by the inference model, performing reranking on the dprnq retrieval results",
            features=RETDPR_INF_features,
            retriever="dprnq",
            feature_format="inference",
            url=URL_DICT,
        ),
        NatQuestionsConfig(
            name="inference_bm25",
            version=datasets.Version("1.0.1", ""),
            description="NatQuestions dataset in a format accepted by the inference model, performing reranking on the bm25 retrieval results",
            features=RETDPR_INF_features,
            retriever="bm25",
            feature_format="inference",
            url=URL_DICT,
        ),

    ]

    def _info(self):
        self.features = self.config.features
        self.retriever = self.config.retriever
        self.feature_format = self.config.feature_format
        self.url = self.config.url
        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=self.config.features,
            supervised_keys=None,
            homepage="",
            citation=_CITATION,

        )
        

    def _split_generators(self, dl_manager):
        print(self.url)
        if len(self.url) > 0:
            filepath = dl_manager.download_and_extract(self.url)
        else:
            filepath = ""
        # filepath = "/home/joberant/home/ohadr/testbed/notebooks/NatQuestions_retrievers"
        
        result = []
        if "train" in filepath[self.info.config_name]:
            result.append(
                datasets.SplitGenerator(
                    name=datasets.Split.TRAIN,
                    gen_kwargs={"filepath": filepath, "split": "train"},
                )
            )
        if "dev" in filepath[self.info.config_name] or self.info.config_name=="reranking_dprnq":
            result.append(
                datasets.SplitGenerator(
                    name=datasets.Split.VALIDATION,
                    gen_kwargs={"filepath": filepath, "split": "dev"},
                )
            )
        if "test" in filepath[self.info.config_name] or self.info.config_name=="reranking_dprnq":
            result.append(
                datasets.SplitGenerator(
                    name=datasets.Split.TEST,
                    gen_kwargs={"filepath": filepath, "split": "test"},
                )
            )
        
        return result

    def _prepare_split(self, split_generator, **kwargs):
        self.info.features = self.config.features
        super()._prepare_split(split_generator, **kwargs)

    def _generate_examples(self, filepath, split):
        if self.info.config_name=="reranking_dprnq" and split in ["dev","test"]:
            for i,dict_element in  new_method(split, "inference_dprnq", f"{filepath['inference_dprnq'][split]}"):
                dict_element['positive_ctxs'] = []
                answers = dict_element['answers']
                any_true = False
                for x in dict_element['ctxs']:
                    x['passage_id'] = x.pop('id')
                    x['has_answer'] = False
                    for ans in answers:
                        if ans in x['title'] or ans in x['text']:
                            if 'id' in x:
                                x['passage_id'] = x.pop('id')
                            x['has_answer'] = True
                            dict_element['positive_ctxs'].append(x)
                            any_true = True
                negative_candidates = [x for x in dict_element['ctxs'] if not x['has_answer']]
                dict_element['hard_negative_ctxs'] = negative_candidates[:len(dict_element['positive_ctxs'])]
                dict_element['ctxs'] = dict_element.pop("ctxs")
                for name in ['positive_ctxs',"hard_negative_ctxs"]:
                    for x in dict_element[name]:
                        x.pop("has_answer",None)
                if any_true:
                    dict_element.pop("ctxs")
                    yield i,dict_element
        else:
            yield from new_method(split, self.info.config_name, f"{filepath[self.info.config_name][split]}")

def new_method(split, config_name, object_path):
    count = 0
    with open(object_path) as f:
        items = ijson.items(f, "item")
        for element in items:
            element.pop("negative_ctxs",None)
            for name in ["positive_ctxs","hard_negative_ctxs","ctxs"]:
                for x in element.get(name,[]):
                    x.pop("title_score",None)
                    x.pop("has_answer", None)
                    if "reranking" in config_name and "id" in x:
                        x["passage_id"] = x.pop("id")
            element["qid"] = f"{count}_{split}"
            yield count, element
            count += 1


# def single_inference_format_example(ctx, question, qid):
#     datum = {}
#     datum["source"] = f"Title: {ctx['meta']['title']}\nText: {ctx['meta']['content']}\nQuestion: {question}\n"
#     datum["meta"] = {}
#     datum["meta"]["question"] = question
#     datum["meta"]["qid"] = qid
#     datum["meta"]["title"] = ctx["meta"]["title"]
#     datum["meta"]["text"] = ctx["meta"]["content"]
#     datum["meta"]["id"] = ctx["id"]
#     return datum


# def inference_format_example(element):
#     return [
#         single_inference_format_example(ctx, element["proof"], element["pid"]) for ctx in element["query_res"]
#     ]


# def inference_example(example):