Hugging Face's logo

Datasets:
bigbio
/
cardiode

Languages:
ger
Multilinguality:
monolingual
License:
Dataset card Files Community
1
cardiode / cardiode.py
gabrielaltay's picture
gabrielaltay
upload hub_repos/cardiode/cardiode.py to hub from bigbio repo
85dad33
raw history blame contribute delete
No virus
10.1 kB
# 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("\n#")
# 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