File size: 4,443 Bytes
56fbd0c |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 |
import dataclasses
from typing import Any, Callable, Dict, List, Optional
import datasets
import pytorch_ie.data.builder
from pytorch_ie.annotations import BinaryRelation, LabeledSpan
from pytorch_ie.core import Annotation, AnnotationList, Document, annotation_field
from src import utils
log = utils.get_pylogger(__name__)
def dl2ld(dict_of_lists):
return [dict(zip(dict_of_lists, t)) for t in zip(*dict_of_lists.values())]
def ld2dl(list_of_dicts, keys: Optional[List[str]] = None, as_list: bool = False):
if keys is None:
keys = list_of_dicts[0].keys()
if as_list:
return [[d[k] for d in list_of_dicts] for k in keys]
else:
return {k: [d[k] for d in list_of_dicts] for k in keys}
@dataclasses.dataclass(frozen=True)
class Attribute(Annotation):
value: str
annotation: Annotation
@dataclasses.dataclass
class CDCPDocument(Document):
text: str
id: Optional[str] = None
metadata: Dict[str, Any] = dataclasses.field(default_factory=dict)
propositions: AnnotationList[LabeledSpan] = annotation_field(target="text")
relations: AnnotationList[BinaryRelation] = annotation_field(target="propositions")
urls: AnnotationList[Attribute] = annotation_field(target="propositions")
def example_to_document(
example: Dict[str, Any],
relation_int2str: Callable[[int], str],
proposition_int2str: Callable[[int], str],
):
document = CDCPDocument(id=example["id"], text=example["text"])
for proposition_dict in dl2ld(example["propositions"]):
proposition = LabeledSpan(
start=proposition_dict["start"],
end=proposition_dict["end"],
label=proposition_int2str(proposition_dict["label"]),
)
document.propositions.append(proposition)
if proposition_dict.get("url", "") != "":
url = Attribute(annotation=proposition, value=proposition_dict["url"])
document.urls.append(url)
for relation_dict in dl2ld(example["relations"]):
relation = BinaryRelation(
head=document.propositions[relation_dict["head"]],
tail=document.propositions[relation_dict["tail"]],
label=relation_int2str(relation_dict["label"]),
)
document.relations.append(relation)
return document
def document_to_example(
document: CDCPDocument,
relation_str2int: Callable[[str], int],
proposition_str2int: Callable[[str], int],
) -> Dict[str, Any]:
result = {"id": document.id, "text": document.text}
proposition2dict = {}
proposition2idx = {}
for idx, proposition in enumerate(document.propositions):
proposition2dict[proposition] = {
"start": proposition.start,
"end": proposition.end,
"label": proposition_str2int(proposition.label),
"url": "",
}
proposition2idx[proposition] = idx
for url in document.urls:
proposition2dict[url.annotation]["url"] = url.value
result["propositions"] = ld2dl(
proposition2dict.values(), keys=["start", "end", "label", "url"]
)
relations = [
{
"head": proposition2idx[relation.head],
"tail": proposition2idx[relation.tail],
"label": relation_str2int(relation.label),
}
for relation in document.relations
]
result["relations"] = ld2dl(relations, keys=["head", "tail", "label"])
return result
class CDCPConfig(datasets.BuilderConfig):
"""BuilderConfig for CDCP."""
def __init__(self, **kwargs):
"""BuilderConfig for CDCP.
Args:
**kwargs: keyword arguments forwarded to super.
"""
super().__init__(**kwargs)
class CDCP(pytorch_ie.data.builder.GeneratorBasedBuilder):
DOCUMENT_TYPE = CDCPDocument
BASE_DATASET_PATH = "DFKI-SLT/cdcp"
BUILDER_CONFIGS = [datasets.BuilderConfig(name="default")]
DEFAULT_CONFIG_NAME = "default" # type: ignore
def _generate_document_kwargs(self, dataset):
return {
"relation_int2str": dataset.features["relations"].feature["label"].int2str,
"proposition_int2str": dataset.features["propositions"].feature["label"].int2str,
}
def _generate_document(self, example, relation_int2str, proposition_int2str):
return example_to_document(
example, relation_int2str=relation_int2str, proposition_int2str=proposition_int2str
)
|