Create conll2012_ontonotesv5.py

conll2012_ontonotesv5.py

@@ -0,0 +1,287 @@
+import dataclasses
+import itertools
+from collections import defaultdict
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import datasets
+import pytorch_ie
+from pytorch_ie.annotations import BinaryRelation, LabeledSpan, NaryRelation, Span
+from pytorch_ie.core import Annotation, AnnotationList, Document, annotation_field
+
+
+@dataclasses.dataclass(eq=True, frozen=True)
+class SpanSet(Annotation):
+    spans: Tuple[Span, ...]
+    score: float = 1.0
+
+    def __post_init__(self) -> None:
+        # make the referenced spans unique, sort them and convert to tuples to make everything hashable
+        object.__setattr__(
+            self,
+            "spans",
+            tuple(sorted(set(s for s in self.spans), key=lambda s: (s.start, s.end))),
+        )
+
+
+@dataclasses.dataclass(eq=True, frozen=True)
+class Attribute(Annotation):
+    target_annotation: Annotation
+    label: str
+    value: Optional[str] = None
+
+
+@dataclasses.dataclass(eq=True, frozen=True)
+class Predicate(Span):
+    lemma: str
+    framenet_id: Optional[str] = None
+
+
+@dataclasses.dataclass
+class Conll2012OntonotesV5Document(Document):
+    tokens: List[str]
+    document_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")
+
+
+def bio2spans(bio: List[str], offset: int = 0) -> List[LabeledSpan]:
+    """Convert a BIO-encoded sequence of labels to a list of labeled spans.
+
+    Args:
+        bio: a BIO-encoded sequence of labels, e.g. ["B-PER", "I-PER", "O", "B-LOC", "I-LOC"]
+        offset: offset to add to the start and end indices of the spans
+
+    Returns:
+        a list of labeled spans
+    """
+
+    spans = []
+    prev_start_and_label: Optional[int, str] = None
+    for idx, bio_value_and_label in enumerate(bio):
+        bio_value = bio_value_and_label[0]
+        bio_label = bio_value_and_label[2:] if bio_value != "O" else None
+        if bio_value == "B":
+            if prev_start_and_label is not None:
+                prev_start, prev_label = prev_start_and_label
+                spans.append(
+                    LabeledSpan(start=prev_start + offset, end=idx + offset, label=prev_label)
+                )
+            prev_start_and_label = (idx, bio_label)
+        elif bio_value == "I":
+            if prev_start_and_label is None:
+                raise ValueError(f"Invalid BIO encoding: {bio}")
+        elif bio_value == "O":
+            if prev_start_and_label is not None:
+                prev_start, prev_label = prev_start_and_label
+                spans.append(
+                    LabeledSpan(start=prev_start + offset, end=idx + offset, label=prev_label)
+                )
+                prev_start_and_label = None
+
+    if prev_start_and_label is not None:
+        prev_start, prev_label = prev_start_and_label
+        spans.append(
+            LabeledSpan(start=prev_start + offset, end=len(bio) + offset, label=prev_label)
+        )
+
+    return spans
+
+
+def example_to_document(
+    example: Dict[str, Any],
+    entities_int2str: Callable[[int], str],
+    pos_tags_int2str: Optional[Callable[[int], str]] = None,
+) -> Conll2012OntonotesV5Document:
+
+    sentences = []
+    tokens = []
+    pos_tags = []
+    parse_trees = []
+    speakers = []
+    entities = []
+    predicates = []
+    coref_mentions = []
+    coref_clusters = []
+    srl_arguments = []
+    srl_relations = []
+    word_senses = []
+    parts = []
+
+    last_part_id_and_start: Optional[Tuple[int, int]] = None
+
+    for sentence_idx, sentence_dict in enumerate(example["sentences"]):
+        sentence_offset = len(tokens)
+        current_tokens = sentence_dict["words"]
+        current_sentence = Span(start=sentence_offset, end=sentence_offset + len(current_tokens))
+        sentences.append(current_sentence)
+
+        if pos_tags_int2str is not None:
+            pos_tags.extend(
+                [pos_tags_int2str(pos_tag_id) for pos_tag_id in sentence_dict["pos_tags"]]
+            )
+        else:
+            pos_tags.extend(sentence_dict["pos_tags"])
+        parse_trees.append(
+            Attribute(target_annotation=current_sentence, label=sentence_dict["parse_tree"])
+        )
+        speakers.append(
+            Attribute(target_annotation=current_sentence, label=sentence_dict["speaker"])
+        )
+        named_entities_bio = [
+            entities_int2str(entity_id) for entity_id in sentence_dict["named_entities"]
+        ]
+        entities.extend(bio2spans(bio=named_entities_bio, offset=len(tokens)))
+
+        for idx, (predicate_lemma_value, predicate_framenet_id) in enumerate(
+            zip(sentence_dict["predicate_lemmas"], sentence_dict["predicate_framenet_ids"])
+        ):
+            token_idx = sentence_offset + idx
+            if predicate_lemma_value is not None:
+                predicate = Predicate(
+                    start=token_idx,
+                    end=token_idx + 1,
+                    lemma=predicate_lemma_value,
+                    framenet_id=predicate_framenet_id,
+                )
+                predicates.append(predicate)
+
+        coref_clusters_dict = defaultdict(list)
+        for cluster_id, start, end in sentence_dict["coref_spans"]:
+            current_coref_mention = Span(
+                start=start + sentence_offset, end=end + 1 + sentence_offset
+            )
+            coref_mentions.append(current_coref_mention)
+            coref_clusters_dict[cluster_id].append(current_coref_mention)
+        current_coref_clusters = [
+            SpanSet(spans=tuple(spans)) for spans in coref_clusters_dict.values()
+        ]
+        coref_clusters.extend(current_coref_clusters)
+
+        # handle srl_frames
+        for frame_dict in sentence_dict["srl_frames"]:
+            current_srl_arguments_with_roles = bio2spans(
+                bio=frame_dict["frames"], offset=sentence_offset
+            )
+            current_srl_arguments = [
+                Span(start=arg.start, end=arg.end) for arg in current_srl_arguments_with_roles
+            ]
+            current_srl_roles = [arg.label for arg in current_srl_arguments_with_roles]
+            current_srl_relation = NaryRelation(
+                arguments=tuple(current_srl_arguments),
+                roles=tuple(current_srl_roles),
+                label="",
+            )
+            srl_arguments.extend(current_srl_arguments)
+            srl_relations.append(current_srl_relation)
+
+        # handle word senses
+        for idx, word_sense in enumerate(sentence_dict["word_senses"]):
+            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)))
+                )
+
+        # handle parts
+        if last_part_id_and_start is not None:
+            last_part_id, last_start = last_part_id_and_start
+            if last_part_id != sentence_dict["part_id"]:
+                parts.append(
+                    LabeledSpan(start=last_start, end=sentence_offset, label=str(last_part_id))
+                )
+                last_part_id_and_start = (sentence_dict["part_id"], sentence_offset)
+        else:
+            last_part_id_and_start = (sentence_dict["part_id"], sentence_offset)
+
+        tokens.extend(current_tokens)
+
+    if last_part_id_and_start is not None:
+        last_part_id, last_start = last_part_id_and_start
+        parts.append(LabeledSpan(start=last_start, end=len(tokens), label=str(last_part_id)))
+
+    doc = Conll2012OntonotesV5Document(
+        tokens=tokens,
+        document_id=example["document_id"],
+        pos_tags=pos_tags,
+    )
+    # add the annotations to the document
+    doc.sentences.extend(sentences)
+    doc.parse_trees.extend(parse_trees)
+    doc.speakers.extend(speakers)
+    doc.entities.extend(entities)
+    doc.predicates.extend(predicates)
+    doc.coref_mentions.extend(coref_mentions)
+    doc.coref_clusters.extend(coref_clusters)
+    doc.srl_arguments.extend(srl_arguments)
+    doc.srl_relations.extend(srl_relations)
+    doc.word_senses.extend(word_senses)
+
+    return doc
+
+
+class Conll2012OntonotesV5Config(datasets.BuilderConfig):
+    """BuilderConfig for the CoNLL formatted OntoNotes dataset."""
+
+    def __init__(self, language=None, conll_version=None, **kwargs):
+        """BuilderConfig for the CoNLL formatted OntoNotes dataset.
+
+        Args:
+          language: string, one of the language {"english", "chinese", "arabic"} .
+          conll_version: string, "v4" or "v12". Note there is only English v12.
+          **kwargs: keyword arguments forwarded to super.
+        """
+        assert language in ["english", "chinese", "arabic"]
+        assert conll_version in ["v4", "v12"]
+        if conll_version == "v12":
+            assert language == "english"
+        super(Conll2012OntonotesV5Config, self).__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
+            **kwargs,
+        )
+        self.language = language
+        self.conll_version = conll_version
+
+
+class Conll2012Ontonotesv5(pytorch_ie.data.builder.GeneratorBasedBuilder):
+    DOCUMENT_TYPE = Conll2012OntonotesV5Document
+
+    BASE_DATASET_PATH = "DFKI-SLT/conll2012_ontonotesv5"
+
+    BUILDER_CONFIGS = [
+        Conll2012OntonotesV5Config(
+            language=lang,
+            conll_version="v4",
+        )
+        for lang in ["english", "chinese", "arabic"]
+    ] + [
+        Conll2012OntonotesV5Config(
+            language="english",
+            conll_version="v12",
+        )
+    ]
+
+    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,
+        )
+
+    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
+        )