# 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, }