upload hub_repos/cardiode/cardiode.py to hub from bigbio repo

cardiode.py

@@ -0,0 +1,300 @@
+# coding=utf-8
+# Copyright 2022 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# 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.
+
+import os
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import datasets
+import pandas as pd
+
+from .bigbiohub import BigBioConfig, Tasks, kb_features
+
+_LOCAL = True
+_CITATION = """\
+@data{
+    data/AFYQDY_2022,
+    author = {Christoph Dieterich},
+    publisher = {heiDATA},
+    title = {{CARDIO:DE}},
+    year = {2022},
+    version = {V5},
+    doi = {10.11588/data/AFYQDY},
+    url = {https://doi.org/10.11588/data/AFYQDY}
+}
+"""
+
+_DESCRIPTION = """\
+First freely available and distributable large German clinical corpus from the cardiovascular domain.
+"""
+
+_HOMEPAGE = "https://heidata.uni-heidelberg.de/dataset.xhtml?persistentId=doi%3A10.11588%2Fdata%2FAFYQDY"
+
+_LICENSE = "DUA"
+_LANGUAGES = ["German"]
+_URLS = {}
+_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_RECOGNITION]
+_SOURCE_VERSION = "5.0.0"
+_BIGBIO_VERSION = "1.0.0"
+_DATASETNAME = "cardiode"
+_DISPLAYNAME = "CARDIO:DE"
+_PUBMED = False
+
+
+class CardioDataset(datasets.GeneratorBasedBuilder):
+    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
+    BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION)
+
+    BUILDER_CONFIGS = [
+        BigBioConfig(
+            name="cardiode_source",
+            version=SOURCE_VERSION,
+            description="CARDIO:DE source schema",
+            schema="source",
+            subset_id="cardiode",
+        ),
+        BigBioConfig(
+            name="cardiode_bigbio_kb",
+            version=BIGBIO_VERSION,
+            description="CARDIO:DE BigBio schema",
+            schema="bigbio_kb",
+            subset_id="cardidoe",
+        ),
+    ]
+
+    DEFAULT_CONFIG_NAME = "cardiode_bigbio_kb"
+
+    def _info(self) -> datasets.DatasetInfo:
+        if self.config.schema == "source":
+            features = datasets.Features(
+                {
+                    "doc_id": datasets.Value("string"),
+                    "annotations": [
+                        {
+                            "text": datasets.Value("string"),
+                            "tokens": [
+                                {
+                                    "id": datasets.Value("string"),
+                                    "offsets": datasets.Value("string"),
+                                    "text": datasets.Value("string"),
+                                    "type": datasets.Value("string"),
+                                    "parent_annotation_id": datasets.Value("string"),
+                                    "section": datasets.Value("string"),
+                                }
+                            ],
+                        }
+                    ],
+                }
+            )
+
+        elif self.config.schema == "bigbio_kb":
+            features = kb_features
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager) -> List[datasets.SplitGenerator]:
+        if self.config.data_dir is None:
+            raise ValueError("This is a local dataset. Please pass the data_dir kwarg to load_dataset.")
+        else:
+            data_dir = self.config.data_dir
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "filepath": os.path.join(data_dir),
+                    "split": "train",
+                },
+            )
+        ]
+
+    def _generate_examples(self, filepath, split: str) -> Tuple[int, Dict]:
+        """Yields examples as (key, example) tuples."""
+        doc_ids = _sort_files(Path(filepath) / "tsv" / "CARDIODE400_main")
+        for uid, doc in enumerate(doc_ids):
+            tsv_path = Path(filepath) / "tsv" / "CARDIODE400_main" / f"{doc}"
+            df, sentences = _parse_tsv(tsv_path)
+            if self.config.schema == "source":
+                yield uid, _make_source(uid, doc, df, sentences)
+            elif self.config.schema == "bigbio_kb":
+                yield uid, _make_bigbio_kb(uid, doc, df, sentences)
+
+
+def _parse_tsv(path: str) -> pd.DataFrame:
+    # read whole .tsv as a string
+    with open(path, encoding="utf-8") as file:
+        content = file.read()
+
+    # separate doc into sentences
+    passages = content.split("#")
+
+    # remove the first line (un-tabbed) of each sentence
+    # split sentences into words/tokens
+    # and store string sentences for the passages
+    sentences = []
+    for i, passage in enumerate(passages):
+        if passage.split("\n")[0].startswith("Text="):
+            sentences.append(passage.split("\n")[0].split("Text=")[1])
+        passages[i] = passage.split("\n")[1:]
+
+    # clean empty sentences and tokens
+    clean_passages = [[token for token in passage if token != ""] for passage in passages if passage != []]
+
+    # make a dataframe out of the clean tokens
+    df = []
+    for passage in clean_passages:
+        for token in passage:
+            df.append(token.split("\t"))
+
+    df = pd.DataFrame(df).rename(
+        columns={
+            0: "passage_token_id",
+            1: "token_offset",
+            2: "text",
+            3: "label",
+            4: "uncertain",
+            5: "relation",
+            6: "section",
+        }
+    )
+
+    # correct weird rows were label is NoneType
+    df["label"].fillna("_", inplace=True)
+
+    # split passage and token ids
+    df[["passage_id", "token_id"]] = df["passage_token_id"].str.split("-", expand=True)
+
+    # split labels and their spans
+    # some docs do not have labels spanning various tokens (or they do not have any labels at all)
+    if df["label"].apply(lambda x: "[" in x).any():
+        df[["lab", "span"]] = df["label"].str.split("[", expand=True)
+        df["span"] = df["span"].str.replace("]", "", regex=True)
+    else:
+        df["lab"] = "_"
+        df["span"] = None
+
+    # split start and end offsets and cast to int
+    df[["offset_start", "offset_end"]] = df["token_offset"].str.split("-", expand=True)
+    df["offset_start"] = df["offset_start"].astype(int)
+    df["offset_end"] = df["offset_end"].astype(int)
+
+    # correct offset gaps between tokens
+    i = 0
+    while i < len(df) - 1:
+        gap = df.loc[i + 1]["offset_start"] - df.loc[i]["offset_end"]
+        if gap > 1:
+            df.loc[i + 1 :, "offset_start"] = df.loc[i + 1 :, "offset_start"] - (gap - 1)
+            df.loc[i + 1 :, "offset_end"] = df.loc[i + 1 :, "offset_end"] - (gap - 1)
+        i += 1
+
+    return df, sentences
+
+
+def _make_source(uid: int, doc_id: str, df: pd.DataFrame, sentences: list):
+    out = {"doc_id": doc_id, "annotations": []}
+    for i, sentence in enumerate(sentences):
+        anno = {"text": sentence, "tokens": []}
+        chunk = df[df["passage_id"] == str(i + 1)]
+        for _, row in chunk.iterrows():
+            anno["tokens"].append(
+                {
+                    "id": row["passage_token_id"],
+                    "offsets": row["token_offset"],
+                    "text": row["text"],
+                    "type": row["label"],
+                    "parent_annotation_id": row["relation"],
+                    "section": row["section"],
+                }
+            )
+        out["annotations"].append(anno)
+    return out
+
+
+def _make_bigbio_kb(uid: int, doc_id: str, df: pd.DataFrame, sentences: list):
+    out = {
+        "id": str(uid),
+        "document_id": doc_id,
+        "passages": [],
+        "entities": [],
+        "events": [],
+        "coreferences": [],
+        "relations": [],
+    }
+
+    # handle passages
+    i, sen_num, offset_mark = 0, 0, 0
+    while i < len(df):
+        pid = df.iloc[i]["passage_id"]
+        passage = df[df["passage_id"] == pid]
+
+        out["passages"].append(
+            {
+                "id": f"{uid}-{pid}",
+                "type": "sentence",
+                "text": [sentences[sen_num]],
+                "offsets": [[offset_mark, offset_mark + len(sentences[sen_num])]],
+            }
+        )
+
+        i += len(passage)
+        offset_mark += len(sentences[sen_num]) + 1
+        sen_num += 1
+
+    # handle entities
+    text = " ".join(sentences)
+    i = 0
+    while i < len(df):
+        if df.iloc[i]["lab"] != "_" and df.iloc[i]["span"] is None:
+            out["entities"].append(
+                {
+                    "id": f'{uid}-{df.iloc[i]["passage_token_id"]}',
+                    "type": df.iloc[i]["lab"],
+                    "text": [text[df.iloc[i]["offset_start"] : df.iloc[i]["offset_end"]]],
+                    "offsets": [[df.iloc[i]["offset_start"], df.iloc[i]["offset_end"]]],
+                    "normalized": [],
+                }
+            )
+            i += 1
+        elif df.iloc[i]["span"] is not None:
+            ent = df[df["span"] == df.iloc[i]["span"]]
+            out["entities"].append(
+                {
+                    "id": f'{uid}-{df.iloc[i]["passage_token_id"]}',
+                    "type": df.iloc[i]["lab"],
+                    "text": [text[ent.iloc[0]["offset_start"] : ent.iloc[-1]["offset_end"]]],
+                    "offsets": [[ent.iloc[0]["offset_start"], ent.iloc[-1]["offset_end"]]],
+                    "normalized": [],
+                }
+            )
+            i += len(ent)
+        else:
+            i += 1
+
+    return out
+
+
+def _sort_files(filepath):
+    doc_ids = os.listdir(filepath)
+    doc_ids = [int(doc_ids[i].split(".")[0]) for i in range(len(doc_ids))]
+    doc_ids = sorted(doc_ids)
+    doc_ids = [f"{doc_ids[i]}.tsv" for i in range(len(doc_ids))]
+    return doc_ids
+