upload hubscripts/nlm_wsd_hub.py to hub from bigbio repo

nlm_wsd.py

@@ -0,0 +1,362 @@
+# 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.
+
+"""
+In order to support research investigating the automatic resolution of word sense ambiguity using natural language
+processing techniques, we have constructed this test collection of medical text in which the ambiguities were resolved
+by hand. Evaluators were asked to examine instances of an ambiguous word and determine the sense intended by selecting
+the Metathesaurus concept (if any) that best represents the meaning of that sense. The test collection consists of 50
+highly frequent ambiguous UMLS concepts from 1998 MEDLINE. Each of the 50 ambiguous cases has 100 ambiguous instances
+randomly selected from the 1998 MEDLINE citations. For a total of 5,000 instances. We had a total of 11 evaluators of
+which 8 completed 100% of the 5,000 instances, 1 completed 56%, 1 completed 44%, and the final evaluator completed 12%
+of the instances. Evaluations were only used when the evaluators completed all 100 instances for a given ambiguity.
+
+Comment from author:
+BigBio schema fixes off by one error of end offset of entities. The source config remains unchanged.
+
+Instructions on how to load locally:
+1) Create directory
+2) Download one of the following annotation sets from https://lhncbc.nlm.nih.gov/restricted/ii/areas/WSD/index.html
+   and put it into the folder:
+   - Full Reviewed Set
+     https://lhncbc.nlm.nih.gov/restricted/ii/areas/WSD/downloads/full_reviewed_results.tar.gz
+     (Link "Full Reviewed Result Set (requires Common Files above)")
+     subset_id = nlm_wsd_reviewed
+   - Full Non-Reviewed Set
+     https://lhncbc.nlm.nih.gov/restricted/ii/areas/WSD/downloads/full_non_reviewed_results.tar.gz
+     (Link "Full Non-Reviewed Result Set (requires Common Files above)")
+     subset_id = nlm_wsd_non_reviewed
+3) Download https://lhncbc.nlm.nih.gov/restricted/ii/areas/WSD/downloads/UMLS1999.tar.gz (Link "1999 UMLS Data Files")
+   and put it into the folder
+4) Set kwarg data_dir of load_datasets to the path of the directory
+"""
+
+import itertools as it
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import datasets
+
+from .bigbiohub import kb_features
+from .bigbiohub import BigBioConfig
+from .bigbiohub import Tasks
+
+_LANGUAGES = ['English']
+_PUBMED = True
+_LOCAL = True
+_CITATION = """\
+@article{weeber2001developing,
+  title    = "Developing a test collection for biomedical word sense
+              disambiguation",
+  author   = "Weeber, M and Mork, J G and Aronson, A R",
+  journal  = "Proc AMIA Symp",
+  pages    = "746--750",
+  year     =  2001,
+  language = "en"
+}
+"""
+
+_DATASETNAME = "nlm_wsd"
+_DISPLAYNAME = "NLM WSD"
+
+_DESCRIPTION = """\
+In order to support research investigating the automatic resolution of word sense ambiguity using natural language
+processing techniques, we have constructed this test collection of medical text in which the ambiguities were resolved
+by hand. Evaluators were asked to examine instances of an ambiguous word and determine the sense intended by selecting
+the Metathesaurus concept (if any) that best represents the meaning of that sense. The test collection consists of 50
+highly frequent ambiguous UMLS concepts from 1998 MEDLINE. Each of the 50 ambiguous cases has 100 ambiguous instances
+randomly selected from the 1998 MEDLINE citations. For a total of 5,000 instances. We had a total of 11 evaluators of
+which 8 completed 100% of the 5,000 instances, 1 completed 56%, 1 completed 44%, and the final evaluator completed 12%
+of the instances. Evaluations were only used when the evaluators completed all 100 instances for a given ambiguity.
+"""
+
+_HOMEPAGE = "https://lhncbc.nlm.nih.gov/restricted/ii/areas/WSD/index.html"
+
+_LICENSE = 'UMLS - Metathesaurus License Agreement'
+
+_URLS = {
+    "UMLS": "UMLS1999.tar.gz",
+    "reviewed": "full_reviewed_results.tar.gz",
+    "non_reviewed": "full_non_reviewed_results.tar.gz",
+}
+
+_SUPPORTED_TASKS = [Tasks.NAMED_ENTITY_DISAMBIGUATION]
+
+_SOURCE_VERSION = "1.0.0"
+_BIGBIO_VERSION = "1.0.0"
+
+
+@dataclass
+class NlmWsdBigBioConfig(BigBioConfig):
+    schema: str = "source"
+    name: str = "nlm_wsd_reviewed_source"
+    version: datasets.Version = datasets.Version(_SOURCE_VERSION)
+    description: str = "NLM-WSD basic reviewed source schema"
+    subset_id: str = "nlm_wsd_reviewed"
+
+
+class NlmWsdDataset(datasets.GeneratorBasedBuilder):
+    """Biomedical Word Sense Disambiguation (WSD)."""
+
+    uid = it.count(0)
+
+    SOURCE_VERSION = datasets.Version(_SOURCE_VERSION)
+    BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION)
+
+    BUILDER_CONFIGS = [
+        NlmWsdBigBioConfig(
+            name="nlm_wsd_non_reviewed_source",
+            version=SOURCE_VERSION,
+            description="NLM-WSD basic non reviewed source schema",
+            schema="source",
+            subset_id="nlm_wsd_non_reviewed",
+        ),
+        NlmWsdBigBioConfig(
+            name="nlm_wsd_non_reviewed_bigbio_kb",
+            version=BIGBIO_VERSION,
+            description="NLM-WSD basic non reviewed BigBio schema",
+            schema="bigbio_kb",
+            subset_id="nlm_wsd_non_reviewed",
+        ),
+        NlmWsdBigBioConfig(
+            name="nlm_wsd_reviewed_source",
+            version=SOURCE_VERSION,
+            description="NLM-WSD basic reviewed source schema",
+            schema="source",
+            subset_id="nlm_wsd_reviewed",
+        ),
+        NlmWsdBigBioConfig(
+            name="nlm_wsd_reviewed_bigbio_kb",
+            version=BIGBIO_VERSION,
+            description="NLM-WSD basic reviewed BigBio schema",
+            schema="bigbio_kb",
+            subset_id="nlm_wsd_reviewed",
+        ),
+    ]
+
+    BUILDER_CONFIG_CLASS = NlmWsdBigBioConfig
+
+    def _info(self) -> datasets.DatasetInfo:
+        if self.config.schema == "source":
+            features = datasets.Features(
+                {
+                    "id": datasets.Value("string"),
+                    "sentence_id": datasets.Value("string"),
+                    "label": datasets.Value("string"),
+                    "sentence": {
+                        "text": datasets.Value("string"),
+                        "ambiguous_word": datasets.Value("string"),
+                        "ambiguous_word_alias": datasets.Value("string"),
+                        "offsets_context": datasets.Sequence(datasets.Value("int32")),
+                        "offsets_ambiguity": datasets.Sequence(datasets.Value("int32")),
+                        "context": datasets.Value("string"),
+                    },
+                    "citation": {
+                        "text": datasets.Value("string"),
+                        "ambiguous_word": datasets.Value("string"),
+                        "ambiguous_word_alias": datasets.Value("string"),
+                        "offsets_context": datasets.Sequence(datasets.Value("int32")),
+                        "offsets_ambiguity": datasets.Sequence(datasets.Value("int32")),
+                        "context": datasets.Value("string"),
+                    },
+                    "choices": [
+                        {
+                            "label": datasets.Value("string"),
+                            "concept": datasets.Value("string"),
+                            "cui": datasets.Value("string"),
+                            "type": [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) -> List[datasets.SplitGenerator]:
+        """Returns SplitGenerators."""
+
+        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 = Path(self.config.data_dir)
+            umls_dir = dl_manager.download_and_extract(data_dir / _URLS["UMLS"])
+            mrcon_path = Path(umls_dir) / "META" / "MRCON"
+            if self.config.subset_id == "nlm_wsd_reviewed":
+                ann_dir = dl_manager.download_and_extract(data_dir / _URLS["reviewed"])
+                ann_dir = Path(ann_dir) / "Reviewed_Results"
+            else:
+                ann_dir = dl_manager.download_and_extract(
+                    data_dir / _URLS["non_reviewed"]
+                )
+                ann_dir = Path(ann_dir) / "Non-Reviewed_Results"
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "mrcon_path": mrcon_path,
+                    "ann_dir": ann_dir,
+                },
+            )
+        ]
+
+    def _generate_examples(self, mrcon_path: Path, ann_dir: Path) -> Tuple[int, Dict]:
+        """Yields examples as (key, example) tuples."""
+
+        # read label->cui map
+        umls_map = {}
+        with mrcon_path.open() as f:
+            content = f.readlines()
+        content = [x.strip() for x in content]
+        for line in content:
+            fields = line.split("|")
+            assert len(fields) == 9, f"{len(fields)}"
+            assert fields[0][0] == "C"
+            umls_map[fields[6]] = fields[0]
+
+        for dir in ann_dir.iterdir():
+            if self.config.schema == "source" and dir.is_dir():
+                for example in self._generate_parsed_documents(dir, umls_map):
+                    yield next(self.uid), example
+
+            elif self.config.schema == "bigbio_kb" and dir.is_dir():
+                for example in self._generate_parsed_documents(dir, umls_map):
+                    yield next(self.uid), self._source_to_kb(example)
+
+    def _generate_parsed_documents(self, dir, umls_map):
+
+        # read choices
+        choices = []
+        choices_path = dir / "choices"
+        with choices_path.open() as f:
+            content = f.readlines()
+        content = [x.strip() for x in content]
+        for line in content:
+            label, concept, *type = line.split("|")
+            type = [x.split(", ")[1] for x in type]
+            m = re.search(r"(?<=\().+(?=\))", concept)
+            if m is None:
+                choices.append(
+                    {"label": label, "concept": concept, "type": type, "cui": ""}
+                )
+            else:
+                concept = m.group()
+                choices.append(
+                    {
+                        "label": label,
+                        "concept": concept,
+                        "type": type,
+                        "cui": umls_map[concept],
+                    }
+                )
+
+        file_path = dir / f"{dir.name}_set"
+        with file_path.open() as f:
+            for raw_document in self._generate_raw_documents(f):
+                document = {}
+                id, document_id, label = raw_document[0].strip().split("|")
+
+                info_sentence = self._parse_ambig_pos_info(raw_document[2].strip())
+                info_sentence["text"] = raw_document[1]
+
+                info_citation = self._parse_ambig_pos_info(raw_document[-1].strip())
+                n_cit = len(raw_document) - 3
+                info_citation["text"] = "".join(raw_document[3 : 3 + n_cit])
+
+                document = {
+                    "id": id,
+                    "sentence_id": document_id,
+                    "label": label,
+                    "sentence": info_sentence,
+                    "citation": info_citation,
+                    "choices": choices,
+                }
+                yield document
+
+    def _generate_raw_documents(self, fstream):
+        raw_document = []
+        for line in fstream:
+            if line.strip():
+                raw_document.append(line)
+            elif raw_document:
+                yield raw_document
+                raw_document = []
+        # needed for last document
+        if raw_document:
+            yield raw_document
+
+    def _parse_ambig_pos_info(self, line):
+        infos = line.split("|")
+        assert len(infos) == 8, f"{len(infos)}"
+        pos_info = {
+            "ambiguous_word": infos[0],
+            "ambiguous_word_alias": infos[1],
+            "offsets_context": [infos[2], infos[3]],
+            "offsets_ambiguity": [infos[4], infos[5]],
+            "context": infos[6],
+        }
+        return pos_info
+
+    def _source_to_kb(self, example):
+        document_ = {}
+        document_["events"] = []
+        document_["relations"] = []
+        document_["coreferences"] = []
+        document_["id"] = next(self.uid)
+        document_["document_id"] = example["sentence_id"].split(".")[0]
+
+        citation = example["citation"]
+        document_["passages"] = [
+            {
+                "id": next(self.uid),
+                "type": "",
+                "text": [citation["text"]],
+                "offsets": [[0, len(citation["text"])]],
+            }
+        ]
+        choices = {x["label"]: x["cui"] for x in example["choices"]}
+        types = {x["label"]: x["type"][0] for x in example["choices"]}
+
+        db_id = (
+            "" if example["label"] in ["None", "UNDEF"] else choices[example["label"]]
+        )
+        type = "" if example["label"] in ["None", "UNDEF"] else types[example["label"]]
+        document_["entities"] = [
+            {
+                "id": next(self.uid),
+                "type": type,
+                "text": [citation["ambiguous_word_alias"]],
+                "offsets": [
+                    [
+                        int(citation["offsets_ambiguity"][0]),
+                        int(citation["offsets_ambiguity"][1]) + 1,
+                    ]
+                ],
+                "normalized": [{"db_name": "UMLS", "db_id": db_id}],
+            }
+        ]
+        return document_