Datasets:
Tasks:
Token Classification
Sub-tasks:
parsing
Languages:
English
Multilinguality:
monolingual
Size Categories:
unknown
Language Creators:
found
Annotations Creators:
expert-generated
Source Datasets:
original
| import glob | |
| import logging | |
| from dataclasses import dataclass | |
| from os import listdir, path | |
| from typing import Dict, List, Optional | |
| import datasets | |
| from datasets import BuilderConfig, DatasetInfo, Features, Sequence, SplitGenerator, Value | |
| logger = logging.getLogger(__name__) | |
| class BratConfig(BuilderConfig): | |
| """BuilderConfig for BRAT.""" | |
| url: str = None # type: ignore | |
| description: Optional[str] = None | |
| citation: Optional[str] = None | |
| homepage: Optional[str] = None | |
| subdirectory_mapping: Optional[Dict[str, str]] = None | |
| file_name_blacklist: Optional[List[str]] = None | |
| ann_file_extension: str = "ann" | |
| txt_file_extension: str = "txt" | |
| class Brat(datasets.GeneratorBasedBuilder): | |
| BUILDER_CONFIG_CLASS = BratConfig | |
| def _info(self): | |
| return DatasetInfo( | |
| description=self.config.description, | |
| citation=self.config.citation, | |
| homepage=self.config.homepage, | |
| features=Features( | |
| { | |
| "context": Value("string"), | |
| "file_name": Value("string"), | |
| "spans": Sequence( | |
| { | |
| "id": Value("string"), | |
| "type": Value("string"), | |
| "locations": Sequence( | |
| { | |
| "start": Value("int32"), | |
| "end": Value("int32"), | |
| } | |
| ), | |
| "text": Value("string"), | |
| } | |
| ), | |
| "relations": Sequence( | |
| { | |
| "id": Value("string"), | |
| "type": Value("string"), | |
| "arguments": Sequence( | |
| {"type": Value("string"), "target": Value("string")} | |
| ), | |
| } | |
| ), | |
| "equivalence_relations": Sequence( | |
| { | |
| "type": Value("string"), | |
| "targets": Sequence(Value("string")), | |
| } | |
| ), | |
| "events": Sequence( | |
| { | |
| "id": Value("string"), | |
| "type": Value("string"), | |
| "trigger": Value("string"), | |
| "arguments": Sequence( | |
| {"type": Value("string"), "target": Value("string")} | |
| ), | |
| } | |
| ), | |
| "attributions": Sequence( | |
| { | |
| "id": Value("string"), | |
| "type": Value("string"), | |
| "target": Value("string"), | |
| "value": Value("string"), | |
| } | |
| ), | |
| "normalizations": Sequence( | |
| { | |
| "id": Value("string"), | |
| "type": Value("string"), | |
| "target": Value("string"), | |
| "resource_id": Value("string"), | |
| "entity_id": Value("string"), | |
| } | |
| ), | |
| "notes": Sequence( | |
| { | |
| "id": Value("string"), | |
| "type": Value("string"), | |
| "target": Value("string"), | |
| "note": Value("string"), | |
| } | |
| ), | |
| } | |
| ), | |
| ) | |
| def _get_location(location_string): | |
| parts = location_string.split(" ") | |
| assert ( | |
| len(parts) == 2 | |
| ), f"Wrong number of entries in location string. Expected 2, but found: {parts}" | |
| return {"start": int(parts[0]), "end": int(parts[1])} | |
| def _get_span_annotation(annotation_line): | |
| """ | |
| example input: | |
| T1 Organization 0 4 Sony | |
| """ | |
| _id, remaining, text = annotation_line.split("\t", maxsplit=2) | |
| _type, locations = remaining.split(" ", maxsplit=1) | |
| return { | |
| "id": _id, | |
| "text": text, | |
| "type": _type, | |
| "locations": [Brat._get_location(loc) for loc in locations.split(";")], | |
| } | |
| def _get_event_annotation(annotation_line): | |
| """ | |
| example input: | |
| E1 MERGE-ORG:T2 Org1:T1 Org2:T3 | |
| """ | |
| _id, remaining = annotation_line.strip().split("\t") | |
| args = [dict(zip(["type", "target"], a.split(":"))) for a in remaining.split(" ")] | |
| return { | |
| "id": _id, | |
| "type": args[0]["type"], | |
| "trigger": args[0]["target"], | |
| "arguments": args[1:], | |
| } | |
| def _get_relation_annotation(annotation_line): | |
| """ | |
| example input: | |
| R1 Origin Arg1:T3 Arg2:T4 | |
| """ | |
| _id, remaining = annotation_line.strip().split("\t") | |
| _type, remaining = remaining.split(" ", maxsplit=1) | |
| args = [dict(zip(["type", "target"], a.split(":"))) for a in remaining.split(" ")] | |
| return {"id": _id, "type": _type, "arguments": args} | |
| def _get_equivalence_relation_annotation(annotation_line): | |
| """ | |
| example input: | |
| * Equiv T1 T2 T3 | |
| """ | |
| _, remaining = annotation_line.strip().split("\t") | |
| parts = remaining.split(" ") | |
| return {"type": parts[0], "targets": parts[1:]} | |
| def _get_attribute_annotation(annotation_line): | |
| """ | |
| example input (binary: implicit value is True, if present, False otherwise): | |
| A1 Negation E1 | |
| example input (multi-value: explicit value) | |
| A2 Confidence E2 L1 | |
| """ | |
| _id, remaining = annotation_line.strip().split("\t") | |
| parts = remaining.split(" ") | |
| # if no value is present, it is implicitly "true" | |
| if len(parts) == 2: | |
| parts.append("true") | |
| return { | |
| "id": _id, | |
| "type": parts[0], | |
| "target": parts[1], | |
| "value": parts[2], | |
| } | |
| def _get_normalization_annotation(annotation_line): | |
| """ | |
| example input: | |
| N1 Reference T1 Wikipedia:534366 Barack Obama | |
| """ | |
| _id, remaining, text = annotation_line.split("\t", maxsplit=2) | |
| _type, target, ref = remaining.split(" ") | |
| res_id, ent_id = ref.split(":") | |
| return { | |
| "id": _id, | |
| "type": _type, | |
| "target": target, | |
| "resource_id": res_id, | |
| "entity_id": ent_id, | |
| } | |
| def _get_note_annotation(annotation_line): | |
| """ | |
| example input: | |
| #1 AnnotatorNotes T1 this annotation is suspect | |
| """ | |
| _id, remaining, note = annotation_line.split("\t", maxsplit=2) | |
| _type, target = remaining.split(" ") | |
| return { | |
| "id": _id, | |
| "type": _type, | |
| "target": target, | |
| "note": note, | |
| } | |
| def _read_annotation_file(filename): | |
| """ | |
| reads a BRAT v1.3 annotations file (see https://brat.nlplab.org/standoff.html) | |
| """ | |
| res = { | |
| "spans": [], | |
| "events": [], | |
| "relations": [], | |
| "equivalence_relations": [], | |
| "attributions": [], | |
| "normalizations": [], | |
| "notes": [], | |
| } | |
| with open(filename) as file: | |
| for i, line in enumerate(file): | |
| if len(line.strip()) == 0: | |
| continue | |
| ann_type = line[0] | |
| # strip away the new line character | |
| if line.endswith("\n"): | |
| line = line[:-1] | |
| if ann_type == "T": | |
| res["spans"].append(Brat._get_span_annotation(line)) | |
| elif ann_type == "E": | |
| res["events"].append(Brat._get_event_annotation(line)) | |
| elif ann_type == "R": | |
| res["relations"].append(Brat._get_relation_annotation(line)) | |
| elif ann_type == "*": | |
| res["equivalence_relations"].append( | |
| Brat._get_equivalence_relation_annotation(line) | |
| ) | |
| elif ann_type in ["A", "M"]: | |
| res["attributions"].append(Brat._get_attribute_annotation(line)) | |
| elif ann_type == "N": | |
| res["normalizations"].append(Brat._get_normalization_annotation(line)) | |
| elif ann_type == "#": | |
| res["notes"].append(Brat._get_note_annotation(line)) | |
| else: | |
| raise ValueError( | |
| f'unknown BRAT annotation id type: "{line}" (from file {filename} @line {i}). ' | |
| f"Annotation ids have to start with T (spans), E (events), R (relations), " | |
| f"A (attributions), or N (normalizations). See " | |
| f"https://brat.nlplab.org/standoff.html for the BRAT annotation file " | |
| f"specification." | |
| ) | |
| return res | |
| def _generate_examples(self, files=None, directory=None): | |
| """Read context (.txt) and annotation (.ann) files.""" | |
| if files is None: | |
| assert ( | |
| directory is not None | |
| ), "If files is None, directory has to be provided, but it is also None." | |
| _files = glob.glob(f"{directory}/*.{self.config.ann_file_extension}") | |
| files = sorted(path.splitext(fn)[0] for fn in _files) | |
| for filename in files: | |
| basename = path.basename(filename) | |
| if ( | |
| self.config.file_name_blacklist is not None | |
| and basename in self.config.file_name_blacklist | |
| ): | |
| logger.info(f"skip annotation file: {basename} (blacklisted)") | |
| continue | |
| ann_fn = f"{filename}.{self.config.ann_file_extension}" | |
| brat_annotations = Brat._read_annotation_file(ann_fn) | |
| txt_fn = f"{filename}.{self.config.txt_file_extension}" | |
| txt_content = open(txt_fn).read() | |
| brat_annotations["context"] = txt_content | |
| brat_annotations["file_name"] = basename | |
| yield basename, brat_annotations | |
| def _split_generators(self, dl_manager): | |
| """Returns SplitGenerators.""" | |
| subdirectory_mapping = self.config.subdirectory_mapping | |
| # since subclasses of BuilderConfig are not allowed to define | |
| # attributes without defaults, check here | |
| assert self.config.url is not None, "data url not specified" | |
| # if url points to a local directory, just point to that | |
| if path.exists(self.config.url) and path.isdir(self.config.url): | |
| data_dir = self.config.url | |
| # otherwise, download and extract | |
| else: | |
| data_dir = dl_manager.download_and_extract(self.config.url) | |
| logging.info(f"load from data dir: {data_dir}") | |
| # if no subdirectory mapping is provided, ... | |
| if subdirectory_mapping is None: | |
| # ... use available subdirectories as split names ... | |
| subdirs = [f for f in listdir(data_dir) if path.isdir(path.join(data_dir, f))] | |
| if len(subdirs) > 0: | |
| subdirectory_mapping = {subdir: subdir for subdir in subdirs} | |
| else: | |
| # ... otherwise, default to a single train split with the base directory | |
| subdirectory_mapping = {"": "train"} | |
| return [ | |
| SplitGenerator( | |
| name=split, | |
| # These kwargs will be passed to _generate_examples | |
| gen_kwargs={ | |
| "directory": path.join(data_dir, subdir), | |
| }, | |
| ) | |
| for subdir, split in subdirectory_mapping.items() | |
| ] |