MuLMS.py

# Experiment resources related to the MuLMS corpus.
# Copyright (c) 2023 Robert Bosch GmbH
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

# 24 October 2023 - Modified by Timo Schrader (find all changes in CHANGELOG)

"""
This module contains the HuggingFace dataset reader for the "Multi-Layer Materials Science Corpus (MuLMS)"
"""

from dataclasses import dataclass
from os import listdir
from os.path import exists, join

import datasets
import pandas as pd
from puima.collection_utils import DocumentCollection

SENT_TYPE = "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Sentence"
MATSCI_SENT_TYPE = "webanno.custom.MatSci_Sentence"
TOKEN_TYPE = "de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Token"
SKIPPING_TYPE = "webanno.custom.MatSci_Skipping"
ENTITY_TYPE = "webanno.custom.MatSci_Entity"
RELATION_TYPE = "webanno.custom.MatSci_Relations"
PASSAGE_TYPE = "webanno.custom.MatSci_Passage"
DOCUMENT_METADATA_TYPE = "de.tudarmstadt.ukp.dkpro.core.api.metadata.type.DocumentMetaData"


def get_token_indices_for_annot(annot, sent_tokens, doc):
    """
    Retrieves indices of tokens within the list of sententence tokens (sent_tokens) for
    the annotation annot.
    param: annot - puima Annotation object
    param: sent_tokens - list of puima Annotation objects (tokens of the sentence)
    """
    indices = [None, None]
    for annot_token in doc.select_covered(TOKEN_TYPE, annot):  # noqa: F405
        token_index = sent_tokens.index(annot_token)
        if indices[0] is None or indices[0] > token_index:
            indices[0] = token_index
        if indices[1] is None or indices[1] < token_index:
            indices[1] = token_index
    return tuple(indices)


def get_token_index_for_annot_if_subtoken(annot, sent_tokens, doc):
    """
    Retrieves indices of tokens within the list of sententence tokens (sent_tokens) for
    the annotation annot.
    param: annot - puima Annotation object
    param: sent_tokens - list of puima Annotation objects (tokens of the sentence)
    """
    annot_token = next(doc.select_covering(TOKEN_TYPE, annot))  # noqa: F405
    token_index = sent_tokens.index(annot_token)
    return (token_index, token_index)


az_content_labels: list = [
    "Experiment",
    "Results",
    "Exp_Preparation",
    "Exp_Characterization",
    "Background_PriorWork",
    "Explanation",
    "Conclusion",
    "Motivation",
    "Background",
]
az_structure_labels: list = ["Metadata", "Caption", "Heading", "Abstract"]

meas_labels: list = ["MEASUREMENT", "QUAL_MEASUREMENT", "O"]

mulms_ne_labels: list = [
    "MAT",
    "NUM",
    "VALUE",
    "UNIT",
    "PROPERTY",
    "CITE",
    "TECHNIQUE",
    "RANGE",
    "INSTRUMENT",
    "SAMPLE",
    "FORM",
    "DEV",
    "MEASUREMENT",
]

rel_labels: list = [
    "hasForm",
    "measuresProperty",
    "usedAs",
    "conditionProperty",
    "conditionSampleFeatures",
    "usesTechnique",
    "conditionEnvironment",
    "propertyValue",
    "usedIn",
    "conditionInstrument",
    "dopedBy",
    "takenFrom",
    "usedTogether",
]

ne_labels_set = set(mulms_ne_labels)
all_az_labels = set(az_content_labels) | set(az_structure_labels)
meas_labels_set = set(meas_labels)
rel_label_set: set = set(rel_labels)

_CITATION = """\
@InProceedings{schrader-etal-2023-mulms,
title = {MuLMS-AZ: An Argumentative Zoning Dataset for the Materials Science Domain},
author={Timo Pierre Schrader, Teresa Bürkle, Sophie Henning, Sherry Tan, Matteo Finco, Stefan Grünewald, Maira Indrikova, Felix Hildebrand, Annemarie Friedrich
},
year={2023}
},
@InProceedings{schrader-etal-2023-mulms,
title = {MuLMS: A Multi-Layer Annotated Text Corpus for Information Extraction in the Materials Science Domain},
author={Timo Pierre Schrader, Matteo Finco, Stefan Grünewald, Felix Hildebrand, Annemarie Friedrich
},
year={2023}
}
"""

_DESCRIPTION = """\
This dataset represents the Multi-Layer Material Science (MuLMS) corpus.
It consists of 50 thoroughly annotated documents from the materials science domain and
provides annotations for named entities, argumentative zoning (AZ), relation extraction,
measurement classification and citation context retrieval. Please refer to our papers for
more details about the MuLMS corpus.
"""

_HOMEPAGE = "https://github.com/boschresearch/mulms-az-codi2023"

_LICENSE = "AGPL-3"

_URLS = "https://github.com/boschresearch/mulms-az-codi2023/raw/refs/heads/main/data/mulms_corpus.zip"  # "Path to MuLMS-AZ files"


@dataclass
class MuLMSDatasetBuilderConfig(datasets.BuilderConfig):
    """
    Config class for the dataset class.
    """

    replace_heading_AZ_labels: bool = True
    remove_figure_and_table_labels: bool = True


class MuLMSDataset(datasets.GeneratorBasedBuilder):
    """This dataset represents the Multi-Layer Material Science Corpus with 50 documents across multiple domains."""

    VERSION = datasets.Version("1.0.0")

    BUILDER_CONFIG_CLASS = MuLMSDatasetBuilderConfig

    BUILDER_CONFIGS = [
        MuLMSDatasetBuilderConfig(
            name="MuLMS_Corpus",
            version=VERSION,
            description="This part of the dataset covers all annotations.",
        ),
        datasets.BuilderConfig(
            name="NER_Dependencies",
            version=VERSION,
            description="This part of the dataset represents Named Entities as dependencies (returned in CONLL format).",
        ),
    ]

    DEFAULT_CONFIG_NAME = "MuLMS_Corpus"

    AZ_HEADING_REPLACEMENT_LABELS = [
        "Supporting Information",
        "Author Contribution",
        "Confict of Interest",
        "Acknowledgment",
    ]

    def _info(self) -> datasets.DatasetInfo:
        """
        Provides information about this dataset.

        Returns:
            datasets.DatasetInfo
        """
        if self.config.name == "default":
            self.config.name = self.DEFAULT_CONFIG_NAME
        if self.config.name == "MuLMS_Corpus":
            features: datasets.Features = datasets.Features(
                {
                    "doc_id": datasets.Value("string"),
                    "sentence": datasets.Value("string"),
                    "tokens": datasets.Sequence(datasets.Value("string")),
                    "beginOffset": datasets.Value("int32"),
                    "endOffset": datasets.Value("int32"),
                    "AZ_labels": datasets.Value("string"),
                    "Measurement_label": datasets.Value("string"),
                    "NER_labels": datasets.Sequence(
                        {
                            "text": datasets.Value("string"),
                            "id": datasets.Value("int32"),
                            "value": datasets.Value("string"),
                            "begin": datasets.Value("string"),
                            "end": datasets.Value("string"),
                            "tokenIndices": datasets.Sequence(datasets.Value("int32")),
                        }
                    ),
                    "NER_labels_BILOU": datasets.Sequence(datasets.Value("string")),
                    "relations": datasets.Sequence(
                        {
                            "ne_id_gov": datasets.Value("int32"),
                            "ne_id_dep": datasets.Value("int32"),
                            "label": datasets.Value("string"),
                        }
                    ),
                    "docFileName": datasets.Value("string"),
                    "data_split": datasets.Value("string"),
                    "category": datasets.Value("string"),
                }
            )
        elif self.config.name == "NER_Dependencies":
            features: datasets.Features = datasets.Features(
                {
                    "ID": datasets.Value("int32"),
                    "sentence": datasets.Value("string"),
                    "token_id": datasets.Value("int32"),
                    "token_text": datasets.Value("string"),
                    "NE_Dependencies": datasets.Value("string"),
                    "data_split": datasets.Value("string"),
                }
            )
        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager) -> list:
        """
        Downloads files from URL or reads them from the file system and provides _generate_examples
        with necessary information.

        Args:
            dl_manager: Handles data retrieval

        Returns:
            list: Information about files and splits
        """

        data_files: list = dl_manager.download_and_extract(_URLS)
        self.data_dir: str = join(data_files, "mulms_corpus")
        data_files = listdir(join(self.data_dir, "xmi"))
        assert exists(
            join(self.data_dir, "MuLMS_Corpus_Metadata.csv")
        ), "MuLMS_Corpus_Metadata.csv is missing."

        if "/" in data_files[0]:
            data_files = [f.split("/")[-1] for f in data_files]
        if "\\" in data_files[0]:
            data_files = [f.split("\\")[-1] for f in data_files]

        metadata_df: pd.DataFrame = pd.read_csv(
            join(self.data_dir, "MuLMS_Corpus_Metadata.csv")
        )
        train_files: list = sorted(
            [
                f
                for f in data_files
                if any(
                    name in f
                    for name in list(metadata_df[metadata_df["set"].str.contains("train")]["name"])
                )
            ]
        )
        dev_files: list = sorted(
            [
                f
                for f in data_files
                if any(
                    name in f for name in list(metadata_df[metadata_df["set"] == "dev"]["name"])
                )
            ]
        )
        test_files: list = sorted(
            [
                f
                for f in data_files
                if any(
                    name in f for name in list(metadata_df[metadata_df["set"] == "test"]["name"])
                )
            ]
        )

        if self.config.name == "MuLMS_Corpus":
            return [
                datasets.SplitGenerator(
                    name=datasets.Split.TRAIN,
                    gen_kwargs={
                        "dir": join(self.data_dir, "xmi"),
                        "files": train_files,
                        "data_split": metadata_df[metadata_df["set"].str.contains("train")][
                            ["name", "set", "category"]
                        ],
                    },
                ),
                datasets.SplitGenerator(
                    name=datasets.Split.VALIDATION,
                    gen_kwargs={
                        "dir": join(self.data_dir, "xmi"),
                        "files": dev_files,
                        "data_split": metadata_df[metadata_df["set"] == "dev"][
                            ["name", "set", "category"]
                        ],
                    },
                ),
                datasets.SplitGenerator(
                    name=datasets.Split.TEST,
                    gen_kwargs={
                        "dir": join(self.data_dir, "xmi"),
                        "files": test_files,
                        "data_split": metadata_df[metadata_df["set"] == "test"][
                            ["name", "set", "category"]
                        ],
                    },
                ),
            ]

        elif self.config.name == "NER_Dependencies":
            return [
                datasets.SplitGenerator(
                    name=datasets.Split.TRAIN,
                    gen_kwargs={
                        "dir": join(self.data_dir, "ne_dependencies_conll"),
                        "files": [
                            "ne_deps_train1.conllu",
                            "ne_deps_train2.conllu",
                            "ne_deps_train3.conllu",
                            "ne_deps_train4.conllu",
                            "ne_deps_train5.conllu",
                        ],
                        "data_split": None,
                    },
                ),
                datasets.SplitGenerator(
                    name=datasets.Split.VALIDATION,
                    gen_kwargs={
                        "dir": join(self.data_dir, "ne_dependencies_conll"),
                        "files": ["ne_deps_dev.conllu"],
                        "data_split": None,
                    },
                ),
                datasets.SplitGenerator(
                    name=datasets.Split.TEST,
                    gen_kwargs={
                        "dir": join(self.data_dir, "ne_dependencies_conll"),
                        "files": ["ne_deps_test.conllu"],
                        "data_split": None,
                    },
                ),
            ]

    def _generate_examples(self, dir: str, files: list, data_split: pd.DataFrame):
        """
        Yields the data during runtime.

        Args:
            dir (str): Path to downloaded or local files.
            files (list): List of filenames corresponding to the current split; must be contained within "dir"
            data_split (pd.DataFrame): Category and train/dev/test split info for each document

        Yields:
            tuple: Yields document ID and dictionary with current data sample
        """

        if self.config.name == "MuLMS_Corpus":

            doc_coll: DocumentCollection = DocumentCollection(
                xmi_dir=dir, file_list=files)

            split_info: str = None
            category_info: str = None

            for doc_name in doc_coll.docs:
                doc = doc_coll.docs[doc_name]
                for sent_id, sent_annot in enumerate(
                    doc.select_annotations(SENT_TYPE)  # noqa: F405
                ):
                    sent_text = doc.get_covered_text(sent_annot)

                    # Argumentative Zoning labels
                    az_labels = set()
                    for matsci_sent in doc.select_covered(
                        MATSCI_SENT_TYPE, sent_annot  # noqa: F405
                    ):
                        content_info = matsci_sent.get_feature_value(
                            "ContentInformation")
                        struct_info = matsci_sent.get_feature_value(
                            "StructureInformation")
                        az_labels.add(content_info)
                        az_labels.add(struct_info)
                    if "None" in az_labels:
                        az_labels.remove("None")
                    if None in az_labels:
                        az_labels.remove(None)
                    # Extract Measurement related label
                    sent_meas_label = list(
                        set.intersection(az_labels, meas_labels))
                    if len(sent_meas_label) == 2:
                        sent_meas_label = "MEASUREMENT"
                    elif len(sent_meas_label) == 1:
                        sent_meas_label = sent_meas_label[0]
                    else:
                        sent_meas_label = "O"
                    # Remove AZ labels that are not in structure / content tags defined
                    az_labels = list(
                        set.intersection(all_az_labels, az_labels)
                    )  # keep only valid labels

                    if len(az_labels) == 0:
                        continue

                    # Tokens
                    sent_tokens = list(doc.select_covered(TOKEN_TYPE, sent_annot))  # noqa: F405
                    sent_token_list = [0] * len(sent_tokens)

                    token2idx = {}
                    for i, token in enumerate(sent_tokens):
                        token2idx[token.begin] = i
                        sent_token_list[i] = doc.get_covered_text(
                            token)  # token text

                    # Named Entity annotations
                    sent_offset: int = sent_annot.begin
                    ner_labels: list = []
                    ner_labels_duplicate_lookup: dict = (
                        dict()
                    )  # Used to detect duplicate Named Entity annotations
                    ne_annot2id: dict = {}
                    for ent_annot in doc.select_covered(ENTITY_TYPE, sent_annot):  # noqa: F405
                        if ent_annot.get_feature_value("implicitEntity") is None:
                            label = ent_annot.get_feature_value("value")
                            if label in ne_labels_set:  # filter by applicable labels
                                # retrieve token indices
                                ent_indices = get_token_indices_for_annot(
                                    ent_annot, sent_tokens, doc
                                )
                                if (
                                    None in ent_indices
                                ):  # happens if entity annotation is subtoken : choose covering token
                                    try:
                                        ent_indices = get_token_index_for_annot_if_subtoken(
                                            ent_annot, sent_tokens, doc
                                        )
                                    except StopIteration:
                                        pass
                                    except ValueError:
                                        pass
                                if None in ent_indices:
                                    continue

                                try:
                                    ne_annot2id[ent_annot] = ent_annot.id
                                    ne_dict: dict = {
                                        "text": doc.get_covered_text(ent_annot),
                                        "id": ent_annot.id,
                                        "value": label,
                                        "begin": ent_annot.begin - sent_offset,
                                        "end": ent_annot.end - sent_offset,
                                        "tokenIndices": ent_indices,
                                    }  # index of first + last token of the NE
                                    if (
                                        not tuple(
                                            [ne_dict["value"],
                                                ne_dict["begin"], ne_dict["end"]]
                                        )
                                        in ner_labels_duplicate_lookup.keys()
                                    ):
                                        ner_labels.append(ne_dict)
                                        ner_labels_duplicate_lookup[
                                            (
                                                tuple(
                                                    [
                                                        ne_dict["value"],
                                                        ne_dict["begin"],
                                                        ne_dict["end"],
                                                    ]
                                                )
                                            )
                                        ] = ent_annot.id
                                    else:
                                        ne_annot2id[ent_annot] = ner_labels_duplicate_lookup[
                                            (
                                                tuple(
                                                    [
                                                        ne_dict["value"],
                                                        ne_dict["begin"],
                                                        ne_dict["end"],
                                                    ]
                                                )
                                            )
                                        ]
                                except KeyError:
                                    pass

                    # Creating Nested Named Entity BIO Labels
                    B: str = "B-{0}"
                    I: str = "I-{0}"
                    L: str = "L-{0}"
                    O: str = "O"
                    U: str = "U-{0}"
                    ner_labels.sort(
                        key=lambda x: (x["tokenIndices"]
                                       [0], -x["tokenIndices"][1])
                    )  # Work from left to right and prioritize longer strings
                    nested_bilou_labels: list = [O] * len(sent_tokens)
                    if len(ner_labels) > 0:
                        for i in range(len(ner_labels)):
                            begin_idx: int = ner_labels[i]["tokenIndices"][0]
                            end_idx: int = ner_labels[i]["tokenIndices"][1]

                            # Check whether there are already two NE annotation layers within this span
                            skip_current_entity: bool = False
                            for j in range(begin_idx, end_idx + 1):
                                if (
                                    nested_bilou_labels[j].count("+") == 2
                                ):  # Already 3 annotations connected via "+"
                                    skip_current_entity = True
                                    break

                            if skip_current_entity:
                                continue

                            tag: str = ner_labels[i]["value"]

                            # Case of Unit Length Tag
                            if begin_idx == end_idx:
                                if nested_bilou_labels[begin_idx] == O:
                                    nested_bilou_labels[begin_idx] = U.format(
                                        tag)
                                else:
                                    nested_bilou_labels[begin_idx] += "+" + \
                                        U.format(tag)
                                continue

                            # Tags that span over more than one token
                            if nested_bilou_labels[begin_idx] == O:
                                nested_bilou_labels[begin_idx] = B.format(tag)
                            else:
                                nested_bilou_labels[begin_idx] += "+" + \
                                    B.format(tag)

                            # Append all inside tags
                            for j in range(begin_idx + 1, end_idx + 1):
                                if j < end_idx:
                                    if nested_bilou_labels[j] == O:
                                        nested_bilou_labels[j] = I.format(tag)
                                    else:
                                        nested_bilou_labels[j] += "+" + \
                                            I.format(tag)
                                else:
                                    if nested_bilou_labels[j] == O:
                                        nested_bilou_labels[j] = L.format(tag)
                                    else:
                                        nested_bilou_labels[j] += "+" + \
                                            L.format(tag)

                    # positive relation instances
                    rel_labels: list = []
                    for rel_annot in doc.select_covered(RELATION_TYPE, sent_annot):  # noqa: F405
                        label: str = rel_annot.get_feature_value(
                            "RelationType")

                        gov_annot = rel_annot.get_feature_value(
                            "Governor", True)
                        dep_annot = rel_annot.get_feature_value(
                            "Dependent", True)

                        gov_label = gov_annot.get_feature_value("value")

                        if (
                            label in rel_label_set
                        ):  # only consider annotation if in selected set of relations

                            # --- Adding transitive links --- #
                            # conditionProperty + propertyValue --> conditionPropertyValue
                            # measuresProperty  + propertyValue --> measuresPropertyValue
                            # Note that this will also happen when the intermediate entity is implicit!
                            if gov_label == "MEASUREMENT" and label in {
                                "conditionProperty",
                                "measuresProperty",
                            }:
                                for rel_annot2 in doc.select_covered(
                                    RELATION_TYPE, sent_annot  # noqa: F405
                                ):
                                    label2: str = rel_annot2.get_feature_value(
                                        "RelationType")
                                    gov_annot2 = rel_annot2.get_feature_value(
                                        "Governor", True)
                                    dep_annot2 = rel_annot2.get_feature_value(
                                        "Dependent", True)

                                    if label2 == "propertyValue" and gov_annot2 == dep_annot:
                                        if label == "conditionProperty":
                                            transitiveLabel = "conditionPropertyValue"
                                        elif label == "measuresProperty":
                                            transitiveLabel = "measuresPropertyValue"
                                        else:
                                            assert False

                                        try:
                                            rel_labels.append(
                                                {
                                                    "ne_id_gov": ne_annot2id[gov_annot],
                                                    "ne_id_dep": ne_annot2id[dep_annot2],
                                                    "label": transitiveLabel,
                                                }
                                            )
                                        except KeyError:
                                            continue
                            # --- End of adding transitive links --- #

                            if (
                                gov_annot.get_feature_value(
                                    "value") not in ne_labels_set
                                or dep_annot.get_feature_value("value") not in ne_labels_set
                            ):
                                # only considering relations between "valid" NE types for now
                                continue
                            if gov_annot is dep_annot:
                                continue
                            if (
                                gov_annot.begin == dep_annot.begin
                                and gov_annot.end == dep_annot.end
                            ):
                                # same span, continue
                                continue

                            if gov_annot not in ne_annot2id:
                                # check if it's in a different sentence
                                if doc.get_covered_text(dep_annot) == "nanoparticle-type":
                                    continue
                                sent_list2 = list(
                                    doc.select_covering(SENT_TYPE, gov_annot)  # noqa: F405
                                )
                                try:
                                    sent_list2.remove(sent_annot)
                                except ValueError:
                                    pass
                                if len(sent_list2) == 0:
                                    continue
                                sent_annot2 = sent_list2[0]
                                if sent_annot2 is not sent_annot:
                                    # gov in different sentence, skipping cross-sentence links
                                    continue
                            if dep_annot not in ne_annot2id:
                                sent_list2 = list(
                                    doc.select_covering(SENT_TYPE, dep_annot)  # noqa: F405
                                )
                                try:
                                    sent_list2.remove(sent_annot)
                                except ValueError:
                                    pass
                                if len(sent_list2) == 0:
                                    continue
                                sent_annot2 = sent_list2[0]
                                if sent_annot2 != sent_annot:
                                    # dep in different sentence, skipping cross-sentence links
                                    continue

                            if gov_annot not in ne_annot2id:
                                if gov_annot.get_feature_value("valueType") == "implicit":
                                    # skip this case, implicit PROPERTY
                                    continue
                                assert False
                            if dep_annot not in ne_annot2id:
                                assert False
                            rel_labels.append(
                                {
                                    "ne_id_gov": ne_annot2id[gov_annot],
                                    "ne_id_dep": ne_annot2id[dep_annot],
                                    "label": label,
                                }
                            )

                    if split_info is None:
                        split_info = data_split[data_split["name"]
                                                == doc_name]["set"].values[0]
                        category_info = data_split[data_split["name"] == doc_name][
                            "category"
                        ].values[0]

                    # Iterator yields data sample sentence-wise
                    yield doc_name + "/" + str(sent_id), {
                        "doc_id": doc_name,
                        "sentence": sent_text,
                        "tokens": sent_token_list,
                        "beginOffset": sent_annot.begin,
                        "endOffset": sent_annot.end,
                        "AZ_labels": az_labels,
                        "Measurement_label": sent_meas_label,
                        "NER_labels": ner_labels,
                        "NER_labels_BILOU": nested_bilou_labels,
                        # [(ne_index_in_list, ne_index_in_list, relation_name)]
                        "relations": rel_labels,
                        "docFileName": doc_name,
                        "data_split": split_info,
                        "category": category_info,
                    }

                split_info = None
                category_info = None
        elif self.config.name == "NER_Dependencies":
            id: int = 0
            sent_id: int = 0
            sent_text: str = None
            for i, f in enumerate(files):
                split_info: str = (
                    f"train{i+1}" if "train" in f else (
                        "dev" if "dev" in f else "test")
                )
                with open(join(dir, f), mode="r", encoding="utf-8") as cf:
                    conll_lines: list[str] = cf.read().splitlines()
                for line in conll_lines:
                    if line.startswith("#"):
                        sent_text = line.split("# text = ")[-1]
                        sent_id += 1
                        continue
                    elif line == "":
                        continue
                    t_id, t_text, deps = line.split("\t")
                    yield id, {
                        "ID": sent_id,
                        "sentence": sent_text,
                        "token_id": t_id,
                        "token_text": t_text,
                        "NE_Dependencies": deps,
                        "data_split": split_info,
                    }
                    id += 1