import dataclasses from collections import defaultdict from typing import Any, Callable, 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 @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] 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, 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 def convert_to_text_document_with_labeled_entities_and_labeled_partitions( doc: Conll2012OntonotesV5Document, token_separator: str = " ", ) -> TextDocumentWithLabeledEntitiesAndLabeledPartitions: start = 0 token_offsets: List[Tuple[int, int]] = [] for token in doc.tokens: end = start + len(token) token_offsets.append((start, end)) # we add the separator after each token start = end + len(token_separator) text = token_separator.join([token for token in doc.tokens]) entity_map: Dict[Tuple[int, int], LabeledSpan] = {} for entity in doc.entities: char_start = token_offsets[entity.start][0] char_end = token_offsets[entity.end - 1][1] char_offset_entity = LabeledSpan(start=char_start, end=char_end, label=entity.label) entity_map[(entity.start, entity.end)] = char_offset_entity sentence_map: Dict[Tuple[int, int], LabeledSpan] = {} for sentence in doc.sentences: char_start = token_offsets[sentence.start][0] char_end = token_offsets[sentence.end - 1][1] 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()) return new_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 DOCUMENT_CONVERTERS = { TextDocumentWithLabeledEntitiesAndLabeledPartitions: convert_to_text_document_with_labeled_entities_and_labeled_partitions } 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 )