# 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. """ The corpus of plant-disease relation consists of plants and diseases and their relation to PubMed abstract. The corpus consists of about 2400 plant and disease entities and 300 annotated relations from 179 abstracts. The big-bio and source version of this script are made by merging the 2 provided annotations on locations they intersected. Both annotations (1, 2) are provided as separate source schemas. """ from collections import defaultdict from pathlib import Path from typing import Dict, Iterator, Optional, Tuple import datasets from .bigbiohub import kb_features from .bigbiohub import BigBioConfig from .bigbiohub import Tasks from .bigbiohub import parse_brat_file from .bigbiohub import brat_parse_to_bigbio_kb _LANGUAGES = ['English'] _PUBMED = True _LOCAL = False _CITATION = """\ @article{kim2019corpus, title={A corpus of plant--disease relations in the biomedical domain}, author={Kim, Baeksoo and Choi, Wonjun and Lee, Hyunju}, journal={PLoS One}, volume={14}, number={8}, pages={e0221582}, year={2019}, publisher={Public Library of Science San Francisco, CA USA} } """ _DATASETNAME = "pdr" _DISPLAYNAME = "PDR" _DESCRIPTION = """ The corpus of plant-disease relation consists of plants and diseases and their relation to PubMed abstract. The corpus consists of about 2400 plant and disease entities and 300 annotated relations from 179 abstracts. """ _HOMEPAGE = "http://gcancer.org/pdr/" _LICENSE = 'License information unavailable' _URLS = {_DATASETNAME: "http://gcancer.org/pdr/Plant-Disease_Corpus.tar.gz"} _SUPPORTED_TASKS = [ Tasks.NAMED_ENTITY_RECOGNITION, # Tasks.RELATION_EXTRACTION, Tasks.EVENT_EXTRACTION, Tasks.COREFERENCE_RESOLUTION, ] _SOURCE_VERSION = "1.0.0" _BIGBIO_VERSION = "1.0.0" class PDRDataset(datasets.GeneratorBasedBuilder): """The corpus of plant-disease relation consists of plants and diseases and their relation to PubMed abstract""" SOURCE_VERSION = datasets.Version(_SOURCE_VERSION) BIGBIO_VERSION = datasets.Version(_BIGBIO_VERSION) BUILDER_CONFIGS = [ BigBioConfig( name="pdr_annotator1_source", version=SOURCE_VERSION, description="PDR annotator 1 source schema", schema="source", subset_id="pdr_annotator1", ), BigBioConfig( name="pdr_annotator2_source", version=SOURCE_VERSION, description="PDR annotator 2 source schema", schema="source", subset_id="pdr_annotator2", ), BigBioConfig( name="pdr_source", version=SOURCE_VERSION, description="PDR source schema", schema="source", subset_id="pdr", ), BigBioConfig( name="pdr_bigbio_kb", version=BIGBIO_VERSION, description="PDR BigBio schema", schema="bigbio_kb", subset_id="pdr", ), ] DEFAULT_CONFIG_NAME = "pdr_source" def _info(self): if self.config.schema == "source": features = datasets.Features( { "document_id": datasets.Value("string"), "text": datasets.Value("string"), "entities": [ { "id": datasets.Value("string"), "type": datasets.Value("string"), "offsets": datasets.Sequence([datasets.Value("int32")]), "text": datasets.Sequence(datasets.Value("string")), "normalized": [ { "db_name": datasets.Value("string"), "db_id": datasets.Value("string"), } ], } ], "relations": [ { "id": datasets.Value("string"), "type": datasets.Value("string"), "arg1_id": datasets.Value("string"), "arg2_id": datasets.Value("string"), "normalized": [ { "db_name": datasets.Value("string"), "db_id": datasets.Value("string"), } ], } ], "events": [ { "id": datasets.Value("string"), "type": datasets.Value("string"), # refers to the text_bound_annotation of the trigger "trigger": { "text": datasets.Sequence(datasets.Value("string")), "offsets": datasets.Sequence([datasets.Value("int32")]), }, "arguments": [ { "role": datasets.Value("string"), "ref_id": datasets.Value("string"), } ], } ], "coreferences": [ { "id": datasets.Value("string"), "entity_ids": datasets.Sequence(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): urls = _URLS[_DATASETNAME] data_dir = Path(dl_manager.download_and_extract(urls)) data_dir = data_dir / "Plant-Disease_Corpus" return [ datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs={"data_dir": data_dir}, ) ] def _generate_examples(self, data_dir: Path) -> Iterator[Tuple[str, Dict]]: if self.config.schema == "source": for file in data_dir.iterdir(): if not str(file).endswith(".txt"): continue if self.config.subset_id == "pdr_annotator1": # Provide annotations of annotator 1 example = parse_brat_file(file, [".ann"]) example = brat_parse_to_bigbio_kb(example) elif self.config.subset_id == "pdr_annotator2": # Provide annotations of annotator 2 example = parse_brat_file(file, [".ann2"]) example = brat_parse_to_bigbio_kb(example) elif self.config.subset_id == "pdr": # Provide merged version of annotator 1 and 2 annotator1 = parse_brat_file(file, [".ann"]) annotator1 = brat_parse_to_bigbio_kb(annotator1) annotator2 = parse_brat_file(file, [".ann2"]) annotator2 = brat_parse_to_bigbio_kb(annotator2) example = self._merge_annotations_by_intersection( file, annotator1, annotator2 ) example["text"] = example["passages"][0]["text"][0] example.pop("id", None) example.pop("passages", None) yield example["document_id"], example elif self.config.schema == "bigbio_kb": for file in data_dir.iterdir(): if not str(file).endswith(".txt"): continue annotator1 = parse_brat_file(file, [".ann"]) annotator1 = brat_parse_to_bigbio_kb(annotator1) annotator2 = parse_brat_file(file, [".ann2"]) annotator2 = brat_parse_to_bigbio_kb(annotator2) merged_annotation = self._merge_annotations_by_intersection( file, annotator1, annotator2 ) merged_annotation["id"] = merged_annotation["document_id"] yield merged_annotation["id"], merged_annotation def _merge_annotations_by_intersection( self, file: Path, example_ann1: Dict, example_ann2: Dict ) -> Dict: """ Merges the two given examples by only keeping annotations on which both annotators agree. """ id_prefix = str(file.stem) + "_" # Mapping entity identifiers from annotator 1 / 2 to merged entity ids a1_entity_to_merged_entity = {} a2_entity_to_merged_entity = {} merged_entities = [] # 1. Find all common entities, i.e. both annotators agree on same type and their offsets overlap entity_id = 1 for entity1 in example_ann1["entities"]: for entity2 in example_ann2["entities"]: if ( self._overlaps(entity1, entity2) and entity1["type"] == entity2["type"] ): text_entity1 = "".join(entity1["text"]) text_entity2 = "".join(entity2["text"]) longer_entity = ( entity1 if len(text_entity1) > len(text_entity2) else entity2 ) merged_entity_id = id_prefix + f"E{entity_id}" entity_id += 1 merged_entity = longer_entity.copy() merged_entity["id"] = merged_entity_id merged_entity["normalized"] = [] merged_entities.append(merged_entity) a1_entity_to_merged_entity[entity1["id"]] = merged_entity_id a2_entity_to_merged_entity[entity2["id"]] = merged_entity_id break # Find all relations the two annotators agree on relations_ann1 = self._map_relations(example_ann1, a1_entity_to_merged_entity) relations_ann2 = self._map_relations(example_ann2, a2_entity_to_merged_entity) relations = [] relation_id = 1 for rel_type, relations_1 in relations_ann1.items(): relations_2 = relations_ann2[rel_type] for relation_pair_1 in relations_1: for relation_pair_2 in relations_2: if relation_pair_1 == relation_pair_2: relations.append( { "id": id_prefix + f"R{relation_id}", "type": rel_type, "arg1_id": relation_pair_1[0], "arg2_id": relation_pair_1[1], "normalized": [], } ) relation_id += 1 break # Find all events the two annotators agree on events_ann1 = self._map_events(example_ann1, a1_entity_to_merged_entity) events_ann2 = self._map_events(example_ann2, a2_entity_to_merged_entity) events = [] event_id = 1 for event_type, events_1 in events_ann1.items(): events_2 = events_ann2[event_type] for (trigger1, theme1, cause1) in events_1: for (trigger2, theme2, cause2) in events_2: if ( theme1 == theme2 and cause1 == cause2 and self._overlaps(trigger1, trigger2) ): trigger1_text = "".join(trigger1["text"]) trigger2_text = "".join(trigger2["text"]) longer_trigger = ( trigger1 if len(trigger1_text) >= len(trigger2_text) else trigger2 ) events.append( { "id": id_prefix + f"T{event_id}", "type": event_type, "trigger": longer_trigger, "arguments": [ {"role": "Theme", "ref_id": theme1}, {"role": "Cause", "ref_id": cause1}, ], } ) event_id += 1 break # Find all coreferences the annotators agree on coferences_ann1 = self._map_coreferences( example_ann1, a1_entity_to_merged_entity ) coferences_ann2 = self._map_coreferences( example_ann2, a2_entity_to_merged_entity ) coreferences = [] coreference_id = 1 for _, entity_ids1 in coferences_ann1.items(): for _, entity_ids2 in coferences_ann2.items(): if entity_ids1.intersection(entity_ids2) == entity_ids1.union( entity_ids2 ): coreferences.append( { "id": id_prefix + f"CO{coreference_id}", "entity_ids": list(entity_ids1), } ) coreference_id += 1 merged_example = example_ann1.copy() merged_example["entities"] = merged_entities merged_example["relations"] = relations merged_example["events"] = events merged_example["coreferences"] = coreferences return merged_example def _map_relations(self, example: Dict, entity_id_mapping: Dict) -> Dict: """ Maps the all relations of the given example to their merged entity identifiers (if existent) """ relation_map = defaultdict(list) for relation in example["relations"]: arg1_id = relation["arg1_id"] arg2_id = relation["arg2_id"] # Are both entities also in the merged version? if arg1_id not in entity_id_mapping or arg2_id not in entity_id_mapping: continue com_arg1_id = entity_id_mapping[arg1_id] com_arg2_id = entity_id_mapping[arg2_id] relation_map[relation["type"]].append((com_arg1_id, com_arg2_id)) return relation_map def _map_events(self, example: Dict, entity_id_mapping: Dict) -> Dict: """ Maps the all events of the given example to their merged entity identifiers (if existent) """ event_map = defaultdict(list) for event in example["events"]: theme_id = self._get_event_argument(event, "Theme") cause_id = self._get_event_argument(event, "Cause") if theme_id not in entity_id_mapping or cause_id not in entity_id_mapping: continue common_theme_id = entity_id_mapping[theme_id] common_cause_id = entity_id_mapping[cause_id] event_map[event["type"]].append( (event["trigger"], common_theme_id, common_cause_id) ) return event_map def _map_coreferences(self, annotation: Dict, entity_mapping: Dict) -> Dict: """ Maps the all coreferences of the given example to their merged entity identifiers (if existent) """ id_to_corefs = defaultdict(set) for coreference in annotation["coreferences"]: entity_ids = set( [ entity_mapping[id] for id in coreference["entity_ids"] if id in entity_mapping ] ) # Are both id's also in the merged version? if len(entity_ids) > 1: id_to_corefs[coreference["id"]] = entity_ids return id_to_corefs def _overlaps(self, annotation1: Dict, annotation2: Dict) -> bool: """ Checks whether the offsets of the two given annotations overlap. """ for (start1, end1) in annotation1["offsets"]: for (start2, end2) in annotation2["offsets"]: if (start2 <= start1 <= end2) or (start2 <= end1 <= end2): return True return False def _get_event_argument(self, event: Dict, role: str) -> Optional[str]: """ Returns the argument with the given role from the given event annotation. """ for argument in event["arguments"]: if argument["role"] == role: return argument["ref_id"] return None