Convert dataset to Parquet (#4)

- Convert dataset to Parquet (29180d9025a08ff69fd08a4fcdddb5b079c740a1)
- Add 'chemprot_shared_task_eval_source' config data files (c5057eca651c41d17959613cb15620a1417ddcde)
- Add 'chemprot_bigbio_kb' config data files (53e5a3d7a9cc2ebe56d982a4c10116c6e7df39a1)
- Delete loading script auxiliary file (2495bdeac0c2f93da48952892d06147dad9ce2b3)
- Delete loading script (3c448eb0fb55220ab2e804c0e681050175ad7a53)
- Delete data file (fe210651ce27c52293682501bcc0423e8dd03143)

README.md

@@ -1,19 +1,219 @@
-
 ---
-language: 
+language:
 - en
-bigbio_language: 
+bigbio_language:
 - English
 license: other
 multilinguality: monolingual
 bigbio_license_shortname: PUBLIC_DOMAIN_MARK_1p0
 pretty_name: ChemProt
 homepage: https://biocreative.bioinformatics.udel.edu/tasks/biocreative-vi/track-5/
-bigbio_pubmed: True
-bigbio_public: True
-bigbio_tasks: 
+bigbio_pubmed: true
+bigbio_public: true
+bigbio_tasks:
 - RELATION_EXTRACTION
 - NAMED_ENTITY_RECOGNITION
+dataset_info:
+- config_name: chemprot_bigbio_kb
+  features:
+  - name: id
+    dtype: string
+  - name: document_id
+    dtype: string
+  - name: passages
+    list:
+    - name: id
+      dtype: string
+    - name: type
+      dtype: string
+    - name: text
+      sequence: string
+    - name: offsets
+      sequence:
+        list: int32
+  - name: entities
+    list:
+    - name: id
+      dtype: string
+    - name: type
+      dtype: string
+    - name: text
+      sequence: string
+    - name: offsets
+      sequence:
+        list: int32
+    - name: normalized
+      list:
+      - name: db_name
+        dtype: string
+      - name: db_id
+        dtype: string
+  - name: events
+    list:
+    - name: id
+      dtype: string
+    - name: type
+      dtype: string
+    - name: trigger
+      struct:
+      - name: text
+        sequence: string
+      - name: offsets
+        sequence:
+          list: int32
+    - name: arguments
+      list:
+      - name: role
+        dtype: string
+      - name: ref_id
+        dtype: string
+  - name: coreferences
+    list:
+    - name: id
+      dtype: string
+    - name: entity_ids
+      sequence: string
+  - name: relations
+    list:
+    - name: id
+      dtype: string
+    - name: type
+      dtype: string
+    - name: arg1_id
+      dtype: string
+    - name: arg2_id
+      dtype: string
+    - name: normalized
+      list:
+      - name: db_name
+        dtype: string
+      - name: db_id
+        dtype: string
+  splits:
+  - name: sample
+    num_bytes: 174378
+    num_examples: 50
+  - name: train
+    num_bytes: 3509825
+    num_examples: 1020
+  - name: test
+    num_bytes: 2838045
+    num_examples: 800
+  - name: validation
+    num_bytes: 2098255
+    num_examples: 612
+  download_size: 3644874
+  dataset_size: 8620503
+- config_name: chemprot_full_source
+  features:
+  - name: pmid
+    dtype: string
+  - name: text
+    dtype: string
+  - name: entities
+    sequence:
+    - name: id
+      dtype: string
+    - name: type
+      dtype: string
+    - name: text
+      dtype: string
+    - name: offsets
+      sequence: int64
+  - name: relations
+    sequence:
+    - name: type
+      dtype: string
+    - name: arg1
+      dtype: string
+    - name: arg2
+      dtype: string
+  splits:
+  - name: sample
+    num_bytes: 159878
+    num_examples: 50
+  - name: train
+    num_bytes: 3161241
+    num_examples: 1020
+  - name: test
+    num_bytes: 2550891
+    num_examples: 800
+  - name: validation
+    num_bytes: 1902042
+    num_examples: 612
+  download_size: 2938603
+  dataset_size: 7774052
+- config_name: chemprot_shared_task_eval_source
+  features:
+  - name: pmid
+    dtype: string
+  - name: text
+    dtype: string
+  - name: entities
+    sequence:
+    - name: id
+      dtype: string
+    - name: type
+      dtype: string
+    - name: text
+      dtype: string
+    - name: offsets
+      sequence: int64
+  - name: relations
+    sequence:
+    - name: type
+      dtype: string
+    - name: arg1
+      dtype: string
+    - name: arg2
+      dtype: string
+  splits:
+  - name: sample
+    num_bytes: 157609
+    num_examples: 50
+  - name: train
+    num_bytes: 3109953
+    num_examples: 1020
+  - name: test
+    num_bytes: 2499388
+    num_examples: 800
+  - name: validation
+    num_bytes: 1876378
+    num_examples: 612
+  download_size: 2924370
+  dataset_size: 7643328
+configs:
+- config_name: chemprot_bigbio_kb
+  data_files:
+  - split: sample
+    path: chemprot_bigbio_kb/sample-*
+  - split: train
+    path: chemprot_bigbio_kb/train-*
+  - split: test
+    path: chemprot_bigbio_kb/test-*
+  - split: validation
+    path: chemprot_bigbio_kb/validation-*
+- config_name: chemprot_full_source
+  data_files:
+  - split: sample
+    path: chemprot_full_source/sample-*
+  - split: train
+    path: chemprot_full_source/train-*
+  - split: test
+    path: chemprot_full_source/test-*
+  - split: validation
+    path: chemprot_full_source/validation-*
+  default: true
+- config_name: chemprot_shared_task_eval_source
+  data_files:
+  - split: sample
+    path: chemprot_shared_task_eval_source/sample-*
+  - split: train
+    path: chemprot_shared_task_eval_source/train-*
+  - split: test
+    path: chemprot_shared_task_eval_source/test-*
+  - split: validation
+    path: chemprot_shared_task_eval_source/validation-*
 ---
 
 

bigbiohub.py

@@ -1,592 +0,0 @@
-from collections import defaultdict
-from dataclasses import dataclass
-from enum import Enum
-import logging
-from pathlib import Path
-from types import SimpleNamespace
-from typing import TYPE_CHECKING, Dict, Iterable, List, Tuple
-
-import datasets
-
-if TYPE_CHECKING:
-    import bioc
-
-logger = logging.getLogger(__name__)
-
-
-BigBioValues = SimpleNamespace(NULL="<BB_NULL_STR>")
-
-
-@dataclass
-class BigBioConfig(datasets.BuilderConfig):
-    """BuilderConfig for BigBio."""
-
-    name: str = None
-    version: datasets.Version = None
-    description: str = None
-    schema: str = None
-    subset_id: str = None
-
-
-class Tasks(Enum):
-    NAMED_ENTITY_RECOGNITION = "NER"
-    NAMED_ENTITY_DISAMBIGUATION = "NED"
-    EVENT_EXTRACTION = "EE"
-    RELATION_EXTRACTION = "RE"
-    COREFERENCE_RESOLUTION = "COREF"
-    QUESTION_ANSWERING = "QA"
-    TEXTUAL_ENTAILMENT = "TE"
-    SEMANTIC_SIMILARITY = "STS"
-    TEXT_PAIRS_CLASSIFICATION = "TXT2CLASS"
-    PARAPHRASING = "PARA"
-    TRANSLATION = "TRANSL"
-    SUMMARIZATION = "SUM"
-    TEXT_CLASSIFICATION = "TXTCLASS"
-
-
-entailment_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "premise": datasets.Value("string"),
-        "hypothesis": datasets.Value("string"),
-        "label": datasets.Value("string"),
-    }
-)
-
-pairs_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "text_1": datasets.Value("string"),
-        "text_2": datasets.Value("string"),
-        "label": datasets.Value("string"),
-    }
-)
-
-qa_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "question_id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "question": datasets.Value("string"),
-        "type": datasets.Value("string"),
-        "choices": [datasets.Value("string")],
-        "context": datasets.Value("string"),
-        "answer": datasets.Sequence(datasets.Value("string")),
-    }
-)
-
-text_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "text": datasets.Value("string"),
-        "labels": [datasets.Value("string")],
-    }
-)
-
-text2text_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "text_1": datasets.Value("string"),
-        "text_2": datasets.Value("string"),
-        "text_1_name": datasets.Value("string"),
-        "text_2_name": datasets.Value("string"),
-    }
-)
-
-kb_features = datasets.Features(
-    {
-        "id": datasets.Value("string"),
-        "document_id": datasets.Value("string"),
-        "passages": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                "text": datasets.Sequence(datasets.Value("string")),
-                "offsets": datasets.Sequence([datasets.Value("int32")]),
-            }
-        ],
-        "entities": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                "text": datasets.Sequence(datasets.Value("string")),
-                "offsets": datasets.Sequence([datasets.Value("int32")]),
-                "normalized": [
-                    {
-                        "db_name": datasets.Value("string"),
-                        "db_id": datasets.Value("string"),
-                    }
-                ],
-            }
-        ],
-        "events": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                # refers to the text_bound_annotation of the trigger
-                "trigger": {
-                    "text": datasets.Sequence(datasets.Value("string")),
-                    "offsets": datasets.Sequence([datasets.Value("int32")]),
-                },
-                "arguments": [
-                    {
-                        "role": datasets.Value("string"),
-                        "ref_id": datasets.Value("string"),
-                    }
-                ],
-            }
-        ],
-        "coreferences": [
-            {
-                "id": datasets.Value("string"),
-                "entity_ids": datasets.Sequence(datasets.Value("string")),
-            }
-        ],
-        "relations": [
-            {
-                "id": datasets.Value("string"),
-                "type": datasets.Value("string"),
-                "arg1_id": datasets.Value("string"),
-                "arg2_id": datasets.Value("string"),
-                "normalized": [
-                    {
-                        "db_name": datasets.Value("string"),
-                        "db_id": datasets.Value("string"),
-                    }
-                ],
-            }
-        ],
-    }
-)
-
-
-TASK_TO_SCHEMA = {
-    Tasks.NAMED_ENTITY_RECOGNITION.name: "KB",
-    Tasks.NAMED_ENTITY_DISAMBIGUATION.name: "KB",
-    Tasks.EVENT_EXTRACTION.name: "KB",
-    Tasks.RELATION_EXTRACTION.name: "KB",
-    Tasks.COREFERENCE_RESOLUTION.name: "KB",
-    Tasks.QUESTION_ANSWERING.name: "QA",
-    Tasks.TEXTUAL_ENTAILMENT.name: "TE",
-    Tasks.SEMANTIC_SIMILARITY.name: "PAIRS",
-    Tasks.TEXT_PAIRS_CLASSIFICATION.name: "PAIRS",
-    Tasks.PARAPHRASING.name: "T2T",
-    Tasks.TRANSLATION.name: "T2T",
-    Tasks.SUMMARIZATION.name: "T2T",
-    Tasks.TEXT_CLASSIFICATION.name: "TEXT",
-}
-
-SCHEMA_TO_TASKS = defaultdict(set)
-for task, schema in TASK_TO_SCHEMA.items():
-    SCHEMA_TO_TASKS[schema].add(task)
-SCHEMA_TO_TASKS = dict(SCHEMA_TO_TASKS)
-
-VALID_TASKS = set(TASK_TO_SCHEMA.keys())
-VALID_SCHEMAS = set(TASK_TO_SCHEMA.values())
-
-SCHEMA_TO_FEATURES = {
-    "KB": kb_features,
-    "QA": qa_features,
-    "TE": entailment_features,
-    "T2T": text2text_features,
-    "TEXT": text_features,
-    "PAIRS": pairs_features,
-}
-
-
-def get_texts_and_offsets_from_bioc_ann(ann: "bioc.BioCAnnotation") -> Tuple:
-
-    offsets = [(loc.offset, loc.offset + loc.length) for loc in ann.locations]
-
-    text = ann.text
-
-    if len(offsets) > 1:
-        i = 0
-        texts = []
-        for start, end in offsets:
-            chunk_len = end - start
-            texts.append(text[i : chunk_len + i])
-            i += chunk_len
-            while i < len(text) and text[i] == " ":
-                i += 1
-    else:
-        texts = [text]
-
-    return offsets, texts
-
-
-def remove_prefix(a: str, prefix: str) -> str:
-    if a.startswith(prefix):
-        a = a[len(prefix) :]
-    return a
-
-
-def parse_brat_file(
-    txt_file: Path,
-    annotation_file_suffixes: List[str] = None,
-    parse_notes: bool = False,
-) -> Dict:
-    """
-    Parse a brat file into the schema defined below.
-    `txt_file` should be the path to the brat '.txt' file you want to parse, e.g. 'data/1234.txt'
-    Assumes that the annotations are contained in one or more of the corresponding '.a1', '.a2' or '.ann' files,
-    e.g. 'data/1234.ann' or 'data/1234.a1' and 'data/1234.a2'.
-    Will include annotator notes, when `parse_notes == True`.
-    brat_features = datasets.Features(
-        {
-            "id": datasets.Value("string"),
-            "document_id": datasets.Value("string"),
-            "text": datasets.Value("string"),
-            "text_bound_annotations": [  # T line in brat, e.g. type or event trigger
-                {
-                    "offsets": datasets.Sequence([datasets.Value("int32")]),
-                    "text": datasets.Sequence(datasets.Value("string")),
-                    "type": datasets.Value("string"),
-                    "id": datasets.Value("string"),
-                }
-            ],
-            "events": [  # E line in brat
-                {
-                    "trigger": datasets.Value(
-                        "string"
-                    ),  # refers to the text_bound_annotation of the trigger,
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "arguments": datasets.Sequence(
-                        {
-                            "role": datasets.Value("string"),
-                            "ref_id": datasets.Value("string"),
-                        }
-                    ),
-                }
-            ],
-            "relations": [  # R line in brat
-                {
-                    "id": datasets.Value("string"),
-                    "head": {
-                        "ref_id": datasets.Value("string"),
-                        "role": datasets.Value("string"),
-                    },
-                    "tail": {
-                        "ref_id": datasets.Value("string"),
-                        "role": datasets.Value("string"),
-                    },
-                    "type": datasets.Value("string"),
-                }
-            ],
-            "equivalences": [  # Equiv line in brat
-                {
-                    "id": datasets.Value("string"),
-                    "ref_ids": datasets.Sequence(datasets.Value("string")),
-                }
-            ],
-            "attributes": [  # M or A lines in brat
-                {
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "ref_id": datasets.Value("string"),
-                    "value": datasets.Value("string"),
-                }
-            ],
-            "normalizations": [  # N lines in brat
-                {
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "ref_id": datasets.Value("string"),
-                    "resource_name": datasets.Value(
-                        "string"
-                    ),  # Name of the resource, e.g. "Wikipedia"
-                    "cuid": datasets.Value(
-                        "string"
-                    ),  # ID in the resource, e.g. 534366
-                    "text": datasets.Value(
-                        "string"
-                    ),  # Human readable description/name of the entity, e.g. "Barack Obama"
-                }
-            ],
-            ### OPTIONAL: Only included when `parse_notes == True`
-            "notes": [  # # lines in brat
-                {
-                    "id": datasets.Value("string"),
-                    "type": datasets.Value("string"),
-                    "ref_id": datasets.Value("string"),
-                    "text": datasets.Value("string"),
-                }
-            ],
-        },
-        )
-    """
-
-    example = {}
-    example["document_id"] = txt_file.with_suffix("").name
-    with txt_file.open() as f:
-        example["text"] = f.read()
-
-    # If no specific suffixes of the to-be-read annotation files are given - take standard suffixes
-    # for event extraction
-    if annotation_file_suffixes is None:
-        annotation_file_suffixes = [".a1", ".a2", ".ann"]
-
-    if len(annotation_file_suffixes) == 0:
-        raise AssertionError(
-            "At least one suffix for the to-be-read annotation files should be given!"
-        )
-
-    ann_lines = []
-    for suffix in annotation_file_suffixes:
-        annotation_file = txt_file.with_suffix(suffix)
-        try:
-            with annotation_file.open() as f:
-                ann_lines.extend(f.readlines())
-        except Exception:
-            continue
-
-    example["text_bound_annotations"] = []
-    example["events"] = []
-    example["relations"] = []
-    example["equivalences"] = []
-    example["attributes"] = []
-    example["normalizations"] = []
-
-    if parse_notes:
-        example["notes"] = []
-
-    for line in ann_lines:
-        line = line.strip()
-        if not line:
-            continue
-
-        if line.startswith("T"):  # Text bound
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["type"] = fields[1].split()[0]
-            ann["offsets"] = []
-            span_str = remove_prefix(fields[1], (ann["type"] + " "))
-            text = fields[2]
-            for span in span_str.split(";"):
-                start, end = span.split()
-                ann["offsets"].append([int(start), int(end)])
-
-            # Heuristically split text of discontiguous entities into chunks
-            ann["text"] = []
-            if len(ann["offsets"]) > 1:
-                i = 0
-                for start, end in ann["offsets"]:
-                    chunk_len = end - start
-                    ann["text"].append(text[i : chunk_len + i])
-                    i += chunk_len
-                    while i < len(text) and text[i] == " ":
-                        i += 1
-            else:
-                ann["text"] = [text]
-
-            example["text_bound_annotations"].append(ann)
-
-        elif line.startswith("E"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-
-            ann["type"], ann["trigger"] = fields[1].split()[0].split(":")
-
-            ann["arguments"] = []
-            for role_ref_id in fields[1].split()[1:]:
-                argument = {
-                    "role": (role_ref_id.split(":"))[0],
-                    "ref_id": (role_ref_id.split(":"))[1],
-                }
-                ann["arguments"].append(argument)
-
-            example["events"].append(ann)
-
-        elif line.startswith("R"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["type"] = fields[1].split()[0]
-
-            ann["head"] = {
-                "role": fields[1].split()[1].split(":")[0],
-                "ref_id": fields[1].split()[1].split(":")[1],
-            }
-            ann["tail"] = {
-                "role": fields[1].split()[2].split(":")[0],
-                "ref_id": fields[1].split()[2].split(":")[1],
-            }
-
-            example["relations"].append(ann)
-
-        # '*' seems to be the legacy way to mark equivalences,
-        # but I couldn't find any info on the current way
-        # this might have to be adapted dependent on the brat version
-        # of the annotation
-        elif line.startswith("*"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["ref_ids"] = fields[1].split()[1:]
-
-            example["equivalences"].append(ann)
-
-        elif line.startswith("A") or line.startswith("M"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-
-            info = fields[1].split()
-            ann["type"] = info[0]
-            ann["ref_id"] = info[1]
-
-            if len(info) > 2:
-                ann["value"] = info[2]
-            else:
-                ann["value"] = ""
-
-            example["attributes"].append(ann)
-
-        elif line.startswith("N"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["text"] = fields[2]
-
-            info = fields[1].split()
-
-            ann["type"] = info[0]
-            ann["ref_id"] = info[1]
-            ann["resource_name"] = info[2].split(":")[0]
-            ann["cuid"] = info[2].split(":")[1]
-            example["normalizations"].append(ann)
-
-        elif parse_notes and line.startswith("#"):
-            ann = {}
-            fields = line.split("\t")
-
-            ann["id"] = fields[0]
-            ann["text"] = fields[2] if len(fields) == 3 else BigBioValues.NULL
-
-            info = fields[1].split()
-
-            ann["type"] = info[0]
-            ann["ref_id"] = info[1]
-            example["notes"].append(ann)
-
-    return example
-
-
-def brat_parse_to_bigbio_kb(brat_parse: Dict) -> Dict:
-    """
-    Transform a brat parse (conforming to the standard brat schema) obtained with
-    `parse_brat_file` into a dictionary conforming to the `bigbio-kb` schema (as defined in ../schemas/kb.py)
-    :param brat_parse:
-    """
-
-    unified_example = {}
-
-    # Prefix all ids with document id to ensure global uniqueness,
-    # because brat ids are only unique within their document
-    id_prefix = brat_parse["document_id"] + "_"
-
-    # identical
-    unified_example["document_id"] = brat_parse["document_id"]
-    unified_example["passages"] = [
-        {
-            "id": id_prefix + "_text",
-            "type": "abstract",
-            "text": [brat_parse["text"]],
-            "offsets": [[0, len(brat_parse["text"])]],
-        }
-    ]
-
-    # get normalizations
-    ref_id_to_normalizations = defaultdict(list)
-    for normalization in brat_parse["normalizations"]:
-        ref_id_to_normalizations[normalization["ref_id"]].append(
-            {
-                "db_name": normalization["resource_name"],
-                "db_id": normalization["cuid"],
-            }
-        )
-
-    # separate entities and event triggers
-    unified_example["events"] = []
-    non_event_ann = brat_parse["text_bound_annotations"].copy()
-    for event in brat_parse["events"]:
-        event = event.copy()
-        event["id"] = id_prefix + event["id"]
-        trigger = next(
-            tr
-            for tr in brat_parse["text_bound_annotations"]
-            if tr["id"] == event["trigger"]
-        )
-        if trigger in non_event_ann:
-            non_event_ann.remove(trigger)
-        event["trigger"] = {
-            "text": trigger["text"].copy(),
-            "offsets": trigger["offsets"].copy(),
-        }
-        for argument in event["arguments"]:
-            argument["ref_id"] = id_prefix + argument["ref_id"]
-
-        unified_example["events"].append(event)
-
-    unified_example["entities"] = []
-    anno_ids = [ref_id["id"] for ref_id in non_event_ann]
-    for ann in non_event_ann:
-        entity_ann = ann.copy()
-        entity_ann["id"] = id_prefix + entity_ann["id"]
-        entity_ann["normalized"] = ref_id_to_normalizations[ann["id"]]
-        unified_example["entities"].append(entity_ann)
-
-    # massage relations
-    unified_example["relations"] = []
-    skipped_relations = set()
-    for ann in brat_parse["relations"]:
-        if (
-            ann["head"]["ref_id"] not in anno_ids
-            or ann["tail"]["ref_id"] not in anno_ids
-        ):
-            skipped_relations.add(ann["id"])
-            continue
-        unified_example["relations"].append(
-            {
-                "arg1_id": id_prefix + ann["head"]["ref_id"],
-                "arg2_id": id_prefix + ann["tail"]["ref_id"],
-                "id": id_prefix + ann["id"],
-                "type": ann["type"],
-                "normalized": [],
-            }
-        )
-    if len(skipped_relations) > 0:
-        example_id = brat_parse["document_id"]
-        logger.info(
-            f"Example:{example_id}: The `bigbio_kb` schema allows `relations` only between entities."
-            f" Skip (for now): "
-            f"{list(skipped_relations)}"
-        )
-
-    # get coreferences
-    unified_example["coreferences"] = []
-    for i, ann in enumerate(brat_parse["equivalences"], start=1):
-        is_entity_cluster = True
-        for ref_id in ann["ref_ids"]:
-            if not ref_id.startswith("T"):  # not textbound -> no entity
-                is_entity_cluster = False
-            elif ref_id not in anno_ids:  # event trigger -> no entity
-                is_entity_cluster = False
-        if is_entity_cluster:
-            entity_ids = [id_prefix + i for i in ann["ref_ids"]]
-            unified_example["coreferences"].append(
-                {"id": id_prefix + str(i), "entity_ids": entity_ids}
-            )
-    return unified_example

chemprot.py

@@ -1,446 +0,0 @@
-# coding=utf-8
-# Copyright 2020 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.
-"""
-The BioCreative VI Chemical-Protein interaction dataset identifies entities of
-chemicals and proteins and their likely relation to one other. Compounds are
-generally agonists (activators) or antagonists (inhibitors) of proteins. The
-script loads dataset in bigbio schema (using knowledgebase schema: schemas/kb)
-AND/OR source (default) schema
-"""
-import os
-from typing import Dict, Tuple
-
-import datasets
-
-from .bigbiohub import kb_features
-from .bigbiohub import BigBioConfig
-from .bigbiohub import Tasks
-
-_LANGUAGES = ['English']
-_PUBMED = True
-_LOCAL = False
-_CITATION = """\
-@article{DBLP:journals/biodb/LiSJSWLDMWL16,
-  author    = {Krallinger, M., Rabal, O., Lourenço, A.},
-  title     = {Overview of the BioCreative VI chemical-protein interaction Track},
-  journal   = {Proceedings of the BioCreative VI Workshop,},
-  volume    = {141-146},
-  year      = {2017},
-  url       = {https://biocreative.bioinformatics.udel.edu/tasks/biocreative-vi/track-5/},
-  doi       = {},
-  biburl    = {},
-  bibsource = {}
-}
-"""
-_DESCRIPTION = """\
-The BioCreative VI Chemical-Protein interaction dataset identifies entities of
-chemicals and proteins and their likely relation to one other. Compounds are
-generally agonists (activators) or antagonists (inhibitors) of proteins.
-"""
-
-_DATASETNAME = "chemprot"
-_DISPLAYNAME = "ChemProt"
-
-_HOMEPAGE = "https://biocreative.bioinformatics.udel.edu/tasks/biocreative-vi/track-5/"
-
-_LICENSE = 'Public Domain Mark 1.0'
-
-_URLs = {
-    "source": "https://huggingface.co/datasets/bigbio/chemprot/resolve/main/ChemProt_Corpus.zip",
-    "bigbio_kb": "https://huggingface.co/datasets/bigbio/chemprot/resolve/main/ChemProt_Corpus.zip",
-}
-
-_SUPPORTED_TASKS = [Tasks.RELATION_EXTRACTION, Tasks.NAMED_ENTITY_RECOGNITION]
-_SOURCE_VERSION = "1.0.0"
-_BIGBIO_VERSION = "1.0.0"
-
-
-# Chemprot specific variables
-# NOTE: There are 3 examples (2 in dev, 1 in training) with CPR:0
-_GROUP_LABELS = {
-    "CPR:0": "Undefined",
-    "CPR:1": "Part_of",
-    "CPR:2": "Regulator",
-    "CPR:3": "Upregulator",
-    "CPR:4": "Downregulator",
-    "CPR:5": "Agonist",
-    "CPR:6": "Antagonist",
-    "CPR:7": "Modulator",
-    "CPR:8": "Cofactor",
-    "CPR:9": "Substrate",
-    "CPR:10": "Not",
-}
-
-
-class ChemprotDataset(datasets.GeneratorBasedBuilder):
-    """BioCreative VI Chemical-Protein Interaction Task."""
-
-    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
-    BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION)
-
-    BUILDER_CONFIGS = [
-        BigBioConfig(
-            name="chemprot_full_source",
-            version=SOURCE_VERSION,
-            description="chemprot source schema",
-            schema="source",
-            subset_id="chemprot_full",
-        ),
-        BigBioConfig(
-            name="chemprot_shared_task_eval_source",
-            version=SOURCE_VERSION,
-            description="chemprot source schema with only the relation types that were used in the shared task evaluation",
-            schema="source",
-            subset_id="chemprot_shared_task_eval",
-        ),
-        BigBioConfig(
-            name="chemprot_bigbio_kb",
-            version=BIGBIO_VERSION,
-            description="chemprot BigBio schema",
-            schema="bigbio_kb",
-            subset_id="chemprot",
-        ),
-    ]
-
-    DEFAULT_CONFIG_NAME = "chemprot_full_source"
-
-    def _info(self):
-
-        if self.config.schema == "source":
-            features = datasets.Features(
-                {
-                    "pmid": datasets.Value("string"),
-                    "text": datasets.Value("string"),
-                    "entities": datasets.Sequence(
-                        {
-                            "id": datasets.Value("string"),
-                            "type": datasets.Value("string"),
-                            "text": datasets.Value("string"),
-                            "offsets": datasets.Sequence(datasets.Value("int64")),
-                        }
-                    ),
-                    "relations": datasets.Sequence(
-                        {
-                            "type": datasets.Value("string"),
-                            "arg1": datasets.Value("string"),
-                            "arg2": datasets.Value("string"),
-                        }
-                    ),
-                }
-            )
-
-        elif self.config.schema == "bigbio_kb":
-            features = kb_features
-
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            license=str(_LICENSE),
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
-        my_urls = _URLs[self.config.schema]
-        data_dir = dl_manager.download_and_extract(my_urls)
-
-        # Extract each of the individual folders
-        # NOTE: omitting "extract" call cause it uses a new folder
-        train_path = dl_manager.extract(
-            os.path.join(data_dir, "ChemProt_Corpus/chemprot_training.zip")
-        )
-        test_path = dl_manager.extract(
-            os.path.join(data_dir, "ChemProt_Corpus/chemprot_test_gs.zip")
-        )
-        dev_path = dl_manager.extract(
-            os.path.join(data_dir, "ChemProt_Corpus/chemprot_development.zip")
-        )
-        sample_path = dl_manager.extract(
-            os.path.join(data_dir, "ChemProt_Corpus/chemprot_sample.zip")
-        )
-
-        return [
-            datasets.SplitGenerator(
-                name="sample",  # should be a named split : /
-                gen_kwargs={
-                    "filepath": os.path.join(sample_path, "chemprot_sample"),
-                    "abstract_file": "chemprot_sample_abstracts.tsv",
-                    "entity_file": "chemprot_sample_entities.tsv",
-                    "relation_file": "chemprot_sample_relations.tsv",
-                    "gold_standard_file": "chemprot_sample_gold_standard.tsv",
-                    "split": "sample",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepath": os.path.join(train_path, "chemprot_training"),
-                    "abstract_file": "chemprot_training_abstracts.tsv",
-                    "entity_file": "chemprot_training_entities.tsv",
-                    "relation_file": "chemprot_training_relations.tsv",
-                    "gold_standard_file": "chemprot_training_gold_standard.tsv",
-                    "split": "train",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "filepath": os.path.join(test_path, "chemprot_test_gs"),
-                    "abstract_file": "chemprot_test_abstracts_gs.tsv",
-                    "entity_file": "chemprot_test_entities_gs.tsv",
-                    "relation_file": "chemprot_test_relations_gs.tsv",
-                    "gold_standard_file": "chemprot_test_gold_standard.tsv",
-                    "split": "test",
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={
-                    "filepath": os.path.join(dev_path, "chemprot_development"),
-                    "abstract_file": "chemprot_development_abstracts.tsv",
-                    "entity_file": "chemprot_development_entities.tsv",
-                    "relation_file": "chemprot_development_relations.tsv",
-                    "gold_standard_file": "chemprot_development_gold_standard.tsv",
-                    "split": "dev",
-                },
-            ),
-        ]
-
-    def _generate_examples(
-        self,
-        filepath,
-        abstract_file,
-        entity_file,
-        relation_file,
-        gold_standard_file,
-        split,
-    ):
-        """Yields examples as (key, example) tuples."""
-        if self.config.schema == "source":
-            abstracts = self._get_abstract(os.path.join(filepath, abstract_file))
-
-            entities, entity_id = self._get_entities(
-                os.path.join(filepath, entity_file)
-            )
-
-            if self.config.subset_id == "chemprot_full":
-                relations = self._get_relations(os.path.join(filepath, relation_file))
-            elif self.config.subset_id == "chemprot_shared_task_eval":
-                relations = self._get_relations_gs(
-                    os.path.join(filepath, gold_standard_file)
-                )
-            else:
-                raise ValueError(self.config)
-
-            for id_, pmid in enumerate(abstracts.keys()):
-                yield id_, {
-                    "pmid": pmid,
-                    "text": abstracts[pmid],
-                    "entities": entities[pmid],
-                    "relations": relations.get(pmid, []),
-                }
-
-        elif self.config.schema == "bigbio_kb":
-
-            abstracts = self._get_abstract(os.path.join(filepath, abstract_file))
-            entities, entity_id = self._get_entities(
-                os.path.join(filepath, entity_file)
-            )
-            relations = self._get_relations(
-                os.path.join(filepath, relation_file), is_mapped=True
-            )
-
-            uid = 0
-            for id_, pmid in enumerate(abstracts.keys()):
-                data = {
-                    "id": str(uid),
-                    "document_id": str(pmid),
-                    "passages": [],
-                    "entities": [],
-                    "relations": [],
-                    "events": [],
-                    "coreferences": [],
-                }
-                uid += 1
-
-                data["passages"] = [
-                    {
-                        "id": str(uid),
-                        "type": "title and abstract",
-                        "text": [abstracts[pmid]],
-                        "offsets": [[0, len(abstracts[pmid])]],
-                    }
-                ]
-                uid += 1
-
-                entity_to_id = {}
-                for entity in entities[pmid]:
-                    _text = entity["text"]
-                    entity.update({"text": [_text]})
-                    entity_to_id[entity["id"]] = str(uid)
-                    entity.update({"id": str(uid)})
-                    _offsets = entity["offsets"]
-                    entity.update({"offsets": [_offsets]})
-                    entity["normalized"] = []
-                    data["entities"].append(entity)
-                    uid += 1
-
-                for relation in relations.get(pmid, []):
-                    relation["arg1_id"] = entity_to_id[relation.pop("arg1")]
-                    relation["arg2_id"] = entity_to_id[relation.pop("arg2")]
-                    relation.update({"id": str(uid)})
-                    relation["normalized"] = []
-                    data["relations"].append(relation)
-                    uid += 1
-
-                yield id_, data
-
-    @staticmethod
-    def _get_abstract(abs_filename: str) -> Dict[str, str]:
-        """
-        For each document in PubMed ID (PMID) in the ChemProt abstract data file, return the abstract. Data is tab-separated.
-
-        :param filename: `*_abstracts.tsv from ChemProt
-
-        :returns Dictionary with PMID keys and abstract text as values.
-        """
-        with open(abs_filename, "r") as f:
-            contents = [i.strip() for i in f.readlines()]
-
-        # PMID is the first column, Abstract is last
-        return {
-            doc.split("\t")[0]: "\n".join(doc.split("\t")[1:]) for doc in contents
-        }  # Includes title as line 1
-
-    @staticmethod
-    def _get_entities(ents_filename: str) -> Tuple[Dict[str, str]]:
-        """
-        For each document in the corpus, return entity annotations per PMID.
-        Each column in the entity file is as follows:
-        (1) PMID
-        (2) Entity Number
-        (3) Entity Type (Chemical, Gene-Y, Gene-N)
-        (4) Start index
-        (5) End index
-        (6) Actual text of entity
-
-        :param ents_filename: `_*entities.tsv` file from ChemProt
-
-        :returns: Dictionary with PMID keys and entity annotations.
-        """
-        with open(ents_filename, "r") as f:
-            contents = [i.strip() for i in f.readlines()]
-
-        entities = {}
-        entity_id = {}
-
-        for line in contents:
-
-            pmid, idx, label, start_offset, end_offset, name = line.split("\t")
-
-            # Populate entity dictionary
-            if pmid not in entities:
-                entities[pmid] = []
-
-            ann = {
-                "offsets": [int(start_offset), int(end_offset)],
-                "text": name,
-                "type": label,
-                "id": idx,
-            }
-
-            entities[pmid].append(ann)
-
-            # Populate entity mapping
-            entity_id.update({idx: name})
-
-        return entities, entity_id
-
-    @staticmethod
-    def _get_relations(rel_filename: str, is_mapped: bool = False) -> Dict[str, str]:
-        """For each document in the ChemProt corpus, create an annotation for all relationships.
-
-        :param is_mapped: Whether to convert into NL the relation tags. Default is OFF
-        """
-        with open(rel_filename, "r") as f:
-            contents = [i.strip() for i in f.readlines()]
-
-        relations = {}
-
-        for line in contents:
-            pmid, label, _, _, arg1, arg2 = line.split("\t")
-            arg1 = arg1.split("Arg1:")[-1]
-            arg2 = arg2.split("Arg2:")[-1]
-
-            if pmid not in relations:
-                relations[pmid] = []
-
-            if is_mapped:
-                label = _GROUP_LABELS[label]
-
-            ann = {
-                "type": label,
-                "arg1": arg1,
-                "arg2": arg2,
-            }
-
-            relations[pmid].append(ann)
-
-        return relations
-
-    @staticmethod
-    def _get_relations_gs(rel_filename: str, is_mapped: bool = False) -> Dict[str, str]:
-        """
-        For each document in the ChemProt corpus, create an annotation for the gold-standard relationships.
-
-        The columns include:
-        (1) PMID
-        (2) Relationship Label (CPR)
-        (3) Used in shared task
-        (3) Interactor Argument 1 Entity Identifier
-        (4) Interactor Argument 2 Entity Identifier
-
-        Gold standard includes CPRs 3-9. Relationships are always Gene + Protein.
-        Unlike entities, there is no counter, hence once must be made
-
-        :param rel_filename: Gold standard file name
-        :param ent_dict: Entity Identifier to text
-        """
-        with open(rel_filename, "r") as f:
-            contents = [i.strip() for i in f.readlines()]
-
-        relations = {}
-
-        for line in contents:
-            pmid, label, arg1, arg2 = line.split("\t")
-            arg1 = arg1.split("Arg1:")[-1]
-            arg2 = arg2.split("Arg2:")[-1]
-
-            if pmid not in relations:
-                relations[pmid] = []
-
-            if is_mapped:
-                label = _GROUP_LABELS[label]
-
-            ann = {
-                "type": label,
-                "arg1": arg1,
-                "arg2": arg2,
-            }
-
-            relations[pmid].append(ann)
-
-        return relations

ChemProt_Corpus.zip → chemprot_bigbio_kb/sample-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:492e3d607f38e2727b799e9d60263b776ebd2a5e61cf0fb59bea2b3eb68e1c28
-size 4977337
+oid sha256:d9e6475f44050d56ad4bb9801c544d890fac6bdd2e2da2396b2bdfe6a4aedbb7
+size 97134

chemprot_bigbio_kb/test-00000-of-00001.parquet

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

chemprot_bigbio_kb/train-00000-of-00001.parquet

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

chemprot_bigbio_kb/validation-00000-of-00001.parquet

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

chemprot_full_source/sample-00000-of-00001.parquet

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

chemprot_full_source/test-00000-of-00001.parquet

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

chemprot_full_source/train-00000-of-00001.parquet

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

chemprot_full_source/validation-00000-of-00001.parquet

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

chemprot_shared_task_eval_source/sample-00000-of-00001.parquet

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

chemprot_shared_task_eval_source/test-00000-of-00001.parquet

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

chemprot_shared_task_eval_source/train-00000-of-00001.parquet

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

chemprot_shared_task_eval_source/validation-00000-of-00001.parquet

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