Using the new conversion script

README.md

@@ -18,8 +18,6 @@ configs:
   data_files:
   - split: train
     path: causality-detection/train.parquet
-  #- split: dev
-  #  path: causality-detection/dev.parquet
   - split: test
     path: causality-detection/test.parquet
   features:
@@ -37,8 +35,6 @@ configs:
   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:
@@ -53,8 +49,6 @@ configs:
   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:

causal-candidate-extraction/test.parquet

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

causal-candidate-extraction/train.parquet

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

conversion_script.py

@@ -5,141 +5,22 @@ Run this script as ./conversion_script.py to convert the UniCausal BECauSE files
 """
 
 # 1) Install dependencies:
-#    pip install pandas pyarrow
+#    pip install git+https://github.com/TheMrSheldon/causality-toolkit.git
 # 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
+from pathlib import Path
 
-import pandas as pd
+from ctk.data.constants import Task
+from ctk.data.conversion import UniCausal2HF
 
+converter = UniCausal2HF({"train": Path.cwd() / "because_train.csv",
+                         "test": Path.cwd() / "because_test.csv"}, Path.cwd())
 
-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")
+converter.convert(Task.CausalityDetection, "train")
+converter.convert(Task.CausalityDetection, "test")
+converter.convert(Task.CausalCandidateExtraction, "train")
+converter.convert(Task.CausalCandidateExtraction, "test")
+converter.convert(Task.CausalityIdentification, "train")
+converter.convert(Task.CausalityIdentification, "test")