Create brat.py

brat.py

@@ -0,0 +1,242 @@
+import dataclasses
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+import datasets
+import pytorch_ie
+from pytorch_ie.annotations import BinaryRelation, LabeledSpan, _post_init_single_label
+from pytorch_ie.core import Annotation, AnnotationList, Document, annotation_field
+
+logger = logging.getLogger(__name__)
+
+
+def dl2ld(dict_of_lists: Dict[str, List[Any]]) -> List[Dict[str, Any]]:
+    return [dict(zip(dict_of_lists, t)) for t in zip(*dict_of_lists.values())]
+
+
+def ld2dl(
+    list_fo_dicts: List[Dict[str, Any]], keys: Optional[List[str]] = None
+) -> Dict[str, List[Any]]:
+    keys = keys or list(list_fo_dicts[0])
+    return {k: [dic[k] for dic in list_fo_dicts] for k in keys}
+
+
+@dataclasses.dataclass(eq=True, frozen=True)
+class Attribution(Annotation):
+    target_annotation: Annotation
+    label: str
+    value: Optional[str] = None
+    score: float = 1.0
+
+    def __post_init__(self) -> None:
+        _post_init_single_label(self)
+
+
+@dataclasses.dataclass
+class BratDocument(Document):
+    text: str
+    id: Optional[str] = None
+    metadata: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    spans: AnnotationList[LabeledSpan] = annotation_field(target="text")
+    relations: AnnotationList[BinaryRelation] = annotation_field(target="spans")
+    span_attributions: AnnotationList[Attribution] = annotation_field(target="spans")
+    relation_attributions: AnnotationList[Attribution] = annotation_field(target="relations")
+
+
+def example_to_document(example: Dict[str, Any]) -> BratDocument:
+    doc = BratDocument(text=example["context"], id=example["file_name"])
+
+    spans: Dict[str, LabeledSpan] = dict()
+    span_locations: List[List[Tuple[int, int]]] = []
+    span_texts: List[str] = []
+    for span_dict in dl2ld(example["spans"]):
+        starts = span_dict["locations"]["start"]
+        ends = span_dict["locations"]["end"]
+        span_locations.append(list(zip(starts, ends)))
+        span_texts.append(span_dict["text"])
+        # sanity check
+        span_text_parts = [doc.text[start:end] for start, end in zip(starts, ends)]
+        joined_span_texts_stripped = " ".join(span_text_parts).strip()
+        span_text_stripped = span_dict["text"].strip()
+        if joined_span_texts_stripped != span_text_stripped:
+            raise Exception(
+                f"joined span parts does not match stripped span text field content. "
+                f'joined_span_texts_stripped: "{joined_span_texts_stripped}" != stripped "text": "{span_text_stripped}"'
+            )
+        # just take everything
+        start = min(starts)
+        end = max(ends)
+        span = LabeledSpan(start=start, end=end, label=span_dict["type"])
+        spans[span_dict["id"]] = span
+
+    doc.spans.extend(spans.values())
+    doc.metadata["span_ids"] = list(spans.keys())
+    doc.metadata["span_locations"] = span_locations
+    doc.metadata["span_texts"] = span_texts
+
+    relations: Dict[str, BinaryRelation] = dict()
+    for rel_dict in dl2ld(example["relations"]):
+        arguments = dict(zip(rel_dict["arguments"]["type"], rel_dict["arguments"]["target"]))
+        assert set(arguments) == {"Arg1", "Arg2"}
+        head = spans[arguments["Arg1"]]
+        tail = spans[arguments["Arg2"]]
+        rel = BinaryRelation(head=head, tail=tail, label=rel_dict["type"])
+        relations[rel_dict["id"]] = rel
+
+    doc.relations.extend(relations.values())
+    doc.metadata["relation_ids"] = list(relations.keys())
+
+    equivalence_relations = dl2ld(example["equivalence_relations"])
+    if len(equivalence_relations) > 0:
+        raise NotImplementedError("converting equivalence_relations is not yet implemented")
+
+    events = dl2ld(example["events"])
+    if len(events) > 0:
+        raise NotImplementedError("converting events is not yet implemented")
+
+    span_attributions: Dict[str, Attribution] = dict()
+    attribution_ids = []
+    for attribution_dict in dl2ld(example["attributions"]):
+        target_id = attribution_dict["target"]
+        if target_id in spans:
+            target_layer_name = "spans"
+            target_annotation = spans[target_id]
+        elif target_id in relations:
+            target_layer_name = "relations"
+            target_annotation = relations[target_id]
+        else:
+            raise Exception("only span and relation attributions are supported yet")
+        attribution = Attribution(
+            target_annotation=target_annotation,
+            label=attribution_dict["type"],
+            value=attribution_dict["value"],
+        )
+        span_attributions[attribution_dict["id"]] = attribution
+        attribution_ids.append((target_layer_name, attribution_dict["id"]))
+
+    doc.span_attributions.extend(span_attributions.values())
+    doc.metadata["attribution_ids"] = attribution_ids
+
+    normalizations = dl2ld(example["normalizations"])
+    if len(normalizations) > 0:
+        raise NotImplementedError("converting normalizations is not yet implemented")
+
+    notes = dl2ld(example["notes"])
+    if len(notes) > 0:
+        raise NotImplementedError("converting notes is not yet implemented")
+
+    return doc
+
+
+def document_to_example(document: BratDocument) -> Dict[str, Any]:
+    example = {
+        "context": document.text,
+        "file_name": document.id,
+    }
+    span_dicts: Dict[LabeledSpan, Dict[str, Any]] = dict()
+    assert len(document.metadata["span_locations"]) == len(document.spans)
+    assert len(document.metadata["span_texts"]) == len(document.spans)
+    assert len(document.metadata["span_ids"]) == len(document.spans)
+    for i, span in enumerate(document.spans):
+        locations = document.metadata["span_locations"][i]
+        assert locations[0][0] == span.start
+        assert locations[-1][1] == span.end
+        starts, ends = zip(*locations)
+        span_dict = {
+            "id": document.metadata["span_ids"][i],
+            "locations": {
+                "start": list(starts),
+                "end": list(ends),
+            },
+            "text": document.metadata["span_texts"][i],
+            "type": span.label,
+        }
+        if span in span_dicts:
+            prev_ann_dict = span_dicts[span]
+            ann_dict = span_dict
+            logger.warning(
+                f"document {document.id}: annotation exists twice: {prev_ann_dict['id']} and {ann_dict['id']} are identical"
+            )
+        span_dicts[span] = span_dict
+    example["spans"] = ld2dl(list(span_dicts.values()), keys=["id", "type", "locations", "text"])
+
+    relation_dicts: Dict[LabeledSpan, Dict[str, Any]] = dict()
+    assert len(document.metadata["relation_ids"]) == len(document.relations)
+    for i, rel in enumerate(document.relations):
+        arg1_id = span_dicts[rel.head]["id"]
+        arg2_id = span_dicts[rel.tail]["id"]
+        relation_dict = {
+            "id": document.metadata["relation_ids"][i],
+            "type": rel.label,
+            "arguments": {
+                "type": ["Arg1", "Arg2"],
+                "target": [arg1_id, arg2_id],
+            },
+        }
+        if rel in relation_dicts:
+            prev_ann_dict = relation_dicts[rel]
+            ann_dict = relation_dict
+            logger.warning(
+                f"document {document.id}: annotation exists twice: {prev_ann_dict['id']} and {ann_dict['id']} are identical"
+            )
+        relation_dicts[rel] = relation_dict
+
+    example["relations"] = ld2dl(list(relation_dicts.values()), keys=["id", "type", "arguments"])
+
+    example["equivalence_relations"] = ld2dl([], keys=["type", "targets"])
+    example["events"] = ld2dl([], keys=["id", "type", "trigger", "arguments"])
+
+    attribution_dicts: Dict[Annotation, Dict[str, Any]] = dict()
+    span_attribution_ids = [
+        attribution_id
+        for target_layer, attribution_id in document.metadata["attribution_ids"]
+        if target_layer == "spans"
+    ]
+    assert len(span_attribution_ids) == len(document.span_attributions)
+    for i, span_attribution in enumerate(document.span_attributions):
+        target_id = span_dicts[span_attribution.target_annotation]["id"]
+        attribution_dict = {
+            "id": span_attribution_ids[i],
+            "type": span_attribution.label,
+            "target": target_id,
+            "value": span_attribution.value,
+        }
+        if span_attribution in attribution_dicts:
+            prev_ann_dict = attribution_dicts[span_attribution]
+            ann_dict = span_attribution
+            logger.warning(
+                f"document {document.id}: annotation exists twice: {prev_ann_dict['id']} and {ann_dict['id']} are identical"
+            )
+        attribution_dicts[span_attribution] = attribution_dict
+
+    example["attributions"] = ld2dl(
+        list(attribution_dicts.values()), keys=["id", "type", "target", "value"]
+    )
+    example["normalizations"] = ld2dl(
+        [], keys=["id", "type", "target", "resource_id", "entity_id"]
+    )
+    example["notes"] = ld2dl([], keys=["id", "type", "target", "note"])
+
+    return example
+
+
+class BratConfig(datasets.BuilderConfig):
+    """BuilderConfig for BratDatasetLoader."""
+
+    def __init__(self, **kwargs):
+        """BuilderConfig for DocRED.
+        Args:
+          **kwargs: keyword arguments forwarded to super.
+        """
+        super().__init__(**kwargs)
+
+
+class BratDatasetLoader(pytorch_ie.data.builder.GeneratorBasedBuilder):
+    DOCUMENT_TYPE = BratDocument
+
+    BUILDER_CONFIG_CLASS = BratConfig
+
+    BASE_DATASET_PATH = "DFKI-SLT/brat"
+
+    def _generate_document(self, example, **kwargs):
+        return example_to_document(example)