upgrade to pie-datasets 0.3.0

README.md

@@ -0,0 +1,80 @@
+# PIE Dataset Card for "conll2003"
+
+This is a [PyTorch-IE](https://github.com/ChristophAlt/pytorch-ie) wrapper for the
+[BRAT Huggingface dataset loading script](https://huggingface.co/datasets/DFKI-SLT/brat).
+
+## Data Schema
+
+The document type for this dataset is `BratDocument` or `BratDocumentWithMergedSpans`, depending on if the
+data was loaded with `merge_fragmented_spans=True` (default: `False`). They define the following data fields:
+
+- `text` (str)
+- `id` (str, optional)
+- `metadata` (dictionary, optional)
+
+and the following annotation layers:
+
+- `spans` (annotation type: `LabeledMultiSpan` in the case of `BratDocument` and `LabeledSpan` and in the case of `BratDocumentWithMergedSpans`, target: `text`)
+- `relations` (annotation type: `BinaryRelation`, target: `spans`)
+- `span_attributes` (annotation type: `Attribute`, target: `spans`)
+- `relation_attributes` (annotation type: `Attribute`, target: `relations`)
+
+The `Attribute` annotation type is defined as follows:
+
+- `annotation` (type: `Annotation`): the annotation to which the attribute is attached
+- `label` (type: `str`)
+- `value` (type: `str`, optional)
+- `score` (type: `float`, optional, not included in comparison)
+
+See [here](https://github.com/ChristophAlt/pytorch-ie/blob/main/src/pytorch_ie/annotations.py) for the remaining annotation type definitions.
+
+## Document Converters
+
+The dataset provides no predefined document converters because the BRAT format is very flexible and can be used
+for many different tasks. You can add your own document converter by doing the following:
+
+```python
+import dataclasses
+from typing import Optional
+
+from pytorch_ie.core import AnnotationList, annotation_field
+from pytorch_ie.documents import TextBasedDocument
+from pytorch_ie.annotations import LabeledSpan
+
+from pie_datasets import DatasetDict
+
+# define your document class
+@dataclasses.dataclass
+class MyDocument(TextBasedDocument):
+    my_field: Optional[str] = None
+    my_span_annotations: AnnotationList[LabeledSpan] = annotation_field(target="text")
+
+# define your document converter
+def my_converter(document: BratDocumentWithMergedSpans) -> MyDocument:
+    # create your document with the data from the original document.
+    # The fields "text", "id" and "metadata" are derived from the TextBasedDocument.
+    my_document = MyDocument(id=document.id, text=document.text, metadata=document.metadata, my_field="my_value")
+
+    # create a new span annotation
+    new_span = LabeledSpan(label="my_label", start=2, end=10)
+    # add the new span annotation to your document
+    my_document.my_span_annotations.append(new_span)
+
+    # add annotations from the document to your document
+    for span in document.spans:
+        # we need to copy the span because an annotation can only be attached to one document
+        my_document.my_span_annotations.append(span.copy())
+
+    return my_document
+
+
+# load the dataset. We use the "merge_fragmented_spans" dataset variant here
+# because it provides documents of type BratDocumentWithMergedSpans.
+dataset = DatasetDict.load_dataset("pie/brat", name="merge_fragmented_spans", data_dir="path/to/brat/data")
+
+# attach your document converter to the dataset
+dataset.register_document_converter(my_converter)
+
+# convert the dataset
+converted_dataset = dataset.to_document_type(MyDocument)
+```

brat.py

@@ -1,16 +1,14 @@
 import dataclasses
 import logging
+from collections import defaultdict
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import datasets
-import pytorch_ie
-from pytorch_ie.annotations import (
-    BinaryRelation,
-    LabeledMultiSpan,
-    LabeledSpan,
-    _post_init_single_label,
-)
-from pytorch_ie.core import Annotation, AnnotationList, Document, annotation_field
+from pytorch_ie.annotations import BinaryRelation, LabeledMultiSpan, LabeledSpan
+from pytorch_ie.core import Annotation, AnnotationList, annotation_field
+from pytorch_ie.documents import TextBasedDocument
+
+from pie_datasets import GeneratorBasedBuilder
 
 logger = logging.getLogger(__name__)
 
@@ -28,41 +26,32 @@ def ld2dl(
 
 @dataclasses.dataclass(eq=True, frozen=True)
 class Attribute(Annotation):
-    target_annotation: Annotation
+    annotation: Annotation
     label: str
     value: Optional[str] = None
-    score: float = 1.0
-
-    def __post_init__(self) -> None:
-        _post_init_single_label(self)
+    score: Optional[float] = dataclasses.field(default=None, compare=False)
 
 
 @dataclasses.dataclass
-class BratDocument(Document):
-    text: str
-    id: Optional[str] = None
-    metadata: Dict[str, Any] = dataclasses.field(default_factory=dict)
+class BratDocument(TextBasedDocument):
     spans: AnnotationList[LabeledMultiSpan] = annotation_field(target="text")
     relations: AnnotationList[BinaryRelation] = annotation_field(target="spans")
-    span_attributions: AnnotationList[Attribute] = annotation_field(target="spans")
-    relation_attributions: AnnotationList[Attribute] = annotation_field(target="relations")
+    span_attributes: AnnotationList[Attribute] = annotation_field(target="spans")
+    relation_attributes: AnnotationList[Attribute] = annotation_field(target="relations")
 
 
 @dataclasses.dataclass
-class BratDocumentWithMergedSpans(Document):
-    text: str
-    id: Optional[str] = None
-    metadata: Dict[str, Any] = dataclasses.field(default_factory=dict)
+class BratDocumentWithMergedSpans(TextBasedDocument):
     spans: AnnotationList[LabeledSpan] = annotation_field(target="text")
     relations: AnnotationList[BinaryRelation] = annotation_field(target="spans")
-    span_attributions: AnnotationList[Attribute] = annotation_field(target="spans")
-    relation_attributions: AnnotationList[Attribute] = annotation_field(target="relations")
+    span_attributes: AnnotationList[Attribute] = annotation_field(target="spans")
+    relation_attributes: AnnotationList[Attribute] = annotation_field(target="relations")
 
 
 def example_to_document(
-    example: Dict[str, Any], merge_non_contiguous_spans: bool = False
+    example: Dict[str, Any], merge_fragmented_spans: bool = False
 ) -> BratDocument:
-    if merge_non_contiguous_spans:
+    if merge_fragmented_spans:
         doc = BratDocumentWithMergedSpans(text=example["context"], id=example["file_name"])
     else:
         doc = BratDocument(text=example["context"], id=example["file_name"])
@@ -85,14 +74,19 @@ def example_to_document(
                 f"joined span parts do not match stripped span text field content. "
                 f'joined_span_texts_stripped: "{joined_span_texts_stripped}" != stripped "text": "{span_text_stripped}"'
             )
-        if merge_non_contiguous_spans:
+        if merge_fragmented_spans:
             if len(starts) > 1:
                 # check if the text in between the fragments holds only space
-                merged_content_texts = [doc.text[start:end] for start, end in zip(ends[:-1],starts[1:])]
-                merged_content_texts_not_empty = [text.strip() for text in merged_content_texts if text.strip() != ""]
+                merged_content_texts = [
+                    doc.text[start:end] for start, end in zip(ends[:-1], starts[1:])
+                ]
+                merged_content_texts_not_empty = [
+                    text.strip() for text in merged_content_texts if text.strip() != ""
+                ]
                 if len(merged_content_texts_not_empty) > 0:
                     logger.warning(
-                        f"document '{doc.id}' contains a non-contiguous span with text content in between (will be merged into a single span): "
+                        f"document '{doc.id}' contains a non-contiguous span with text content in between "
+                        f"(will be merged into a single span): "
                         f"newly covered text parts: {merged_content_texts_not_empty}, "
                         f"merged span text: '{doc.text[starts[0]:ends[-1]]}', "
                         f"annotation: {span_dict}"
@@ -130,28 +124,29 @@ def example_to_document(
     if len(events) > 0:
         raise NotImplementedError("converting events is not yet implemented")
 
-    span_attributions: Dict[str, Attribute] = dict()
-    attribution_ids = []
-    for attribution_dict in dl2ld(example["attributions"]):
-        target_id = attribution_dict["target"]
+    attribute_annotations: Dict[str, Dict[str, Attribute]] = defaultdict(dict)
+    attribute_ids = []
+    for attribute_dict in dl2ld(example["attributions"]):
+        target_id = attribute_dict["target"]
         if target_id in spans:
             target_layer_name = "spans"
-            target_annotation = spans[target_id]
+            annotation = spans[target_id]
         elif target_id in relations:
             target_layer_name = "relations"
-            target_annotation = relations[target_id]
+            annotation = relations[target_id]
         else:
-            raise Exception("only span and relation attributions are supported yet")
-        attribution = Attribute(
-            target_annotation=target_annotation,
-            label=attribution_dict["type"],
-            value=attribution_dict["value"],
+            raise Exception("only span and relation attributes are supported yet")
+        attribute = Attribute(
+            annotation=annotation,
+            label=attribute_dict["type"],
+            value=attribute_dict["value"],
         )
-        span_attributions[attribution_dict["id"]] = attribution
-        attribution_ids.append((target_layer_name, attribution_dict["id"]))
+        attribute_annotations[target_layer_name][attribute_dict["id"]] = attribute
+        attribute_ids.append((target_layer_name, attribute_dict["id"]))
 
-    doc.span_attributions.extend(span_attributions.values())
-    doc.metadata["attribution_ids"] = attribution_ids
+    doc.span_attributes.extend(attribute_annotations["spans"].values())
+    doc.relation_attributes.extend(attribute_annotations["relations"].values())
+    doc.metadata["attribute_ids"] = attribute_ids
 
     normalizations = dl2ld(example["normalizations"])
     if len(normalizations) > 0:
@@ -199,7 +194,8 @@ def document_to_example(
             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"
+                f"document {document.id}: annotation exists twice: {prev_ann_dict['id']} and {ann_dict['id']} "
+                f"are identical"
             )
         span_dicts[span] = span_dict
     example["spans"] = ld2dl(list(span_dicts.values()), keys=["id", "type", "locations", "text"])
@@ -221,7 +217,8 @@ def document_to_example(
             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"
+                f"document {document.id}: annotation exists twice: {prev_ann_dict['id']} and {ann_dict['id']} "
+                f"are identical"
             )
         relation_dicts[rel] = relation_dict
 
@@ -230,31 +227,41 @@ def document_to_example(
     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
+    annotation_dicts = {
+        "spans": span_dicts,
+        "relations": relation_dicts,
+    }
+    all_attribute_annotations = {
+        "spans": document.span_attributes,
+        "relations": document.relation_attributes,
+    }
+    attribute_dicts: Dict[Annotation, Dict[str, Any]] = dict()
+    attribute_ids_per_target = defaultdict(list)
+    for target_layer, attribute_id in document.metadata["attribute_ids"]:
+        attribute_ids_per_target[target_layer].append(attribute_id)
+
+    for target_layer, attribute_ids in attribute_ids_per_target.items():
+        attribute_annotations = all_attribute_annotations[target_layer]
+        assert len(attribute_ids) == len(attribute_annotations)
+        for i, attribute_annotation in enumerate(attribute_annotations):
+            target_id = annotation_dicts[target_layer][attribute_annotation.annotation]["id"]
+            attribute_dict = {
+                "id": attribute_ids_per_target[target_layer][i],
+                "type": attribute_annotation.label,
+                "target": target_id,
+                "value": attribute_annotation.value,
+            }
+            if attribute_annotation in attribute_dicts:
+                prev_ann_dict = attribute_dicts[attribute_annotation]
+                ann_dict = attribute_annotation
+                logger.warning(
+                    f"document {document.id}: annotation exists twice: {prev_ann_dict['id']} and {ann_dict['id']} "
+                    f"are identical"
+                )
+            attribute_dicts[attribute_annotation] = attribute_dict
 
     example["attributions"] = ld2dl(
-        list(attribution_dicts.values()), keys=["id", "type", "target", "value"]
+        list(attribute_dicts.values()), keys=["id", "type", "target", "value"]
     )
     example["normalizations"] = ld2dl(
         [], keys=["id", "type", "target", "resource_id", "entity_id"]
@@ -267,31 +274,32 @@ def document_to_example(
 class BratConfig(datasets.BuilderConfig):
     """BuilderConfig for BratDatasetLoader."""
 
-    def __init__(self, merge_non_contiguous_spans: bool = False, **kwargs):
+    def __init__(self, merge_fragmented_spans: bool = False, **kwargs):
         """BuilderConfig for DocRED.
+
         Args:
           **kwargs: keyword arguments forwarded to super.
         """
         super().__init__(**kwargs)
-        self.merge_non_contiguous_spans = merge_non_contiguous_spans
+        self.merge_fragmented_spans = merge_fragmented_spans
 
 
-class BratDatasetLoader(pytorch_ie.data.builder.GeneratorBasedBuilder):
+class BratDatasetLoader(GeneratorBasedBuilder):
     # this requires https://github.com/ChristophAlt/pytorch-ie/pull/288
     DOCUMENT_TYPES = {
         "default": BratDocument,
-        "merge_non_contiguous_spans": BratDocumentWithMergedSpans,
+        "merge_fragmented_spans": BratDocumentWithMergedSpans,
     }
 
     DEFAULT_CONFIG_NAME = "default"
     BUILDER_CONFIGS = [
         BratConfig(name="default"),
-        BratConfig(name="merge_non_contiguous_spans", merge_non_contiguous_spans=True),
+        BratConfig(name="merge_fragmented_spans", merge_fragmented_spans=True),
     ]
 
     BASE_DATASET_PATH = "DFKI-SLT/brat"
 
     def _generate_document(self, example, **kwargs):
         return example_to_document(
-            example, merge_non_contiguous_spans=self.config.merge_non_contiguous_spans
+            example, merge_fragmented_spans=self.config.merge_fragmented_spans
         )

requirements.txt

@@ -0,0 +1 @@
+pie-datasets>=0.3.0