sofc_materials_articles.py

# 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.
"""TODO: Add a description here."""


import glob
import os

import pandas as pd

import datasets


_CITATION = """\
@misc{friedrich2020sofcexp,
      title={The SOFC-Exp Corpus and Neural Approaches to Information Extraction in the Materials Science Domain},
      author={Annemarie Friedrich and Heike Adel and Federico Tomazic and Johannes Hingerl and Renou Benteau and Anika Maruscyk and Lukas Lange},
      year={2020},
      eprint={2006.03039},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
"""

_DESCRIPTION = """\
The SOFC-Exp corpus consists of 45 open-access scholarly articles annotated by domain experts.
A corpus and an inter-annotator agreement study demonstrate the complexity of the suggested
named entity recognition and slot filling tasks as well as high annotation quality is presented
in the accompanying paper.
"""

_HOMEPAGE = "https://arxiv.org/abs/2006.03039"

_LICENSE = ""

_URL = "data.zip"


class SOFCMaterialsArticles(datasets.GeneratorBasedBuilder):
    """ """

    VERSION = datasets.Version("1.1.0")

    def _info(self):
        features = datasets.Features(
            {
                "text": datasets.Value("string"),
                "sentence_offsets": datasets.features.Sequence(
                    {"begin_char_offset": datasets.Value("int64"), "end_char_offset": datasets.Value("int64")}
                ),
                "sentences": datasets.features.Sequence(datasets.Value("string")),
                "sentence_labels": datasets.features.Sequence(datasets.Value("int64")),
                "token_offsets": datasets.features.Sequence(
                    {
                        "offsets": datasets.features.Sequence(
                            {"begin_char_offset": datasets.Value("int64"), "end_char_offset": datasets.Value("int64")}
                        )
                    }
                ),
                "tokens": datasets.features.Sequence(datasets.features.Sequence(datasets.Value("string"))),
                "entity_labels": datasets.features.Sequence(
                    datasets.features.Sequence(
                        datasets.features.ClassLabel(
                            names=[
                                "B-DEVICE",
                                "B-EXPERIMENT",
                                "B-MATERIAL",
                                "B-VALUE",
                                "I-DEVICE",
                                "I-EXPERIMENT",
                                "I-MATERIAL",
                                "I-VALUE",
                                "O",
                            ]
                        )
                    )
                ),
                "slot_labels": datasets.features.Sequence(
                    datasets.features.Sequence(
                        datasets.features.ClassLabel(
                            names=[
                                "B-anode_material",
                                "B-cathode_material",
                                "B-conductivity",
                                "B-current_density",
                                "B-degradation_rate",
                                "B-device",
                                "B-electrolyte_material",
                                "B-experiment_evoking_word",
                                "B-fuel_used",
                                "B-interlayer_material",
                                "B-interconnect_material",
                                "B-open_circuit_voltage",
                                "B-power_density",
                                "B-resistance",
                                "B-support_material",
                                "B-thickness",
                                "B-time_of_operation",
                                "B-voltage",
                                "B-working_temperature",
                                "I-anode_material",
                                "I-cathode_material",
                                "I-conductivity",
                                "I-current_density",
                                "I-degradation_rate",
                                "I-device",
                                "I-electrolyte_material",
                                "I-experiment_evoking_word",
                                "I-fuel_used",
                                "I-interlayer_material",
                                "I-interconnect_material",
                                "I-open_circuit_voltage",
                                "I-power_density",
                                "I-resistance",
                                "I-support_material",
                                "I-thickness",
                                "I-time_of_operation",
                                "I-voltage",
                                "I-working_temperature",
                                "O",
                            ]
                        )
                    )
                ),
                "links": datasets.Sequence(
                    {
                        "relation_label": datasets.features.ClassLabel(
                            names=["coreference", "experiment_variation", "same_experiment", "thickness"]
                        ),
                        "start_span_id": datasets.Value("int64"),
                        "end_span_id": datasets.Value("int64"),
                    }
                ),
                "slots": datasets.features.Sequence(
                    {
                        "frame_participant_label": datasets.features.ClassLabel(
                            names=[
                                "anode_material",
                                "cathode_material",
                                "current_density",
                                "degradation_rate",
                                "device",
                                "electrolyte_material",
                                "fuel_used",
                                "interlayer_material",
                                "open_circuit_voltage",
                                "power_density",
                                "resistance",
                                "support_material",
                                "time_of_operation",
                                "voltage",
                                "working_temperature",
                            ]
                        ),
                        "slot_id": datasets.Value("int64"),
                    }
                ),
                "spans": datasets.features.Sequence(
                    {
                        "span_id": datasets.Value("int64"),
                        "entity_label": datasets.features.ClassLabel(names=["", "DEVICE", "MATERIAL", "VALUE"]),
                        "sentence_id": datasets.Value("int64"),
                        "experiment_mention_type": datasets.features.ClassLabel(
                            names=["", "current_exp", "future_work", "general_info", "previous_work"]
                        ),
                        "begin_char_offset": datasets.Value("int64"),
                        "end_char_offset": datasets.Value("int64"),
                    }
                ),
                "experiments": datasets.features.Sequence(
                    {
                        "experiment_id": datasets.Value("int64"),
                        "span_id": datasets.Value("int64"),
                        "slots": datasets.features.Sequence(
                            {
                                "frame_participant_label": datasets.features.ClassLabel(
                                    names=[
                                        "anode_material",
                                        "cathode_material",
                                        "current_density",
                                        "degradation_rate",
                                        "conductivity",
                                        "device",
                                        "electrolyte_material",
                                        "fuel_used",
                                        "interlayer_material",
                                        "open_circuit_voltage",
                                        "power_density",
                                        "resistance",
                                        "support_material",
                                        "time_of_operation",
                                        "voltage",
                                        "working_temperature",
                                    ]
                                ),
                                "slot_id": datasets.Value("int64"),
                            }
                        ),
                    }
                ),
            }
        )

        return datasets.DatasetInfo(
            # This is the description that will appear on the datasets page.
            description=_DESCRIPTION,
            # This defines the different columns of the dataset and their types
            features=features,  # Here we define them above because they are different between the two configurations
            # If there's a common (input, target) tuple from the features,
            # specify them here. They'll be used if as_supervised=True in
            # builder.as_dataset.
            supervised_keys=None,
            # Homepage of the dataset for documentation
            homepage=_HOMEPAGE,
            # License for the dataset if available
            license=_LICENSE,
            # Citation for the dataset
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        """Returns SplitGenerators."""
        data_dir = dl_manager.download_and_extract(_URL)
        data_dir = os.path.join(data_dir, "sofc-exp-corpus")

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "data_dir": data_dir,
                    "split": "train",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "data_dir": data_dir,
                    "split": "test",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "data_dir": data_dir,
                    "split": "dev",
                },
            ),
        ]

    def _generate_examples(self, data_dir, split):
        """Yields examples."""
        metadata = pd.read_csv(os.path.join(data_dir, "SOFC-Exp-Metadata.csv"), sep="\t")
        names = metadata[metadata["set"] == split]["name"].tolist()

        # The dataset consists of the original article text as well as annotations
        textfile_base_path = os.path.join(data_dir, "texts")
        annotations_base_path = os.path.join(data_dir, "annotations")

        # The annotations are mostly references to offsets in the source text
        # with corresponding labels, so we'll refer to them as `meta`
        sentence_meta_base_path = os.path.join(annotations_base_path, "sentences")
        tokens_meta_base_path = os.path.join(annotations_base_path, "tokens")
        ets_meta_base_path = os.path.join(annotations_base_path, "entity_types_and_slots")
        frame_meta_base_path = os.path.join(annotations_base_path, "frames")

        # Define the headers for the sentence and token and entity metadata
        sentence_meta_header = ["sentence_id", "label", "begin_char_offset", "end_char_offset"]
        tokens_meta_header = ["sentence_id", "token_id", "begin_char_offset", "end_char_offset"]
        ets_meta_header = [
            "sentence_id",
            "token_id",
            "begin_char_offset",
            "end_char_offset",
            "entity_label",
            "slot_label",
        ]

        # Start the processing loop
        # For each text file, we'll load all of the
        # associated annotation files
        for id_, name in enumerate(sorted(names)):
            # Load the main source text
            textfile_path = os.path.join(textfile_base_path, name + ".txt")
            text = open(textfile_path, encoding="utf-8").read()

            # Load the sentence offsets file
            sentence_meta_path = os.path.join(sentence_meta_base_path, name + ".csv")
            sentence_meta = pd.read_csv(sentence_meta_path, sep="\t", names=sentence_meta_header)

            # Load the tokens offsets file
            tokens_meta_path = os.path.join(tokens_meta_base_path, name + ".csv")
            tokens_meta = pd.read_csv(tokens_meta_path, sep="\t", names=tokens_meta_header)

            # Load the entity offsets file
            ets_meta_path = os.path.join(ets_meta_base_path, name + ".csv")
            ets_meta = pd.read_csv(ets_meta_path, sep="\t", names=ets_meta_header)

            # Create a list of lists indexed as [sentence][token] for the entity and slot labels
            entity_labels = ets_meta.groupby("sentence_id").apply(lambda x: x["entity_label"].tolist()).to_list()
            slot_labels = ets_meta.groupby("sentence_id").apply(lambda x: x["slot_label"].tolist()).to_list()

            # Create a list of lists for the token offsets indexed as [sentence][token]
            # Each element will contain a dict with beginning and ending character offsets
            token_offsets = (
                tokens_meta.groupby("sentence_id")[["begin_char_offset", "end_char_offset"]]
                .apply(lambda x: x.to_dict(orient="records"))
                .tolist()
            )

            # Load the frames metadata. The frames file contains the data for all of the annotations
            # in a condensed format that varies throughout the file. More information on this format
            # can be found: https://framenet.icsi.berkeley.edu/fndrupal/
            frames_meta_path = os.path.join(frame_meta_base_path, name + ".csv")
            frames_meta = open(frames_meta_path, encoding="utf-8").readlines()

            # Parse the sentence offsets, producing a list of dicts with the
            # starting and ending position of each sentence in the original text
            sentence_offsets = (
                sentence_meta[["begin_char_offset", "end_char_offset"]].apply(lambda x: x.to_dict(), axis=1).tolist()
            )

            # The sentence labels are a binary label that describes whether the sentence contains
            # any annotations
            sentence_labels = sentence_meta["label"].tolist()

            # Materialiaze a list of strings of the actual sentences
            sentences = [text[ost["begin_char_offset"] : ost["end_char_offset"]] for ost in sentence_offsets]

            # Materialize a list of lists of the tokens in each sentence.
            # Annotation labels are aligned with these tokens, so be careful with
            # alignment if using your own tokenization scheme with the sentences above
            tokens = [
                [s[tto["begin_char_offset"] : tto["end_char_offset"]] for tto in to]
                for s, to in zip(sentences, token_offsets)
            ]

            # The frames file first contains spans annotations (in one format),
            # then contains experiments annotations (in another format),
            # then links annotations (in yet another format).
            # Here we find the beginning of the experiments and links sections of the file
            # Additionally, each experiment annotation in the experiment annotations begins with a
            # line starting with the word EXPERIMENT (in one format)
            # followed by the annotations for that experiment (in yet _another_ format)
            # Here we get the start positions for each experiment _within_ the experiments
            # section of the frames data
            experiment_starts = [i for i, line in enumerate(frames_meta) if line.startswith("EXPERIMENT")]
            experiment_start = min(experiment_starts)
            link_start = min([i for i, line in enumerate(frames_meta) if line.startswith("LINK")])

            # Pick out the spans section of the data for parsing
            spans_raw = frames_meta[:experiment_start]

            # Iterate through the spans data
            spans = []
            for span in spans_raw:
                # Split out the elements in each tab-delimited line
                _, span_id, entity_label_or_exp, sentence_id, begin_char_offset, end_char_offset = span.split("\t")

                # The entity label for experiment spans have a sub-label,
                # called the experiment mention type,
                # which is sub-delimited by a ':'
                # The code below standardizes the fields produced by
                # each line to a common schema, some fields of which may
                # be empty depending on the data available in the line
                if entity_label_or_exp.startswith("EXPERIMENT"):
                    exp, experiment_mention_type = entity_label_or_exp.split(":")
                    entity_label = ""
                else:
                    entity_label = entity_label_or_exp
                    exp = ""
                    experiment_mention_type = ""

                s = {
                    "span_id": span_id,
                    "entity_label": entity_label,
                    "sentence_id": sentence_id,
                    "experiment_mention_type": experiment_mention_type,
                    "begin_char_offset": int(begin_char_offset),
                    "end_char_offset": int(end_char_offset),
                }
                spans.append(s)

            # Pull out the links annotations for from the frames data
            links_raw = [f.rstrip("\n") for f in frames_meta[link_start:]]

            # Iterate through the links data, which is in a simple tab-delimited format
            links = []
            for link in links_raw:
                _, relation_label, start_span_id, end_span_id = link.split("\t")

                link_out = {
                    "relation_label": relation_label,
                    "start_span_id": int(start_span_id),
                    "end_span_id": int(end_span_id),
                }
                links.append(link_out)

            # Iterate through the experiments data and parse each experiment
            experiments = []
            # Zip the experiment start offsets to get start/end position tuples
            # for each experiment in the experiments data
            for start, end in zip(experiment_starts[:-1], experiment_starts[1:]):
                current_experiment = frames_meta[start:end]
                # The first line of each experiment annotation contains the
                # experiment id and the span id
                _, experiment_id, span_id = current_experiment[0].rstrip("\n").split("\t")
                exp = {"experiment_id": int(experiment_id), "span_id": int(span_id)}

                # The remaining lines in the experiment annotations contain
                # slot level information for each experiment.
                slots = []
                for e in current_experiment[1:]:
                    e = e.rstrip("\n")
                    _, frame_participant_label, slot_id = e.split("\t")
                    to_add = {"frame_participant_label": frame_participant_label, "slot_id": int(slot_id)}
                    slots.append(to_add)
                exp["slots"] = slots

                experiments.append(exp)

            # Yield the final parsed example output
            # NOTE: the `token_offsets` is converted to a list of
            # dicts to accommodate processing to the arrow files
            # in the `features` schema defined above
            yield id_, {
                "text": text,
                "sentence_offsets": sentence_offsets,
                "sentences": sentences,
                "sentence_labels": sentence_labels,
                "token_offsets": [{"offsets": to} for to in token_offsets],
                "tokens": tokens,
                "entity_labels": entity_labels,
                "slot_labels": slot_labels,
                "links": links,
                "slots": slots,
                "spans": spans,
                "experiments": experiments,
            }