Create README.md

README.md

@@ -0,0 +1,192 @@
+In the next section the README from the original project and below the code to generate the dataset.
+
+## NLI style FEVER Download Link
+Link: [NLI style FEVER dataset]().
+
+## What is in the file?
+This file contains the NLI style FEVER dataset introduced in the [**Adversarial NLI paper**](https://arxiv.org/abs/1910.14599).
+The dataset is used together with [**SNLI**](https://nlp.stanford.edu/projects/snli/) and [**MultiNLI**](https://www.nyu.edu/projects/bowman/multinli/) to train the backend NLI model in the [**Adversarial NLI**](https://adversarialnli.com/).
+
+## What is the Original FEVER dataset?
+Each data point in the original FEVER dataset is a textual claim paired with a label (support / refute / not enough information) depending on whether the claim can be verified by the Wikipedia.
+For examples with support and refute labels in the training set and dev set, ground truth location of the evidence in the Wikipedia is also provided. (Please refer to [the original paper](https://arxiv.org/abs/1803.05355) for details)
+
+## What is the difference between the original FEVER and this file?
+In the original FEVER setting, the input is a claim and the Wikipedia and the expected output is a label. 
+However, this is different from the standard NLI formalization which is basically a *pair-of-sequence to label* problem.
+To facilitate NLI-related research take advantage of the FEVER dataset, we pair the claims in the FEVER dataset with **textual evidence** and make it a *pair-of-sequence to label* formatted dataset.
+
+## How is the pairing implemented?
+We first applied evidence selection using the method in previous [SOTA fact-checking system](https://arxiv.org/abs/1811.07039) such that each claim will have a collection of potential evidential sentences.
+Then, for claims in FEVER dev set, test set and the claims with not-enough-info label in training set, we directly paired them with the concatenation of all selected evidential sentences. 
+(Note that for not-enough-info claims in FEVER training set, no ground truth evidence locations are provided in the original dataset.)
+For claims in FEVER training set with support and refute label where ground truth evidence locations are provided, we paired them with ground truth textual evidence plus some other randomly sampled evidence from the sentence collection selected by [SOTA fact-checking system](https://arxiv.org/abs/1811.07039).
+Therefore, the same claim might got paired with multiple different contexts.
+This can help the final NLI model be adaptive to the noisy upstream evidence.
+
+## What is the format?
+The train/dev/test data are contained in the three jsonl files. 
+The `query' and `context' field correspond to `premise' and `hypothesis' and the `SUPPORT', `REFUTE', and `NOT ENOUGH INFO' labels correspond to `ENTAILMENT', `CONTRADICT', and `NEUTRAL' label, respectively, in typical NLI settings.
+The `cid' can be mapped back the original FEVER `id' field. (The labels for both dev and test are hidden but you can retrieve the label for dev using the cid and the original FEVER data.)
+Finally, you can train your NLI model using this data and get FEVER verification label results. The label accuracy on dev and test will be comparable to the previous fact-checking works and you can submit your entries to [FEVER CodaLab Leaderboard](https://competitions.codalab.org/competitions/18814#results) to report test results.
+
+## Citation
+If you used the data in this file, please cite the following paper:
+```
+@inproceedings{nie2019combining,
+  title={Combining Fact Extraction and Verification with Neural Semantic Matching Networks},
+  author={Yixin Nie and Haonan Chen and Mohit Bansal},
+  booktitle={Association for the Advancement of Artificial Intelligence ({AAAI})},
+  year={2019}
+}
+```
+
+
+
+
+## Code to generate dataset
+```python
+import pandas as pd
+from datasets import Dataset, ClassLabel, load_dataset, Value, Features, DatasetDict
+import json
+
+
+# download data from https://www.dropbox.com/s/hylbuaovqwo2zav/nli_fever.zip?dl=0
+paths = {
+    "train": "<some_path>/nli_fever/train_fitems.jsonl",
+    "validation": "<some_path>/nli_fever/dev_fitems.jsonl",
+    "test": "<some_path>/nli_fever/test_fitems.jsonl",
+}
+
+
+# parsing code from https://github.com/facebookresearch/anli/blob/main/src/utils/common.py
+registered_jsonabl_classes = {}
+
+
+def register_class(cls):
+    global registered_jsonabl_classes
+    if cls not in registered_jsonabl_classes:
+        registered_jsonabl_classes.update({cls.__name__: cls})
+
+
+def unserialize_JsonableObject(d):
+    global registered_jsonabl_classes
+    classname = d.pop("_jcls_", None)
+    if classname:
+        cls = registered_jsonabl_classes[classname]
+        obj = cls.__new__(cls)  # Make instance without calling __init__
+        for key, value in d.items():
+            setattr(obj, key, value)
+        return obj
+    else:
+        return d
+
+
+def load_jsonl(filename, debug_num=None):
+    d_list = []
+    with open(filename, encoding="utf-8", mode="r") as in_f:
+        print("Load Jsonl:", filename)
+        for line in in_f:
+            item = json.loads(line.strip(), object_hook=unserialize_JsonableObject)
+            d_list.append(item)
+            if debug_num is not None and 0 < debug_num == len(d_list):
+                break
+
+    return d_list
+
+
+def get_original_fever() -> pd.DataFrame:
+    """Get original fever datasets."""
+
+    fever_v1 = load_dataset("fever", "v1.0")
+    fever_v2 = load_dataset("fever", "v2.0")
+
+    columns = ["id", "label"]
+    splits = ["paper_test", "paper_dev", "labelled_dev", "train"]
+    list_dfs = [fever_v1[split].to_pandas()[columns] for split in splits]
+    list_dfs.append(fever_v2["validation"].to_pandas()[columns])
+
+    dfs = pd.concat(list_dfs, ignore_index=False)
+    dfs = dfs.drop_duplicates()
+
+    dfs = dfs.rename(columns={"label": "fever_gold_label"})
+    return dfs
+
+
+def load_and_process(path: str, fever_df: pd.DataFrame) -> pd.DataFrame:
+    """Load data split and merge with fever."""
+
+    df = pd.DataFrame(load_jsonl(path))
+    df = df.rename(columns={"query": "premise", "context": "hypothesis"})
+
+    # adjust dtype
+    df["cid"] = df["cid"].astype(int)
+
+    # merge with original fever to get labels
+    df = pd.merge(df, fever_df, left_on="cid", right_on="id", how="inner").drop_duplicates()
+
+    return df
+
+
+def encode_labels(df: pd.DataFrame) -> pd.DataFrame:
+    """Encode labels using the mapping used in SNLI and MultiNLI"""
+    mapping = {
+        "SUPPORTS": 0,  # entailment
+        "NOT ENOUGH INFO": 1,  # neutral
+        "REFUTES": 2,  # contradiction
+    }
+    df["label"] = df["fever_gold_label"].map(mapping)
+
+    # verifiable
+    df["verifiable"] = df["verifiable"].map({"NOT VERIFIABLE": 0, "VERIFIABLE": 1})
+
+    return df
+
+
+if __name__ == "__main__":
+    fever_df = get_original_fever()
+
+    dataset_splits = {}
+
+    for split, path in paths.items():
+
+        # from json to dataframe and merge with fever
+        df = load_and_process(path, fever_df)
+
+        if not len(df) > 0:
+            print(f"Split `{split}` has no matches")
+            continue
+
+        if split == "train":
+            # train must have same labels
+            assert sum(df["fever_gold_label"] != df["label"]) == 0
+
+        # encode labels using the default mapping used by other nli datasets
+        # i.e, entailment: 0, neutral: 1, contradiction: 2
+        df = df.drop(columns=["label"])
+        df = encode_labels(df)
+
+        # cast to dataset
+        features = Features(
+            {
+                "cid": Value(dtype="int64", id=None),
+                "fid": Value(dtype="string", id=None),
+                "id": Value(dtype="int32", id=None),
+                "premise": Value(dtype="string", id=None),
+                "hypothesis": Value(dtype="string", id=None),
+                "verifiable": Value(dtype="int64", id=None),
+                "fever_gold_label": Value(dtype="string", id=None),
+                "label": ClassLabel(num_classes=3, names=["entailment", "neutral", "contradiction"]),
+            }
+        )
+        if "test" in path:
+            # no features for test set
+            df["label"] = -1
+            df["verifiable"] = -1
+            df["fever_gold_label"] = "not available"
+        dataset = Dataset.from_pandas(df, features=features)
+        dataset_splits[split] = dataset
+
+    nli_fever = DatasetDict(dataset_splits)
+    nli_fever.push_to_hub("pietrolesci/nli_fever", token="<your token>")
+```