added data

README.md

@@ -5,14 +5,112 @@ task_categories:
 - token-classification
 language:
 - en
+multilinguality:
+- monolingual
+size_categories:
+- 1K<n<10K
 tags:
 - causality
 pretty_name: BECausE
 paperswithcode_id: ../paper/the-because-corpus-20-annotating-causality
-config_names:
-- causality detection
-- causal candidate extraction
-- causality identification
+configs:
+- config_name: causality detection
+  data_files:
+  - split: train
+    path: causality-detection/train.parquet
+  - split: dev
+    path: causality-detection/dev.parquet
+#  - split: test
+#    path: causality-detection/test.parquet
+  features:
+  - name: index
+    dtype: string
+  - name: text
+    dtype: string
+  - name: label
+    dtype:
+      class_label:
+        names:
+          '0': uncausal
+          '1': causal
+- config_name: causal candidate extraction
+  data_files:
+  - split: train
+    path: causal-candidate-extraction/train.parquet
+  # - split: dev
+  #   path: causal-candidate-extraction/dev.parquet
+  - split: test
+    path: causal-candidate-extraction/test.parquet
+  features:
+    - name: index
+      dtype: string
+    - name: tokens
+      sequence: string
+    - name: entity
+      sequence:
+        sequence: int32
+- config_name: causality identification
+  data_files:
+  - split: train
+    path: causality-identification/train.parquet
+  # - split: dev
+  #   path: causal-candidate-extraction/dev.parquet
+  - split: test
+    path: causality-identification/test.parquet
+  features:
+  - name: index
+    dtype: string
+  - name: text
+    dtype: string
+  - name: relations
+    list:
+    - name: relationship
+      dtype:
+        class_label:
+          names:
+            '0': no-rel  # Does not really make sense but exists to have the same labels as the classification task
+            '1': causal
+    - name: first
+      dtype: string
+    - name: second
+      dtype: string
+train-eval-index:
+- config: causality detection
+  task: text-classification
+  task_id: text_classification
+  splits:
+    train_split: train
+    eval_split: test
+  col_mapping:
+    text: text
+    label: label
+  metrics:
+  - type: accuracy
+  - type: precision
+  - type: recall
+  - type: f1
+- config: causal candidate extraction
+  task: token-classification
+  task_id: token_classification
+  splits:
+    train_split: train
+    eval_split: test
+  metrics:
+  - type: accuracy
+  - type: precision
+  - type: recall
+  - type: f1
+- config: causality identification
+  task: text-classification
+  task_id: text_classification
+  splits:
+    train_split: train
+    eval_split: test
+  metrics:
+  - type: accuracy
+  - type: precision
+  - type: recall
+  - type: f1
 ---
 
 > [!NOTE]  
@@ -20,6 +118,11 @@ config_names:
 > [here](https://github.com/duncanka/BECAUSE). We used the [UniCausal](https://github.com/tanfiona/UniCausal/tree/main/data/splits) reformatting of the data as the basis
 > for this repository. Please see the [citations](#citations) at the end of this README.
 
+## Dataset Description
+
+- **Repository:** https://github.com/duncanka/BECAUSE
+- **Paper:** [The BECauSE Corpus 2.0: Annotating Causality and Overlapping Relations](https://doi.org/10.18653/v1/W17-0812)
+
 # Usage
 ## Causality Detection
 ```py
@@ -56,7 +159,7 @@ The BECauSE v2.0 paper by [Dunietz et al., 2017](https://www.cs.cmu.edu/~jduniet
 }
 ```
 
-UniCausal by [Tan et al., 2023](https://link.springer.com/chapter/10.1007/978-3-031-39831-5_23) -- who's dataformat we used to make BECausE compatible with hf datasets:
+UniCausal by [Tan et al., 2023](https://link.springer.com/chapter/10.1007/978-3-031-39831-5_23) &mdash; who's dataformat we used to make BECausE compatible with hf datasets:
 ```bib
 @inproceedings{tan:2023,
   title = {{{UniCausal}}: {{Unified Benchmark}} and {{Repository}} for {{Causal Text Mining}}},

causal-candidate-extraction/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd820e1d8a340c9b3417593de5628bc713c9e97a55495508ac10e2d41cf52444
+size 5469

causal-candidate-extraction/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e069976da5d897facbd7636dfa6d2d57e262423e2e239fc49ae430227bc3f74
+size 59878

causality-detection/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f080a50b0a0a97472c2f65b6cb8d5d18ff1290f98a2f47076edfce4c924a4f42
+size 5304

causality-detection/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31bb185248965b2b559e92316cd439f5a818b0768b28c5a66a1a0a37826498e0
+size 51859

causality-identification/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f88248bbd785127271e4315af735f320cbc6a85533dfee93e809656497dcfd21
+size 6390

causality-identification/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8407c49547a94cd3e30fd2e611069a3ace78c74f285a17676cb4ff38bcc1bd3b
+size 59625

conversion_script.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+
+"""
+Run this script as ./conversion_script.py to convert the UniCausal BECauSE files to HF-compatible parquet files.
+"""
+
+# 1) Install dependencies:
+#    pip install pandas pyarrow
+# 2) Download these files:
+#  - https://raw.githubusercontent.com/tanfiona/UniCausal/refs/heads/main/data/grouped/splits/because_test.csv
+#  - https://raw.githubusercontent.com/tanfiona/UniCausal/refs/heads/main/data/grouped/splits/because_train.csv
+
+import ast
+from collections import defaultdict
+import re
+from typing import Literal, Union
+
+import pandas as pd
+
+
+Split = Literal["train", "dev", "test"]
+
+RelationCauseEffect: int = 1
+
+def __extract_entities_and_relations(row) -> tuple:
+    """
+    Converts ["<ARG0>Bla</Arg0> bla <ARG1>Bla</ARG1>", "Bla <ARG0>bla</ARG0> <ARG1>Bla</ARG1>"] to
+    ["Bla", " ", "bla", " ", "Bla"], [[1], [], [2], [], [3]], {relationship: 1, "first": 0, "second": 1}
+    """
+    text, withpairs = row["text"], row["causal_text_w_pairs"]
+    # Step 1: Remove all <SIG> tags
+    withpairs = [re.sub(r"<(/?)SIG(\d+)>", "", t) for t in withpairs]
+    # Step 2: Check that all texts are the same if we remove the ARG tags
+    without_tags = [re.sub(r"<(/?)ARG(\d+)>", "", t) for t in withpairs]
+    assert all(x == text for x in without_tags)  # All texts without tags must be equal to text
+    # Step 3: Iteratively update the tags
+    splits: list[str] = [text]
+    tags: list[list[int]] = [[]]
+    relations: list[tuple[int, int, int]] = []
+    def split_at_charidx(idx: int) -> int:
+        for i, s in enumerate(splits):
+            if idx < len(s):
+                if idx == 0: # We are already at the beginning of a str; no need to split
+                    return i
+                else: # Need to split
+                    # Concurrent editing an iterating the list; OK here since we return right after
+                    splits.insert(i+1, s[idx:])
+                    splits[i] = s[:idx]
+                    tags.insert(i+1, tags[i].copy())
+                    return i+1
+            idx -= len(s)
+        return len(splits)
+    def minify(tags: list[list[int]]) -> tuple[list[list[int]], dict[int, int]]:
+        """
+        Joins entities that denote the same spans.
+        Maps, e.g., [[0], [], [1, 2], [], [3], []] to [[0], [], [1], [], [2], []]
+        """
+        tag2pos = defaultdict(list) # Maps tags to the positions they occur in
+        for idx, lst in enumerate(tags):
+            for x in lst:
+                tag2pos[x].append(idx)
+        pos2tag = defaultdict(list)
+        for tag, pos in tag2pos.items():
+            pos2tag[tuple(pos)].append(tag)
+        newtags = [[] for _ in range(len(tags))]
+        tagmap: dict[int, int] = dict()
+        for i, (pos, tags) in enumerate(pos2tag.items()):
+            for t in tags:
+                tagmap[t] = i
+            for p in pos:
+                newtags[p].append(i)
+        return newtags, tagmap
+    nexttag: int = 0
+    for t in withpairs:
+        curtags: set[int] = set()
+        offset: int = 0
+        tagmap: dict[int, int] = dict()
+        for match in re.finditer(r"(.*?)<(/?)ARG(\d+)>", t):
+            # Put the text span from offset to offset+len(match[1]) into a new entity and set the entity label
+            # appropriately; should do nothing if the entity is already separated.
+            startidx = split_at_charidx(offset) # Will never split but we can use it to get the index
+            stopidx = split_at_charidx(offset + len(match[1]))
+            for i in range(startidx, stopidx):
+                tags[i].extend(curtags)
+            if match[2] == "":
+                if int(match[3]) not in tagmap:
+                    tagmap[int(match[3])] = nexttag
+                    nexttag += 1
+                curtags.add(tagmap[int(match[3])])
+            else:
+                curtags.remove(tagmap[int(match[3])])
+            offset += len(match[1])
+        # Each entry in withpairs contains exactly one cause (ARG0) and effect (ARG1)
+        relations.append((RelationCauseEffect, tagmap[0], tagmap[1]))
+    tags, tagmap = minify(tags)
+    for i in range(len(relations)):
+        relations[i] = (relations[i][0], tagmap[relations[i][1]], tagmap[relations[i][2]])
+    return (splits, tags, relations)
+
+def convert_for_causality_detection(split: Split) -> None:
+    df = pd.read_csv(f"because_{split}.csv", converters={"causal_text_w_pairs": lambda x: ast.literal_eval(x) if x else [] })
+    df["label"] = df["causal_text_w_pairs"].apply(lambda x: 0 if len(x) == 0 else 1)
+    df = df.set_index("index")
+    df = df[["label", "text"]]
+    df.to_parquet(f"./causality-detection/{split}.parquet", engine="pyarrow")
+
+def convert_for_causal_candidate_extraction(split: Split) -> None:
+    def map_list_to_tokens(row):
+        splits, tags, _ = __extract_entities_and_relations(row)
+        return pd.Series((splits, tags))
+    df = pd.read_csv(f"because_{split}.csv", converters={"causal_text_w_pairs": lambda x: ast.literal_eval(x) if x else [] })
+    df[["tokens", "entity"]] = df[["text", "causal_text_w_pairs"]].apply(map_list_to_tokens, axis=1)
+    df = df[["index", "tokens", "entity"]].set_index("index")
+    df.to_parquet(f"./causal-candidate-extraction/{split}.parquet", engine="pyarrow")
+
+def convert_for_causality_identification(split: Split) -> None:
+    def map_to_labels(row):
+        splits, tags, relations = __extract_entities_and_relations(row)
+        text: str = ""
+        cur_ents: set[int] = set()
+        for s, t in zip(splits, tags):
+            for newent in (set(t)-cur_ents):
+                text += f"<e{newent+1}>"
+            for oldent in (cur_ents-set(t)):
+                text += f"</e{oldent+1}>"
+            cur_ents = set(t)
+            text += s
+        reldict: list[dict[str, Union[int,  str]]] = []
+        for rtype, rfirst, rsecond in relations:
+            reldict.append({"relationship": rtype, "first": f"e{rfirst+1}", "second": f"e{rsecond+1}"})
+        return pd.Series((text, reldict))
+    df = pd.read_csv(f"because_{split}.csv", converters={"causal_text_w_pairs": lambda x: ast.literal_eval(x) if x else [] })
+    df[["text", "relations"]] = df[["text", "causal_text_w_pairs"]].apply(map_to_labels, axis=1)
+    df = df[["index", "text", "relations"]].set_index("index")
+    return df.to_parquet(f"./causality-identification/{split}.parquet", engine="pyarrow")
+
+convert_for_causality_detection("test")
+# convert_for_causality_detection("dev")
+convert_for_causality_detection("train")
+convert_for_causal_candidate_extraction("test")
+#convert_for_causal_candidate_extraction("dev")
+convert_for_causal_candidate_extraction("train")
+convert_for_causality_identification("test")
+#convert_for_causality_identification("dev")
+convert_for_causality_identification("train")