# 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 . # 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 datasets.utils.download_manager import DownloadManager 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 = "data.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: DownloadManager) -> list: """ Downloads files from URL or reads them from the file system and provides _generate_examples with necessary information. Args: dl_manager (DownloadManager): 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, "data/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