|
from dataclasses import dataclass, field |
|
from typing import Any, Dict, Optional |
|
|
|
import datasets |
|
from pie_modules.document.processing import token_based_document_to_text_based |
|
from pytorch_ie.annotations import BinaryRelation, LabeledSpan |
|
from pytorch_ie.core import Annotation, AnnotationList, annotation_field |
|
from pytorch_ie.documents import ( |
|
TextDocumentWithLabeledSpansAndBinaryRelations, |
|
TokenBasedDocument, |
|
) |
|
|
|
from pie_datasets import GeneratorBasedBuilder |
|
|
|
|
|
@dataclass(eq=True, frozen=True) |
|
class TokenRelation(Annotation): |
|
head_idx: int |
|
tail_idx: int |
|
label: str |
|
score: float = field(default=1.0, compare=False) |
|
|
|
|
|
@dataclass(eq=True, frozen=True) |
|
class TokenAttribute(Annotation): |
|
idx: int |
|
label: str |
|
|
|
|
|
@dataclass |
|
class TacredDocument(TokenBasedDocument): |
|
stanford_ner: AnnotationList[TokenAttribute] = annotation_field(target="tokens") |
|
stanford_pos: AnnotationList[TokenAttribute] = annotation_field(target="tokens") |
|
entities: AnnotationList[LabeledSpan] = annotation_field(target="tokens") |
|
relations: AnnotationList[BinaryRelation] = annotation_field(target="entities") |
|
dependency_relations: AnnotationList[TokenRelation] = annotation_field(target="tokens") |
|
|
|
|
|
@dataclass |
|
class SimpleTacredDocument(TokenBasedDocument): |
|
labeled_spans: AnnotationList[LabeledSpan] = annotation_field(target="tokens") |
|
binary_relations: AnnotationList[BinaryRelation] = annotation_field(target="labeled_spans") |
|
|
|
|
|
def example_to_document( |
|
example: Dict[str, Any], |
|
relation_labels: datasets.ClassLabel, |
|
ner_labels: datasets.ClassLabel, |
|
) -> TacredDocument: |
|
document = TacredDocument( |
|
tokens=tuple(example["token"]), id=example["id"], metadata=dict(doc_id=example["docid"]) |
|
) |
|
|
|
for idx, (ner, pos) in enumerate(zip(example["stanford_ner"], example["stanford_pos"])): |
|
document.stanford_ner.append(TokenAttribute(idx=idx, label=ner)) |
|
document.stanford_pos.append(TokenAttribute(idx=idx, label=pos)) |
|
|
|
for tail_idx, (deprel_label, head_idx) in enumerate( |
|
zip(example["stanford_deprel"], example["stanford_head"]) |
|
): |
|
if head_idx >= 0: |
|
document.dependency_relations.append( |
|
TokenRelation( |
|
head_idx=head_idx, |
|
tail_idx=tail_idx, |
|
label=deprel_label, |
|
) |
|
) |
|
|
|
head = LabeledSpan( |
|
start=example["subj_start"], |
|
end=example["subj_end"], |
|
label=ner_labels.int2str(example["subj_type"]), |
|
) |
|
tail = LabeledSpan( |
|
start=example["obj_start"], |
|
end=example["obj_end"], |
|
label=ner_labels.int2str(example["obj_type"]), |
|
) |
|
document.entities.append(head) |
|
document.entities.append(tail) |
|
|
|
relation_str = relation_labels.int2str(example["relation"]) |
|
relation = BinaryRelation(head=head, tail=tail, label=relation_str) |
|
document.relations.append(relation) |
|
|
|
return document |
|
|
|
|
|
def _entity_to_dict( |
|
entity: LabeledSpan, key_prefix: str = "", labels: Optional[datasets.ClassLabel] = None |
|
) -> Dict[str, Any]: |
|
return { |
|
f"{key_prefix}start": entity.start, |
|
f"{key_prefix}end": entity.end, |
|
f"{key_prefix}type": labels.str2int(entity.label) if labels is not None else entity.label, |
|
} |
|
|
|
|
|
def document_to_example( |
|
document: TacredDocument, |
|
ner_labels: Optional[datasets.ClassLabel] = None, |
|
relation_labels: Optional[datasets.ClassLabel] = None, |
|
) -> Dict[str, Any]: |
|
token = list(document.tokens) |
|
stanford_ner_dict = {ner.idx: ner.label for ner in document.stanford_ner} |
|
stanford_pos_dict = {pos.idx: pos.label for pos in document.stanford_pos} |
|
stanford_ner = [stanford_ner_dict[idx] for idx in range(len(token))] |
|
stanford_pos = [stanford_pos_dict[idx] for idx in range(len(token))] |
|
|
|
stanford_deprel = ["ROOT"] * len(document.tokens) |
|
stanford_head = [-1] * len(document.tokens) |
|
for dep_rel in document.dependency_relations: |
|
stanford_deprel[dep_rel.tail_idx] = dep_rel.label |
|
stanford_head[dep_rel.tail_idx] = dep_rel.head_idx |
|
|
|
rel = document.relations[0] |
|
obj: LabeledSpan = rel.tail |
|
subj: LabeledSpan = rel.head |
|
return { |
|
"id": document.id, |
|
"docid": document.metadata["doc_id"], |
|
"relation": rel.label if relation_labels is None else relation_labels.str2int(rel.label), |
|
"token": token, |
|
"stanford_ner": stanford_ner, |
|
"stanford_pos": stanford_pos, |
|
"stanford_deprel": stanford_deprel, |
|
"stanford_head": stanford_head, |
|
**_entity_to_dict(obj, key_prefix="obj_", labels=ner_labels), |
|
**_entity_to_dict(subj, key_prefix="subj_", labels=ner_labels), |
|
} |
|
|
|
|
|
def convert_to_text_document_with_labeled_spans_and_binary_relations( |
|
document: TacredDocument, |
|
) -> TextDocumentWithLabeledSpansAndBinaryRelations: |
|
doc_simplified = document.as_type( |
|
SimpleTacredDocument, |
|
field_mapping={"entities": "labeled_spans", "relations": "binary_relations"}, |
|
) |
|
result = token_based_document_to_text_based( |
|
doc_simplified, |
|
result_document_type=TextDocumentWithLabeledSpansAndBinaryRelations, |
|
join_tokens_with=" ", |
|
) |
|
return result |
|
|
|
|
|
class TacredConfig(datasets.BuilderConfig): |
|
"""BuilderConfig for Tacred.""" |
|
|
|
def __init__(self, **kwargs): |
|
"""BuilderConfig for Tacred. |
|
|
|
Args: |
|
**kwargs: keyword arguments forwarded to super. |
|
""" |
|
super().__init__(**kwargs) |
|
|
|
|
|
class Tacred(GeneratorBasedBuilder): |
|
DOCUMENT_TYPE = TacredDocument |
|
|
|
DOCUMENT_CONVERTERS = { |
|
TextDocumentWithLabeledSpansAndBinaryRelations: convert_to_text_document_with_labeled_spans_and_binary_relations, |
|
} |
|
|
|
BASE_DATASET_PATH = "DFKI-SLT/tacred" |
|
BASE_DATASET_REVISION = "c801dc186b40a532c5820b4662570390da90431b" |
|
|
|
BUILDER_CONFIGS = [ |
|
TacredConfig( |
|
name="original", version=datasets.Version("1.1.0"), description="The original TACRED." |
|
), |
|
TacredConfig( |
|
name="revisited", |
|
version=datasets.Version("1.1.0"), |
|
description="The revised TACRED (corrected labels in dev and test split).", |
|
), |
|
TacredConfig( |
|
name="re-tacred", |
|
version=datasets.Version("1.1.0"), |
|
description="Relabeled TACRED (corrected labels for all splits and pruned)", |
|
), |
|
] |
|
|
|
def _generate_document_kwargs(self, dataset): |
|
return { |
|
"ner_labels": dataset.features["subj_type"], |
|
"relation_labels": dataset.features["relation"], |
|
} |
|
|
|
def _generate_document(self, example, **kwargs): |
|
return example_to_document(example, **kwargs) |
|
|
