use pie-modules instead of pytorch-ie

see https://github.com/ArneBinder/pie-datasets/pull/204 for further information

README.md

@@ -0,0 +1,47 @@
+# PIE Dataset Card for CoNLL2012 shared task data based on OntoNotes 5.0
+
+This is a [PyTorch-IE](https://github.com/ChristophAlt/pytorch-ie) (PIE) wrapper for the
+[CoNLL 2012 OntoNotes v.5.0 Huggingface dataset loading script](https://huggingface.co/datasets/conll2012_ontonotesv5).
+
+## Dataset Variants
+
+This dataset contains data in three languages and two versions:
+
+- `arabic_v4`
+- `chinese_v4`
+- `english_v4`
+- `english_v12`
+
+## Data Schema
+
+The document type for this dataset is `Conll2012OntonotesV5Document` which defines the following data fields:
+
+- `id` (str)
+- `tokens` (tuple)
+- `pos_tags` (list)
+- `metadata` (dictionary, optional)
+
+and the following annotation layers:
+
+- `entities` (annotation type: `LabeledSpan`, target: `tokens`)
+- `parts` (annotation type: `LabeledSpan`, target: `tokens`)
+- `predicates` (annotation type: `Predicate`, target: `tokens`)
+- `sentences` (annotation type: `Span`, target: `tokens`)
+- `coref_mentions` (annotation type: `Span`, target: `tokens`)
+- `coref_clusters` (annotation type: `SpanSet`, target: `coref_mentions`)
+- `srl_arguments` (annotation type: `Span`, target: `tokens`)
+- `srl_relations` (annotation type: `NaryRelation`, target: `srl_arguments`)
+- `word_senses` (annotation type: `LabeledSpan`, target: `tokens`)
+- `speakers` (annotation type: `Attribute`, target: `sentences`)
+- `parse_trees` (annotation type: `Attribute`, target: `sentences`)
+
+See [here](https://github.com/ArneBinder/pie-modules/blob/main/src/pie_modules/annotations.py) for the annotation type definitions.
+
+## Document Converters
+
+The dataset provides document converters for the following target document types:
+
+- `pie_modules.documents.TextDocumentWithLabeledSpansAndLabeledPartitions`
+
+See [here](https://github.com/ArneBinder/pie-modules/blob/main/src/pie_modules/documents.py) for the document type
+definitions.

conll2012_ontonotesv5.py

@@ -1,12 +1,16 @@
 import dataclasses
 from collections import defaultdict
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import datasets
-import pytorch_ie
-from pytorch_ie.annotations import LabeledSpan, NaryRelation, Span
-from pytorch_ie.core import Annotation, AnnotationList, Document, annotation_field
-from pytorch_ie.documents import TextDocumentWithLabeledEntitiesAndLabeledPartitions
+from pie_core import Annotation, AnnotationLayer, annotation_field
+from pie_modules.annotations import LabeledSpan, NaryRelation, Span
+from pie_modules.documents import (
+    TextDocumentWithLabeledSpansAndLabeledPartitions,
+    TokenBasedDocument,
+)
+
+from pie_datasets import GeneratorBasedBuilder
 
 
 @dataclasses.dataclass(eq=True, frozen=True)
@@ -19,7 +23,7 @@ class SpanSet(Annotation):
         object.__setattr__(
             self,
             "spans",
-            tuple(sorted(set(s for s in self.spans), key=lambda s: (s.start, s.end))),
+            tuple(sorted({s for s in self.spans}, key=lambda s: (s.start, s.end))),
         )
 
 
@@ -37,21 +41,19 @@ class Predicate(Span):
 
 
 @dataclasses.dataclass
-class Conll2012OntonotesV5Document(Document):
-    tokens: List[str]
-    id: str
-    pos_tags: List[str]
-    sentences: AnnotationList[Span] = annotation_field(target="tokens")
-    parse_trees: AnnotationList[Attribute] = annotation_field(target="sentences")
-    speakers: AnnotationList[Attribute] = annotation_field(target="sentences")
-    parts: AnnotationList[LabeledSpan] = annotation_field(target="tokens")
-    coref_mentions: AnnotationList[Span] = annotation_field(target="tokens")
-    coref_clusters: AnnotationList[SpanSet] = annotation_field(target="coref_mentions")
-    srl_arguments: AnnotationList[Span] = annotation_field(target="tokens")
-    srl_relations: AnnotationList[NaryRelation] = annotation_field(target="srl_arguments")
-    entities: AnnotationList[LabeledSpan] = annotation_field(target="tokens")
-    predicates: AnnotationList[Predicate] = annotation_field(target="tokens")
-    word_senses: AnnotationList[LabeledSpan] = annotation_field(target="tokens")
+class Conll2012OntonotesV5Document(TokenBasedDocument):
+    pos_tags: Optional[List[str]] = None
+    sentences: AnnotationLayer[Span] = annotation_field(target="tokens")
+    parse_trees: AnnotationLayer[Attribute] = annotation_field(target="sentences")
+    speakers: AnnotationLayer[Attribute] = annotation_field(target="sentences")
+    parts: AnnotationLayer[LabeledSpan] = annotation_field(target="tokens")
+    coref_mentions: AnnotationLayer[Span] = annotation_field(target="tokens")
+    coref_clusters: AnnotationLayer[SpanSet] = annotation_field(target="coref_mentions")
+    srl_arguments: AnnotationLayer[Span] = annotation_field(target="tokens")
+    srl_relations: AnnotationLayer[NaryRelation] = annotation_field(target="srl_arguments")
+    entities: AnnotationLayer[LabeledSpan] = annotation_field(target="tokens")
+    predicates: AnnotationLayer[Predicate] = annotation_field(target="tokens")
+    word_senses: AnnotationLayer[LabeledSpan] = annotation_field(target="tokens")
 
 
 def bio2spans(bio: List[str], offset: int = 0) -> List[LabeledSpan]:
@@ -99,10 +101,9 @@ def bio2spans(bio: List[str], offset: int = 0) -> List[LabeledSpan]:
 
 def example_to_document(
     example: Dict[str, Any],
-    entities_int2str: Callable[[int], str],
-    pos_tags_int2str: Optional[Callable[[int], str]] = None,
+    entity_labels: datasets.ClassLabel,
+    pos_tag_labels: Optional[datasets.ClassLabel] = None,
 ) -> Conll2012OntonotesV5Document:
-
     sentences = []
     tokens = []
     pos_tags = []
@@ -112,6 +113,7 @@ def example_to_document(
     predicates = []
     coref_mentions = []
     coref_clusters = []
+    coref_cluster_ids = []
     srl_arguments = []
     srl_relations = []
     word_senses = []
@@ -125,10 +127,12 @@ def example_to_document(
         current_sentence = Span(start=sentence_offset, end=sentence_offset + len(current_tokens))
         sentences.append(current_sentence)
 
-        if pos_tags_int2str is not None:
+        if pos_tag_labels is not None:
             pos_tags.extend(
-                [pos_tags_int2str(pos_tag_id) for pos_tag_id in sentence_dict["pos_tags"]]
+                [pos_tag_labels.int2str(pos_tag_id) for pos_tag_id in sentence_dict["pos_tags"]]
             )
+            if pos_tag_labels.int2str is None:
+                raise ValueError("pos_tag_labels.int2str is None.")
         else:
             pos_tags.extend(sentence_dict["pos_tags"])
         parse_trees.append(
@@ -138,7 +142,7 @@ def example_to_document(
             Attribute(target_annotation=current_sentence, label=sentence_dict["speaker"])
         )
         named_entities_bio = [
-            entities_int2str(entity_id) for entity_id in sentence_dict["named_entities"]
+            entity_labels.int2str(entity_id) for entity_id in sentence_dict["named_entities"]
         ]
         entities.extend(bio2spans(bio=named_entities_bio, offset=len(tokens)))
 
@@ -146,7 +150,7 @@ def example_to_document(
             zip(sentence_dict["predicate_lemmas"], sentence_dict["predicate_framenet_ids"])
         ):
             token_idx = sentence_offset + idx
-            if predicate_lemma_value is not None:
+            if predicate_lemma_value is not None or predicate_framenet_id is not None:
                 predicate = Predicate(
                     start=token_idx,
                     end=token_idx + 1,
@@ -165,7 +169,9 @@ def example_to_document(
         current_coref_clusters = [
             SpanSet(spans=tuple(spans)) for spans in coref_clusters_dict.values()
         ]
+        current_coref_cluster_ids = [cluster_id for cluster_id in coref_clusters_dict.keys()]
         coref_clusters.extend(current_coref_clusters)
+        coref_cluster_ids.extend(current_coref_cluster_ids)
 
         # handle srl_frames
         for frame_dict in sentence_dict["srl_frames"]:
@@ -189,7 +195,8 @@ def example_to_document(
             token_idx = sentence_offset + idx
             if word_sense is not None:
                 word_senses.append(
-                    LabeledSpan(start=token_idx, end=token_idx + 1, label=str(int(word_sense)))
+                    # LabeledSpan(start=token_idx, end=token_idx + 1, label=str(int(word_sense)))
+                    LabeledSpan(start=token_idx, end=token_idx + 1, label=str(word_sense))
                 )
 
         # handle parts
@@ -210,11 +217,12 @@ def example_to_document(
         parts.append(LabeledSpan(start=last_start, end=len(tokens), label=str(last_part_id)))
 
     doc = Conll2012OntonotesV5Document(
-        tokens=tokens,
+        tokens=tuple(tokens),
         id=example["document_id"],
         pos_tags=pos_tags,
     )
     # add the annotations to the document
+    doc.parts.extend(parts)
     doc.sentences.extend(sentences)
     doc.parse_trees.extend(parse_trees)
     doc.speakers.extend(speakers)
@@ -225,14 +233,136 @@ def example_to_document(
     doc.srl_arguments.extend(srl_arguments)
     doc.srl_relations.extend(srl_relations)
     doc.word_senses.extend(word_senses)
+    doc.metadata["coref_cluster_ids"] = coref_cluster_ids
 
     return doc
 
 
-def convert_to_text_document_with_labeled_entities_and_labeled_partitions(
+def document_to_example(
+    document: Conll2012OntonotesV5Document,
+    entity_labels: datasets.ClassLabel,
+    pos_tag_labels: Optional[datasets.ClassLabel] = None,
+) -> Dict[str, Any]:
+    example = {
+        "document_id": document.id,
+        "sentences": [],
+    }
+
+    for idx, sentence in enumerate(document.sentences):
+        sent_start = sentence.start
+        sent_end = sentence.end
+        sent_len = sent_end - sent_start
+
+        predicate_lemmas = [None] * sent_len
+        predicate_framenet_ids = [None] * sent_len
+        for pred in document.predicates:
+            if sent_start <= pred.start and pred.end <= sent_end:
+                pred_len = pred.end - pred.start
+                predicate_lemmas[pred.start - sent_start : pred.end - sent_start] = [
+                    pred.lemma
+                ] * pred_len
+                if pred.framenet_id is not None:
+                    predicate_framenet_ids[pred.start - sent_start : pred.end - sent_start] = [
+                        pred.framenet_id
+                    ] * pred_len
+
+        word_senses = [None] * sent_len
+        for sense in document.word_senses:
+            if sent_start <= sense.start and sense.end <= sent_end:
+                word_senses[sense.start - sent_start : sense.end - sent_start] = [
+                    float(sense.label)
+                ] * (sense.end - sense.start)
+
+        named_entities = [0] * sent_len
+        for ent in document.entities:
+            if sent_start <= ent.start and ent.end <= sent_end:
+                ent_len = ent.end - ent.start
+                named_entities[ent.start - sent_start] = entity_labels.str2int("B-" + ent.label)
+                if ent_len > 1:
+                    named_entities[ent.start - sent_start + 1 : ent.end - sent_start] = [
+                        entity_labels.str2int("I-" + ent.label)
+                    ] * (ent_len - 1)
+
+        srl_frames = []
+        for srl_rel in document.srl_relations:
+            span_start = min([span.start for span in srl_rel.arguments])
+            span_end = max([span.end for span in srl_rel.arguments])
+            if sent_start <= span_start and span_end <= sent_end:
+                verb = None
+                frames = ["O"] * sent_len
+                for arg, role in zip(srl_rel.arguments, srl_rel.roles):
+                    frames[arg.start - sent_start] = "B-" + role
+                    if arg.end - arg.start > 1:
+                        frames[arg.start - sent_start + 1 : arg.end - sent_start] = [
+                            "I-" + role
+                        ] * (arg.end - arg.start - 1)
+                    # english_v4 and arabic_v4 contain some weird role names (in addition to "V") for the verb
+                    if role in [
+                        "V",
+                        "ARG0(V",
+                        "ARG1(V",
+                        "C-ARG0(V",
+                        "C-ARG1(V",
+                        "C-ARG2(V",
+                        "R-ARG0(V",
+                        "R-ARG1(V",
+                    ]:
+                        verb = document.tokens[arg.start]
+                if verb is None:
+                    raise ValueError(f"Verb not found for SRL relation: {srl_rel}")
+                srl_frames.append({"verb": verb, "frames": frames})
+
+        coref_spans = []
+        for cluster, id in zip(document.coref_clusters, document.metadata["coref_cluster_ids"]):
+            span_start = min([span.start for span in cluster.spans])
+            span_end = max([span.end for span in cluster.spans])
+            if sent_start <= span_start and span_end <= sent_end:
+                current_coref = [
+                    [id, span.start - sent_start, span.end - sent_start - 1]
+                    for span in cluster.spans
+                ]
+                coref_spans.extend(current_coref)
+
+        for part in document.parts:
+            if part.start <= sent_start and sent_end <= part.end:
+                part_id = int(part.label)
+
+        pos_tags = []
+        if pos_tag_labels is not None:
+            pos_tags.extend(
+                [
+                    pos_tag_labels.str2int(pos_tag)
+                    for pos_tag in document.pos_tags[sent_start:sent_end]
+                ]
+            )
+            if pos_tag_labels.int2str is None:
+                raise ValueError("pos_tag_labels.str2int is None.")
+        else:
+            pos_tags = document.pos_tags[sent_start:sent_end]
+
+        example_sentence = {
+            "part_id": part_id,
+            "words": list(document.tokens[sent_start:sent_end]),
+            "pos_tags": pos_tags,
+            "parse_tree": document.parse_trees[idx].label,
+            "predicate_lemmas": predicate_lemmas,
+            "predicate_framenet_ids": predicate_framenet_ids,
+            "word_senses": word_senses,
+            "speaker": document.speakers[idx].label,
+            "named_entities": named_entities,
+            "srl_frames": srl_frames,
+            "coref_spans": coref_spans,
+        }
+
+        example["sentences"].append(example_sentence)
+
+    return example
+
+
+def convert_to_text_document_with_labeled_spans_and_labeled_partitions(
     doc: Conll2012OntonotesV5Document,
     token_separator: str = " ",
-) -> TextDocumentWithLabeledEntitiesAndLabeledPartitions:
+) -> TextDocumentWithLabeledSpansAndLabeledPartitions:
     start = 0
     token_offsets: List[Tuple[int, int]] = []
     for token in doc.tokens:
@@ -258,9 +388,9 @@ def convert_to_text_document_with_labeled_entities_and_labeled_partitions(
         char_offset_sentence = LabeledSpan(start=char_start, end=char_end, label="sentence")
         sentence_map[(sentence.start, sentence.end)] = char_offset_sentence
 
-    new_doc = TextDocumentWithLabeledEntitiesAndLabeledPartitions(text=text, id=doc.id)
-    new_doc.entities.extend(entity_map.values())
-    new_doc.partitions.extend(sentence_map.values())
+    new_doc = TextDocumentWithLabeledSpansAndLabeledPartitions(text=text, id=doc.id)
+    new_doc.labeled_spans.extend(entity_map.values())
+    new_doc.labeled_partitions.extend(sentence_map.values())
 
     return new_doc
 
@@ -280,7 +410,7 @@ class Conll2012OntonotesV5Config(datasets.BuilderConfig):
         assert conll_version in ["v4", "v12"]
         if conll_version == "v12":
             assert language == "english"
-        super(Conll2012OntonotesV5Config, self).__init__(
+        super().__init__(
             name=f"{language}_{conll_version}",
             description=f"{conll_version} of CoNLL formatted OntoNotes dataset for {language}.",
             version=datasets.Version("1.0.0"),  # hf dataset script version
@@ -290,14 +420,15 @@ class Conll2012OntonotesV5Config(datasets.BuilderConfig):
         self.conll_version = conll_version
 
 
-class Conll2012Ontonotesv5(pytorch_ie.data.builder.GeneratorBasedBuilder):
+class Conll2012Ontonotesv5(GeneratorBasedBuilder):
     DOCUMENT_TYPE = Conll2012OntonotesV5Document
 
     DOCUMENT_CONVERTERS = {
-        TextDocumentWithLabeledEntitiesAndLabeledPartitions: convert_to_text_document_with_labeled_entities_and_labeled_partitions
+        TextDocumentWithLabeledSpansAndLabeledPartitions: convert_to_text_document_with_labeled_spans_and_labeled_partitions
     }
 
-    BASE_DATASET_PATH = "DFKI-SLT/conll2012_ontonotesv5"
+    BASE_DATASET_PATH = "conll2012_ontonotesv5"
+    BASE_DATASET_REVISION = "1161216f7e7185a4b2f4d0a4e0734dc7919dfa15"
 
     BUILDER_CONFIGS = [
         Conll2012OntonotesV5Config(
@@ -315,13 +446,11 @@ class Conll2012Ontonotesv5(pytorch_ie.data.builder.GeneratorBasedBuilder):
     def _generate_document_kwargs(self, dataset):
         pos_tags_feature = dataset.features["sentences"][0]["pos_tags"].feature
         return dict(
-            entities_int2str=dataset.features["sentences"][0]["named_entities"].feature.int2str,
-            pos_tags_int2str=pos_tags_feature.int2str
-            if isinstance(pos_tags_feature, datasets.ClassLabel)
-            else None,
+            entity_labels=dataset.features["sentences"][0]["named_entities"].feature,
+            pos_tag_labels=(
+                pos_tags_feature if isinstance(pos_tags_feature, datasets.ClassLabel) else None
+            ),
         )
 
-    def _generate_document(self, example, entities_int2str, pos_tags_int2str):
-        return example_to_document(
-            example, entities_int2str=entities_int2str, pos_tags_int2str=pos_tags_int2str
-        )
+    def _generate_document(self, example, **document_kwargs):
+        return example_to_document(example, **document_kwargs)

requirements.txt

@@ -0,0 +1,2 @@
+pie-datasets>=0.10.11,<0.11.0
+pie-modules>=0.15.9,<0.16.0